Improved the basic support of Dwarf information.

31 files changed, 2998 insertions, 55 deletions

diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index 5884350..e617767 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -298,7 +298,6 @@ GLoadedBinary *g_loaded_binary_new(GBinContent *content)
     log_variadic_message(LMT_PROCESS, _("Opening binary data from '%s'..."),
                          g_binary_content_describe(content, true));
 
-    g_object_ref(G_OBJECT(content));
     result->content = content;
 
     /* Format d'exécutable */
diff --git a/src/format/debuggable-int.h b/src/format/debuggable-int.h
index 855a7bf..1fbe4c3 100644
--- a/src/format/debuggable-int.h
+++ b/src/format/debuggable-int.h
@@ -29,6 +29,7 @@
 
 
 #include "format-int.h"
+#include "executable.h"
 
 
 
@@ -37,6 +38,8 @@ struct _GDbgFormat
 {
     GBinFormat parent;                      /* A laisser en premier        */
 
+    GExeFormat *executable;                 /* Binaire principal attaché   */
+
 };
 
 /* Format de débogage générique (classe) */
@@ -47,5 +50,9 @@ struct _GDbgFormatClass
 };
 
 
+/* Associe officiellement des formats exécutable et de débogage. */
+void g_debuggable_format_attach_executable(GDbgFormat *, GExeFormat *);
+
+
 
 #endif  /* _FORMAT_DEBUGGABLE_INT_H */
diff --git a/src/format/debuggable.c b/src/format/debuggable.c
index f66ab96..03ee4ed 100644
--- a/src/format/debuggable.c
+++ b/src/format/debuggable.c
@@ -39,6 +39,9 @@ static void g_debuggable_format_class_init(GDbgFormatClass *);
 /* Initialise une instance de format d'exécutable générique. */
 static void g_debuggable_format_init(GDbgFormat *);
 
+/* Indique le boutisme employé par le format binaire analysé. */
+static SourceEndian g_debuggable_format_get_endianness(const GDbgFormat *);
+
 
 
 /* Indique le type défini pour un format de débogage générique. */
@@ -59,6 +62,11 @@ G_DEFINE_TYPE(GDbgFormat, g_debuggable_format, G_TYPE_BIN_FORMAT);
 
 static void g_debuggable_format_class_init(GDbgFormatClass *klass)
 {
+    GBinFormatClass *fmt;                   /* Version en format basique   */
+
+    fmt = G_BIN_FORMAT_CLASS(klass);
+
+    fmt->get_endian = (format_get_endian_fc)g_debuggable_format_get_endianness;
 
 }
 
@@ -81,8 +89,42 @@ static void g_debuggable_format_init(GDbgFormat *format)
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = description du binaire de débogage à consulter.     *
+*                                                                             *
+*  Description : Indique le boutisme employé par le format binaire analysé.   *
+*                                                                             *
+*  Retour      : Boutisme associé au format.                                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static SourceEndian g_debuggable_format_get_endianness(const GDbgFormat *format)
+{
+    return g_binary_format_get_endianness(G_BIN_FORMAT(format->executable));
+
+}
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format     = description du binaire de débogage à compléter. *
+*                executable = référence vers le binaire exécutable à lier.    *
+*                                                                             *
+*  Description : Associe officiellement des formats exécutable et de débogage.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+void g_debuggable_format_attach_executable(GDbgFormat *format, GExeFormat *executable)
+{
+    format->executable = executable;
 
+    g_object_ref(G_OBJECT(executable));
 
+}
diff --git a/src/format/dwarf/Makefile.am b/src/format/dwarf/Makefile.am
index e3889c4..6ebea4e 100644
--- a/src/format/dwarf/Makefile.am
+++ b/src/format/dwarf/Makefile.am
@@ -2,8 +2,13 @@
 noinst_LTLIBRARIES = libformatdwarf.la
 
 libformatdwarf_la_SOURCES =				\
+	abbrev.h abbrev.c					\
+	die.h die.c							\
 	dwarf.h dwarf.c						\
-	dwarf-int.h dwarf-int.c
+	dwarf-int.h dwarf-int.c				\
+	form.h form.c						\
+	info.h info.c						\
+	symbols.h symbols.c
 
 # libformatdwarf_la_SOURCES =				\
 # 	abbrev.h abbrev.c					\
diff --git a/src/format/dwarf/abbrev.c b/src/format/dwarf/abbrev.c
index 0428806..039c3a0 100644
--- a/src/format/dwarf/abbrev.c
+++ b/src/format/dwarf/abbrev.c
@@ -25,6 +25,611 @@
 
 
 #include <malloc.h>
+
+
+#include "dwarf-int.h"
+
+
+
+
+
+/* Description d'un attribut d'une abréviation */
+typedef struct _dw_abbrev_attr
+{
+    DwarfAttrib name;                       /* Sujet de l'élément          */
+    DwarfForm form;                         /* Représentation              */
+
+} dw_abbrev_attr;
+
+
+/* Description d'une abréviation */
+struct _dw_abbrev
+{
+    uleb128_t code;                         /* Identifiant attribué        */
+    DwarfTag tag;                           /* Sujet de l'élément          */
+
+    dw_abbrev_attr *attribs;                /* Liste des attributs         */
+    size_t attribs_count;                   /* Nombre de ces attributs     */
+
+    struct _dw_abbrev **children;           /* Liste des sous-éléments     */
+    size_t children_count;                  /* Nombre de ces enfants       */
+
+};
+
+
+
+
+
+/* Procède à la conversion de base d'une abréviation DWARF. */
+static bool check_abbreviation_decl(const GDwarfFormat *, const dw_abbrev_decl *, dw_abbrev *);
+
+/* Procède à la conversion d'un attribut d'abréviation DWARF. */
+static bool check_abbreviation_attrib(const GDwarfFormat *, const dw_abbrev_raw_attr *, dw_abbrev_attr *);
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à constituer.              *
+*                                                                             *
+*  Description : Charge toutes les abbréviations présentes dans un DWARF.     *
+*                                                                             *
+*  Retour      : Bilan de l'opération, potentiellement un succès sans sortie. *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool load_all_dwarf_abbreviations(GDwarfFormat *format)
+{
+    bool result;                            /* Bilan à faire remonter      */
+    mrange_t range;                         /* Couverture d'une section    */
+    vmpa2t *pos;                            /* Position de tête de lecture */
+
+    result = g_exe_format_get_section_range_by_name(G_DBG_FORMAT(format)->executable, ".debug_abbrev", &range);
+
+    pos = get_mrange_addr(&range);
+
+    printf("start :: 0x%08x\n", (unsigned int)pos->physical);
+
+    result &= load_dwarf_abbreviation(format, pos, &format->abbreviations);
+
+    printf("abbrevs :: %p\n", format->abbreviations);
+
+    if (format->abbreviations != NULL)
+        printf(" -> children : %zu\n", format->abbreviations->children_count);
+    else
+        printf(" -> (nothing)\n");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à consulter.               *
+*                pos    = tête de lecture à faire évoluer.                    *
+*                abbrev = abréviation lue et complète, NULL si aucune. [OUT]  *
+*                                                                             *
+*  Description : Charge une abréviation valide pour un DWARF en mémoire.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération, potentiellement un succès sans sortie. *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool load_dwarf_abbreviation(const GDwarfFormat *format, vmpa2t *pos, dw_abbrev **abbrev)
+{
+    dw_abbrev_decl decl;                    /* En-tête d'abréviation       */
+    bool status;                            /* Bilan d'une lecture         */
+    dw_abbrev_raw_attr attr;                /* Attribut de l'abréviation   */
+    dw_abbrev *child;                       /* Rejeton à intégrer          */
+
+    *abbrev = NULL;
+
+    /**
+     * Cette routine est la transcription du paragraphe 7.5.3 ("Abbreviations Tables"),
+     * de la quatrième version de la définition du format DWARF.
+     *
+     * La spécification précise :
+     *
+     *    As mentioned in Section 2.3, each chain of sibling entries is terminated by a null entry.
+     *
+     * Cependant, ce formalisme n'est pas constaté dans la pratique. D'ailleurs, readelf
+     * comporte le commentaire suivant dans le fichier 'dwarf_reader.cc' :
+     *
+     *    Read the abbrev code. A zero here indicates the end of the abbrev table.
+     *
+     */
+
+    if (!read_dwarf_abbrev_decl(format, pos, &decl))
+        goto lda_bad_exit;
+
+    if (decl.code == 0)
+        goto lda_exit;
+
+    *abbrev = (dw_abbrev *)calloc(1, sizeof(dw_abbrev));
+
+    if (!check_abbreviation_decl(format, &decl, *abbrev))
+        goto lda_bad_exit;
+
+    /* Chargement des attributs */
+
+    for (;;)
+    {
+        status = read_dwarf_abbrev_attr(format, pos, &attr);
+        if (!status) goto lda_bad_exit;
+
+        printf(" -- [0x%llx] [0x%llx] name = %u\tform = %u\n",
+               (unsigned long long)pos->physical,
+               (unsigned long long)decl.code,
+               (unsigned int)attr.name, (unsigned int)attr.form);
+
+        if (attr.name == DW_ATTR_invalid && attr.form == DW_FORM_invalid)
+            break;
+
+        (*abbrev)->attribs_count++;
+        (*abbrev)->attribs = (dw_abbrev_attr *)realloc((*abbrev)->attribs,
+                                                       (*abbrev)->attribs_count * sizeof(dw_abbrev_attr));
+
+        status = check_abbreviation_attrib(format, &attr,
+                                           &(*abbrev)->attribs[(*abbrev)->attribs_count - 1]);
+        if (!status) goto lda_bad_exit;
+
+    }
+
+    /* Chargement des enfants */
+
+    printf(" || children ? %d vs %d\n", (int)decl.has_children, (int)DW_CHILDREN_yes);
+
+    if (decl.has_children == DW_CHILDREN_yes)
+        for (;;)
+        {
+            status = load_dwarf_abbreviation(format, pos, &child);
+            if (!status) goto lda_bad_exit;
+
+            if (child == NULL)
+                break;
+
+            (*abbrev)->children_count++;
+            (*abbrev)->children = (dw_abbrev **)realloc((*abbrev)->children,
+                                                        (*abbrev)->children_count * sizeof(dw_abbrev));
+
+            (*abbrev)->children[(*abbrev)->children_count - 1] = child;
+
+        }
+
+ lda_exit:
+
+    return true;
+
+ lda_bad_exit:
+
+    free_dwarf_abbreviation(*abbrev);
+
+    return false;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : abbrev = abréviation chargée en mémoire à traiter.           *
+*                                                                             *
+*  Description : Supprime de la mémoire toute trace d'une abréviation DWARF.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void free_dwarf_abbreviation(dw_abbrev *abbrev)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    if (abbrev->attribs != NULL)
+        free(abbrev->attribs);
+
+    if (abbrev->children != NULL)
+    {
+        for (i = 0; i < abbrev->children_count; i++)
+            free_dwarf_abbreviation(abbrev->children[i]);
+
+        free(abbrev->attribs);
+
+    }
+
+    free(abbrev);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                decl   = structure brute dont le contenu est à valider.      *
+*                abbrev = abréviation à constituer à partir du brut. [OUT]    *
+*                                                                             *
+*  Description : Procède à la conversion de base d'une abréviation DWARF.     *
+*                                                                             *
+*  Retour      : Validité confirmée ou non.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool check_abbreviation_decl(const GDwarfFormat *format, const dw_abbrev_decl *decl, dw_abbrev *abbrev)
+{
+    bool result;                            /* Validité à retourner        */
+
+    result = (decl->has_children == DW_CHILDREN_no
+              || decl->has_children == DW_CHILDREN_yes);
+
+
+    /* TODO : vérifier les bornes de 'tag' */
+
+
+    if (result)
+    {
+        abbrev->code = decl->code;
+        abbrev->tag = decl->tag;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                decl   = structure brute dont le contenu est à valider.      *
+*                abbrev = abréviation à constituer à partir du brut. [OUT]    *
+*                                                                             *
+*  Description : Procède à la conversion d'un attribut d'abréviation DWARF.   *
+*                                                                             *
+*  Retour      : Validité confirmée ou non.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool check_abbreviation_attrib(const GDwarfFormat *format, const dw_abbrev_raw_attr *attr, dw_abbrev_attr *attrib)
+{
+    bool result;                            /* Validité à retourner        */
+
+    result = true;
+
+
+    /* TODO : vérifier les bornes de 'name' et 'form' */
+
+
+    if (result)
+    {
+        attrib->name = attr->name;
+        attrib->form = attr->form;
+
+
+
+    }
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : abbrev = abréviation chargée en mémoire à consulter.         *
+*                                                                             *
+*  Description : Fournit l'étiquette associée à l'ensemble des attributs.     *
+*                                                                             *
+*  Retour      : Etiquette officielle de l'ensemble représenté.               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+DwarfTag dwarf_abbreviation_get_tag(const dw_abbrev *abbrev)
+{
+    return abbrev->tag;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : abbrev = abréviation chargée en mémoire à consulter.         *
+*                                                                             *
+*  Description : Compte le nombre d'attributs présents dans une abréviation.  *
+*                                                                             *
+*  Retour      : Quantité d'attributs pris en compte dans l'abréviation.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t dwarf_abbreviation_count_attribs(const dw_abbrev *abbrev)
+{
+    return abbrev->attribs_count;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : abbrev = abréviation chargée en mémoire à consulter.         *
+*                attrib = désignation de l'attribut à retrouver.              *
+*                index  = indice de cet attribut dans l'ensemble. [OUT]       *
+*                                                                             *
+*  Description : Recherche un attribut dans une abréviation.                  *
+*                                                                             *
+*  Retour      : Indication sur le bilan des recherches.                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool dwarf_abbreviation_get_attrib_index(const dw_abbrev *abbrev, DwarfAttrib attrib, size_t *index)
+{
+    bool result;                            /* Etat de validité à renvoyer */
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < abbrev->attribs_count; i++)
+        if (abbrev->attribs[i].name == attrib)
+            break;
+
+    if (i < abbrev->attribs_count)
+    {
+        result = true;
+        *index = i;
+    }
+    else
+        result = false;
+
+    return result;
+
+}
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : abbrev = abréviation chargée en mémoire à consulter.         *
+*                attrib = désignation de l'attribut à retrouver.              *
+*                index  = indice de cet attribut dans l'ensemble.             *
+*                form   = type de valeur attendu pour un attribut donné. [OUT]*
+*                                                                             *
+*  Description : Détermine le type d'un attribut dans une abréviation.        *
+*                                                                             *
+*  Retour      : Indication sur le bilan des accès.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool dwarf_abbreviation_get_form_for_index(const dw_abbrev *abbrev, size_t index, DwarfForm *form)
+{
+    if (index >= abbrev->attribs_count)
+        return false;
+
+    *form = abbrev->attribs[index].form;
+
+    return true;
+
+}
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : abbrev = abréviation chargée en mémoire à consulter.         *
+*                                                                             *
+*  Description : Indique si une abbréviation comporte des sous-définitions.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool dwarf_abbreviation_has_children(const dw_abbrev *abbrev)
+{
+    return (abbrev->children_count > 0);
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à consulter.               *
+*                code   = identifiant de l'abbréviation recherchée.           *
+*                                                                             *
+*  Description : Recherche une abréviation DWARF donnée.                      *
+*                                                                             *
+*  Retour      : Adresse d'une abréviation ou NULL en cas d'échec.            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const dw_abbrev *find_dwarf_abbreviations(const GDwarfFormat *format, uleb128_t code)
+{
+    const dw_abbrev *result;                /* Trouvaille à retourner      */
+
+    if (format->abbreviations->code == code)
+        result = format->abbreviations;
+
+    else
+    {
+        const dw_abbrev *_find_dwarf_abbreviations(const dw_abbrev *abbrev, uleb128_t c)
+        {
+            const dw_abbrev *found;         /* Trouvaille à retourner      */
+            size_t i;                       /* Boucle de parcours          */
+
+            if (abbrev->code == c)
+                found = abbrev;
+            else
+            {
+                found = NULL;
+
+                for (i = 0; i < abbrev->children_count && found == NULL; i++)
+                    found = _find_dwarf_abbreviations(abbrev->children[i], c);
+
+            }
+
+            return found;
+
+        }
+
+        result = _find_dwarf_abbreviations(format->abbreviations, code);
+
+    }
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = contenu binaire de débogage à parcourir.            *
+*                cu     = unité de compilation parente.                       *
+*                form   = nature de la valeur à lire.                         *
+*                pos    = tête de lecture au sein des données. [OUT]          *
+*                value  = valeur au format donné lue. [OUT]                   *
+*                                                                             *
+*  Description : Lit la valeur correspondant à un type donné.                 *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+dw_value *translate_abbreviation_attributes(const GDwarfFormat *format, const dw_abbrev *abbrev, const dw_compil_unit_header *cu, vmpa2t *pos)
+{
+    dw_value *result;                       /* Valeurs lues retournées     */
+    size_t i;                               /* Boucle de parcours          */
+    bool status;                            /* Bilan d'une lecture         */
+
+    result = (dw_value *)calloc(abbrev->attribs_count, sizeof(dw_value));
+
+    for (i = 0; i < abbrev->attribs_count; i++)
+    {
+        result[i].attrib = abbrev->attribs[i].name;
+
+        printf("-- loading attrib %x (%u)  -- form = %x (%u) -- pos = %llx --\n",
+               (unsigned int)abbrev->attribs[i].name,
+               (unsigned int)abbrev->attribs[i].name,
+               (unsigned int)abbrev->attribs[i].form,
+               (unsigned int)abbrev->attribs[i].form,
+               (unsigned long long)(pos->physical - 0x1039));
+
+        status = G_DWARF_FORMAT_GET_CLASS(format)->read_form(format, cu,
+                                                             abbrev->attribs[i].form, pos, &result[i].value);
+        if (!status) printf("[%zu] failed for  %x\n", i, abbrev->attribs[i].form);
+        if (status)  printf("[%zu] success for %x\n", i, abbrev->attribs[i].form);
+        printf("    current pos :: %llx\n", (unsigned long long)(pos->physical - 0x1039));
+        if (!status) break;
+
+    }
+
+    if (i != abbrev->attribs_count)
+    {
+        free(result);
+        result = NULL;
+    }
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#if 0
+
+#include <malloc.h>
 #include <stdarg.h>
 #include <string.h>
 
@@ -781,3 +1386,5 @@ bool skip_dwarf_abbrev(dwarf_format *format, off_t *pos, const dw_abbrev *abbrev
     return result;
 
 }
+
+#endif
diff --git a/src/format/dwarf/abbrev.h b/src/format/dwarf/abbrev.h
index 469d572..bc7efe6 100644
--- a/src/format/dwarf/abbrev.h
+++ b/src/format/dwarf/abbrev.h
@@ -28,6 +28,73 @@
 #include <stdbool.h>
 
 
+#include "dwarf.h"
+#include "dwarf_def.h"
+
+
+
+
+/* Description d'une abréviation */
+typedef struct _dw_abbrev dw_abbrev;
+
+
+
+
+
+
+
+/* Charge toutes les abbréviations présentes dans un DWARF. */
+bool load_all_dwarf_abbreviations(GDwarfFormat *);
+
+/* Charge une abréviation valide pour un DWARF en mémoire. */
+bool load_dwarf_abbreviation(const GDwarfFormat *, vmpa2t *, dw_abbrev **);
+
+/* Supprime de la mémoire toute trace d'une abréviation DWARF. */
+void free_dwarf_abbreviation(dw_abbrev *);
+
+/* Fournit l'étiquette associée à l'ensemble des attributs. */
+DwarfTag dwarf_abbreviation_get_tag(const dw_abbrev *);
+
+/* Compte le nombre d'attributs présents dans une abréviation. */
+size_t dwarf_abbreviation_count_attribs(const dw_abbrev *);
+
+/* Recherche un attribut dans une abréviation. */
+bool dwarf_abbreviation_get_attrib_index(const dw_abbrev *, DwarfAttrib, size_t *);
+
+
+/* Détermine le type d'un attribut dans une abréviation. */
+bool dwarf_abbreviation_get_form_for_index(const dw_abbrev *, size_t, DwarfForm *);
+
+
+/* Indique si une abbréviation comporte des sous-définitions. */
+bool dwarf_abbreviation_has_children(const dw_abbrev *);
+
+
+
+/* Recherche une abréviation DWARF donnée. */
+const dw_abbrev *find_dwarf_abbreviations(const GDwarfFormat *, uleb128_t);
+
+/* Lit la valeur correspondant à un type donné. */
+dw_value *translate_abbreviation_attributes(const GDwarfFormat *, const dw_abbrev *, const dw_compil_unit_header *, vmpa2t *);
+
+
+
+
+
+
+
+
+
+
+
+
+
+#if 0
+
+
+#include <stdbool.h>
+
+
 #include "d_dwarf.h"
 #include "dwarf-int.h"
 
@@ -52,5 +119,8 @@ bool read_dwarf_abbrev_attribute(dwarf_format *, off_t *, bool, const dw_abbrev
 bool skip_dwarf_abbrev(dwarf_format *, off_t *, const dw_abbrev *);
 
 
+#endif
+
+
 
 #endif  /* _FORMAT_DWARF_ABBREV_H */
diff --git a/src/format/dwarf/die.c b/src/format/dwarf/die.c
new file mode 100644
index 0000000..8c25a1d
--- /dev/null
+++ b/src/format/dwarf/die.c
@@ -0,0 +1,303 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * die.c - gestion des entrées renvoyant à des informations de débogage
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "die.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+
+
+#include "dwarf-int.h"
+
+
+
+/**
+ * § 2.1 The Debugging Information Entry (DIE).
+ */
+
+typedef struct _dw_die
+{
+    unsigned int level;                     /* Niveau hiérarchique         */
+    phys_t offset;                          /* Position dans le flux       */
+
+    const dw_abbrev *abbrev;                /* Lien vers la représentation */
+
+    dw_value *values;                       /* Liste des valeurs associées */
+
+    bool has_children;                      /* Feuille ou noeud de l'arbre */
+    struct _dw_die **children;              /* Liste d'éventuels enfants   */
+    size_t children_count;                  /* Taille de cette liste       */
+
+} dw_die;
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
+*                endian = boutisme reconnu dans le format.                    *
+*                header = en-tête de description de l'unité à traiter.        *
+*                die    = emplacement de stockage de l'entrée ou NULL. [OUT]  *
+*                                                                             *
+*  Description : Procède à la lecture de l'en-tête d'une unité de compilation.*
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : Le format autorise à ne rien produire ici légitimement.      *
+*                                                                             *
+******************************************************************************/
+
+bool build_dwarf_die(GDwarfFormat *format, vmpa2t *pos, SourceEndian endian, const dw_compil_unit_header *header, dw_die **die)
+{
+    uleb128_t code;                         /* Code de la description liée */
+    bool status;                            /* Bilan de la lecture         */
+    const dw_abbrev *abbrev;                /* Lien vers la représentation */
+    dw_value *values;                       /* Liste des valeurs associées */
+
+    *die = NULL;
+
+    /**
+     * § 7.5.2 Debugging Information Entry.
+     */
+
+    status = g_binary_content_read_uleb128(G_BIN_FORMAT(format)->content, pos, &code);
+    if (!status) return false;
+
+    printf("[ok] code = 0x%llx\n", (unsigned long long)code);
+
+    if (code == 0) return true;
+
+    abbrev = find_dwarf_abbreviations(format, code);
+
+    printf("[ok] abbrev = %p\n", abbrev);
+
+    printf("----------------------\n");
+
+
+    values = translate_abbreviation_attributes(format, abbrev, header, pos);
+    if (values == NULL) return false;
+
+    printf("[ok] values = %p\n", values);
+
+
+
+    *die = (dw_die *)calloc(1, sizeof(dw_die));
+
+    (*die)->abbrev = abbrev;
+
+    (*die)->values = values;
+
+    (*die)->has_children = dwarf_abbreviation_has_children(abbrev);
+
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : die = entrée à libérer de la mémoire.                        *
+*                                                                             *
+*  Description : Supprime les éléments mis en place pour une entrée d'info.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void delete_dwarf_die(dw_die *die)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    if (die->values != NULL)
+        free(die->values);
+
+    for (i = 0; i < die->children_count; i++)
+        delete_dwarf_die(die->children[i]);
+
+    if (die->children != NULL)
+        free(die->children);
+
+    free(die);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : die = entrée à consulter.                                    *
+*                                                                             *
+*  Description : Fournit un lien vers l'abréviation de représentation.        *
+*                                                                             *
+*  Retour      : Structure de représentation en place.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const dw_abbrev *dw_die_get_abbrev(const dw_die *die)
+{
+    return die->abbrev;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : die   = entrée à consulter.                                  *
+*                index = indice de cet attribut dans l'ensemble.              *
+*                                                                             *
+*  Description : Fournit un lien vers l'abréviation de représentation.        *
+*                                                                             *
+*  Retour      : Valeur recherchée ou NULL en cas d'erreur.                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const dw_form_value *dw_die_peek_value(const dw_die *die, size_t index)
+{
+    dw_form_value *result;                  /* Valeur ciblée à retourner   */
+
+    if (index >= dwarf_abbreviation_count_attribs(die->abbrev))
+        return NULL;
+
+    result = &die->values[index].value;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : die    = entrée d'information à consulter.                   *
+*                attrib = désignation de l'attribut à retrouver.              *
+*                form   = type de valeur attendu pour un attribut donné. [OUT]*
+*                                                                             *
+*  Description : Fournit un lien vers l'abréviation de représentation.        *
+*                                                                             *
+*  Retour      : Valeur recherchée ou NULL en cas d'erreur.                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const dw_form_value *dw_die_peek_extended_value(const dw_die *die, DwarfAttrib attrib, DwarfForm *form)
+{
+    const dw_form_value *result;            /* Valeur ciblée à retourner   */
+    size_t index;                           /* Indice d'élément à relire   */
+    bool status;                            /* Bilan d'une récupération    */
+
+    status = dwarf_abbreviation_get_attrib_index(die->abbrev, attrib, &index);
+    if (!status) return NULL;
+
+    status = dwarf_abbreviation_get_form_for_index(die->abbrev, index, form);
+    if (!status) return NULL;
+
+    result = dw_die_peek_value(die, index);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : die = entrée à consulter.                                    *
+*                                                                             *
+*  Description : Indique si une entrée de débogage possède des enfants.       *
+*                                                                             *
+*  Retour      : true ou false selon la situation.                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool dw_die_has_children(const dw_die *die)
+{
+    return die->has_children;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : die = entrée à consulter.                                    *
+*                                                                             *
+*  Description : Indique si une entrée de débogage possède des enfants.       *
+*                                                                             *
+*  Retour      : true ou false selon la situation.                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void dw_die_append_child(dw_die *die, dw_die *child)
+{
+    assert(die->has_children);
+
+    die->children = (dw_die **)realloc(die->children, ++die->children_count * sizeof(dw_die *));
+
+    die->children[die->children_count - 1] = child;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                              TRAITEMENT PAR ENSEMBLES                              */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : root    = entrée première à consulter.                       *
+*                visitor = intervention régulière à respecter.                *
+*                data    = données quelconques à associer aux visites.        *
+*                                                                             *
+*  Description : Entame une grande tournée de toutes les entrées présentes.   *
+*                                                                             *
+*  Retour      : true si l'opération s'est déroulée complètement, false sinon.*
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool dw_die_visit(dw_die *root, visit_dies_fc visitor, void *data)
+{
+    bool result;                            /* Bilan à retourner           */
+    size_t i;                               /* Boucle de parcours          */
+
+    result = visitor(root, data);
+
+    for (i = 0; i < root->children_count && result; i++)
+        result = dw_die_visit(root->children[i], visitor, data);
+
+    return result;
+
+}
diff --git a/src/format/dwarf/die.h b/src/format/dwarf/die.h
new file mode 100644
index 0000000..79634cb
--- /dev/null
+++ b/src/format/dwarf/die.h
@@ -0,0 +1,76 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * die.h - prototypes pour la gestion des entrées renvoyant à des informations de débogage
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_DWARF_DIE_H
+#define _FORMAT_DWARF_DIE_H
+
+
+#include <stdbool.h>
+
+
+#include "abbrev.h"
+#include "dwarf.h"
+#include "dwarf_def.h"
+
+
+
+/* § 2.1 The Debugging Information Entry (DIE). */
+typedef struct _dw_die dw_die;
+
+
+/* Procède à la lecture de l'en-tête d'une unité de compilation. */
+bool build_dwarf_die(GDwarfFormat *, vmpa2t *pos, SourceEndian endian, const dw_compil_unit_header *header, dw_die **);
+
+/* Supprime les éléments mis en place pour une entrée d'info. */
+void delete_dwarf_die(dw_die *);
+
+/* Fournit un lien vers l'abréviation de représentation. */
+const dw_abbrev *dw_die_get_abbrev(const dw_die *);
+
+/* Fournit un lien vers l'abréviation de représentation. */
+const dw_form_value *dw_die_peek_value(const dw_die *, size_t);
+
+/* Fournit un lien vers l'abréviation de représentation. */
+const dw_form_value *dw_die_peek_extended_value(const dw_die *, DwarfAttrib, DwarfForm *);
+
+/* Indique si une entrée de débogage possède des enfants. */
+bool dw_die_has_children(const dw_die *);
+
+/* Indique si une entrée de débogage possède des enfants. */
+void dw_die_append_child(dw_die *, dw_die *);
+
+
+
+/* ---------------------------- TRAITEMENT PAR ENSEMBLES ---------------------------- */
+
+
+/* Procédure appelée pour chaque élément recontré pendant une visite. */
+typedef bool (* visit_dies_fc) (const dw_die *, void *);
+
+
+/* Entame une grande tournée de toutes les entrées présentes. */
+bool dw_die_visit(dw_die *, visit_dies_fc, void *);
+
+
+
+#endif  /* _FORMAT_DWARF_DIE_H */
diff --git a/src/format/dwarf/dwarf-int.c b/src/format/dwarf/dwarf-int.c
index 310f926..5c18aaf 100644
--- a/src/format/dwarf/dwarf-int.c
+++ b/src/format/dwarf/dwarf-int.c
@@ -29,10 +29,73 @@
 *                                                                             *
 *  Paramètres  : format = informations chargées à consulter.                  *
 *                pos    = position de début de lecture. [OUT]                 *
+*                attr   = structure lue à retourner. [OUT]                    *
+*                                                                             *
+*  Description : Procède à la lecture d'un attribut d'abréviation DWARF.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dwarf_abbrev_attr(const GDwarfFormat *format, vmpa2t *pos, dw_abbrev_raw_attr *attr)
+{
+    bool result;                            /* Bilan à retourner           */
+    const GBinContent *content;             /* Contenu binaire à lire      */
+
+    content = G_BIN_FORMAT(format)->content;
+
+    result = g_binary_content_read_uleb128(content, pos, &attr->name);
+    result &= g_binary_content_read_uleb128(content, pos, &attr->form);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
+*                decl   = structure lue à retourner. [OUT]                    *
+*                                                                             *
+*  Description : Procède à la lecture d'une déclaration d'abréviation DWARF.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dwarf_abbrev_decl(const GDwarfFormat *format, vmpa2t *pos, dw_abbrev_decl *decl)
+{
+    bool result;                            /* Bilan à retourner           */
+    const GBinContent *content;             /* Contenu binaire à lire      */
+
+    content = G_BIN_FORMAT(format)->content;
+
+    result = g_binary_content_read_uleb128(content, pos, &decl->code);
+    result &= g_binary_content_read_uleb128(content, pos, &decl->tag);
+    result &= g_binary_content_read_u8(content, pos, &decl->has_children);
+
+    return result;
+
+}
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
 *                endian = boutisme reconnu dans le format.                    *
 *                header = en-tête à déterminer. [OUT]                         *
 *                                                                             *
-*  Description : Procède à la lecture de l'en-tête d'un contenu binaire ELF.  *
+*  Description : Procède à la lecture de l'en-tête d'un contenu binaire DWARF.*
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -73,3 +136,72 @@ bool read_dwarf_section_header(GBinContent *content, vmpa2t *pos, SourceEndian e
     return result;
 
 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
+*                endian = boutisme reconnu dans le format.                    *
+*                header = en-tête à déterminer. [OUT]                         *
+*                                                                             *
+*  Description : Procède à la lecture de l'en-tête d'une unité de compilation.*
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dwarf_compil_unit_header(GBinContent *content, vmpa2t *pos, SourceEndian endian, dw_compil_unit_header *header)
+{
+    bool result;                            /* Bilan à retourner           */
+    uint32_t val32;                         /* Premier paquet d'octets     */
+    bool status;                            /* Bilan d'opération           */
+
+    result = read_dwarf_section_header(content, pos, endian, (dw_section_header *)header);
+    if (!result) goto rdcuh_exit;
+
+    if (header->is_32b)
+    {
+        status = g_binary_content_read_u32(content, pos, endian, &val32);
+        if (!status) goto rdcuh_exit;
+
+        header->debug_abbrev_offset = val32;
+
+    }
+    else
+    {
+        status = g_binary_content_read_u64(content, pos, endian, &header->debug_abbrev_offset);
+        if (!status) goto rdcuh_exit;
+
+    }
+
+    result &= g_binary_content_read_u8(content, pos, &header->address_size);
+
+ rdcuh_exit:
+
+    return result;
+
+}
+
+
+
+
+
+
+
diff --git a/src/format/dwarf/dwarf-int.h b/src/format/dwarf/dwarf-int.h
index d3bf14a..c91609e 100644
--- a/src/format/dwarf/dwarf-int.h
+++ b/src/format/dwarf/dwarf-int.h
@@ -35,12 +35,21 @@
 
 #include "../debuggable-int.h"
 
+#include "abbrev.h"
+#include "die.h"
 #include "dwarf_def.h"
 
 
 
 
 
+/* Procède à la lecture d'un attribut d'abréviation DWARF. */
+bool read_dwarf_abbrev_attr(const GDwarfFormat *, vmpa2t *, dw_abbrev_raw_attr *);
+
+/* Procède à la lecture d'une déclaration d'abréviation DWARF. */
+bool read_dwarf_abbrev_decl(const GDwarfFormat *, vmpa2t *, dw_abbrev_decl *);
+
+
 
 
 /* En-tête présente dans certaines sections */
@@ -65,19 +74,38 @@ bool read_dwarf_section_header(GBinContent *, vmpa2t *, SourceEndian, dw_section
 
 
 
+/* Procède à la lecture de l'en-tête d'une unité de compilation. */
+bool read_dwarf_compil_unit_header(GBinContent *, vmpa2t *, SourceEndian, dw_compil_unit_header *);
+
+
+
+///---------------------
+
 
 
 
+//-------------------------------
 
 
 
 
 
+/* Lit la valeur correspondant à un type donné. */
+typedef bool (* read_form_value_fc) (const GDwarfFormat *, const dw_compil_unit_header *, DwarfForm, vmpa2t *, dw_form_value *);
+
+
 /* Format de débogage DWARF (instance) */
 struct _GDwarfFormat
 {
     GDbgFormat parent;                      /* A laisser en premier        */
 
+    dw_abbrev *abbreviations;               /* Racine des abbréviations    */
+
+
+    dw_die *info_die;
+
+
+
 };
 
 /* Format de débogage DWARF (classe) */
@@ -85,13 +113,16 @@ struct _GDwarfFormatClass
 {
     GDbgFormatClass parent;                 /* A laisser en premier        */
 
-};
+    read_form_value_fc read_form;           /* lecture de valeurs formatées*/
 
+};
 
 
 
 
 
+/* Charge de façon générique toutes les informations DWARF. */
+bool g_dwarf_format_load(GDwarfFormat *, GExeFormat *);
 
 
 
@@ -119,29 +150,6 @@ typedef enum _DwarfFormat
 
 
 
-/* Description d'un attribut d'une abréviation */
-typedef struct _dw_abbrev_attr
-{
-    DwarfAttrib attrib;                     /* Sujet de l'élément          */
-    DwarfForm form;                         /* Représentation              */
-
-} dw_abbrev_attr;
-
-
-/* Description d'une abréviation */
-typedef struct _dw_abbrev
-{
-    off_t offset;                           /* Position dans le corps      */
-    DwarfTag tag;                           /* Sujet de l'élément          */
-
-    dw_abbrev_attr *attribs;                /* Liste des attributs         */
-    size_t attribs_count;                   /* Nombre de ces attributs     */
-
-    struct _dw_abbrev **children;           /* Liste des sous-éléments     */
-    size_t children_count;                  /* Nombre de ces enfants       */
-
-} dw_abbrev;
-
 
 /* Eléments récupérés sur une fonction */
 typedef struct _dw_dbg_function
diff --git a/src/format/dwarf/dwarf.c b/src/format/dwarf/dwarf.c
index 519aa49..3fe5e88 100644
--- a/src/format/dwarf/dwarf.c
+++ b/src/format/dwarf/dwarf.c
@@ -24,7 +24,10 @@
 #include "dwarf.h"
 
 
+#include "abbrev.h"
 #include "dwarf-int.h"
+#include "info.h"
+#include "symbols.h"
 #include "../../common/cpp.h"
 
 
@@ -120,6 +123,9 @@ FormatMatchStatus dwarf_is_matching(GBinContent *content, GExeFormat *parent, vo
 
     if (parent == NULL)
         return FMS_UNKNOWN;
+    return FMS_UNKNOWN;
+    *key = strdup("dwarf_v4");
+    return FMS_MATCHED;
 
     /* Lecture des indices présents */
 
@@ -145,6 +151,9 @@ FormatMatchStatus dwarf_is_matching(GBinContent *content, GExeFormat *parent, vo
         equal = true;
 
         for (k = 0; k < count && equal; k++)
+            printf("  -> %hhu vs %hhu\n", ref[k], cur[k]);
+
+        for (k = 0; k < count && equal; k++)
             equal = (cur[k] == 0) || (ref[k] == cur[k]);
 
         return equal;
@@ -158,6 +167,8 @@ FormatMatchStatus dwarf_is_matching(GBinContent *content, GExeFormat *parent, vo
      * du fait de l'absence de section, donc il n'y aura pas d'incompatibilité.
      */
 
+    printf("---dwarf v4\n");
+
     found = check_dwarf_version(dwarf_v4_versions, current_versions, ARRAY_SIZE(section_names));
 
     if (found)
@@ -168,6 +179,8 @@ FormatMatchStatus dwarf_is_matching(GBinContent *content, GExeFormat *parent, vo
 
     if (result == FMS_UNKNOWN)
     {
+        printf("---dwarf v3\n");
+
         found = check_dwarf_version(dwarf_v3_versions, current_versions, ARRAY_SIZE(section_names));
 
         if (found)
@@ -180,6 +193,8 @@ FormatMatchStatus dwarf_is_matching(GBinContent *content, GExeFormat *parent, vo
 
     if (result == FMS_UNKNOWN)
     {
+        printf("---dwarf v2\n");
+
         found = check_dwarf_version(dwarf_v2_versions, current_versions, ARRAY_SIZE(section_names));
 
         if (found)
@@ -277,3 +292,46 @@ static void g_dwarf_format_finalize(GDwarfFormat *format)
     G_OBJECT_CLASS(g_dwarf_format_parent_class)->finalize(G_OBJECT(format));
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format     = description du binaire de débogage à compléter. *
+*                executable = référence vers le binaire exécutable à lier.    *
+*                                                                             *
+*  Description : Charge de façon générique toutes les informations DWARF.     *
+*                                                                             *
+*  Retour      : Bilan du chargement : réussi ou non ?                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_dwarf_format_load(GDwarfFormat *format, GExeFormat *executable)
+{
+    bool result;                            /* Bilan à faire remonter      */
+
+    result = true;
+
+    g_debuggable_format_attach_executable(G_DBG_FORMAT(format), executable);
+
+    printf("Loading abbrev...\n");
+
+    result &= load_all_dwarf_abbreviations(format);
+
+    printf("Loading debug info...\n");
+
+    result &= load_dwarf_debug_information(format);
+
+    printf("Done!\n");
+
+    result &= load_dwarf_symbols(format);
+
+    printf("Got symbols...\n");
+
+    exit(0);
+
+    return result;
+
+}
+
diff --git a/src/format/dwarf/dwarf_def.h b/src/format/dwarf/dwarf_def.h
index 35fcdc0..7067472 100644
--- a/src/format/dwarf/dwarf_def.h
+++ b/src/format/dwarf/dwarf_def.h
@@ -26,6 +26,430 @@
 
 
 
+#include <stdint.h>
+
+
+#include "../../arch/vmpa.h"
+#include "../../common/leb128.h"
+
+
+
+
+/**
+ * § 7.5.1.1 Compilation Unit Header.
+ */
+
+/* En-tête présente dans certaines sections */
+typedef struct _dw_compil_unit_header
+{
+    uint64_t unit_length;                   /* Taille totale sans le champ */
+    bool is_32b;                            /* Le format est-il sur 32b ?  */
+
+    uint16_t version;                       /* Version de la section       */
+
+    uint64_t debug_abbrev_offset;           /* Emplacement dans la section */
+    uint8_t address_size;                   /* Taille des adresses         */
+
+} dw_compil_unit_header;
+
+
+/**
+ * § 7.5.4 Attribute Encodings
+ */
+
+/* Figure 18, Tag encodings, begins here. */
+
+typedef enum _DwarfTag
+{
+    DW_TAG_array_type               = 0x01,
+    DW_TAG_class_type               = 0x02,
+    DW_TAG_entry_point              = 0x03,
+    DW_TAG_enumeration_type         = 0x04,
+    DW_TAG_formal_parameter         = 0x05,
+    DW_TAG_imported_declaration     = 0x08,
+    DW_TAG_label                    = 0x0a,
+    DW_TAG_lexical_block            = 0x0b,
+    DW_TAG_member                   = 0x0d,
+    DW_TAG_pointer_type             = 0x0f,
+    DW_TAG_reference_type           = 0x10,
+    DW_TAG_compile_unit             = 0x11,
+    DW_TAG_string_type              = 0x12,
+    DW_TAG_structure_type           = 0x13,
+    DW_TAG_subroutine_type          = 0x15,
+    DW_TAG_typedef                  = 0x16,
+    DW_TAG_union_type               = 0x17,
+    DW_TAG_unspecified_parameters   = 0x18,
+    DW_TAG_variant                  = 0x19,
+    DW_TAG_common_block             = 0x1a,
+    DW_TAG_common_inclusion         = 0x1b,
+    DW_TAG_inheritance              = 0x1c,
+    DW_TAG_inlined_subroutine       = 0x1d,
+    DW_TAG_module                   = 0x1e,
+    DW_TAG_ptr_to_member_type       = 0x1f,
+    DW_TAG_set_type                 = 0x20,
+    DW_TAG_subrange_type            = 0x21,
+    DW_TAG_with_stmt                = 0x22,
+    DW_TAG_access_declaration       = 0x23,
+    DW_TAG_base_type                = 0x24,
+    DW_TAG_catch_block              = 0x25,
+    DW_TAG_const_type               = 0x26,
+    DW_TAG_constant                 = 0x27,
+    DW_TAG_enumerator               = 0x28,
+    DW_TAG_file_type                = 0x29,
+    DW_TAG_friend                   = 0x2a,
+    DW_TAG_namelist                 = 0x2b,
+    DW_TAG_namelist_item            = 0x2c,
+    DW_TAG_packed_type              = 0x2d,
+    DW_TAG_subprogram               = 0x2e,
+    DW_TAG_template_type_parameter  = 0x2f,
+    DW_TAG_template_value_parameter = 0x30,
+    DW_TAG_thrown_type              = 0x31,
+    DW_TAG_try_block                = 0x32,
+    DW_TAG_variant_part             = 0x33,
+    DW_TAG_variable                 = 0x34,
+    DW_TAG_volatile_type            = 0x35,
+
+    DW_TAG_dwarf_procedure          = 0x36,
+    DW_TAG_restrict_type            = 0x37,
+    DW_TAG_interface_type           = 0x38,
+    DW_TAG_namespace                = 0x39,
+    DW_TAG_imported_module          = 0x3a,
+    DW_TAG_unspecified_type         = 0x3b,
+    DW_TAG_partial_unit             = 0x3c,
+    DW_TAG_imported_unit            = 0x3d,
+    DW_TAG_condition                = 0x3f,
+    DW_TAG_shared_type              = 0x40,
+
+    /* Nouveautés v.4 */
+
+    DW_TAG_type_unit                = 0x41,
+    DW_TAG_rvalue_reference_type    = 0x42,
+    DW_TAG_template_alias           = 0x43,
+
+    DW_TAG_lo_user                  = 0x4080,
+    DW_TAG_hi_user                  = 0xffff
+
+} DwarfTag;
+
+/* Figure 19. Child determination encodings. */
+
+#define DW_CHILDREN_no 0x00
+#define DW_CHILDREN_yes 0x01
+
+/* Figure 21. Attribute form encodings. */
+
+typedef enum _DwarfForm
+{
+    DW_FORM_invalid     = 0x00,
+
+    DW_FORM_addr        = 0x01,
+    DW_FORM_block2      = 0x03,
+    DW_FORM_block4      = 0x04,
+    DW_FORM_data2       = 0x05,
+    DW_FORM_data4       = 0x06,
+    DW_FORM_data8       = 0x07,
+    DW_FORM_string      = 0x08,
+    DW_FORM_block       = 0x09,
+    DW_FORM_block1      = 0x0a,
+    DW_FORM_data1       = 0x0b,
+    DW_FORM_flag        = 0x0c,
+    DW_FORM_sdata       = 0x0d,
+    DW_FORM_strp        = 0x0e,
+    DW_FORM_udata       = 0x0f,
+    DW_FORM_ref_addr    = 0x10,
+    DW_FORM_ref1        = 0x11,
+    DW_FORM_ref2        = 0x12,
+    DW_FORM_ref4        = 0x13,
+    DW_FORM_ref8        = 0x14,
+    DW_FORM_ref_udata   = 0x15,
+    DW_FORM_indirect    = 0x16,
+
+    /* Nouveautés v4 */
+
+    DW_FORM_sec_offset  = 0x17,
+    DW_FORM_exprloc     = 0x18,
+    DW_FORM_flag_present = 0x19,
+    DW_FORM_ref_sig8    = 0x20
+
+} DwarfForm;
+
+
+
+
+
+
+/* Résumé des différentes valeurs dans DWARF v2 */
+typedef union _dw_v2_form_value
+{
+    /* DW_FORM_addr */
+    virt_t address;
+
+    /* DW_FORM_data[1248] */
+    uint8_t data1;
+    uint16_t data2;
+    uint32_t data4;
+    uint64_t data8;
+
+    /* DW_FORM_sdata */
+    leb128_t sdata;
+
+    /* DW_FORM_udata */
+    uleb128_t udata;
+
+    /* DW_FORM_block[124]? */
+    struct
+    {
+        const bin_t *start;
+        phys_t size;
+
+    } block;
+
+    /* DW_FORM_string */
+    /* DW_FORM_strp */
+    const char *string;
+
+    /* DW_FORM_flag */
+    uint8_t flag;
+
+    /* DW_FORM_ref[1248] */
+    uint8_t ref1;
+    uint16_t ref2;
+    uint32_t ref4;
+    uint64_t ref8;
+
+    /* DW_FORM_ref_udata */
+    uleb128_t ref_udata;
+
+} dw_v2_form_value;
+
+
+/* Résumé des différentes valeurs dans DWARF v4 */
+typedef union _dw_v4_form_value
+{
+    dw_v2_form_value v2;
+
+    /* DW_FORM_sec_offset */
+    uint64_t sec_offset;
+
+    /* DW_FORM_exprloc */
+    struct
+    {
+        const bin_t *start;
+        phys_t size;
+
+    } expr;
+
+    /* DW_FORM_flag_present */
+    bool has_flag;
+
+    /* DW_FORM_ref_sig8 */
+    uint64_t signature;
+
+} dw_v4_form_value;
+
+
+/* Résumé des différentes valeurs dans DWARF */
+typedef union _dw_form_value
+{
+    dw_v2_form_value v2;
+    dw_v2_form_value v4;
+
+} dw_form_value;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * § 7.5.3 Abbreviations Tables.
+ */
+
+/* Description d'un attribut d'une abréviation */
+typedef struct _dw_abbrev_raw_attr
+{
+    uleb128_t name;                         /* Désignation de l'attribut   */
+    uleb128_t form;                         /* Nature de sa valeur         */
+
+} dw_abbrev_raw_attr;
+
+/* En-tête de déclaration d'une abréviation */
+typedef struct _dw_abbrev_decl
+{
+    uleb128_t code;                         /* Identifiant attribué        */
+    uleb128_t tag;                          /* Identifiant attribué        */
+
+    uint8_t has_children;                   /* Présence de sous-entrées ?  */
+
+} dw_abbrev_decl;
+
+
+
+
+
+
+
+
+
+
+/* Liste des attributs rencontrés */
+typedef enum _DwarfAttrib
+{
+    DW_AT_sibling               = 0x01,
+    DW_AT_location              = 0x02,
+    DW_AT_name                  = 0x03,
+    DW_AT_ordering              = 0x09,
+    DW_AT_byte_size             = 0x0b,
+    DW_AT_bit_offset            = 0x0c,
+    DW_AT_bit_size              = 0x0d,
+    DW_AT_stmt_list             = 0x10,
+    DW_AT_low_pc                = 0x11,
+    DW_AT_high_pc               = 0x12,
+    DW_AT_language              = 0x13,
+    DW_AT_discr                 = 0x15,
+    DW_AT_discr_value           = 0x16,
+    DW_AT_visibility            = 0x17,
+    DW_AT_import                = 0x18,
+    DW_AT_string_length         = 0x19,
+    DW_AT_common_reference      = 0x1a,
+    DW_AT_comp_dir              = 0x1b,
+    DW_AT_const_value           = 0x1c,
+    DW_AT_containing_type       = 0x1d,
+    DW_AT_default_value         = 0x1e,
+    DW_AT_inline                = 0x20,
+    DW_AT_is_optional           = 0x21,
+    DW_AT_lower_bound           = 0x22,
+    DW_AT_producer              = 0x25,
+    DW_AT_prototyped            = 0x27,
+    DW_AT_return_addr           = 0x2a,
+    DW_AT_start_scope           = 0x2c,
+    DW_AT_bit_stride            = 0x2e,
+    DW_AT_upper_bound           = 0x2f,
+    DW_AT_abstract_origin       = 0x31,
+    DW_AT_accessibility         = 0x32,
+    DW_AT_address_class         = 0x33,
+    DW_AT_artificial            = 0x34,
+    DW_AT_base_types            = 0x35,
+    DW_AT_calling_convention    = 0x36,
+    DW_AT_count                 = 0x37,
+    DW_AT_data_member_location  = 0x38,
+    DW_AT_decl_column           = 0x39,
+    DW_AT_decl_file             = 0x3a,
+    DW_AT_decl_line             = 0x3b,
+    DW_AT_declaration           = 0x3c,
+    DW_AT_discr_list            = 0x3d,
+    DW_AT_encoding              = 0x3e,
+    DW_AT_external              = 0x3f,
+    DW_AT_frame_base            = 0x40,
+    DW_AT_friend                = 0x41,
+    DW_AT_identifier_case       = 0x42,
+    DW_AT_macro_info            = 0x43,
+    DW_AT_namelist_item         = 0x44,
+    DW_AT_priority              = 0x45,
+    DW_AT_segment               = 0x46,
+    DW_AT_specification         = 0x47,
+    DW_AT_static_link           = 0x48,
+    DW_AT_type                  = 0x49,
+    DW_AT_use_location          = 0x4a,
+    DW_AT_variable_parameter    = 0x4b,
+    DW_AT_virtuality            = 0x4c,
+    DW_AT_vtable_elem_location  = 0x4d,
+    DW_AT_allocated             = 0x4e,
+    DW_AT_associated            = 0x4f,
+    DW_AT_data_location         = 0x50,
+    DW_AT_byte_stride           = 0x51,
+    DW_AT_entry_pc              = 0x52,
+    DW_AT_use_UTF8              = 0x53,
+    DW_AT_extension             = 0x54,
+    DW_AT_ranges                = 0x55,
+    DW_AT_trampoline            = 0x56,
+    DW_AT_call_column           = 0x57,
+    DW_AT_call_file             = 0x58,
+    DW_AT_call_line             = 0x59,
+    DW_AT_description           = 0x5a,
+    DW_AT_binary_scale          = 0x5b,
+    DW_AT_decimal_scale         = 0x5c,
+    DW_AT_small                 = 0x5d,
+    DW_AT_decimal_sign          = 0x5e,
+    DW_AT_digit_count           = 0x5f,
+    DW_AT_picture_string        = 0x60,
+    DW_AT_mutable               = 0x61,
+    DW_AT_threads_scaled        = 0x62,
+    DW_AT_explicit              = 0x63,
+    DW_AT_object_pointer        = 0x64,
+    DW_AT_endianity             = 0x65,
+    DW_AT_elemental             = 0x66,
+    DW_AT_pure                  = 0x67,
+    DW_AT_recursive             = 0x68,
+
+    /* Nouveautés v4 */
+
+    DW_AT_signature             = 0x69,
+    DW_AT_main_subprogram       = 0x6a,
+    DW_AT_data_bit_offset       = 0x6b,
+    DW_AT_const_expr            = 0x6c,
+    DW_AT_enum_class            = 0x6d,
+    DW_AT_linkage_name          = 0x6e,
+
+    DW_AT_lo_user               = 0x2000,
+    DW_AT_hi_user               = 0x3fff,
+
+} DwarfAttrib;
+
+
+#define DW_ATTR_invalid 0 /* FIXME */
+
+
+typedef struct _dw_value
+{
+    DwarfAttrib attrib;                     /* Sujet de l'élément          */
+    dw_form_value value;                    /* Valeur instanciée associée  */
+
+} dw_value;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#if 0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 /* Liste des balises rencontrées */
 typedef enum _DwarfTag
 {
@@ -399,5 +823,8 @@ typedef enum _DwarfForm
 } DwarfForm;
 
 
+#endif
+
+
 
 #endif  /* _FORMAT_DWARF_DWARF_DEF_H */
diff --git a/src/format/dwarf/form.c b/src/format/dwarf/form.c
new file mode 100644
index 0000000..9d05c8e
--- /dev/null
+++ b/src/format/dwarf/form.c
@@ -0,0 +1,113 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * form.h - prototypes pour la transmission des valeurs d'attributs
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "form.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : value = valeur au format Dwarf à consulter.                  *
+*                form   = nature de la valeur à lire.                         *
+*                addr   = valeur utilisable en interne récupérée. [OUT]       *
+*                                                                             *
+*  Description : Transcrit une valeur Dwarf brute en adresse virtuelle.       *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool translate_form_into_address(const dw_form_value *value, DwarfForm form, virt_t *addr)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = true;
+
+    switch (form)
+    {
+        case DW_FORM_addr:
+            *addr = value->v2.address;
+            break;
+
+        case DW_FORM_data1:
+            *addr = value->v2.data1;
+            break;
+
+        case DW_FORM_data2:
+            *addr = value->v2.data2;
+            break;
+
+        case DW_FORM_data4:
+            *addr = value->v2.data4;
+            break;
+
+        case DW_FORM_data8:
+            *addr = value->v2.data8;
+            break;
+
+        default:
+            result = false;
+            break;
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : value = valeur au format Dwarf à consulter.                  *
+*                form   = nature de la valeur à lire.                         *
+*                                                                             *
+*  Description : Transcrit une valeur Dwarf brute en chaîne de caractères.    *
+*                                                                             *
+*  Retour      : Bilan de l'opération : chaîne de caractères ou NULL si échec.*
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *translate_form_into_string(const dw_form_value *value, DwarfForm form)
+{
+    const char *result;                     /* Valeur et bilan à retourner */
+
+    switch (form)
+    {
+        case DW_FORM_string:
+        case DW_FORM_strp:
+            result = value->v2.string;
+            break;
+
+        default:
+            result = NULL;
+            break;
+
+    }
+
+    return result;
+
+}
diff --git a/src/format/dwarf/form.h b/src/format/dwarf/form.h
new file mode 100644
index 0000000..b6c3f47
--- /dev/null
+++ b/src/format/dwarf/form.h
@@ -0,0 +1,40 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * form.h - prototypes pour la transmission des valeurs d'attributs
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_DWARF_FORM_H
+#define _FORMAT_DWARF_FORM_H
+
+
+#include "dwarf_def.h"
+
+
+
+/* Transcrit une valeur Dwarf brute en adresse virtuelle. */
+bool translate_form_into_address(const dw_form_value *, DwarfForm, virt_t *);
+
+/* Transcrit une valeur Dwarf brute en chaîne de caractères. */
+const char *translate_form_into_string(const dw_form_value *, DwarfForm);
+
+
+
+#endif  /* _FORMAT_DWARF_FORM_H */
diff --git a/src/format/dwarf/info.c b/src/format/dwarf/info.c
index 8106114..4ef6484 100644
--- a/src/format/dwarf/info.c
+++ b/src/format/dwarf/info.c
@@ -24,6 +24,170 @@
 #include "info.h"
 
 
+#include "die.h"
+#include "dwarf-int.h"
+#include "../debuggable-int.h"
+
+
+
+
+
+static bool extract_dies_from_debug_information(GDwarfFormat *format, vmpa2t *pos, SourceEndian endian, const dw_compil_unit_header *header, dw_die *parent, dw_die **die);
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage DWARF à compléter.         *
+*                                                                             *
+*  Description : Charge les informations depuis une section ".debug_info".    *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool load_dwarf_debug_information(GDwarfFormat *format)
+{
+    bool result;                            /* Bilan à renvoyer            */
+
+
+
+    mrange_t range;                         /* Couverture d'une section    */
+    vmpa2t end;
+    vmpa2t iter;                            /* Tête de lecture mouvante    */
+
+    dw_compil_unit_header header;
+    dw_die *die;
+
+
+
+    result = g_exe_format_get_section_range_by_name(G_DBG_FORMAT(format)->executable, ".debug_info", &range);
+    if (!result) goto lddi_exit;
+
+    copy_vmpa(&iter, get_mrange_addr(&range));
+
+
+    printf("[%d] Passage :: 0x%08llx 0x%08llx\n",
+           result,
+           (unsigned long long)range.addr.physical,
+           (unsigned long long)range.addr.virtual);
+
+    compute_mrange_end_addr(&range, &end);
+
+    while (result)
+    {
+        /* Si il n'y a plus rien à lire dans la section... */
+        if (cmp_vmpa(&iter, &end) >= 0) break;
+
+
+        printf("========================================================================\n");
+        printf("========================================================================\n");
+        printf("========================================================================\n");
+        printf("========================================================================\n");
+        printf("\n");
+        printf("HEADER START :: 0x%x\n", (unsigned int)iter.physical);
+
+
+        result = read_dwarf_compil_unit_header(G_BIN_FORMAT(format)->content, &iter,
+                                               SRE_LITTLE /* FIXME */, &header);
+        if (!result) break;
+
+        printf("[%d] header :: addr size=%hhu\n", result, header.address_size);
+
+
+        result = extract_dies_from_debug_information(format, &iter,
+                                                     SRE_LITTLE /* FIXME */, &header,
+                                                     NULL, &die);
+
+
+
+    }
+
+
+    format->info_die = die;
+
+
+ lddi_exit:
+
+    return result;
+
+}
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage DWARF à compléter.         *
+*                pos    = position de début de lecture. [OUT]                 *
+*                endian = boutisme reconnu dans le format.                    *
+*                header = en-tête de description de l'unité à traiter.        *
+*                parent = entrée parent de rattachement ou NULL si racine.    *
+*                die    = emplacement de stockage de l'entrée. [OUT]          *
+*                                                                             *
+*  Description : Procède à la lecture de l'en-tête d'un contenu binaire DWARF.*
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool extract_dies_from_debug_information(GDwarfFormat *format, vmpa2t *pos, SourceEndian endian, const dw_compil_unit_header *header, dw_die *parent, dw_die **die)
+{
+    bool result;                            /* Bilan à faire remonter      */
+    dw_die *child;                          /* Entrée subordonnée à charger*/
+
+    printf("==================================\n");
+    printf("===        version : 0x%hx\n", header->version);
+    printf("===  offset abbrev : 0x%llx\n", (unsigned long long)header->debug_abbrev_offset);
+    printf("==================================\n");
+
+
+    phys_t start = 0x1039;
+
+    printf("start :: 0x%x\n", (unsigned int)(pos->physical - start));
+    printf("start :: 0x%x\n", (unsigned int)(0x0 + pos->physical));
+
+    result = build_dwarf_die(format, pos, SRE_LITTLE /* FIXME */, header, die);
+    if (*die == NULL) return result;
+
+    if (parent != NULL)
+        dw_die_append_child(parent, *die);
+
+    if (dw_die_has_children(*die))
+    {
+        printf("<<<< children >>>>\n");
+
+        printf("next :: 0x%x\n", (unsigned int)(pos->physical - start));
+
+        while (result)
+        {
+            result = extract_dies_from_debug_information(format, pos, endian, header, *die, &child);
+
+            if (!result)
+                delete_dwarf_die(*die);
+
+            /* Entrée avec un code nul -> fin */
+            if (child == NULL) break;
+
+        }
+
+    }
+
+    return result;
+
+}
+
+
+
+
+
+
+
+#if 0
 #include <malloc.h>
 #include <string.h>
 
@@ -686,3 +850,4 @@ char *resolve_dwarf_function_type(dwarf_format *format, const dw_abbrev *abbrev,
     return result;
 
 }
+#endif
diff --git a/src/format/dwarf/info.h b/src/format/dwarf/info.h
index 0c0f154..805306b 100644
--- a/src/format/dwarf/info.h
+++ b/src/format/dwarf/info.h
@@ -28,6 +28,25 @@
 #include <stdbool.h>
 
 
+#include "dwarf.h"
+
+
+
+/* Charge les informations depuis une section ".debug_info". */
+bool load_dwarf_debug_information(GDwarfFormat *);
+
+
+
+
+
+
+
+
+#if 0
+
+#include <stdbool.h>
+
+
 #include "d_dwarf.h"
 
 
@@ -37,6 +56,7 @@ bool load_dwarf_information(dwarf_format *);
 
 /* Décharge les informations trouvées dans un DWARF. */
 void unload_dwarf_information(dwarf_format *);
+#endif
 
 
 
diff --git a/src/format/dwarf/symbols.c b/src/format/dwarf/symbols.c
new file mode 100644
index 0000000..ceaee9e
--- /dev/null
+++ b/src/format/dwarf/symbols.c
@@ -0,0 +1,318 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * symbols.c - gestion des symboles d'un DWARF
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "symbols.h"
+
+
+#include "die.h"
+#include "dwarf-int.h"
+#include "form.h"
+#include "../mangling/demangler.h"
+#include "../../core/params.h"
+
+
+
+/* Charge les informations d'une routine en tant que symbole. */
+static bool load_routine_as_symbol_from_dwarf(GDwarfFormat *, const dw_die *, const dw_abbrev *, bool);
+
+/* Charge les informations d'un objet en tant que symbole. */
+static bool load_object_as_symbol_from_dwarf(GDwarfFormat *, const dw_die *, const dw_abbrev *, bool);
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format   = description de l'exécutable à compléter.          *
+*                die      = entrée d'informations de débogage à utiliser.     *
+*                abbrev   = abréviation déjà chargée sur laquelle s'appuyer.  *
+*                use_virt = oriente le choix de la distinction ultime.        *
+*                                                                             *
+*  Description : Charge les informations d'une routine en tant que symbole.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool load_routine_as_symbol_from_dwarf(GDwarfFormat *format, const dw_die *die, const dw_abbrev *abbrev, bool use_virt)
+{
+    DwarfForm form;                         /* Type d'une valeur d'attribut*/
+    const dw_form_value *value;             /* Valeur concrète d'attribut  */
+    virt_t virt;                            /* Adresse virtuelle de départ */
+    bool status;                            /* Bilan d'une récupération    */
+    virt_t len;                             /* Taille de la zone couverte  */
+    vmpa2t addr;                            /* Localisation complète       */
+    mrange_t range;                         /* Espace de couverture total  */
+    const char *name;                       /* Désignation humaine         */
+    char alt_name[6 + VMPA_MAX_LEN];        /* Nom abstrait de substitution*/
+    GBinRoutine *routine;                   /* Nouvelle routine trouvée    */
+    GBinSymbol *symbol;                     /* Nouveau symbole construit   */
+
+    /* Surface couverte */
+
+    value = dw_die_peek_extended_value(die, DW_AT_low_pc, &form);
+    if (value == NULL) goto lrasfd_bad_start;
+
+    status = translate_form_into_address(value, form, &virt);
+    if (!status) goto lrasfd_bad_start;
+
+    value = dw_die_peek_extended_value(die, DW_AT_high_pc, &form);
+    if (value == NULL) goto lrasfd_bad_start;
+
+    status &= translate_form_into_address(value, form, &len);
+    if (!status) goto lrasfd_bad_start;
+
+    if (!g_exe_format_translate_address_into_vmpa(G_DBG_FORMAT(format)->executable, virt, &addr))
+        init_vmpa(&addr, VMPA_NO_PHYSICAL, virt);
+
+    init_mrange(&range, &addr, len);
+
+    /* Désignation humaine */
+
+    value = dw_die_peek_extended_value(die, DW_AT_name, &form);
+    if (value == NULL) goto lrasfd_bad_name;
+
+    name = translate_form_into_string(value, form);
+
+    if (name == NULL)
+    {
+        strcpy(alt_name, "func_");
+
+        if (use_virt)
+            vmpa2_virt_to_string(&addr, MDS_UNDEFINED, alt_name + 5, NULL);
+        else
+            vmpa2_phys_to_string(&addr, MDS_UNDEFINED, alt_name + 5, NULL);
+
+        name = alt_name;
+
+    }
+
+    /* Intégration en bonne et due forme */
+
+    routine = try_to_demangle_routine(name);
+
+    g_binary_routine_set_range(routine, &range);
+
+    symbol = g_binary_symbol_new(STP_ROUTINE);
+    g_binary_symbol_attach_routine(symbol, routine);
+
+    _g_binary_format_add_symbol(G_BIN_FORMAT(format), symbol, false);
+
+
+
+
+    printf(" --> [valid ?= %d] start @ 0x%08llx\n", status, virt);
+    printf(" --> [valid ?= %d]   len = 0x%08llx\n", status, len);
+    printf(" --> [valid ?= %d]  name = '%s'\n", status, name);
+
+
+    return true;
+
+ lrasfd_bad_start:
+ lrasfd_bad_name:
+
+    return false;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format   = description de l'exécutable à compléter.          *
+*                die      = entrée d'informations de débogage à utiliser.     *
+*                abbrev   = abréviation déjà chargée sur laquelle s'appuyer.  *
+*                use_virt = oriente le choix de la distinction ultime.        *
+*                                                                             *
+*  Description : Charge les informations d'un objet en tant que symbole.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool load_object_as_symbol_from_dwarf(GDwarfFormat *format, const dw_die *die, const dw_abbrev *abbrev, bool use_virt)
+{
+    DwarfForm form;                         /* Type d'une valeur d'attribut*/
+    const dw_form_value *value;             /* Valeur concrète d'attribut  */
+    virt_t virt;                            /* Adresse virtuelle de départ */
+    bool status;                            /* Bilan d'une récupération    */
+    virt_t len;                             /* Taille de la zone couverte  */
+    vmpa2t addr;                            /* Localisation complète       */
+    mrange_t range;                         /* Espace de couverture total  */
+    const char *name;                       /* Désignation humaine         */
+    char alt_name[5 + VMPA_MAX_LEN];        /* Nom abstrait de substitution*/
+    GBinRoutine *routine;                   /* Nouvelle routine trouvée    */
+    GBinSymbol *symbol;                     /* Nouveau symbole construit   */
+
+    /* Surface couverte */
+
+
+
+
+
+
+    /*
+    value = dw_die_peek_extended_value(die, DW_AT_low_pc, &form);
+    if (value == NULL) goto lrasfd_bad_start;
+
+    status = translate_form_into_address(value, form, &virt);
+    if (!status) goto lrasfd_bad_start;
+
+    value = dw_die_peek_extended_value(die, DW_AT_high_pc, &form);
+    if (value == NULL) goto lrasfd_bad_start;
+
+    status &= translate_form_into_address(value, form, &len);
+    if (!status) goto lrasfd_bad_start;
+
+    if (!g_exe_format_translate_address_into_vmpa(G_DBG_FORMAT(format)->executable, virt, &addr))
+        init_vmpa(&addr, VMPA_NO_PHYSICAL, virt);
+
+    init_mrange(&range, &addr, len);
+    */
+
+
+
+
+
+    /* Désignation humaine */
+
+    value = dw_die_peek_extended_value(die, DW_AT_name, &form);
+    if (value == NULL) goto lrasfd_bad_name;
+
+    name = translate_form_into_string(value, form);
+
+    if (name == NULL)
+    {
+        strcpy(alt_name, "obj_");
+
+        if (use_virt)
+            vmpa2_virt_to_string(&addr, MDS_UNDEFINED, alt_name + 5, NULL);
+        else
+            vmpa2_phys_to_string(&addr, MDS_UNDEFINED, alt_name + 5, NULL);
+
+        name = alt_name;
+
+    }
+
+    /* Intégration en bonne et due forme */
+
+    /*
+    routine = try_to_demangle_routine(name);
+
+    g_binary_routine_set_range(routine, &range);
+
+    symbol = g_binary_symbol_new(STP_OBJECT);
+    g_binary_symbol_attach_routine(symbol, routine);
+
+    _g_binary_format_add_symbol(G_BIN_FORMAT(format), symbol, false);
+    */
+
+
+
+    //printf(" --> [valid ?= %d] start @ 0x%08llx\n", status, virt);
+    //printf(" --> [valid ?= %d]   len = 0x%08llx\n", status, len);
+    printf(" --> [valid ?= %d]  name = '%s'\n", status, name);
+
+
+    return true;
+
+ lrasfd_bad_start:
+ lrasfd_bad_name:
+
+    return false;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = description de l'exécutable à compléter.            *
+*                                                                             *
+*  Description : Charge en mémoire la liste humaine des symboles.             *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool load_dwarf_symbols(GDwarfFormat *format)
+{
+    bool result;                            /* Bilan à retourner           */
+    bool no_name;                           /* Choix de construction de nom*/
+
+    typedef struct _die_visit_info
+    {
+        GDwarfFormat *format;
+        bool use_virt;
+
+    } die_visit_info;
+
+    die_visit_info vinfo;                   /* Information pour visiteur   */
+
+
+    bool catch_dwarf_symbol(const dw_die *die, die_visit_info *info)
+    {
+        const dw_abbrev *abbrev;            /* Lien vers la représentation */
+        DwarfTag tag;                       /* Etiquette à analyser        */
+        bool status;                        /* Bilan d'un chargement       */
+
+        abbrev = dw_die_get_abbrev(die);
+        tag = dwarf_abbreviation_get_tag(abbrev);
+
+        switch (tag)
+        {
+            case DW_TAG_subprogram:
+                printf(" DIE ==> %p -> %p // tag = %x\n", die, abbrev, tag);
+                status = load_routine_as_symbol_from_dwarf(info->format, die, abbrev, info->use_virt);
+                break;
+
+            case DW_TAG_variable:
+                printf(" DIE ==> %p -> %p // tag = %x\n", die, abbrev, tag);
+                status = load_object_as_symbol_from_dwarf(info->format, die, abbrev, info->use_virt);
+                break;
+
+            default:
+                status = true;
+                break;
+
+        }
+
+        return status;
+
+    }
+
+
+    if (!g_generic_config_get_value(get_main_configuration(), MPK_FORMAT_NO_NAME, &no_name))
+        return false;
+
+    vinfo.format = format;
+    vinfo.use_virt = no_name;
+
+    result = dw_die_visit(format->info_die, (visit_dies_fc)catch_dwarf_symbol, &vinfo);
+
+    return result;
+
+}
diff --git a/src/format/dwarf/symbols.h b/src/format/dwarf/symbols.h
new file mode 100644
index 0000000..cc6085a
--- /dev/null
+++ b/src/format/dwarf/symbols.h
@@ -0,0 +1,40 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * symbols.h - prototypes pour la gestion des symboles d'un DWARF
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_DWARF_SYMBOLS_H
+#define _FORMAT_DWARF_SYMBOLS_H
+
+
+#include <stdbool.h>
+
+
+#include "dwarf.h"
+
+
+
+/* Charge en mémoire la liste humaine des symboles. */
+bool load_dwarf_symbols(GDwarfFormat *);
+
+
+
+#endif  /* _FORMAT_DWARF_SYMBOLS_H */
diff --git a/src/format/dwarf/v2/Makefile.am b/src/format/dwarf/v2/Makefile.am
index 54e7719..04dee14 100644
--- a/src/format/dwarf/v2/Makefile.am
+++ b/src/format/dwarf/v2/Makefile.am
@@ -2,7 +2,8 @@
 noinst_LTLIBRARIES = libformatdwarfv2.la
 
 libformatdwarfv2_la_SOURCES =			\
-	dwarf.h dwarf.c
+	dwarf.h dwarf.c						\
+	form.h form.c
 
 libformatdwarfv2_la_LDFLAGS = $(LIBGTK_LIBS)
 
diff --git a/src/format/dwarf/v2/dwarf.c b/src/format/dwarf/v2/dwarf.c
index 73e4e04..ccef01f 100644
--- a/src/format/dwarf/v2/dwarf.c
+++ b/src/format/dwarf/v2/dwarf.c
@@ -27,6 +27,9 @@
 #include "../dwarf-int.h"
 
 
+#include "form.h"
+
+
 
 /* Format de débogage DWARF v2 (instance) */
 struct _GDwarfV2Format
@@ -76,12 +79,17 @@ G_DEFINE_TYPE(GDwarfV2Format, g_dwarfv2_format, G_TYPE_DWARF_FORMAT);
 static void g_dwarfv2_format_class_init(GDwarfV2FormatClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
+    GDwarfFormatClass *dwarf;               /* Version parente de la classe*/
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_dwarfv2_format_dispose;
     object->finalize = (GObjectFinalizeFunc)g_dwarfv2_format_finalize;
 
+    dwarf = G_DWARF_FORMAT_CLASS(klass);
+
+    dwarf->read_form = (read_form_value_fc)read_dwarf_v2_form_value;
+
 }
 
 
diff --git a/src/format/dwarf/v2/form.c b/src/format/dwarf/v2/form.c
new file mode 100644
index 0000000..8a16887
--- /dev/null
+++ b/src/format/dwarf/v2/form.c
@@ -0,0 +1,272 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * form.c - chargement en mémoire des valeurs d'attributs
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "form.h"
+
+
+#include "../dwarf-int.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = contenu binaire de débogage à parcourir.            *
+*                cu     = unité de compilation parente.                       *
+*                form   = nature de la valeur à lire.                         *
+*                pos    = tête de lecture au sein des données. [OUT]          *
+*                value  = valeur au format donné lue. [OUT]                   *
+*                                                                             *
+*  Description : Lit la valeur correspondant à un type donné.                 *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dwarf_v2_form_value(const GDwarfFormat *format, const dw_compil_unit_header *cu, DwarfForm form, vmpa2t *pos, dw_v2_form_value *value)
+{
+    bool result;                            /* Bilan de lecture à renvoyer */
+    GBinContent *content;                   /* Contenu binaire à parcourir */
+    SourceEndian endian;                    /* Boutisme des enregistrements*/
+    GExeFormat *exe;                        /* Format d'exécutable rattaché*/
+    const bin_t *tmp;                       /* Données quelconques         */
+    uint8_t tmp8;                           /* Données sur 8 bits          */
+    uint16_t tmp16;                         /* Données sur 16 bits         */
+    uint32_t tmp32;                         /* Données sur 32 bits         */
+    uint64_t tmp64;                         /* Données sur 64 bits         */
+    uleb128_t tmpuleb;                      /* Données sur xxx bits        */
+    phys_t offset;                          /* Décalage à appliquer        */
+    mrange_t range;                         /* Couverture d'une section    */
+    vmpa2t iter;                            /* Point de lecture parallèle  */
+
+    content = G_BIN_FORMAT(format)->content;
+    endian = g_binary_format_get_endianness(G_BIN_FORMAT(format));
+    exe = G_DBG_FORMAT(format)->executable;
+
+    switch (form)
+    {
+        case DW_FORM_addr:
+
+            switch (cu->address_size)
+            {
+                case 2:
+                    result = g_binary_content_read_u16(content, pos, endian, &tmp16);
+                    if (result) value->address = tmp16;
+                    break;
+                case 4:
+                    result = g_binary_content_read_u32(content, pos, endian, &tmp32);
+                    if (result) value->address = tmp32;
+                    break;
+                case 8:
+                    result = g_binary_content_read_u64(content, pos, endian, &tmp64);
+                    if (result) value->address = tmp64;
+                    break;
+                default:
+                    result = false;
+                    break;
+            }
+            break;
+
+        case DW_FORM_block2:
+            result = g_binary_content_read_u16(content, pos, endian, &tmp16);
+            if (result)
+            {
+                value->block.size = tmp16;
+                goto block_finish;
+            }
+            break;
+
+        case DW_FORM_block4:
+            result = g_binary_content_read_u32(content, pos, endian, &tmp32);
+            if (result)
+            {
+                value->block.size = tmp32;
+                goto block_finish;
+            }
+            break;
+
+        case DW_FORM_data2:
+            result = g_binary_content_read_u16(content, pos, endian, &value->data2);
+            break;
+
+        case DW_FORM_data4:
+            result = g_binary_content_read_u32(content, pos, endian, &value->data4);
+            break;
+
+        case DW_FORM_data8:
+            result = g_binary_content_read_u64(content, pos, endian, &value->data8);
+            break;
+
+        case DW_FORM_string:
+
+            tmp = g_binary_content_get_raw_access(content, pos, 1);
+            result = (tmp != NULL);
+
+            if (result)
+            {
+                value->string = (const char *)tmp;
+
+                while (result && *tmp != '\0')
+                {
+                    tmp = g_binary_content_get_raw_access(content, pos, 1);
+                    result = (tmp != NULL);
+                }
+
+            }
+
+            break;
+
+        case DW_FORM_block:
+
+            tmpuleb = 0;    /* Pour GCC */
+
+            result = g_binary_content_read_uleb128(content, pos, &tmpuleb);
+            if (!result) break;
+
+            value->block.size = tmpuleb;
+
+ block_finish:
+
+            value->block.start = g_binary_content_get_raw_access(content, pos, value->block.size);
+
+            result = (value->block.start != NULL);
+            break;
+
+        case DW_FORM_block1:
+            result = g_binary_content_read_u8(content, pos, &tmp8);
+            if (result)
+            {
+                value->block.size = tmp8;
+                goto block_finish;
+            }
+            break;
+
+        case DW_FORM_data1:
+            result = g_binary_content_read_u8(content, pos, &value->data1);
+            break;
+
+        case DW_FORM_flag:
+            result = g_binary_content_read_u8(content, pos, &value->flag);
+            break;
+
+        case DW_FORM_sdata:
+            result = g_binary_content_read_leb128(content, pos, &value->sdata);
+            break;
+
+        case DW_FORM_strp:
+
+            /* Définition des positions */
+
+            if (cu->is_32b)
+            {
+                    result = g_binary_content_read_u32(content, pos, endian, &tmp32);
+                    offset = tmp32;
+            }
+            else
+            {
+                result = g_binary_content_read_u64(content, pos, endian, &tmp64);
+                offset = tmp64;
+            }
+
+            /* Lecture dans la section adaptée */
+
+            if (result)
+                result = g_exe_format_get_section_range_by_name(exe, ".debug_str", &range);
+
+            if (result)
+            {
+                copy_vmpa(&iter, get_mrange_addr(&range));
+                advance_vmpa(&iter, offset);
+
+                tmp = g_binary_content_get_raw_access(content, &iter, 1);
+                result = (tmp != NULL);
+
+                if (result)
+                {
+                    value->string = (const char *)tmp;
+
+                    while (result && *tmp != '\0')
+                    {
+                        tmp = g_binary_content_get_raw_access(content, &iter, 1);
+                        result = (tmp != NULL);
+                    }
+
+                }
+
+            }
+
+            break;
+
+        case DW_FORM_udata:
+            result = g_binary_content_read_uleb128(content, pos, &value->udata);
+            break;
+
+
+
+
+
+
+
+
+
+
+
+        case DW_FORM_ref1:
+            result = g_binary_content_read_u8(content, pos, &value->ref1);
+            break;
+
+        case DW_FORM_ref2:
+            result = g_binary_content_read_u16(content, pos, endian, &value->ref2);
+            break;
+
+        case DW_FORM_ref4:
+            result = g_binary_content_read_u32(content, pos, endian, &value->ref4);
+            break;
+
+        case DW_FORM_ref8:
+            result = g_binary_content_read_u64(content, pos, endian, &value->ref8);
+            break;
+
+        case DW_FORM_ref_udata:
+            result = g_binary_content_read_uleb128(content, pos, &value->ref_udata);
+            break;
+
+
+
+
+
+
+
+
+
+
+        default:
+            result = false;
+            break;
+
+    }
+
+    return result;
+
+}
diff --git a/src/format/dwarf/v2/form.h b/src/format/dwarf/v2/form.h
new file mode 100644
index 0000000..f88001b
--- /dev/null
+++ b/src/format/dwarf/v2/form.h
@@ -0,0 +1,39 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * form.h - prototypes pour le chargement en mémoire des valeurs d'attributs
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_DWARF_V2_FORM_H
+#define _FORMAT_DWARF_V2_FORM_H
+
+
+#include "../dwarf.h"
+#include "../dwarf_def.h"
+#include "../../../analysis/content.h"
+
+
+
+/* Lit la valeur correspondant à un type donné. */
+bool read_dwarf_v2_form_value(const GDwarfFormat *, const dw_compil_unit_header *, DwarfForm, vmpa2t *, dw_v2_form_value *);
+
+
+
+#endif  /* _FORMAT_DWARF_V2_FORM_H */
diff --git a/src/format/dwarf/v4/Makefile.am b/src/format/dwarf/v4/Makefile.am
index fb3bc43..b0c9719 100644
--- a/src/format/dwarf/v4/Makefile.am
+++ b/src/format/dwarf/v4/Makefile.am
@@ -2,7 +2,8 @@
 noinst_LTLIBRARIES = libformatdwarfv4.la
 
 libformatdwarfv4_la_SOURCES =			\
-	dwarf.h dwarf.c
+	dwarf.h dwarf.c						\
+	form.h form.c
 
 libformatdwarfv4_la_LDFLAGS = $(LIBGTK_LIBS)
 
diff --git a/src/format/dwarf/v4/dwarf.c b/src/format/dwarf/v4/dwarf.c
index 164d321..52345e8 100644
--- a/src/format/dwarf/v4/dwarf.c
+++ b/src/format/dwarf/v4/dwarf.c
@@ -27,6 +27,9 @@
 #include "../dwarf-int.h"
 
 
+#include "form.h"
+
+
 
 /* Format de débogage DWARF v4 (instance) */
 struct _GDwarfV4Format
@@ -76,12 +79,17 @@ G_DEFINE_TYPE(GDwarfV4Format, g_dwarfv4_format, G_TYPE_DWARF_FORMAT);
 static void g_dwarfv4_format_class_init(GDwarfV4FormatClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
+    GDwarfFormatClass *dwarf;               /* Version parente de la classe*/
 
     object = G_OBJECT_CLASS(klass);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_dwarfv4_format_dispose;
     object->finalize = (GObjectFinalizeFunc)g_dwarfv4_format_finalize;
 
+    dwarf = G_DWARF_FORMAT_CLASS(klass);
+
+    dwarf->read_form = (read_form_value_fc)read_dwarf_v4_form_value;
+
 }
 
 
@@ -160,11 +168,13 @@ GBinFormat *g_dwarfv4_format_new(GBinContent *content, GExeFormat *parent)
 
     result = g_object_new(G_TYPE_DWARFV4_FORMAT, NULL);
 
-
-
     g_binary_format_set_content(G_BIN_FORMAT(result), content);
 
-
+    if (!g_dwarf_format_load(G_DWARF_FORMAT(result), parent))
+    {
+        g_object_unref(G_OBJECT(result));
+        result = NULL;
+    }
 
     return G_BIN_FORMAT(result);
 
diff --git a/src/format/dwarf/v4/form.c b/src/format/dwarf/v4/form.c
new file mode 100644
index 0000000..fffc0c3
--- /dev/null
+++ b/src/format/dwarf/v4/form.c
@@ -0,0 +1,106 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * form.c - chargement en mémoire des valeurs d'attributs
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "form.h"
+
+
+#include "../dwarf-int.h"
+#include "../v2/form.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = contenu binaire de débogage à parcourir.            *
+*                cu     = unité de compilation parente.                       *
+*                form   = nature de la valeur à lire.                         *
+*                pos    = tête de lecture au sein des données. [OUT]          *
+*                value  = valeur au format donné lue. [OUT]                   *
+*                                                                             *
+*  Description : Lit la valeur correspondant à un type donné.                 *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dwarf_v4_form_value(const GDwarfFormat *format, const dw_compil_unit_header *cu, DwarfForm form, vmpa2t *pos, dw_v4_form_value *value)
+{
+    bool result;                            /* Bilan de lecture à renvoyer */
+    GBinContent *content;                   /* Contenu binaire à parcourir */
+    SourceEndian endian;                    /* Boutisme des enregistrements*/
+    uint32_t tmp32;                         /* Données sur 32 bits         */
+    uint64_t tmp64;                         /* Données sur 64 bits         */
+    uleb128_t tmpuleb;                      /* Données sur xxx bits        */
+
+    content = G_BIN_FORMAT(format)->content;
+    endian = g_binary_format_get_endianness(G_BIN_FORMAT(format));
+
+    switch (form)
+    {
+        case DW_FORM_sec_offset:
+
+            if (cu->is_32b)
+            {
+                    result = g_binary_content_read_u32(content, pos, endian, &tmp32);
+                    tmp64 = tmp32;
+            }
+            else
+                result = g_binary_content_read_u64(content, pos, endian, &tmp64);
+
+            value->sec_offset = tmp64;
+            break;
+
+        case DW_FORM_exprloc:
+
+            tmpuleb = 0;    /* Pour GCC */
+
+            result = g_binary_content_read_uleb128(content, pos, &tmpuleb);
+            if (!result) break;
+
+            value->expr.size = tmpuleb;
+
+            value->expr.start = g_binary_content_get_raw_access(content, pos, value->expr.size);
+            result = (value->expr.start != NULL);
+
+            break;
+
+        case DW_FORM_flag_present:
+            result = true;
+            value->has_flag = true;
+            break;
+
+        case DW_FORM_ref_sig8:
+            result = g_binary_content_read_u64(content, pos, endian, &value->signature);
+            break;
+
+        default:
+            result = read_dwarf_v2_form_value(format, cu, form, pos, &value->v2);
+            break;
+
+    }
+
+    return result;
+
+}
diff --git a/src/format/dwarf/v4/form.h b/src/format/dwarf/v4/form.h
new file mode 100644
index 0000000..ac36142
--- /dev/null
+++ b/src/format/dwarf/v4/form.h
@@ -0,0 +1,39 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * form.h - prototypes pour le chargement en mémoire des valeurs d'attributs
+ *
+ * Copyright (C) 2015 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_DWARF_V4_FORM_H
+#define _FORMAT_DWARF_V4_FORM_H
+
+
+#include "../dwarf.h"
+#include "../dwarf_def.h"
+#include "../../../analysis/content.h"
+
+
+
+/* Lit la valeur correspondant à un type donné. */
+bool read_dwarf_v4_form_value(const GDwarfFormat *, const dw_compil_unit_header *, DwarfForm, vmpa2t *, dw_v4_form_value *);
+
+
+
+#endif  /* _FORMAT_DWARF_V4_FORM_H */
diff --git a/src/format/elf/elf.c b/src/format/elf/elf.c
index 4bc8bbf..0c7760c 100644
--- a/src/format/elf/elf.c
+++ b/src/format/elf/elf.c
@@ -62,6 +62,9 @@ static void g_elf_format_dispose(GElfFormat *);
 /* Procède à la libération totale de la mémoire. */
 static void g_elf_format_finalize(GElfFormat *);
 
+/* Informe quant au boutisme utilisé. */
+static SourceEndian g_elf_format_get_endianness(const GElfFormat *);
+
 /* Indique le type d'architecture visée par le format. */
 static const char *g_elf_format_get_target_machine(const GElfFormat *);
 
@@ -142,6 +145,7 @@ G_DEFINE_TYPE(GElfFormat, g_elf_format, G_TYPE_EXE_FORMAT);
 static void g_elf_format_class_init(GElfFormatClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
+    GBinFormatClass *fmt;                   /* Version en format basique   */
     GExeFormatClass *exe;                   /* Version en exécutable       */
 
     object = G_OBJECT_CLASS(klass);
@@ -149,6 +153,10 @@ static void g_elf_format_class_init(GElfFormatClass *klass)
     object->dispose = (GObjectFinalizeFunc/* ! */)g_elf_format_dispose;
     object->finalize = (GObjectFinalizeFunc)g_elf_format_finalize;
 
+    fmt = G_BIN_FORMAT_CLASS(klass);
+
+    fmt->get_endian = (format_get_endian_fc)g_elf_format_get_endianness;
+
     exe = G_EXE_FORMAT_CLASS(klass);
 
     exe->get_machine = (get_target_machine_fc)g_elf_format_get_target_machine;
@@ -311,6 +319,25 @@ GBinFormat *g_elf_format_new(GBinContent *content, GExeFormat *parent)
 *                                                                             *
 *  Paramètres  : format = informations chargées à consulter.                  *
 *                                                                             *
+*  Description : Informe quant au boutisme utilisé.                           *
+*                                                                             *
+*  Retour      : Indicateur de boutisme.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static SourceEndian g_elf_format_get_endianness(const GElfFormat *format)
+{
+    return format->endian;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                                                                             *
 *  Description : Indique le type d'architecture visée par le format.          *
 *                                                                             *
 *  Retour      : Identifiant de l'architecture ciblée par le format.          *
@@ -703,22 +730,3 @@ const elf_header *g_elf_format_get_header(const GElfFormat *format)
     return &format->header;
 
 }
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : format = informations chargées à consulter.                  *
-*                                                                             *
-*  Description : Informe quant au boutisme utilisé.                           *
-*                                                                             *
-*  Retour      : Indicateur de boutisme.                                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-SourceEndian g_elf_format_get_endianness(const GElfFormat *format)
-{
-    return format->endian;
-
-}
diff --git a/src/format/elf/elf.h b/src/format/elf/elf.h
index a557927..d6f631e 100644
--- a/src/format/elf/elf.h
+++ b/src/format/elf/elf.h
@@ -61,9 +61,6 @@ GBinFormat *g_elf_format_new(GBinContent *, GExeFormat *);
 /* Présente l'en-tête ELF du format chargé. */
 const elf_header *g_elf_format_get_header(const GElfFormat *);
 
-/* Informe quant au boutisme utilisé. */
-SourceEndian g_elf_format_get_endianness(const GElfFormat *);
-
 
 
 #endif  /* _FORMAT_ELF_ELF_H */
diff --git a/src/format/format-int.h b/src/format/format-int.h
index 84f77c4..90b278e 100644
--- a/src/format/format-int.h
+++ b/src/format/format-int.h
@@ -32,6 +32,9 @@
 /* ------------------------ TRAITEMENT INDIVIDUEL DE FORMATS ------------------------ */
 
 
+/* Indique le boutisme employé par le format binaire analysé. */
+typedef SourceEndian (* format_get_endian_fc) (const GBinFormat *);
+
 /* Procède à la décompilation complète du format. */
 typedef void (* format_decompile_fc) (const GBinFormat *, GCodeBuffer *, const char *);
 
@@ -75,6 +78,8 @@ struct _GBinFormatClass
 {
     GObjectClass parent;                    /* A laisser en premier        */
 
+    format_get_endian_fc get_endian;        /* Boutisme employé            */
+
 };
 
 
diff --git a/src/format/format.c b/src/format/format.c
index 387894c..88f59b8 100644
--- a/src/format/format.c
+++ b/src/format/format.c
@@ -149,6 +149,10 @@ bool g_binary_format_complete_loading(GBinFormat *format)
 
 void g_binary_format_set_content(GBinFormat *format, GBinContent *content)
 {
+    assert(format->content == NULL);
+
+    g_object_ref(G_OBJECT(content));
+
     format->content = content;
 
 }
@@ -177,6 +181,25 @@ GBinContent *g_binary_format_get_content(const GBinFormat *format)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                                                                             *
+*  Description : Indique le boutisme employé par le format binaire analysé.   *
+*                                                                             *
+*  Retour      : Boutisme associé au format.                                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+SourceEndian g_binary_format_get_endianness(const GBinFormat *format)
+{
+    return G_BIN_FORMAT_GET_CLASS(format)->get_endian(format);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : format = description de l'exécutable à compléter.            *
 *                pt     = point de l'espace mémoire à considérer.             *
 *                entry  = nature du point fourni.                             *
diff --git a/src/format/format.h b/src/format/format.h
index b1f0110..4a56d47 100644
--- a/src/format/format.h
+++ b/src/format/format.h
@@ -40,7 +40,8 @@
 #define G_TYPE_BIN_FORMAT               g_binary_format_get_type()
 #define G_BIN_FORMAT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_binary_format_get_type(), GBinFormat))
 #define G_IS_BIN_FORMAT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_binary_format_get_type()))
-#define G_BIN_FORMAT_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_binary_format_get_type(), GBinFormatIface))
+#define G_BIN_FORMAT_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BIN_FORMAT, GBinFormatClass))
+#define G_IS_BIN_FORMAT_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BIN_FORMAT))
 #define G_BIN_FORMAT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BIN_FORMAT, GBinFormatClass))
 
 
@@ -57,6 +58,9 @@ GType g_binary_format_get_type(void);
 /* Fournit une référence vers le contenu binaire analysé. */
 GBinContent *g_binary_format_get_content(const GBinFormat *);
 
+/* Indique le boutisme employé par le format binaire analysé. */
+SourceEndian g_binary_format_get_endianness(const GBinFormat *);
+
 /* Enregistre une adresse comme début d'une zone de code. */
 void g_binary_format_register_code_point(GBinFormat *, virt_t, bool);