/* Chrysalide - Outil d'analyse de fichiers binaires
* utils.h - prototypes pour les fonctions d'aisance vis à vis du format DWARF
*
* Copyright (C) 2008-2017 Cyrille Bagard
*
* This file is part of Chrysalide.
*
* Chrysalide is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* Chrysalide is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Chrysalide. If not, see <http://www.gnu.org/licenses/>.
*/
#include "utils.h"
#include <string.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] *
* update = indique si la position est à mettre à jour. *
* *
* Description : Lit une valeur Little Endian Base 128 signée. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : En cas d'échec, la tête de lecture est indéterminée. *
* *
******************************************************************************/
bool read_leb128(dwarf_format *format, off_t *pos, int64_t *value, bool update)
{
off_t curpos; /* Tête de lecture effective */
int shift; /* Décalage à appliquer */
off_t i; /* Boucle de parcours */
curpos = *pos;
shift = 0;
*value = 0;
for (i = 0; i < 8; i++)
{
/* On évite les débordements... */
if (curpos >= DBG_FORMAT(format)->length) return false;
*value |= (DBG_FORMAT(format)->content[curpos] & 0x7f) << shift;
shift += 7;
curpos++;
if ((DBG_FORMAT(format)->content[*pos + i] & 0x80) == 0x00) break;
}
if ((shift < 64) && (DBG_FORMAT(format)->content[curpos - 1] & 0x40) == 0x40)
*value |= - (1 << shift);
if (update) *pos = curpos;
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] *
* update = indique si la position est à mettre à jour. *
* *
* Description : Lit une valeur Little Endian Base 128 non signée. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : En cas d'échec, la tête de lecture est indéterminée. *
* *
******************************************************************************/
bool read_uleb128(dwarf_format *format, off_t *pos, uint64_t *value, bool update)
{
off_t curpos; /* Tête de lecture effective */
int shift; /* Décalage à appliquer */
off_t i; /* Boucle de parcours */
curpos = *pos;
shift = 0;
*value = 0;
for (i = 0; i < 8; i++)
{
/* On évite les débordements... */
if (curpos >= DBG_FORMAT(format)->length) return false;
*value |= (DBG_FORMAT(format)->content[curpos] & 0x7f) << shift;
shift += 7;
curpos++;
if ((DBG_FORMAT(format)->content[*pos + i] & 0x80) == 0x00) break;
}
if (update) *pos = curpos;
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;
}