Looked for prototyped functions using the registered abbreviations.

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

1 files changed, 223 insertions, 0 deletions

diff --git a/src/format/dwarf/utils.c b/src/format/dwarf/utils.c
index b5dbf6b..fa8ef20 100644
--- a/src/format/dwarf/utils.c
+++ b/src/format/dwarf/utils.c
@@ -24,6 +24,9 @@
 #include "utils.h"
 
 
+#include <string.h>
+
+
 #include "dwarf-int.h"
 
 
@@ -47,6 +50,7 @@ bool read_leb128(dwarf_format *format, off_t *pos, int64_t *value)
     int shift;                              /* Décallage à appliquer       */
     off_t i;                                /* Boucle de parcours          */
 
+    shift = 0;
     *value = 0;
 
     for (i = 0; i < 8; i++)
@@ -69,3 +73,222 @@ bool read_leb128(dwarf_format *format, off_t *pos, int64_t *value)
     return (i < 8);
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  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 non signée.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_uleb128(dwarf_format *format, off_t *pos, uint64_t *value)
+{
+    int shift;                              /* Décallage à appliquer       */
+    off_t i;                                /* Boucle de parcours          */
+
+    shift = 0;
+    *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;
+
+    }
+
+    return (i < 8);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à consulter.               *
+*                pos    = tête de lecture à mettre à jour. [OUT]              *
+*                value  = valeur entière lue. [OUT]                           *
+*                                                                             *
+*  Description : Lit une valeur représentant une longueur d'unité.            *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : Un peu sale : la sortie est signée et dépend du système,     *
+*                alors que la valeur est non signée et dépend de la cible.    *
+*                                                                             *
+******************************************************************************/
+
+bool read_unit_length(dwarf_format *format, off_t *pos, off_t *value)
+{
+    bool result;                            /* Bilan à retourner           */
+    uint32_t val32;                         /* Entier sur 4 octets         */
+    uint64_t val64;                         /* Entier sur 8 octets         */
+
+    /* FIXME : Endian... */
+
+    if (format->format == DWF_32_BITS)
+    {
+        result = ((*pos + 4) <= DBG_FORMAT(format)->length);
+
+        if (result)
+        {
+            memcpy(&val32, &DBG_FORMAT(format)->content[*pos], 4);
+            (*pos) += 4;
+
+            *value = val32;
+
+        }
+
+    }
+    else
+    {
+        result = ((*pos + 4 + 8) <= DBG_FORMAT(format)->length);
+
+        if (result)
+        {
+            memcpy(&val64, &DBG_FORMAT(format)->content[*pos + 4], 8);
+            (*pos) += 4 + 8;
+
+            *value = val64;
+
+        }
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à consulter.               *
+*                pos    = tête de lecture à mettre à jour. [OUT]              *
+*                value  = valeur entière non signée lue. [OUT]                *
+*                                                                             *
+*  Description : Lit une valeur non signée sur deux octets.                   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_uhalf(dwarf_format *format, off_t *pos, uint16_t *value)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    /* FIXME : Endian... */
+
+    result = ((*pos + 2) <= DBG_FORMAT(format)->length);
+
+    if (result)
+    {
+        memcpy(value, &DBG_FORMAT(format)->content[*pos], 2);
+        (*pos) += 2;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à consulter.               *
+*                pos    = tête de lecture à mettre à jour. [OUT]              *
+*                value  = valeur entière lue. [OUT]                           *
+*                                                                             *
+*  Description : Lit une valeur indiquant une position dans les abréviations. *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : Un peu sale : la sortie est signée et dépend du système,     *
+*                alors que la valeur est non signée et dépend de la cible.    *
+*                                                                             *
+******************************************************************************/
+
+bool read_abbrev_offset(dwarf_format *format, off_t *pos, off_t *value)
+{
+    bool result;                            /* Bilan à retourner           */
+    uint32_t val32;                         /* Entier sur 4 octets         */
+    uint64_t val64;                         /* Entier sur 8 octets         */
+
+    /* FIXME : Endian... */
+
+    if (format->format == DWF_32_BITS)
+    {
+        result = ((*pos + 4) <= DBG_FORMAT(format)->length);
+
+        if (result)
+        {
+            memcpy(&val32, &DBG_FORMAT(format)->content[*pos], 4);
+            (*pos) += 4;
+
+            *value = val32;
+
+        }
+
+    }
+    else
+    {
+        result = ((*pos + 8) <= DBG_FORMAT(format)->length);
+
+        if (result)
+        {
+            memcpy(&val64, &DBG_FORMAT(format)->content[*pos], 8);
+            (*pos) += 8;
+
+            *value = val64;
+
+        }
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations de débogage à consulter.               *
+*                pos    = tête de lecture à mettre à jour. [OUT]              *
+*                value  = valeur entière non signée lue. [OUT]                *
+*                                                                             *
+*  Description : Lit une valeur indiquant la taille des adresses mémoire.     *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_address_size(dwarf_format *format, off_t *pos, uint8_t *value)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = ((*pos + 1) <= DBG_FORMAT(format)->length);
+
+    if (result)
+    {
+        *value = DBG_FORMAT(format)->content[*pos];
+        (*pos)++;
+    }
+
+    return result;
+
+}