Read all the DWARF abbreviations.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@16 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

7 files changed, 724 insertions, 4 deletions

diff --git a/src/format/dwarf/Makefile.am b/src/format/dwarf/Makefile.am
index d9a3ca6..6103ac2 100644
--- a/src/format/dwarf/Makefile.am
+++ b/src/format/dwarf/Makefile.am
@@ -3,7 +3,9 @@ lib_LIBRARIES = libformatdwarf.a
 
 libformatdwarf_a_SOURCES =				\
 	abbrev.h abbrev.c					\
-	d_dwarf.h d_dwarf.c
+	d_dwarf.h d_dwarf.c					\
+	dwarf_def.h							\
+	utils.h utils.c
 
 libformatdwarf_a_CFLAGS = $(AM_CFLAGS)
 
diff --git a/src/format/dwarf/abbrev.c b/src/format/dwarf/abbrev.c
index 8cf5dcd..6eada92 100644
--- a/src/format/dwarf/abbrev.c
+++ b/src/format/dwarf/abbrev.c
@@ -28,12 +28,20 @@
 
 
 #include "dwarf-int.h"
+#include "utils.h"
 
 
 
+#include <ctype.h>
 
 
 
+/* Libère de la mémoire une abréviation DWARF. */
+void free_dwarf_abbrev(dw_abbrev *);
+
+/* Charge une abréviations DWARF. */
+dw_abbrev *read_dwarf_abbreviations(dwarf_format *, off_t *, int64_t *);
+
 
 
 /******************************************************************************
@@ -50,34 +58,50 @@
 
 bool load_dwarf_abbreviations(dwarf_format *format)
 {
-
+    bool result;                            /* Bilan à renvoyer            */
 
 
 
 
     off_t offset;
+    off_t start;
     off_t size;
 
     bool test;
 
     int i;
+    int j;
 
 
+    dw_abbrev *abbrev;
+    int64_t index;
+
     printf("Searching...\n");
 
 
-    test = find_exe_section(DBG_FORMAT(format)->e_format, ".debug_abbrev", &offset, &size, NULL);
+    result = true;
 
+    test = find_exe_section(DBG_FORMAT(format)->e_format, ".debug_abbrev", &start, &size, NULL);
 
+    offset = start;
 
 
     printf(" -> offset=%d   size=%d\n", offset, size);
 
 
+
     for (i = 0; i < size; i++)
     {
         if (i % 10 == 0) printf("\n");
         printf("0x%02hhx ", DBG_FORMAT(format)->content[offset + i]);
+
+        if ((i + 1) % 10 == 0)
+        {
+            printf("\t\t");
+            for (j = 0; j < 10; j++)
+                printf("%c", (isprint(DBG_FORMAT(format)->content[offset + i]) ? DBG_FORMAT(format)->content[offset + i] : '.'));
+        }
+
     }
 
     printf("\n");
@@ -85,9 +109,158 @@ bool load_dwarf_abbreviations(dwarf_format *format)
 
 
 
+    while (offset < (start + size))
+    {
+        abbrev = read_dwarf_abbreviations(format, &offset, &index);
+
+        offset++;   /* 0x00 */
+
+        printf("abbrev :: %p\n", abbrev);
+
+        if (abbrev != NULL)
+        {
+            format->abbrevs = (dw_abbrev **)realloc(format->abbrevs, ++format->abbrevs_count * sizeof(dw_abbrev *));
+            format->abbrevs[format->abbrevs_count - 1] = abbrev;
+
+            printf(" %d attribs, %d children\n", abbrev->attribs_count, abbrev->children_count);
+
+        }
+        else
+        {
+            unload_dwarf_abbreviations(format);
+            result = false;
+            break;
+        }
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à effacer.                 *
+*                                                                             *
+*  Description : Décharge les abréviations trouvés pour un DWARF.             *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void unload_dwarf_abbreviations(dwarf_format *format)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < format->abbrevs_count; i++)
+        free_dwarf_abbrev(format->abbrevs[i]);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : abbrev = élément à supprimer de la mémoire.                  *
+*                                                                             *
+*  Description : Libère de la mémoire une abréviation DWARF.                  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void free_dwarf_abbrev(dw_abbrev *abbrev)
+{
+    size_t i;                               /* Boucle de parcours          */
 
+    for (i = 0; i < abbrev->children_count; i++)
+        free_dwarf_abbrev(abbrev->children[i]);
 
+    free(abbrev->attribs);
+    free(abbrev->children);
 
+    free(abbrev);
 
 }
 
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à compléter.               *
+*                pos    = tête de lecture à mettre à jour. [OUT]              *
+*                index  = code de l'abréviation. [OUT]                        *
+*                                                                             *
+*  Description : Charge une abréviations DWARF.                               *
+*                                                                             *
+*  Retour      : Adresse d'une abréviation ou NULL en cas d'échec.            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+dw_abbrev *read_dwarf_abbreviations(dwarf_format *format, off_t *pos, int64_t *index)
+{
+    dw_abbrev *result;                      /* Abréviation à retourner     */
+    bool has_children;                      /* Indique la présence de fils */
+    int64_t value1;                         /* Valeur quelconque lue #1    */
+    int64_t value2;                         /* Valeur quelconque lue #2    */
+    int64_t sub_index;                      /* Indice d'un sous-élément    */
+    dw_abbrev *child;                       /* Sous-élément à intégrer     */
+
+    /* Code de l'élément */
+    if (!read_leb128(format, pos, index)) return NULL;
+
+    result = (dw_abbrev *)calloc(1, sizeof(dw_abbrev));
+
+    if (!read_leb128(format, pos, &value1)) goto rda_error;
+    result->tag = value1;
+
+    if (*pos >= DBG_FORMAT(format)->length) goto rda_error;
+    has_children = (DBG_FORMAT(format)->content[(*pos)++] == DW_CHILDREN_YES);
+
+    /* Liste des attributs */
+
+    while (DBG_FORMAT(format)->content[*pos] != 0x00)
+    {
+        if (!read_leb128(format, pos, &value1)) goto rda_error;
+        if (!read_leb128(format, pos, &value2)) goto rda_error;
+
+        result->attribs = (dw_abbrev_attr *)realloc(result->attribs, ++result->attribs_count * sizeof(dw_abbrev_attr));
+
+        result->attribs[result->attribs_count - 1].attrib = value1;
+        result->attribs[result->attribs_count - 1].form = value2;
+
+    }
+
+    (*pos) += 2;    /* 0x00 0x00 */
+
+    /* Chargement des sous-éléments */
+
+    if (has_children)
+        while (DBG_FORMAT(format)->content[*pos] != 0x00)
+        {
+            child = read_dwarf_abbreviations(format, pos, &sub_index);
+
+            if (child == NULL) goto rda_error;
+
+            //if ((sub_index - *index - 1) != result->children_count) goto rda_error;
+
+            result->children = (dw_abbrev **)realloc(result->children, ++result->children_count * sizeof(dw_abbrev *));
+
+            result->children[result->children_count - 1] = child;
+
+        }
+
+    return result;
+
+ rda_error:
+
+    free_dwarf_abbrev(result);
+
+    return NULL;
+
+}
diff --git a/src/format/dwarf/abbrev.h b/src/format/dwarf/abbrev.h
index a949be9..f375abc 100644
--- a/src/format/dwarf/abbrev.h
+++ b/src/format/dwarf/abbrev.h
@@ -35,6 +35,8 @@
 /* Charge les abréviations trouvés pour un DWARF. */
 bool load_dwarf_abbreviations(dwarf_format *);
 
+/* Décharge les abréviations trouvés pour un DWARF. */
+void unload_dwarf_abbreviations(dwarf_format *);
 
 
 
diff --git a/src/format/dwarf/dwarf-int.h b/src/format/dwarf/dwarf-int.h
index e3bb212..371d193 100644
--- a/src/format/dwarf/dwarf-int.h
+++ b/src/format/dwarf/dwarf-int.h
@@ -29,6 +29,34 @@
 
 #include "../dbg_format-int.h"
 
+#include "dwarf_def.h"
+
+
+
+
+/* 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
+{
+    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;
+
+
 
 
 /* Description du format DWARF */
@@ -36,7 +64,8 @@ struct _dwarf_format
 {
     dbg_format dummy;                       /* A laisser en premier        */
 
-
+    dw_abbrev **abbrevs;                    /* Liste des abréviations      */
+    size_t abbrevs_count;                   /* Nombre de ces abréviations  */
 
 };
 
diff --git a/src/format/dwarf/dwarf_def.h b/src/format/dwarf/dwarf_def.h
new file mode 100644
index 0000000..56731b0
--- /dev/null
+++ b/src/format/dwarf/dwarf_def.h
@@ -0,0 +1,403 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dwarf_def.h - liste des constantes utilisées par le format DWARF
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_DWARF_DWARF_DEF_H
+#define _FORMAT_DWARF_DWARF_DEF_H
+
+
+
+/* Liste des balises rencontrées */
+typedef enum _DwarfTag
+{
+    DWT_NONE                        = 0x00,
+
+    DWT_ARRAY_TYPE                  = 0x01,
+    DWT_CLASS_TYPE                  = 0x02,
+    DWT_ENTRY_POINT                 = 0x03,
+    DWT_ENUMERATION_TYPE            = 0x04,
+    DWT_FORMAL_PARAMETER            = 0x05,
+    DWT_IMPORTED_DECLARATION        = 0x08,
+    DWT_LABEL                       = 0x0a,
+    DWT_LEXICAL_BLOCK               = 0x0b,
+    DWT_MEMBER                      = 0x0d,
+    DWT_POINTER_TYPE                = 0x0f,
+    DWT_REFERENCE_TYPE              = 0x10,
+    DWT_COMPILE_UNIT                = 0x11,
+    DWT_STRING_TYPE                 = 0x12,
+    DWT_STRUCTURE_TYPE              = 0x13,
+    DWT_SUBROUTINE_TYPE             = 0x15,
+    DWT_TYPEDEF                     = 0x16,
+    DWT_UNION_TYPE                  = 0x17,
+    DWT_UNSPECIFIED_PARAMETERS      = 0x18,
+    DWT_VARIANT                     = 0x19,
+    DWT_COMMON_BLOCK                = 0x1a,
+    DWT_COMMON_INCLUSION            = 0x1b,
+    DWT_INHERITANCE                 = 0x1c,
+    DWT_INLINED_SUBROUTINE          = 0x1d,
+    DWT_MODULE                      = 0x1e,
+    DWT_PTR_TO_MEMBER_TYPE          = 0x1f,
+    DWT_SET_TYPE                    = 0x20,
+    DWT_SUBRANGE_TYPE               = 0x21,
+    DWT_WITH_STMT                   = 0x22,
+    DWT_ACCESS_DECLARATION          = 0x23,
+    DWT_BASE_TYPE                   = 0x24,
+    DWT_CATCH_BLOCK                 = 0x25,
+    DWT_CONST_TYPE                  = 0x26,
+    DWT_CONSTANT                    = 0x27,
+    DWT_ENUMERATOR                  = 0x28,
+    DWT_FILE_TYPE                   = 0x29,
+    DWT_FRIEND                      = 0x2a,
+    DWT_NAMELIST                    = 0x2b,
+
+    DWT_NAMELIST_ITEM               = 0x2c,
+    DWT_PACKED_TYPE                 = 0x2d,
+    DWT_SUBPROGRAM                  = 0x2e,
+
+    DWT_TEMPLATE_TYPE_PARAM         = 0x2f,     /* DWARF2 */
+    DWT_TEMPLATE_TYPE_PARAMETER     = 0x2f,     /* DWARF3 */
+    DWT_TEMPLATE_VALUE_PARAM        = 0x30,     /* DWARF2 */
+    DWT_TEMPLATE_VALUE_PARAMETER    = 0x30,     /* DWARF3 */
+    DWT_THROWN_TYPE                 = 0x31,
+    DWT_TRY_BLOCK                   = 0x32,
+    DWT_VARIANT_PART                = 0x33,
+    DWT_VARIABLE                    = 0x34,
+    DWT_VOLATILE_TYPE               = 0x35,
+    DWT_DWARF_PROCEDURE             = 0x36,     /* DWARF3 */
+    DWT_RESTRICT_TYPE               = 0x37,     /* DWARF3 */
+    DWT_INTERFACE_TYPE              = 0x38,     /* DWARF3 */
+    DWT_NAMESPACE                   = 0x39,     /* DWARF3 */
+    DWT_IMPORTED_MODULE             = 0x3a,     /* DWARF3 */
+    DWT_UNSPECIFIED_TYPE            = 0x3b,     /* DWARF3 */
+    DWT_PARTIAL_UNIT                = 0x3c,     /* DWARF3 */
+    DWT_IMPORTED_UNIT               = 0x3d,     /* DWARF3 */
+
+    DWT_MUTABLE_TYPE                = 0x3e,     /* Oublié en faveur des deux suivantes (DWARF3 -> DWARF3f) */
+    DWT_CONDITION                   = 0x3f,     /* DWARF3f */
+    DWT_SHARED_TYPE                 = 0x40,     /* DWARF3f */
+
+    DWT_LO_USER                     = 0x4080,
+
+    DWT_MIPS_LOOP                   = 0x4081,
+
+    /* Extensions HP */
+
+    DWT_HP_ARRAY_DESCRIPTOR         = 0x4090,
+
+    /* Extensions GNU */
+
+    DWT_GNU_FORMAT_LABEL            = 0x4101,   /* Fortran. */
+    DWT_GNU_FUNCTION_TEMPLATE       = 0x4102,   /* C++ */
+    DWT_GNU_CLASS_TEMPLATE          = 0x4103,   /* C++ */
+    DWT_GNU_BINCL                   = 0x4104,
+    DWT_GNU_EINCL                   = 0x4105,
+
+    /* Extensions ALTIUM */
+
+    DWT_ALTIUM_CIRC_TYPE            = 0x5101,   /* DSP-C/Starcore __circ qualifier */
+    DWT_ALTIUM_MWA_CIRC_TYPE        = 0x5102,   /* Starcore __mwa_circ qualifier */        
+    DWT_ALTIUM_REV_CARRY_TYPE       = 0x5103,   /* Starcore __rev_carry qualifier */
+    DWT_ALTIUM_ROM                  = 0x5111,   /* M16 __rom qualifier */
+
+    /* Extensions pour le support UPC */
+
+    DWT_UPC_SHARED_TYPE             = 0x8765,
+    DWT_UPC_STRICT_TYPE             = 0x8766,
+    DWT_UPC_RELAXED_TYPE            = 0x8767,
+
+    /* Extensions PGI (STMicroelectronics) */
+
+    DWT_PGI_KANJI_TYPE              = 0xa000,
+    DWT_PGI_INTERFACE_BLOCK         = 0xa020,
+
+    /* Extensions SUN */
+
+    DWT_SUN_FUNCTION_TEMPLATE       = 0x4201,
+    DWT_SUN_CLASS_TEMPLATE          = 0x4202,
+    DWT_SUN_STRUCT_TEMPLATE         = 0x4203,
+    DWT_SUN_UNION_TEMPLATE          = 0x4204,
+    DWT_SUN_INDIRECT_INHERITANCE    = 0x4205,
+    DWT_SUN_CODEFLAGS               = 0x4206,
+    DWT_SUN_MEMOP_INFO              = 0x4207,
+    DWT_SUN_OMP_CHILD_FUNC          = 0x4208,
+    DWT_SUN_RTTI_DESCRIPTOR         = 0x4209,
+    DWT_SUN_DTOR_INFO               = 0x420a,
+    DWT_SUN_DTOR                    = 0x420b,
+    DWT_SUN_F90_INTERFACE           = 0x420c,
+    DWT_SUN_FORTRAN_VAX_STRUCTURE   = 0x420d,
+    DWT_SUN_HI                      = 0x42ff,
+
+    DWT_HI_USER                     = 0xffff
+
+} DwarfTag;
+
+
+#define DW_CHILDREN_NO  0x00
+#define DW_CHILDREN_YES 0x01
+
+
+/* Liste des attributs rencontrés */
+typedef enum _DwarfAttrib
+{
+    DWA_SIBLING                         = 0x01,
+    DWA_LOCATION                        = 0x02,
+    DWA_NAME                            = 0x03,
+    DWA_ORDERING                        = 0x09,
+    DWA_SUBSCR_DATA                     = 0x0a,
+    DWA_BYTE_SIZE                       = 0x0b,
+    DWA_BIT_OFFSET                      = 0x0c,
+    DWA_BIT_SIZE                        = 0x0d,
+    DWA_ELEMENT_LIST                    = 0x0f,
+    DWA_STMT_LIST                       = 0x10,
+    DWA_LOW_PC                          = 0x11,
+    DWA_HIGH_PC                         = 0x12,
+    DWA_LANGUAGE                        = 0x13,
+    DWA_MEMBER                          = 0x14,
+    DWA_DISCR                           = 0x15,
+    DWA_DISCR_VALUE                     = 0x16,
+    DWA_VISIBILITY                      = 0x17,
+    DWA_IMPORT                          = 0x18,
+    DWA_STRING_LENGTH                   = 0x19,
+    DWA_COMMON_REFERENCE                = 0x1a,
+    DWA_COMP_DIR                        = 0x1b,
+    DWA_CONST_VALUE                     = 0x1c,
+    DWA_CONTAINING_TYPE                 = 0x1d,
+    DWA_DEFAULT_VALUE                   = 0x1e,
+    DWA_INLINE                          = 0x20,
+    DWA_IS_OPTIONAL                     = 0x21,
+    DWA_LOWER_BOUND                     = 0x22,
+    DWA_PRODUCER                        = 0x25,
+    DWA_PROTOTYPED                      = 0x27,
+    DWA_RETURN_ADDR                     = 0x2a,
+    DWA_START_SCOPE                     = 0x2c,
+    DWA_BIT_STRIDE                      = 0x2e,     /* DWARF3 */
+    DWA_STRIDE_SIZE                     = 0x2e,     /* DWARF2 */
+    DWA_UPPER_BOUND                     = 0x2f,
+    DWA_ABSTRACT_ORIGIN                 = 0x31,
+    DWA_ACCESSIBILITY                   = 0x32,
+    DWA_ADDRESS_CLASS                   = 0x33,
+    DWA_ARTIFICIAL                      = 0x34,
+    DWA_BASE_TYPES                      = 0x35,
+    DWA_CALLING_CONVENTION              = 0x36,
+    DWA_COUNT                           = 0x37,
+    DWA_DATA_MEMBER_LOCATION            = 0x38,
+    DWA_DECL_COLUMN                     = 0x39,
+    DWA_DECL_FILE                       = 0x3a,
+    DWA_DECL_LINE                       = 0x3b,
+    DWA_DECLARATION                     = 0x3c,
+    DWA_DISCR_LIST                      = 0x3d,
+    DWA_ENCODING                        = 0x3e,
+    DWA_EXTERNAL                        = 0x3f,
+    DWA_FRAME_BASE                      = 0x40,
+    DWA_FRIEND                          = 0x41,
+    DWA_IDENTIFIER_CASE                 = 0x42,
+    DWA_MACRO_INFO                      = 0x43,
+    DWA_NAMELIST_ITEM                   = 0x44,
+    DWA_PRIORITY                        = 0x45,
+    DWA_SEGMENT                         = 0x46,
+    DWA_SPECIFICATION                   = 0x47,
+    DWA_STATIC_LINK                     = 0x48,
+    DWA_TYPE                            = 0x49,
+    DWA_USE_LOCATION                    = 0x4a,
+    DWA_VARIABLE_PARAMETER              = 0x4b,
+    DWA_VIRTUALITY                      = 0x4c,
+    DWA_VTABLE_ELEM_LOCATION            = 0x4d,
+    DWA_ALLOCATED                       = 0x4e,     /* DWARF3 */
+    DWA_ASSOCIATED                      = 0x4f,     /* DWARF3 */
+    DWA_DATA_LOCATION                   = 0x50,     /* DWARF3 */
+    DWA_BYTE_STRIDE                     = 0x51,     /* DWARF3f */
+    DWA_STRIDE                          = 0x51,     /* DWARF3 (ne pas utiliser) */
+    DWA_ENTRY_PC                        = 0x52,     /* DWARF3 */
+    DWA_USE_UTF8                        = 0x53,     /* DWARF3 */
+    DWA_EXTENSION                       = 0x54,     /* DWARF3 */
+    DWA_RANGES                          = 0x55,     /* DWARF3 */
+    DWA_TRAMPOLINE                      = 0x56,     /* DWARF3 */
+    DWA_CALL_COLUMN                     = 0x57,     /* DWARF3 */
+    DWA_CALL_FILE                       = 0x58,     /* DWARF3 */
+    DWA_CALL_LINE                       = 0x59,     /* DWARF3 */
+    DWA_DESCRIPTION                     = 0x5a,     /* DWARF3 */
+    DWA_BINARY_SCALE                    = 0x5b,     /* DWARF3f */
+    DWA_DECIMAL_SCALE                   = 0x5c,     /* DWARF3f */
+    DWA_SMALL                           = 0x5d,     /* DWARF3f */
+    DWA_DECIMAL_SIGN                    = 0x5e,     /* DWARF3f */
+    DWA_DIGIT_COUNT                     = 0x5f,     /* DWARF3f */
+    DWA_PICTURE_STRING                  = 0x60,     /* DWARF3f */
+    DWA_MUTABLE                         = 0x61,     /* DWARF3f */
+    DWA_THREADS_SCALED                  = 0x62,     /* DWARF3f */
+    DWA_EXPLICIT                        = 0x63,     /* DWARF3f */
+    DWA_OBJECT_POINTER                  = 0x64,     /* DWARF3f */
+    DWA_ENDIANITY                       = 0x65,     /* DWARF3f */
+    DWA_ELEMENTAL                       = 0x66,     /* DWARF3f */
+    DWA_PURE                            = 0x67,     /* DWARF3f */
+    DWA_RECURSIVE                       = 0x68,     /* DWARF3f */
+
+    DWA_LO_USER                         = 0x2000,
+
+    /* Extension HP */
+
+    DWA_HP_BLOCK_INDEX                  = 0x2000,
+
+    /* Extensions MIPS/SGI */
+
+    DWA_MIPS_FDE                        = 0x2001,
+    DWA_MIPS_LOOP_BEGIN                 = 0x2002,
+    DWA_MIPS_TAIL_LOOP_BEGIN            = 0x2003,
+    DWA_MIPS_EPILOG_BEGIN               = 0x2004,
+    DWA_MIPS_LOOP_UNROLL_FACTOR         = 0x2005,
+    DWA_MIPS_SOFTWARE_PIPELINE_DEPTH    = 0x2006,
+    DWA_MIPS_LINKAGE_NAME               = 0x2007,
+    DWA_MIPS_STRIDE                     = 0x2008,
+    DWA_MIPS_ABSTRACT_NAME              = 0x2009,
+    DWA_MIPS_CLONE_ORIGIN               = 0x200a,
+    DWA_MIPS_HAS_INLINES                = 0x200b,
+    DWA_MIPS_STRIDE_BYTE                = 0x200c,
+    DWA_MIPS_STRIDE_ELEM                = 0x200d,
+    DWA_MIPS_PTR_DOPETYPE               = 0x200e,
+    DWA_MIPS_ALLOCATABLE_DOPETYPE       = 0x200f,
+    DWA_MIPS_ASSUMED_SHAPE_DOPETYPE     = 0x2010,
+    DWA_MIPS_ASSUMED_SIZE               = 0x2011,
+
+    /* Extensions HP */
+
+    DWA_HP_unmodifiable                 = 0x2001,   /* conflit : MIPS */
+    DWA_HP_actuals_stmt_list            = 0x2010,   /* conflit : MIPS */
+    DWA_HP_proc_per_section             = 0x2011,   /* conflit : MIPS */
+    DWA_HP_raw_data_ptr                 = 0x2012,
+    DWA_HP_pass_by_reference            = 0x2013,
+    DWA_HP_opt_level                    = 0x2014,
+    DWA_HP_prof_version_id              = 0x2015,
+    DWA_HP_opt_flags                    = 0x2016,
+    DWA_HP_cold_region_low_pc           = 0x2017,
+    DWA_HP_cold_region_high_pc          = 0x2018,
+    DWA_HP_all_variables_modifiable     = 0x2019,
+    DWA_HP_linkage_name                 = 0x201a,
+    DWA_HP_prof_flags                   = 0x201b,
+
+    /* Extensions GNU */
+
+    DWA_GNU_SF_NAMES                    = 0x2101,
+    DWA_GNU_SRC_INFO                    = 0x2102,
+    DWA_GNU_MAC_INFO                    = 0x2103,
+    DWA_GNU_SRC_COORDS                  = 0x2104,
+    DWA_GNU_BODY_BEGIN                  = 0x2105,
+    DWA_GNU_BODY_END                    = 0x2106,
+    DWA_GNU_VECTOR                      = 0x2107,
+
+    /* Extensions SUN */
+
+    DWA_SUN_TEMPLATE                    = 0x2201,
+    DWA_SUN_RTNBEG_PD_ADDRESS           = 0x2201,
+    DWA_SUN_ALIGNMENT                   = 0x2202,
+    DWA_SUN_VTABLE                      = 0x2203,
+    DWA_SUN_COUNT_GUARANTEE             = 0x2204,
+    DWA_SUN_COMMAND_LINE                = 0x2205,
+    DWA_SUN_VBASE                       = 0x2206,
+    DWA_SUN_COMPILE_OPTIONS             = 0x2207,
+    DWA_SUN_LANGUAGE                    = 0x2208,
+    DWA_SUN_BROWSER_FILE                = 0x2209,
+    DWA_SUN_VTABLE_ABI                  = 0x2210,
+    DWA_SUN_FUNC_OFFSETS                = 0x2211,
+    DWA_SUN_CF_KIND                     = 0x2212,
+    DWA_SUN_VTABLE_INDEX                = 0x2213,
+    DWA_SUN_OMP_TPRIV_ADDR              = 0x2214,
+    DWA_SUN_OMP_CHILD_FUNC              = 0x2215,
+    DWA_SUN_FUNC_OFFSET                 = 0x2216,
+    DWA_SUN_MEMOP_TYPE_REF              = 0x2217,
+    DWA_SUN_PROFILE_ID                  = 0x2218,
+    DWA_SUN_MEMOP_SIGNATURE             = 0x2219,
+    DWA_SUN_OBJ_DIR                     = 0x2220,
+    DWA_SUN_OBJ_FILE                    = 0x2221,
+    DWA_SUN_ORIGINAL_NAME               = 0x2222,
+    DWA_SUN_HWCPROF_SIGNATURE           = 0x2223,
+    DWA_SUN_AMD64_PARMDUMP              = 0x2224,
+    DWA_SUN_PART_LINK_NAME              = 0x2225,
+    DWA_SUN_LINK_NAME                   = 0x2226,
+    DWA_SUN_PASS_WITH_CONST             = 0x2227,
+    DWA_SUN_RETURN_WITH_CONST           = 0x2228,
+    DWA_SUN_IMPORT_BY_NAME              = 0x2229,
+    DWA_SUN_F90_POINTER                 = 0x222a,
+    DWA_SUN_PASS_BY_REF                 = 0x222b,
+    DWA_SUN_F90_ALLOCATABLE             = 0x222c,
+    DWA_SUN_F90_ASSUMED_SHAPE_ARRAY     = 0x222d,
+    DWA_SUN_C_VLA                       = 0x222e,
+    DWA_SUN_RETURN_VALUE_PTR            = 0x2230,
+    DWA_SUN_DTOR_START                  = 0x2231,
+    DWA_SUN_DTOR_LENGTH                 = 0x2232,
+    DWA_SUN_DTOR_STATE_INITIAL          = 0x2233,
+    DWA_SUN_DTOR_STATE_FINAL            = 0x2234,
+    DWA_SUN_DTOR_STATE_DELTAS           = 0x2235,
+    DWA_SUN_IMPORT_BY_LNAME             = 0x2236,
+    DWA_SUN_F90_USE_ONLY                = 0x2237,
+    DWA_SUN_NAMELIST_SPEC               = 0x2238,
+    DWA_SUN_IS_OMP_CHILD_FUNC           = 0x2239,
+    DWA_SUN_FORTRAN_MAIN_ALIAS          = 0x223a,
+    DWA_SUN_FORTRAN_BASED               = 0x223b,
+
+    /* Extensions ALTIUM */
+
+    DWA_ALTIUM_LOCLIST                  = 0x2300,
+
+    /* Extensions PGI (STMicroelectronics) */
+
+    DWA_PGI_LBASE                       = 0x3a00,
+    DWA_PGI_SOFFSET                     = 0x3a01,
+    DWA_PGI_LSTRIDE                     = 0x3a02,
+
+    /* Extensions pour le support UPC */
+
+    DWA_UPC_THREADS_SCALED              = 0x3210,
+
+    DWA_HI_USER                         = 0x3fff
+
+} DwarfAttrib;
+
+
+/* Liste des types de données */
+typedef enum _DwarfForm
+{
+    DWF_ADDR        = 0x01,
+    DWF_BLOCK2      = 0x03,
+    DWF_BLOCK4      = 0x04,
+    DWF_DATA2       = 0x05,
+    DWF_DATA4       = 0x06,
+    DWF_DATA8       = 0x07,
+    DWF_STRING      = 0x08,
+    DWF_BLOCK       = 0x09,
+    DWF_BLOCK1      = 0x0a,
+    DWF_DATA1       = 0x0b,
+    DWF_FLAG        = 0x0c,
+    DWF_SDATA       = 0x0d,
+    DWF_STRP        = 0x0e,
+    DWF_UDATA       = 0x0f,
+    DWF_REF_ADDR    = 0x10,
+    DWF_REF1        = 0x11,
+    DWF_REF2        = 0x12,
+    DWF_REF4        = 0x13,
+    DWF_REF8        = 0x14,
+    DWF_REF_UDATA   = 0x15,
+    DWF_INDIRECT    = 0x16
+
+} DwarfForm;
+
+
+
+#endif  /* _FORMAT_DWARF_DWARF_DEF_H */
diff --git a/src/format/dwarf/utils.c b/src/format/dwarf/utils.c
new file mode 100644
index 0000000..b5dbf6b
--- /dev/null
+++ b/src/format/dwarf/utils.c
@@ -0,0 +1,71 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * utils.h - prototypes pour les fonctions d'aisance vis à vis du format DWARF
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "utils.h"
+
+
+#include "dwarf-int.h"
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à consulter.               *
+*                pos    = tête de lecture à mettre à jour. [OUT]              *
+*                value  = valeur au format LEB128 lue. [OUT]                  *
+*                                                                             *
+*  Description : Lit une valeur Little Endian Base 128 signée.                *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_leb128(dwarf_format *format, off_t *pos, int64_t *value)
+{
+    int shift;                              /* Décallage à appliquer       */
+    off_t i;                                /* Boucle de parcours          */
+
+    *value = 0;
+
+    for (i = 0; i < 8; i++)
+    {
+        /* On évite les débordements... */
+        if ((*pos + i) >= DBG_FORMAT(format)->length) return false;
+
+        *value |= (DBG_FORMAT(format)->content[*pos + i] & 0x7f) << shift;
+
+        shift += 7;
+        (*pos)++;
+
+        if ((DBG_FORMAT(format)->content[*pos] & 0x80) == 0x00) break;
+
+    }
+
+    if ((shift < 64) && (DBG_FORMAT(format)->content[*pos - 1] & 0x40) == 0x40)
+        *value |= - (1 << shift);
+
+    return (i < 8);
+
+}
diff --git a/src/format/dwarf/utils.h b/src/format/dwarf/utils.h
new file mode 100644
index 0000000..556e4d9
--- /dev/null
+++ b/src/format/dwarf/utils.h
@@ -0,0 +1,40 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * utils.h - prototypes pour les fonctions d'aisance vis à vis du format DWARF
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_DWARF_UTILS_H
+#define _FORMAT_DWARF_UTILS_H
+
+
+#include <stdbool.h>
+
+
+#include "d_dwarf.h"
+
+
+
+/* Lit une valeur Little Endian Base 128 signée. */
+bool read_leb128(dwarf_format *, off_t *, int64_t *);
+
+
+
+#endif  /* _FORMAT_DWARF_UTILS_H */