diff options
Diffstat (limited to 'plugins/dwarf')
38 files changed, 1993 insertions, 4817 deletions
diff --git a/plugins/dwarf/Makefile.am b/plugins/dwarf/Makefile.am index 3020643..7ef847d 100644 --- a/plugins/dwarf/Makefile.am +++ b/plugins/dwarf/Makefile.am @@ -1,38 +1,46 @@ -noinst_LTLIBRARIES = libformatdwarf.la +lib_LTLIBRARIES = libdwarf.la -libformatdwarf_la_SOURCES = \ +libdir = $(pluginslibdir) + + +libdwarf_la_SOURCES = \ abbrev.h abbrev.c \ + checks.h checks.c \ + core.h core.c \ + def.h \ die.h die.c \ - dwarf.h dwarf.c \ - dwarf-int.h dwarf-int.c \ - dwarf_def.h \ form.h form.c \ + format.h format.c \ info.h info.c \ - symbols.h symbols.c + utils.h utils.c + -# libformatdwarf_la_SOURCES = \ +# libdwarf_la_SOURCES = \ # abbrev.h abbrev.c \ +# die.h die.c \ # dwarf.h dwarf.c \ -# d_dwarf.h d_dwarf.c \ +# dwarf-int.h dwarf-int.c \ # dwarf_def.h \ +# form.h form.c \ # info.h info.c \ -# utils.h utils.c +# symbols.h symbols.c -libformatdwarf_la_LIBADD = \ - v2/libformatdwarfv2.la \ - v3/libformatdwarfv3.la \ - v4/libformatdwarfv4.la +libdwarf_la_LIBADD = \ + v2/libdwarfv2.la \ + v3/libdwarfv3.la \ + v4/libdwarfv4.la -libformatdwarf_la_LDFLAGS = $(LIBGTK_LIBS) +libdwarf_la_LDFLAGS = \ + -L$(top_srcdir)/src/.libs -lchrysacore -devdir = $(includedir)/chrysalide/$(subdir:src/%=%) +devdir = $(includedir)/chrysalide-$(subdir) -dev_HEADERS = $(libformatdwarf_la_SOURCES:%c=) +dev_HEADERS = $(libdwarf_la_SOURCES:%c=) -AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) +AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) -I$(top_srcdir)/src AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) diff --git a/plugins/dwarf/abbrev.c b/plugins/dwarf/abbrev.c index f214430..e755acf 100644 --- a/plugins/dwarf/abbrev.c +++ b/plugins/dwarf/abbrev.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * abbrev.c - manipulation des abréviation DWARF * - * Copyright (C) 2008-2017 Cyrille Bagard + * Copyright (C) 2008-2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -24,13 +24,16 @@ #include "abbrev.h" -#include <malloc.h> +#include <analysis/contents/restricted.h> -#include "dwarf-int.h" +#include "checks.h" +#include "format-int.h" +#include "utils.h" +/* ----------------------- TRAITEMENT D'ABREVIATION A L'UNITE ----------------------- */ /* Description d'un attribut d'une abréviation */ @@ -41,78 +44,59 @@ typedef struct _dw_abbrev_attr } 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 */ + bool has_children; /* Présence de sous-éléments ? */ - struct _dw_abbrev **children; /* Liste des sous-éléments */ - size_t children_count; /* Nombre de ces enfants */ + dw_abbrev_attr *attribs; /* Liste des attributs */ + size_t count; /* Nombre de ces attributs */ }; +/* Charge une abréviation valide pour un DWARF en mémoire. */ +static bool load_dwarf_abbreviation(GDwarfFormat *, const dw_compil_unit_header *, GBinContent *, vmpa2t *, dw_abbrev **); - +/* Supprime de la mémoire toute trace d'une abréviation DWARF. */ +static void free_dwarf_abbrev(dw_abbrev *); /* Procède à la conversion de base d'une abréviation DWARF. */ -static bool check_abbreviation_decl(const GDwarfFormat *, const dw_abbrev_decl *, dw_abbrev *); +static bool conv_abbrev_decl(GDwarfFormat *, const dw_compil_unit_header *, const dw_abbrev_decl *, dw_abbrev *, const vmpa2t *); /* 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 *); +static bool conv_abbrev_attrib(GDwarfFormat *, const dw_compil_unit_header *, const dw_abbrev_raw_attr *, dw_abbrev_attr *, const vmpa2t *); +/* ----------------------- TRAITEMENT D'ABREVIATIONS PAR LOTS ----------------------- */ -/****************************************************************************** -* * -* 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) +/* Brochette d'abréviations */ +struct _dw_abbrev_brotherhood { - bool result; /* Bilan à faire remonter */ - mrange_t range; /* Couverture d'une section */ - vmpa2t *pos; /* Position de tête de lecture */ + dw_abbrev **abbrevs; /* Liste des sous-éléments */ + size_t count; /* Nombre de ces éléments */ - 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; -} +/* ---------------------------------------------------------------------------------- */ +/* TRAITEMENT D'ABREVIATION A L'UNITE */ +/* ---------------------------------------------------------------------------------- */ /****************************************************************************** * * -* 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] * +* Paramètres : format = informations de débogage à consulter. * +* cu = unité de compilation parente. * +* content = contenu binaire borné à parcourir. * +* pos = tête de lecture à faire évoluer. [OUT] * +* abbrev = abréviation lue et complète, NULL si aucune. [OUT] * * * * Description : Charge une abréviation valide pour un DWARF en mémoire. * * * @@ -122,14 +106,15 @@ bool load_all_dwarf_abbreviations(GDwarfFormat *format) * * ******************************************************************************/ -bool load_dwarf_abbreviation(const GDwarfFormat *format, vmpa2t *pos, dw_abbrev **abbrev) +static bool load_dwarf_abbreviation(GDwarfFormat *format, const dw_compil_unit_header *cu, GBinContent *content, vmpa2t *pos, dw_abbrev **abbrev) { + vmpa2t old; /* Mémorisation d'une position */ + dw_abbrev *new; /* Nouvelle abréviation */ 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 */ + bool status; /* Bilan d'une lecture */ - *abbrev = NULL; + new = NULL; /** * Cette routine est la transcription du paragraphe 7.5.3 ("Abbreviations Tables"), @@ -139,77 +124,58 @@ bool load_dwarf_abbreviation(const GDwarfFormat *format, vmpa2t *pos, dw_abbrev * * 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' : + * Par 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)) + copy_vmpa(&old, pos); + + if (!read_dwarf_abbrev_decl(content, pos, &decl)) goto lda_bad_exit; if (decl.code == 0) goto lda_exit; - *abbrev = (dw_abbrev *)calloc(1, sizeof(dw_abbrev)); + new = (dw_abbrev *)calloc(1, sizeof(dw_abbrev)); - if (!check_abbreviation_decl(format, &decl, *abbrev)) + if (!conv_abbrev_decl(format, cu, &decl, new, &old)) goto lda_bad_exit; /* Chargement des attributs */ for (;;) { - status = read_dwarf_abbrev_attr(format, pos, &attr); - if (!status) goto lda_bad_exit; + copy_vmpa(&old, pos); - 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); + status = read_dwarf_abbrev_attr(content, pos, &attr); + if (!status) goto lda_bad_exit; - if (attr.name == DW_ATTR_invalid && attr.form == DW_FORM_invalid) + if (attr.name == 0 && attr.form == 0) break; - (*abbrev)->attribs_count++; - (*abbrev)->attribs = (dw_abbrev_attr *)realloc((*abbrev)->attribs, - (*abbrev)->attribs_count * sizeof(dw_abbrev_attr)); + new->count++; + new->attribs = (dw_abbrev_attr *)realloc(new->attribs, + new->count * sizeof(dw_abbrev_attr)); - status = check_abbreviation_attrib(format, &attr, - &(*abbrev)->attribs[(*abbrev)->attribs_count - 1]); + status = conv_abbrev_attrib(format, cu, &attr, &new->attribs[new->count - 1], &old); 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: + *abbrev = new; + return true; lda_bad_exit: - free_dwarf_abbreviation(*abbrev); + if (new != NULL) + free_dwarf_abbrev(new); + + *abbrev = NULL; return false; @@ -228,22 +194,11 @@ bool load_dwarf_abbreviation(const GDwarfFormat *format, vmpa2t *pos, dw_abbrev * * ******************************************************************************/ -void free_dwarf_abbreviation(dw_abbrev *abbrev) +static void free_dwarf_abbrev(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); } @@ -251,9 +206,11 @@ void free_dwarf_abbreviation(dw_abbrev *abbrev) /****************************************************************************** * * -* Paramètres : format = informations chargées à consulter. * +* Paramètres : format = informations de débogage à consulter. * +* cu = unité de compilation parente. * * decl = structure brute dont le contenu est à valider. * * abbrev = abréviation à constituer à partir du brut. [OUT] * +* pos = emplacement de l'élément à vérifier dans le binaire.* * * * Description : Procède à la conversion de base d'une abréviation DWARF. * * * @@ -263,21 +220,19 @@ void free_dwarf_abbreviation(dw_abbrev *abbrev) * * ******************************************************************************/ -static bool check_abbreviation_decl(const GDwarfFormat *format, const dw_abbrev_decl *decl, dw_abbrev *abbrev) +static bool conv_abbrev_decl(GDwarfFormat *format, const dw_compil_unit_header *cu, const dw_abbrev_decl *decl, dw_abbrev *abbrev, const vmpa2t *pos) { bool result; /* Validité à retourner */ - result = (decl->has_children == DW_CHILDREN_no - || decl->has_children == DW_CHILDREN_yes); - - - /* TODO : vérifier les bornes de 'tag' */ - + result = check_dwarf_abbrev_decl(format, decl, cu->version, pos); if (result) { abbrev->code = decl->code; abbrev->tag = decl->tag; + + abbrev->has_children = (decl->has_children == DW_CHILDREN_yes); + } return result; @@ -287,9 +242,11 @@ static bool check_abbreviation_decl(const GDwarfFormat *format, const dw_abbrev_ /****************************************************************************** * * -* Paramètres : format = informations chargées à consulter. * +* Paramètres : format = informations de débogage à consulter. * +* cu = unité de compilation parente. * * decl = structure brute dont le contenu est à valider. * * abbrev = abréviation à constituer à partir du brut. [OUT] * +* pos = emplacement de l'élément à vérifier dans le binaire.* * * * Description : Procède à la conversion d'un attribut d'abréviation DWARF. * * * @@ -299,23 +256,16 @@ static bool check_abbreviation_decl(const GDwarfFormat *format, const dw_abbrev_ * * ******************************************************************************/ -static bool check_abbreviation_attrib(const GDwarfFormat *format, const dw_abbrev_raw_attr *attr, dw_abbrev_attr *attrib) +static bool conv_abbrev_attrib(GDwarfFormat *format, const dw_compil_unit_header *cu, const dw_abbrev_raw_attr *attr, dw_abbrev_attr *attrib, const vmpa2t *pos) { bool result; /* Validité à retourner */ - result = true; - - - /* TODO : vérifier les bornes de 'name' et 'form' */ - + result = check_dwarf_abbrev_attrib(format, attr, cu->version, pos); if (result) { attrib->name = attr->name; attrib->form = attr->form; - - - } return result; @@ -323,31 +273,6 @@ static bool check_abbreviation_attrib(const GDwarfFormat *format, const dw_abbre } - - - - - - -/****************************************************************************** -* * -* 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. * @@ -362,178 +287,18 @@ DwarfTag dwarf_abbreviation_get_tag(const dw_abbrev *abbrev) 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; + return abbrev->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. * -* 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] * +* Paramètres : abbrev = abréviation à consulter. * +* format = contenu binaire de débogage à parcourir. * +* content = contenu encadré à parcourir. * +* pos = tête de lecture au sein des données. [OUT] * +* cu = unité de compilation parente. * * * * Description : Lit la valeur correspondant à un type donné. * * * @@ -543,37 +308,28 @@ const dw_abbrev *find_dwarf_abbreviations(const GDwarfFormat *format, uleb128_t * * ******************************************************************************/ -dw_value *translate_abbreviation_attributes(const GDwarfFormat *format, const dw_abbrev *abbrev, const dw_compil_unit_header *cu, vmpa2t *pos) +dw_value *translate_abbrev_attribs(const dw_abbrev *abbrev, const GDwarfFormat *format, GBinContent *content, vmpa2t *pos, const dw_compil_unit_header *cu) { 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)); + result = (dw_value *)calloc(abbrev->count, sizeof(dw_value)); - for (i = 0; i < abbrev->attribs_count; i++) + for (i = 0; i < abbrev->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)); + status = read_dwarf_form_value(format, content, pos, cu, + abbrev->attribs[i].form, &result[i].value); + if (!status) break; } - if (i != abbrev->attribs_count) + if (i != abbrev->count) { - free(result); + free_abbrev_attribs(result, abbrev->count); result = NULL; } @@ -582,195 +338,12 @@ dw_value *translate_abbreviation_attributes(const GDwarfFormat *format, const dw } - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#if 0 - -#include <malloc.h> -#include <stdarg.h> -#include <string.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 *, uint64_t *); - -/* Recherche une abréviation DWARF donnée. */ -const dw_abbrev *_find_dwarf_abbreviations(const dw_abbrev *, uint8_t *); - -/* Lit la valeur d'un attribut DWARF. */ -bool _read_dwarf_abbrev_attribute(dwarf_format *, off_t *, DwarfForm, ...); - - - -/****************************************************************************** -* * -* Paramètres : format = informations de débogage à compléter. * -* * -* Description : Charge les abréviations trouvées pour un DWARF. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool load_dwarf_abbreviations(dwarf_format *format) -{ - bool result; /* Bilan à renvoyer */ - - - - - off_t offset; - off_t start; - off_t size; - - bool test; - - int i; - - - dw_abbrev *abbrev; - uint64_t index; - - printf("Searching...\n"); - - - 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]); - } - - printf("\n"); - - - - - while (offset < (start + size)) - { - abbrev = read_dwarf_abbreviations(format, &offset, &index); - - offset++; /* 0x00 */ - - printf("abbrev :: %p\n", abbrev); - - if (abbrev != NULL) - { - abbrev->offset -= start; - - 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ées 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. * +* Paramètres : values = liste de valeurs typées à traiter. * +* count = nombre d'éléments de la liste. * * * -* Description : Libère de la mémoire une abréviation DWARF. * +* Description : Supprime de la mémoire une liste de valeurs typées. * * * * Retour : - * * * @@ -778,511 +351,118 @@ void unload_dwarf_abbreviations(dwarf_format *format) * * ******************************************************************************/ -void free_dwarf_abbrev(dw_abbrev *abbrev) +void free_abbrev_attribs(dw_value *values, size_t count) { 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); + for (i = 0; i < count; i++) + if (values[i].value != NULL) + free_dwarf_form_value(values[i].value); - free(abbrev); + free(values); } /****************************************************************************** * * -* Paramètres : format = informations de débogage à compléter. * -* pos = tête de lecture à mettre à jour. [OUT] * -* index = code de l'abréviation. [OUT] * +* Paramètres : abbrev = abréviation à consulter. * * * -* Description : Charge une abréviation DWARF. * +* Description : Détermine si l'abréviation possède des enfants. * * * -* Retour : Adresse d'une abréviation ou NULL en cas d'échec. * +* Retour : true si des sous-éléments sont présents. * * * * Remarques : - * * * ******************************************************************************/ -dw_abbrev *read_dwarf_abbreviations(dwarf_format *format, off_t *pos, uint64_t *index) +bool has_abbrev_children(const dw_abbrev *abbrev) { - dw_abbrev *result; /* Abréviation à retourner */ - bool has_children; /* Indique la présence de fils */ - uint64_t value1; /* Valeur quelconque lue #1 */ - uint64_t value2; /* Valeur quelconque lue #2 */ - uint64_t sub_index; /* Indice d'un sous-élément */ - dw_abbrev *child; /* Sous-élément à intégrer */ - - result = (dw_abbrev *)calloc(1, sizeof(dw_abbrev)); - - result->offset = *pos; - - /* Code de l'élément */ - if (!read_uleb128(format, pos, index, true)) goto rda_error; - - if (!read_uleb128(format, pos, &value1, true)) goto rda_error; - result->tag = value1; - - printf(" --ta :: 0x%02llx\n", value1); - - if (*pos >= DBG_FORMAT(format)->length) goto rda_error; - has_children = (DBG_FORMAT(format)->content[(*pos)++] == DW_CHILDREN_YES); - - printf(" --ch ? %d\n", has_children); - - /* Liste des attributs */ - - while (DBG_FORMAT(format)->content[*pos] != 0x00) - { - if (!read_uleb128(format, pos, &value1, true)) goto rda_error; - if (!read_uleb128(format, pos, &value2, true)) 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 *)); + bool result; /* Bilan à retourner */ - result->children[result->children_count - 1] = child; - - } + result = abbrev->has_children; return result; - rda_error: - - free_dwarf_abbrev(result); - - return NULL; - } -/****************************************************************************** -* * -* Paramètres : abbrev = abréviation racine à parcourir. * -* index = code de l'abréviation. [OUT] * -* * -* 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 dw_abbrev *abbrev, uint8_t *index) -{ - const dw_abbrev *result; /* Structure à retourner */ - size_t i; /* Boucle de parcours */ - - result = NULL; - - if (*index == 0) result = abbrev; - else - for (i = 0; i < abbrev->children_count && result == NULL; i++) - { - (*index)--; - result = _find_dwarf_abbreviations(abbrev->children[i], index); - } - - return result; -} +/* ---------------------------------------------------------------------------------- */ +/* TRAITEMENT D'ABREVIATIONS PAR LOTS */ +/* ---------------------------------------------------------------------------------- */ /****************************************************************************** * * -* Paramètres : format = informations de débogage à consulter. * -* offset = position dans les abréviations. * -* pos = position dans le flux binaire courant. [OUT] * +* Paramètres : format = informations de débogage à constituer. * +* cu = en-tête de description de l'unité à traiter. * * * -* Description : Recherche une abréviation DWARF donnée. * +* Description : Charge une série d'abréviations présentes dans un DWARF. * * * -* Retour : Adresse d'une abréviation ou NULL en cas d'échec. * +* Retour : Structure mise en place, ou NULL en cas d'erreur. * * * -* Remarques : - * +* Remarques : Le décalage est positionné à VMPA_NO_PHYSICAL en cas de fin. * * * ******************************************************************************/ -const dw_abbrev *find_dwarf_abbreviations(dwarf_format *format, const off_t *offset, off_t *pos) +dw_abbrev_brotherhood *load_all_dwarf_abbreviations(GDwarfFormat *format, const dw_compil_unit_header *cu) { - const dw_abbrev *result; /* Structure à retourner */ - uint64_t index; /* Code de l'abréviation */ - size_t i; /* Boucle de parcours */ + dw_abbrev_brotherhood *result; /* Abréviations à retourner */ + GExeFormat *exe; /* Exécutable associé */ + mrange_t range; /* Couverture d'une section */ + bool status; /* Bilan d'un appel */ + GBinContent *content; /* Contenu binaire à lire */ + GBinContent *restricted; /* Limitation des traitements */ + vmpa2t pos; /* Position de tête de lecture */ + dw_abbrev *abbrev; /* Nouvelle abréviation */ result = NULL; - do - { - if (!read_uleb128(format, pos, &index, true)) - { - printf("error skipping padding...\n"); - return NULL; - } - } - while (index == 0); - - for (i = 0; i < format->abbrevs_count; i++) - if (format->abbrevs[i]->offset == *offset) break; - - if (i < format->abbrevs_count) - { - index--; - result = _find_dwarf_abbreviations(format->abbrevs[i], &index); - } - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : abbrev = informations à parcourir. * -* attrib = attribut visé par la lecture. * -* * -* Description : Indique la présence ou l'absence d'un attribut donné. * -* * -* Retour : true si l'attribut est présent, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool test_dwarf_abbrev_attribute(const dw_abbrev *abbrev, DwarfAttrib attrib) -{ - bool result; /* Bilan à retourner */ - size_t i; /* Boucle de parcours */ - - result = false; - - for (i = 0; i < abbrev->attribs_count && !result; i++) - result = (abbrev->attribs[i].attrib == attrib); - - return result; - -} + exe = G_DBG_FORMAT(format)->executable; + status = g_exe_format_get_section_range_by_name(exe, ".debug_abbrev", &range); -/****************************************************************************** -* * -* Paramètres : format = informations de débogage à compléter. * -* pos = tête de lecture à mettre à jour. [OUT] * -* form = format des données à lire. * -* ... = lieu d'enregistrement ou NULL. [OUT] * -* * -* Description : Lit la valeur d'un attribut DWARF. * -* * -* Retour : true si la lecture est un succès, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool _read_dwarf_abbrev_attribute(dwarf_format *format, off_t *pos, DwarfForm form, ...) -{ - bool result; /* Bilan à revoyer */ - va_list ap; /* Adresse fournie en dernier */ - uint8_t *val8; /* Données sur 8 bits */ - uint16_t *val16; /* Données sur 16 bits */ - uint32_t *val32; /* Données sur 32 bits */ - uint64_t *val64; /* Données sur 64 bits */ - uint64_t *sval64; /* Données sur 64 bits (signée)*/ - bool *boolval; /* Valeur booléenne */ - 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 */ - uint64_t stmp64; /* Données sur 64 bits (signée)*/ - uint64_t size_to_read; /* Nombre d'octets à lire */ - off_t offset; /* Décalage dans une zone */ - char **strval; /* Chaîne de caractères */ - size_t length; /* Taille d'une chaîne */ - - va_start(ap, form); - - switch (form) + if (status) { - case DWF_ADDR: - result = ((*pos + (format->format == DWF_32_BITS ? 4 : 8)) <= DBG_FORMAT(format)->length); - if (result) - { - val64 = va_arg(ap, uint64_t *); - if (val64 != NULL) - { - if (format->format == DWF_32_BITS) - { - memcpy(&tmp32, &DBG_FORMAT(format)->content[*pos], 4); - *val64 = tmp32; - } - else memcpy(val64, &DBG_FORMAT(format)->content[*pos], 8); - } - *pos += (format->format == DWF_32_BITS ? 4 : 8); - } - break; + /* Définition d'un zone de travail */ - case DWF_BLOCK2: - result = ((*pos + 2) <= DBG_FORMAT(format)->length); - if (result) - { - memcpy(&tmp16, &DBG_FORMAT(format)->content[*pos], 2); - size_to_read = tmp16; - /* ... */ - *pos += 2 + size_to_read; - } - break; + content = G_BIN_FORMAT(format)->content; + restricted = g_restricted_content_new(content, &range); - case DWF_BLOCK4: - result = ((*pos + 4) <= DBG_FORMAT(format)->length); - if (result) - { - memcpy(&tmp32, &DBG_FORMAT(format)->content[*pos], 4); - size_to_read = tmp32; - /* ... */ - *pos += 4 + size_to_read; - } - break; + copy_vmpa(&pos, get_mrange_addr(&range)); + advance_vmpa(&pos, cu->debug_abbrev_offset); - case DWF_DATA2: - result = ((*pos + 2) <= DBG_FORMAT(format)->length); - if (result) - { - val16 = va_arg(ap, uint16_t *); - if (val16 != NULL) memcpy(val16, &DBG_FORMAT(format)->content[*pos], 2); - *pos += 2; - } - break; + /* Lecture de toutes les abréviations */ - case DWF_DATA4: - result = ((*pos + 4) <= DBG_FORMAT(format)->length); - if (result) - { - val32 = va_arg(ap, uint32_t *); - if (val32 != NULL) memcpy(val32, &DBG_FORMAT(format)->content[*pos], 4); - *pos += 4; - } - break; - - case DWF_DATA8: - result = ((*pos + 8) <= DBG_FORMAT(format)->length); - if (result) - { - val64 = va_arg(ap, uint64_t *); - if (val64 != NULL) memcpy(val64, &DBG_FORMAT(format)->content[*pos], 8); - *pos += 8; - } - break; - - case DWF_STRING: - result = ((*pos + 1) <= DBG_FORMAT(format)->length); - if (result) - { - strval = va_arg(ap, char **); - if (strval != NULL) *strval = (char *)calloc(1, sizeof(char)); - length = 0; - - while (result) - { - if (DBG_FORMAT(format)->content[*pos] == '\0') break; - - length++; - - if (strval != NULL) - { - *strval = (char *)realloc(*strval, (length + 1) * sizeof(char)); - (*strval)[length - 1] = DBG_FORMAT(format)->content[*pos]; - } - - result = ((*pos + 1) <= DBG_FORMAT(format)->length); - if (!result) break; - - (*pos)++; - - } - - result = ((*pos + 1) <= DBG_FORMAT(format)->length); - - if (result) - { - (*pos)++; - - if (strval != NULL) - (*strval)[length] = 0; - - } - else if (strval != NULL) - { - free(*strval); - *strval = NULL; - } - - } - - break; - - case DWF_BLOCK: - result = read_uleb128(format, pos, &size_to_read, true); - result &= ((*pos + size_to_read) <= DBG_FORMAT(format)->length); - if (result) - { - /* ... */ - *pos += size_to_read; - } - break; - - case DWF_BLOCK1: - result = ((*pos + 1) <= DBG_FORMAT(format)->length); - if (result) - { - memcpy(&tmp8, &DBG_FORMAT(format)->content[*pos], 1); - size_to_read = tmp8; - /* ... */ - *pos += 1 + size_to_read; - } - break; - - case DWF_DATA1: - result = ((*pos + 1) <= DBG_FORMAT(format)->length); - if (result) - { - val8 = va_arg(ap, uint8_t *); - if (val8 != NULL) memcpy(val8, &DBG_FORMAT(format)->content[*pos], 1); - *pos += 1; - } - break; - - case DWF_FLAG: - result = ((*pos + 1) <= DBG_FORMAT(format)->length); - if (result) - { - boolval = va_arg(ap, bool *); - if (boolval != NULL) *boolval = (DBG_FORMAT(format)->content[*pos] != 0x00); - *pos += 1; - } - break; - - case DWF_SDATA: - sval64 = va_arg(ap, int64_t *); - if (sval64 == NULL) sval64 = &stmp64; - result = read_uleb128(format, pos, sval64, true); - break; - - case DWF_STRP: - result = read_abbrev_offset(format, pos, &offset); - if (result) - { - if (va_arg(ap, bool *) != NULL) - { - printf("TODO\n"); - exit(0); - } - /* - boolval = va_arg(ap, bool *); - if (boolval != NULL) *boolval = (DBG_FORMAT(format)->content[*pos] != 0x00); - */ - } - break; - - case DWF_UDATA: - val64 = va_arg(ap, uint64_t *); - if (val64 == NULL) val64 = &tmp64; - result = read_uleb128(format, pos, val64, true); - break; - - case DWF_REF_ADDR: - result = ((*pos + 4) <= DBG_FORMAT(format)->length); - - printf("bad at %d\n", __LINE__); exit(0); - - break; - - - case DWF_REF1: - result = ((*pos + 1) <= DBG_FORMAT(format)->length); - if (result) - { - val8 = va_arg(ap, uint8_t *); - if (val8 != NULL) memcpy(val8, &DBG_FORMAT(format)->content[*pos], 1); - *pos += 1; - } - break; - - case DWF_REF2: - result = ((*pos + 2) <= DBG_FORMAT(format)->length); - if (result) - { - val16 = va_arg(ap, uint16_t *); - if (val16 != NULL) memcpy(val16, &DBG_FORMAT(format)->content[*pos], 2); - *pos += 2; - } - break; - - case DWF_REF4: - result = ((*pos + 4) <= DBG_FORMAT(format)->length); - if (result) - { - val32 = va_arg(ap, uint32_t *); - if (val32 != NULL) memcpy(val32, &DBG_FORMAT(format)->content[*pos], 4); - *pos += 4; - } - break; - - case DWF_REF8: - result = ((*pos + 8) <= DBG_FORMAT(format)->length); - if (result) - { - val64 = va_arg(ap, uint64_t *); - if (val64 != NULL) memcpy(val64, &DBG_FORMAT(format)->content[*pos], 8); - *pos += 8; - } - break; - - case DWF_REF_UDATA: - result = ((*pos + 4) <= DBG_FORMAT(format)->length); - - printf("bad at %d\n", __LINE__); exit(0); - - break; + result = calloc(1, sizeof(dw_abbrev_brotherhood)); + while (true) + { + status = load_dwarf_abbreviation(format, cu, restricted, &pos, &abbrev); + if (!status) break; - case DWF_INDIRECT: - result = ((*pos + 4) <= DBG_FORMAT(format)->length); + if (abbrev == NULL) + break; - printf("bad at %d\n", __LINE__); exit(0); + result->abbrevs = realloc(result->abbrevs, ++result->count * sizeof(dw_abbrev *)); - break; + result->abbrevs[result->count - 1] = abbrev; + } + /* Nettoyage */ + if (!status) + { + free_all_dwarf_abbreviations(result); + result = NULL; + } - default: - result = false; - break; + g_object_unref(G_OBJECT(restricted)); } - va_end(ap); - return result; } @@ -1290,101 +470,58 @@ bool _read_dwarf_abbrev_attribute(dwarf_format *format, off_t *pos, DwarfForm fo /****************************************************************************** * * -* Paramètres : format = informations de débogage à compléter. * -* pos = tête de lecture à mettre à jour. [OUT] * -* update = indique si la position est à mettre à jour. * -* abbrev = informations à parcourir. * -* attrib = attribut visé par la lecture. * -* ... = lieu d'enregistrement ou NULL. [OUT] * +* Paramètres : list = série d'abréviations chargées en mémoire à traiter. * * * -* Description : Lit la valeur d'un attribut DWARF. * +* Description : Supprime de la mémoire toute trace d'abréviations DWARF. * * * -* Retour : true si la lecture est un succès, false sinon. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -bool read_dwarf_abbrev_attribute(dwarf_format *format, off_t *pos, bool update, const dw_abbrev *abbrev, DwarfAttrib attrib, ...) +void free_all_dwarf_abbreviations(dw_abbrev_brotherhood *list) { - bool result; /* Bilan à retourner */ - off_t curpos; /* Tête de lecture effective */ size_t i; /* Boucle de parcours */ - va_list ap; /* Adresse fournie en dernier */ - - result = true; - - curpos = *pos; - - for (i = 0; i < abbrev->attribs_count && result; i++) - if (abbrev->attribs[i].attrib == attrib) break; - else result = _read_dwarf_abbrev_attribute(format, &curpos, abbrev->attribs[i].form, NULL); - - if (result) - { - va_start(ap, attrib); - - if (i < abbrev->attribs_count) - result = _read_dwarf_abbrev_attribute(format, &curpos, abbrev->attribs[i].form, va_arg(ap, void *)); - else - result = false; - va_end(ap); + for (i = 0; i < list->count; i++) + free_dwarf_abbrev(list->abbrevs[i]); - } - - if (result && update) *pos = curpos; + if (list->abbrevs != NULL) + free(list->abbrevs); - return result; + free(list); } /****************************************************************************** * * -* Paramètres : format = informations de débogage à compléter. * -* pos = tête de lecture à mettre à jour. [OUT] * -* abbrev = informations à survoler. * +* Paramètres : list = série d'abréviations à consulter. * +* code = identifiant de l'abbréviation recherchée. * * * -* Description : Fait avancer la tête de lecture d'une seule abréviation. * +* Description : Recherche une abréviation DWARF donnée. * * * -* Retour : true si l'opération est un succès, false sinon. * +* Retour : Adresse d'une abréviation ou NULL en cas d'échec. * * * * Remarques : - * * * ******************************************************************************/ -bool skip_dwarf_abbrev(dwarf_format *format, off_t *pos, const dw_abbrev *abbrev) +const dw_abbrev *find_dwarf_abbreviation(const dw_abbrev_brotherhood *list, uleb128_t code) { - bool result; /* Bilan à revoyer */ + const dw_abbrev *result; /* Trouvaille à retourner */ size_t i; /* Boucle de parcours */ - uint64_t index; /* Code de padding */ - - result = true; - - /* Ecartement du corps */ - for (i = 0; i < abbrev->attribs_count && result; i++) - result = _read_dwarf_abbrev_attribute(format, pos, abbrev->attribs[i].form, NULL); - - /* Ecartement du padding */ + result = NULL; - do - { - if (!read_uleb128(format, pos, &index, false)) + for (i = 0; i < list->count; i++) + if (list->abbrevs[i]->code == code) { - printf("error skipping padding...\n"); - return false; + result = list->abbrevs[i]; + break; } - if (index == 0) - read_uleb128(format, pos, &index, true); - - } - while (index == 0); - return result; } - -#endif diff --git a/plugins/dwarf/abbrev.h b/plugins/dwarf/abbrev.h index b5fe3be..6536b72 100644 --- a/plugins/dwarf/abbrev.h +++ b/plugins/dwarf/abbrev.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * abbrev.h - prototypes pour la manipulation des abréviation DWARF * - * Copyright (C) 2008-2017 Cyrille Bagard + * Copyright (C) 2008-2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,106 +21,65 @@ */ -#ifndef _FORMAT_DWARF_ABBREV_H -#define _FORMAT_DWARF_ABBREV_H +#ifndef _PLUGINS_DWARF_ABBREV_H +#define _PLUGINS_DWARF_ABBREV_H #include <stdbool.h> -#include "dwarf.h" -#include "dwarf_def.h" +#include "form.h" +#include "format.h" +/* ----------------------- TRAITEMENT D'ABREVIATION A L'UNITE ----------------------- */ -/* 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 *); +/* Description d'une abréviation */ +typedef struct _dw_abbrev 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 *); +/* Forme de valeur typée */ +typedef struct _dw_value +{ + DwarfAttrib attrib; /* Sujet de l'élément */ + dw_form_value *value; /* Valeur instanciée associée */ -/* Indique si une abbréviation comporte des sous-définitions. */ -bool dwarf_abbreviation_has_children(const dw_abbrev *); +} dw_value; - -/* 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 *); - +dw_value *translate_abbrev_attribs(const dw_abbrev *, const GDwarfFormat *, GBinContent *, vmpa2t *, const dw_compil_unit_header *); +/* Supprime de la mémoire une liste de valeurs typées. */ +void free_abbrev_attribs(dw_value *, size_t); +/* Détermine si l'abréviation possède des enfants. */ +bool has_abbrev_children(const dw_abbrev *); +/* ----------------------- TRAITEMENT D'ABREVIATIONS PAR LOTS ----------------------- */ +/* Brochette d'abréviations */ +typedef struct _dw_abbrev_brotherhood dw_abbrev_brotherhood; +/* Charge une série d'abréviations présentes dans un DWARF. */ +dw_abbrev_brotherhood *load_all_dwarf_abbreviations(GDwarfFormat *, const dw_compil_unit_header *); - - -#if 0 - - -#include <stdbool.h> - - -#include "d_dwarf.h" -#include "dwarf-int.h" - - - -/* Charge les abréviations trouvées pour un DWARF. */ -bool load_dwarf_abbreviations(dwarf_format *); - -/* Décharge les abréviations trouvées pour un DWARF. */ -void unload_dwarf_abbreviations(dwarf_format *); +/* Supprime de la mémoire toute trace d'abréviations DWARF. */ +void free_all_dwarf_abbreviations(dw_abbrev_brotherhood *); /* Recherche une abréviation DWARF donnée. */ -const dw_abbrev *find_dwarf_abbreviations(dwarf_format *, const off_t *, off_t *); - -/* Indique la présence ou l'absence d'un attribut donné. */ -bool test_dwarf_abbrev_attribute(const dw_abbrev *, DwarfAttrib); - -/* Lit la valeur d'un attribut DWARF. */ -bool read_dwarf_abbrev_attribute(dwarf_format *, off_t *, bool, const dw_abbrev *, DwarfAttrib, ...); - -/* Fait avancer la tête de lecture d'une seule abréviation. */ -bool skip_dwarf_abbrev(dwarf_format *, off_t *, const dw_abbrev *); - - -#endif +const dw_abbrev *find_dwarf_abbreviation(const dw_abbrev_brotherhood *, uleb128_t); -#endif /* _FORMAT_DWARF_ABBREV_H */ +#endif /* _PLUGINS_DWARF_ABBREV_H */ diff --git a/plugins/dwarf/checks.c b/plugins/dwarf/checks.c new file mode 100644 index 0000000..7dc8a7c --- /dev/null +++ b/plugins/dwarf/checks.c @@ -0,0 +1,224 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * checks.c - validations liées au format DWARF v2 + * + * Copyright (C) 2018 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 "checks.h" + + +#include <malloc.h> +#include <stdio.h> + + +#include <i18n.h> +#include <common/cpp.h> +#include <format/format.h> + + +#include "core.h" +#include "v2/checks.h" +#include "v3/checks.h" +#include "v4/checks.h" + + + +/** + * Opérations disponibles par version. + */ + +/* Procède à la conversion de base d'une abréviation DWARF. */ +typedef bool (* check_dwarf_decl_fc) (const dw_abbrev_decl *); + +/* Procède à la conversion d'un attribut d'abréviation DWARF. */ +typedef bool (* check_dwarf_attrib_fc) (const dw_abbrev_raw_attr *); + +typedef struct _abbrev_check_op +{ + check_dwarf_decl_fc check_decl; /* Validation des déclarations */ + check_dwarf_attrib_fc check_attrib; /* Validation des attributs */ + +} abbrev_check_op; + +static const abbrev_check_op _check_ops[5] = { + + [2] = { + .check_decl = (check_dwarf_decl_fc)check_dwarfv2_abbrev_decl, + .check_attrib = (check_dwarf_attrib_fc)check_dwarfv2_abbrev_attrib + }, + + [3] = { + .check_decl = (check_dwarf_decl_fc)check_dwarfv3_abbrev_decl, + .check_attrib = (check_dwarf_attrib_fc)check_dwarfv3_abbrev_attrib + }, + + [4] = { + .check_decl = (check_dwarf_decl_fc)check_dwarfv4_abbrev_decl, + .check_attrib = (check_dwarf_attrib_fc)check_dwarfv4_abbrev_attrib + } + +}; + + + +/****************************************************************************** +* * +* Paramètres : format = informations de débogage à consulter. * +* decl = structure brute dont le contenu est à valider. * +* target = version ciblée par le format. * +* pos = emplacement de l'élément à vérifier dans le binaire.* +* * +* Description : Procède à la conversion de base d'une abréviation DWARF. * +* * +* Retour : Validité confirmée ou non. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool check_dwarf_abbrev_decl(GDwarfFormat *format, const dw_abbrev_decl *decl, uint16_t target, const vmpa2t *pos) +{ + bool result; /* Validité à retourner */ + char *msg; /* Message à imprimer */ + uint16_t i; /* Boucle de parcours */ + VMPA_BUFFER(loc); /* Position humainement lisible*/ + + result = false; + + if (target < 2) + { + asprintf(&msg, _("Too old DWARF compilation unit (%hu < 2) ; fixed!"), target); + + g_binary_format_add_error(G_BIN_FORMAT(format), BFE_STRUCTURE, pos, msg); + + free(msg); + + target = 2; + + } + + for (i = target; i < ARRAY_SIZE(_check_ops); i++) + { + result = _check_ops[i].check_decl(decl); + + if (result) + break; + + } + + if (result) + { + if (i > target) + { + asprintf(&msg, _("The DWARF abbreviation declaration belongs to another version (%hu vs %hu)"), + i, target); + + g_binary_format_add_error(G_BIN_FORMAT(format), BFE_STRUCTURE, pos, msg); + + free(msg); + + } + + } + + else + { + vmpa2_phys_to_string(pos, MDS_UNDEFINED, loc, NULL); + + log_dwarf_variadic_message(LMT_BAD_BINARY, _("Invalid abbreviation declaration at %s"), loc); + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : format = informations de débogage à consulter. * +* decl = structure brute dont le contenu est à valider. * +* target = version ciblée par le format. * +* pos = emplacement de l'élément à vérifier dans le binaire.* +* * +* Description : Procède à la conversion d'un attribut d'abréviation DWARF. * +* * +* Retour : Validité confirmée ou non. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool check_dwarf_abbrev_attrib(GDwarfFormat *format, const dw_abbrev_raw_attr *attr, uint16_t target, const vmpa2t *pos) +{ + bool result; /* Validité à retourner */ + char *msg; /* Message à imprimer */ + uint16_t i; /* Boucle de parcours */ + VMPA_BUFFER(loc); /* Position humainement lisible*/ + + result = false; + + if (target < 2) + { + asprintf(&msg, _("Too old DWARF compilation unit (%hu < 2) ; fixed!"), target); + + g_binary_format_add_error(G_BIN_FORMAT(format), BFE_STRUCTURE, pos, msg); + + free(msg); + + target = 2; + + } + + for (i = target; i < ARRAY_SIZE(_check_ops); i++) + { + result = _check_ops[i].check_attrib(attr); + + if (result) + break; + + } + + if (result) + { + if (i > target) + { + asprintf(&msg, _("The DWARF abbreviation attribute belongs to another version (%hu vs %hu)"), + i, target); + + g_binary_format_add_error(G_BIN_FORMAT(format), BFE_STRUCTURE, pos, msg); + + free(msg); + + } + + } + + else + { + vmpa2_phys_to_string(pos, MDS_UNDEFINED, loc, NULL); + + log_dwarf_variadic_message(LMT_BAD_BINARY, _("Invalid abbreviation attribute at %s"), loc); + + } + + return result; + +} diff --git a/plugins/dwarf/checks.h b/plugins/dwarf/checks.h new file mode 100644 index 0000000..87c02e7 --- /dev/null +++ b/plugins/dwarf/checks.h @@ -0,0 +1,41 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * checks.h - prototypes pour les validations liées au format DWARF + * + * Copyright (C) 2018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_DWARF_CHECKS_H +#define _PLUGINS_DWARF_CHECKS_H + + +#include "def.h" +#include "format.h" + + + +/* Procède à la conversion de base d'une abréviation DWARF. */ +bool check_dwarf_abbrev_decl(GDwarfFormat *, const dw_abbrev_decl *, uint16_t, const vmpa2t *); + +/* Procède à la conversion d'un attribut d'abréviation DWARF. */ +bool check_dwarf_abbrev_attrib(GDwarfFormat *, const dw_abbrev_raw_attr *, uint16_t, const vmpa2t *); + + + +#endif /* _PLUGINS_DWARF_CHECKS_H */ diff --git a/plugins/dwarf/v3/dwarf.c b/plugins/dwarf/core.c index 942c289..fa7e0ec 100644 --- a/plugins/dwarf/v3/dwarf.c +++ b/plugins/dwarf/core.c @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * dwarf.c - support du format DWARF v3 + * core.c - intégration du support du format DWARF * - * Copyright (C) 2015-2017 Cyrille Bagard + * Copyright (C) 2017 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,51 +21,31 @@ */ -#include "dwarf.h" +#include "core.h" -#include "../dwarf-int.h" +#include <plugins/plugin-def.h> +#include "format.h" -/* Format de débogage DWARF v3 (instance) */ -struct _GDwarfV3Format -{ - GDwarfFormat parent; /* A laisser en premier */ - -}; - -/* Format de débogage DWARF v3 (classe) */ -struct _GDwarfV3FormatClass -{ - GDwarfFormatClass parent; /* A laisser en premier */ - -}; - - -/* Initialise la classe des formats de débogage DWARF v3. */ -static void g_dwarfv3_format_class_init(GDwarfV3FormatClass *); -/* Initialise une instance de format de débogage DWARF v3. */ -static void g_dwarfv3_format_init(GDwarfV3Format *); -/* Supprime toutes les références externes. */ -static void g_dwarfv3_format_dispose(GDwarfV3Format *); +DEFINE_CHRYSALIDE_PLUGIN("dwarf", "Add support for the DWARF format", "0.1.0", + RL("PyChrysalide"), AL(PGA_PLUGIN_INIT, PGA_FORMAT_ATTACH_DEBUG)); -/* Procède à la libération totale de la mémoire. */ -static void g_dwarfv3_format_finalize(GDwarfV3Format *); +/* Conservation d'une référence au greffon pour les messages */ +static GPluginModule *_this = NULL; -/* Indique le type défini pour un format de débogage DWARF v3. */ -G_DEFINE_TYPE(GDwarfV3Format, g_dwarfv3_format, G_TYPE_DWARF_FORMAT); /****************************************************************************** * * -* Paramètres : klass = classe à initialiser. * +* Paramètres : plugin = greffon à manipuler. * * * -* Description : Initialise la classe des formats de débogage DWARF v3. * +* Description : Prend acte du chargement du greffon. * * * * Retour : - * * * @@ -73,23 +53,26 @@ G_DEFINE_TYPE(GDwarfV3Format, g_dwarfv3_format, G_TYPE_DWARF_FORMAT); * * ******************************************************************************/ -static void g_dwarfv3_format_class_init(GDwarfV3FormatClass *klass) +G_MODULE_EXPORT bool chrysalide_plugin_init(GPluginModule *plugin) { - GObjectClass *object; /* Autre version de la classe */ + bool result; /* Bilan à retourner */ - object = G_OBJECT_CLASS(klass); + _this = plugin; - object->dispose = (GObjectFinalizeFunc/* ! */)g_dwarfv3_format_dispose; - object->finalize = (GObjectFinalizeFunc)g_dwarfv3_format_finalize; + result = true; + + return result; } /****************************************************************************** * * -* Paramètres : format = instance à initialiser. * +* Paramètres : plugin = greffon à manipuler. * +* action = type d'action attendue. * +* format = format de binaire à manipuler pendant l'opération. * * * -* Description : Initialise une instance de format de débogage DWARF v3. * +* Description : Procède au rattachement d'éventuelles infos de débogage. * * * * Retour : - * * * @@ -97,36 +80,23 @@ static void g_dwarfv3_format_class_init(GDwarfV3FormatClass *klass) * * ******************************************************************************/ -static void g_dwarfv3_format_init(GDwarfV3Format *format) +G_MODULE_EXPORT void chrysalide_plugin_attach_debug(const GPluginModule *plugin, PluginAction action, GExeFormat *format) { + GDbgFormat *info; -} + info = check_dwarf_format(format); - -/****************************************************************************** -* * -* Paramètres : format = instance d'objet GLib à traiter. * -* * -* Description : Supprime toutes les références externes. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dwarfv3_format_dispose(GDwarfV3Format *format) -{ - G_OBJECT_CLASS(g_dwarfv3_format_parent_class)->dispose(G_OBJECT(format)); + if (info != NULL) + g_exe_format_add_debug_info(format, info); } /****************************************************************************** * * -* Paramètres : format = instance d'objet GLib à traiter. * +* Paramètres : msg = message à faire apparaître à l'écran. * * * -* Description : Procède à la libération totale de la mémoire. * +* Description : Présente dans le journal un message simple. * * * * Retour : - * * * @@ -134,39 +104,42 @@ static void g_dwarfv3_format_dispose(GDwarfV3Format *format) * * ******************************************************************************/ -static void g_dwarfv3_format_finalize(GDwarfV3Format *format) +void log_dwarf_simple_message(LogMessageType type, const char *msg) { - G_OBJECT_CLASS(g_dwarfv3_format_parent_class)->finalize(G_OBJECT(format)); + g_plugin_module_log_simple_message(_this, type, msg); } /****************************************************************************** * * -* Paramètres : content = contenu binaire à parcourir. * -* parent = éventuel format exécutable déjà chargé. * - status = barre de statut à tenir informée. * +* Paramètres : type = espèce du message à ajouter. * +* fmt = format du message à faire apparaître à l'écran. * +* ... = éventuels arguments venant compléter le message. * * * -* Description : Prend en charge un nouveau format DWARF (v3). * +* Description : Présente dans le journal un message complexe. * * * -* Retour : Adresse de la structure mise en place ou NULL en cas d'échec.* +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -GBinFormat *g_dwarfv3_format_new(GBinContent *content, GExeFormat *parent, GtkStatusStack *status) +void log_dwarf_variadic_message(LogMessageType type, const char *fmt, ...) { - GDwarfV3Format *result; /* Structure à retourner */ - - result = g_object_new(G_TYPE_DWARFV3_FORMAT, NULL); - - + va_list ap; /* Liste d'arguments variable */ + char *buffer; /* Tampon du msg reconstitué */ - g_binary_format_set_content(G_BIN_FORMAT(result), content); + va_start(ap, fmt); + buffer = build_variadic_message(fmt, ap); + va_end(ap); + if (buffer != NULL) + { + g_plugin_module_log_simple_message(_this, type, buffer); + free(buffer); - return G_BIN_FORMAT(result); + } } diff --git a/plugins/dwarf/core.h b/plugins/dwarf/core.h new file mode 100644 index 0000000..7e2c367 --- /dev/null +++ b/plugins/dwarf/core.h @@ -0,0 +1,47 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * core.h - prototypes pour l'intégration du support du format DWARF + * + * Copyright (C) 2018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_DWARF_CORE_H +#define _PLUGINS_DWARF_CORE_H + + +#include <plugins/plugin.h> +#include <plugins/plugin-int.h> + + + +/* Prend acte du chargement du greffon. */ +G_MODULE_EXPORT bool chrysalide_plugin_init(GPluginModule *); + +/* Procède au rattachement d'éventuelles infos de débogage. */ +G_MODULE_EXPORT void chrysalide_plugin_attach_debug(const GPluginModule *, PluginAction, GExeFormat *); + +/* Présente dans le journal un message simple. */ +void log_dwarf_simple_message(LogMessageType, const char *); + +/* Présente dans le journal un message complexe. */ +void log_dwarf_variadic_message(LogMessageType, const char *, ...); + + + +#endif /* _PLUGINS_DWARF_CORE_H */ diff --git a/plugins/dwarf/def.h b/plugins/dwarf/def.h new file mode 100644 index 0000000..cb0d836 --- /dev/null +++ b/plugins/dwarf/def.h @@ -0,0 +1,315 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * def.h - prototype pour la manipulation directe du format DWARF + * + * Copyright (C) 20018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_DWARF_DEF_H +#define _PLUGINS_DWARF_DEF_H + + +#include <stdint.h> + + +#include <common/leb128.h> + + + +/* Plus petit dénominateur commun des différents en-têtes */ +typedef struct _dw_section_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 */ + +} dw_section_header; + + +/** + * § 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.3 Abbreviations Tables. + */ + +/* 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; + +/* 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; + +/* Figure 18. Tag encodings */ + +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, + + /* Nouveautés v.3 */ + + 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, + + /* Possiblités d'extensions */ + + 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 20. Attribute encodings */ +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, + + /* Nouveautés v3 */ + + 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, + + /* Possiblités d'extensions */ + + DW_AT_lo_user = 0x2000, + DW_AT_hi_user = 0x3fff, + +} DwarfAttrib; + +/* Figure 21. Attribute form encodings. */ + +typedef enum _DwarfForm +{ + 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; + + + +#endif /* _PLUGINS_DWARF_DEF_H */ diff --git a/plugins/dwarf/die.c b/plugins/dwarf/die.c index 0c1887c..0a8cbec 100644 --- a/plugins/dwarf/die.c +++ b/plugins/dwarf/die.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * die.c - gestion des entrées renvoyant à des informations de débogage * - * Copyright (C) 2016-2017 Cyrille Bagard + * Copyright (C) 2016-2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -24,13 +24,6 @@ #include "die.h" -#include <assert.h> -#include <malloc.h> - - -#include "dwarf-int.h" - - /** * § 2.1 The Debugging Information Entry (DIE). @@ -38,14 +31,9 @@ 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 */ + size_t values_count; /* Taille de cette liste */ - 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 */ @@ -55,13 +43,13 @@ typedef struct _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] * +* Paramètres : format = informations chargées à consulter. * +* content = contenu encadré à parcourir. * +* pos = position de début de lecture. [OUT] * +* cu = 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.* +* Description : Procède à la lecture d'un élément d'information de débogage. * * * * Retour : Bilan de l'opération. * * * @@ -69,50 +57,67 @@ typedef struct _dw_die * * ******************************************************************************/ -bool build_dwarf_die(GDwarfFormat *format, vmpa2t *pos, SourceEndian endian, const dw_compil_unit_header *header, dw_die **die) +bool build_dwarf_die(GDwarfFormat *format, GBinContent *content, vmpa2t *pos, const dw_compil_unit_header *cu, const dw_abbrev_brotherhood *abbrevs, dw_die **die) { + bool result; /* Bilan à retourner */ 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 */ + dw_die *child; /* Sous-élément à intégrer */ - *die = NULL; + result = false; /** * § 7.5.2 Debugging Information Entry. */ - status = g_binary_content_read_uleb128(G_BIN_FORMAT(format)->content, pos, &code); - if (!status) return false; + status = g_binary_content_read_uleb128(content, pos, &code); + if (!status) goto exit; - printf("[ok] code = 0x%llx\n", (unsigned long long)code); + if (code == 0) + { + *die = NULL; + goto end_of_sibling; + } - if (code == 0) return true; + abbrev = find_dwarf_abbreviation(abbrevs, code); + if (abbrev == NULL) goto exit; - abbrev = find_dwarf_abbreviations(format, code); + values = translate_abbrev_attribs(abbrev, format, content, pos, cu); + if (values == NULL) goto exit; - printf("[ok] abbrev = %p\n", abbrev); + *die = calloc(1, sizeof(dw_die)); - printf("----------------------\n"); - - - values = translate_abbreviation_attributes(format, abbrev, header, pos); - if (values == NULL) return false; + (*die)->values = values; + (*die)->values_count = dwarf_abbreviation_count_attribs(abbrev); - printf("[ok] values = %p\n", values); + if (has_abbrev_children(abbrev)) + while (true) + { + status = build_dwarf_die(format, content, pos, cu, abbrevs, &child); + if (!status) + { + delete_dwarf_die(*die); + goto exit; + } + if (child == NULL) + break; - *die = (dw_die *)calloc(1, sizeof(dw_die)); + (*die)->children = realloc((*die)->children, ++(*die)->children_count * sizeof(dw_die *)); + (*die)->children[(*die)->children_count - 1] = child; - (*die)->abbrev = abbrev; + } - (*die)->values = values; + end_of_sibling: - (*die)->has_children = dwarf_abbreviation_has_children(abbrev); + result = true; + exit: - return true; + return result; } @@ -134,7 +139,7 @@ void delete_dwarf_die(dw_die *die) size_t i; /* Boucle de parcours */ if (die->values != NULL) - free(die->values); + free_abbrev_attribs(die->values, die->values_count); for (i = 0; i < die->children_count; i++) delete_dwarf_die(die->children[i]); @@ -145,159 +150,3 @@ void delete_dwarf_die(dw_die *die) 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/plugins/dwarf/die.h b/plugins/dwarf/die.h index 8bff4a9..6d85d56 100644 --- a/plugins/dwarf/die.h +++ b/plugins/dwarf/die.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * die.h - prototypes pour la gestion des entrées renvoyant à des informations de débogage * - * Copyright (C) 2016-2017 Cyrille Bagard + * Copyright (C) 2016-2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,16 +21,19 @@ */ -#ifndef _FORMAT_DWARF_DIE_H -#define _FORMAT_DWARF_DIE_H +#ifndef _PLUGINS_DWARF_DIE_H +#define _PLUGINS_DWARF_DIE_H #include <stdbool.h> +#include <analysis/content.h> + + #include "abbrev.h" -#include "dwarf.h" -#include "dwarf_def.h" +#include "def.h" +#include "format.h" @@ -38,39 +41,12 @@ 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 **); +/* Procède à la lecture d'un élément d'information de débogage. */ +bool build_dwarf_die(GDwarfFormat *, GBinContent *, vmpa2t *, const dw_compil_unit_header *, const dw_abbrev_brotherhood *, 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 */ +#endif /* _PLUGINS_DWARF_DIE_H */ diff --git a/plugins/dwarf/dwarf-int.c b/plugins/dwarf/dwarf-int.c deleted file mode 100644 index 365414b..0000000 --- a/plugins/dwarf/dwarf-int.c +++ /dev/null @@ -1,207 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * dwarf-int.c - structures internes du format DWARF - * - * Copyright (C) 2015-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 "dwarf-int.h" - - - -/****************************************************************************** -* * -* 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 DWARF.* -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool read_dwarf_section_header(GBinContent *content, vmpa2t *pos, SourceEndian endian, dw_section_header *header) -{ - bool result; /* Bilan à retourner */ - uint32_t first; /* Premier paquet d'octets */ - bool status; /* Bilan d'opération */ - - result = false; - - status = g_binary_content_read_u32(content, pos, endian, &first); - if (!status) goto rdsh_exit; - - if (first >= 0xfffffff0 && first != 0xffffffff) - goto rdsh_exit; - - if (first == 0xffffffff) - { - result = g_binary_content_read_u64(content, pos, endian, &header->unit_length); - header->is_32b = false; - } - else - { - result = true; - header->unit_length = first; - header->is_32b = true; - } - - result &= g_binary_content_read_u16(content, pos, endian, &header->version); - - rdsh_exit: - - 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/plugins/dwarf/dwarf-int.h b/plugins/dwarf/dwarf-int.h deleted file mode 100644 index 6f8f921..0000000 --- a/plugins/dwarf/dwarf-int.h +++ /dev/null @@ -1,185 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * dwarf-int.h - prototypes pour les structures internes 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/>. - */ - - -#ifndef _FORMAT_DWARF_DWARF_INT_H -#define _FORMAT_DWARF_DWARF_INT_H - - -#include "dwarf.h" - - -#include <stdint.h> - - - - -#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 */ -typedef struct _dw_section_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 */ - -} dw_section_header; - - - - - - -/* Procède à la lecture de l'en-tête d'un contenu binaire ELF. */ -bool read_dwarf_section_header(GBinContent *, vmpa2t *, SourceEndian, dw_section_header *); - - - - - -/* 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) */ -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 *); - - - - - - - - - - - - - - - - -/* Format du DWARF */ -typedef enum _DwarfFormat -{ - DWF_32_BITS, /* Mode 32 bits */ - DWF_64_BITS /* Mode 64 bits */ - -} DwarfFormat; - - - - - -/* Eléments récupérés sur une fonction */ -typedef struct _dw_dbg_function -{ - char *name; /* Nom de la fonction */ - char *prototype; /* Chaîne descriptive */ - - uint64_t low_pc; /* Début de la fonction */ - uint64_t high_pc; /* Fin de la fonction */ - -} dw_dbg_function; - - -#if 0 -/* Description du format DWARF */ -struct _dwarf_format -{ - dbg_format dummy; /* A laisser en premier */ - - DwarfFormat format; /* Format de l'instance */ - - dw_abbrev **abbrevs; /* Liste des abréviations */ - size_t abbrevs_count; /* Nombre de ces abréviations */ - - dw_dbg_function **dbg_functions; /* Liste de fonctions trouvées */ - size_t dbg_fc_count; /* Nombre de ces fonctions */ - -}; -#endif - - - -#endif /* _FORMAT_DWARF_DWARF_INT_H */ diff --git a/plugins/dwarf/dwarf_def.h b/plugins/dwarf/dwarf_def.h deleted file mode 100644 index 6641576..0000000 --- a/plugins/dwarf/dwarf_def.h +++ /dev/null @@ -1,830 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * dwarf_def.h - liste des constantes utilisées par le 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/>. - */ - - -#ifndef _FORMAT_DWARF_DWARF_DEF_H -#define _FORMAT_DWARF_DWARF_DEF_H - - - -#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 -{ - 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 - - - -#endif /* _FORMAT_DWARF_DWARF_DEF_H */ diff --git a/plugins/dwarf/form.c b/plugins/dwarf/form.c index d7922f7..78fbd63 100644 --- a/plugins/dwarf/form.c +++ b/plugins/dwarf/form.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * form.h - prototypes pour la transmission des valeurs d'attributs * - * Copyright (C) 2016-2017 Cyrille Bagard + * Copyright (C) 2016-2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -24,6 +24,412 @@ #include "form.h" +#include <malloc.h> + + +#include "format-int.h" + + + +/* Valeurs dans DWARF */ +union _dw_form_value +{ + /** + * Version 2. + */ + /* 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; + + + /** + * Version 4. + */ + + /* 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; + +}; + + +/****************************************************************************** +* * +* Paramètres : format = contenu binaire de débogage à parcourir. * +* content = contenu encadré à parcourir. * +* pos = tête de lecture au sein des données. [OUT] * +* cu = unité de compilation parente. * +* form = nature de la valeur à lire. * +* output = valeur au format donné lue. [OUT] * +* * +* Description : Lit la valeur correspondant à un type donné. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool read_dwarf_form_value(const GDwarfFormat *format, GBinContent *content, vmpa2t *pos, const dw_compil_unit_header *cu, DwarfForm form, dw_form_value **output) +{ + bool result; /* Bilan de lecture à renvoyer */ + dw_form_value *value; /* Valeur constituée */ + SourceEndian endian; /* Boutisme des enregistrements*/ + + + 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 */ + GExeFormat *exe; /* Format d'exécutable rattaché*/ + mrange_t range; /* Couverture d'une section */ + vmpa2t iter; /* Point de lecture parallèle */ + + + value = (dw_form_value *)malloc(sizeof(dw_form_value)); + + endian = g_binary_format_get_endianness(G_BIN_FORMAT(format)); + + switch (form) + { + + + + + /* Version 2 */ + + + 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) + { + exe = G_DBG_FORMAT(format)->executable; + result = g_exe_format_get_section_range_by_name(exe, ".debug_str", &range); + } + + if (result) + { + copy_vmpa(&iter, get_mrange_addr(&range)); + + result = g_binary_content_seek(content, &iter, offset); + + if (!result) + break; + + 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; + + + + + + + + + + + + + + + + + /* Version 4 */ + + 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 = false; + break; + + } + + if (result) + *output = value; + else + free_dwarf_form_value(value); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : value = valeur à librérer de la mémoire. * +* * +* Description : Supprime de la mémoire une valeur correspondant à un type. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void free_dwarf_form_value(dw_form_value *value) +{ + free(value); + +} + /****************************************************************************** * * @@ -48,23 +454,23 @@ bool translate_form_into_address(const dw_form_value *value, DwarfForm form, vir switch (form) { case DW_FORM_addr: - *addr = value->v2.address; + *addr = value->address; break; case DW_FORM_data1: - *addr = value->v2.data1; + *addr = value->data1; break; case DW_FORM_data2: - *addr = value->v2.data2; + *addr = value->data2; break; case DW_FORM_data4: - *addr = value->v2.data4; + *addr = value->data4; break; case DW_FORM_data8: - *addr = value->v2.data8; + *addr = value->data8; break; default: @@ -99,7 +505,7 @@ const char *translate_form_into_string(const dw_form_value *value, DwarfForm for { case DW_FORM_string: case DW_FORM_strp: - result = value->v2.string; + result = value->string; break; default: diff --git a/plugins/dwarf/form.h b/plugins/dwarf/form.h index bdef9b3..ec1ce1a 100644 --- a/plugins/dwarf/form.h +++ b/plugins/dwarf/form.h @@ -25,9 +25,22 @@ #define _FORMAT_DWARF_FORM_H -#include "dwarf_def.h" +#include "format.h" +#include <analysis/content.h> + + + +/* Valeurs dans DWARF */ +typedef union _dw_form_value dw_form_value; + + +/* Lit la valeur correspondant à un type donné. */ +bool read_dwarf_form_value(const GDwarfFormat *, GBinContent *, vmpa2t *, const dw_compil_unit_header *, DwarfForm, dw_form_value **); + +/* Supprime de la mémoire une valeur correspondant à un type. */ +void free_dwarf_form_value(dw_form_value *); /* Transcrit une valeur Dwarf brute en adresse virtuelle. */ bool translate_form_into_address(const dw_form_value *, DwarfForm, virt_t *); diff --git a/plugins/dwarf/format-int.h b/plugins/dwarf/format-int.h new file mode 100644 index 0000000..c13af65 --- /dev/null +++ b/plugins/dwarf/format-int.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * dwarf-int.h - prototypes pour les structures internes du format DWARF + * + * Copyright (C) 2018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _PLUGINS_DWARF_FORMAT_INT_H +#define _PLUGINS_DWARF_FORMAT_INT_H + + +#include "format.h" + + +#include <format/debuggable-int.h> + + +#include "abbrev.h" +#include "die.h" + + + +/* Format de débogage DWARF (instance) */ +struct _GDwarfFormat +{ + GDbgFormat parent; /* A laisser en premier */ + + dw_die **info; /* DIE de debug_info */ + size_t info_count; /* Quantité de ces éléments */ + +}; + +/* Format de débogage DWARF (classe) */ +struct _GDwarfFormatClass +{ + GDbgFormatClass parent; /* A laisser en premier */ + +}; + + + +#endif /* _PLUGINS_DWARF_FORMAT_INT_H */ diff --git a/plugins/dwarf/dwarf.c b/plugins/dwarf/format.c index 0c0dab8..6bd47cd 100644 --- a/plugins/dwarf/dwarf.c +++ b/plugins/dwarf/format.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * dwarf.c - support du format Dwarf * - * Copyright (C) 2009-2017 Cyrille Bagard + * Copyright (C) 2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,14 +21,18 @@ */ -#include "dwarf.h" +#include "format.h" -#include "abbrev.h" -#include "dwarf-int.h" +#include <i18n.h> +#include <common/cpp.h> +#include <format/format.h> + + +#include "def.h" +#include "format-int.h" #include "info.h" -#include "symbols.h" -#include "../../common/cpp.h" +#include "utils.h" @@ -44,166 +48,41 @@ static void g_dwarf_format_dispose(GDwarfFormat *); /* Procède à la libération totale de la mémoire. */ static void g_dwarf_format_finalize(GDwarfFormat *); +/* Assure l'interprétation d'un format en différé. */ +static bool g_dwarf_format_analyze(GDwarfFormat *, wgroup_id_t, GtkStatusStack *); + /****************************************************************************** * * -* Paramètres : content = contenu binaire à parcourir. * -* parent = éventuel format exécutable déjà chargé. * -* unused = adresse non utilisée ici. * -* key = identifiant de format trouvé ou NULL. [OUT] * +* Paramètres : format = exécutable auquel on peut tenter de se raccrocher. * * * -* Description : Indique si le format peut être pris en charge ici. * +* Description : Valide un contenu comme étant un format Dwarf. * * * -* Retour : Conclusion de haut niveau sur la reconnaissance effectuée. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -FormatMatchStatus dwarf_is_matching(GBinContent *content, GExeFormat *parent, void *unused, char **key) +GDbgFormat *check_dwarf_format(GExeFormat *format) { - FormatMatchStatus result; /* Bilan à renvoyer */ - size_t i; /* Boucle de parcours */ - mrange_t range; /* Couverture d'une section */ - dw_section_header header; /* En-tête DWARF de section */ - bool found; /* Bilan d'une comparaison */ + GDbgFormat *result; /* Eventuel format à renvoyer */ + bool matched; /* Correspondance probable */ + size_t i; /* Boucle de parcours #1 */ static const char *section_names[] = { - ".debug_aranges", - ".debug_frame", - ".debug_info", - ".debug_line", - ".debug_pubnames", - ".debug_pubtypes", - ".debug_types" - }; - - static const uint16_t dwarf_v2_versions[] = { - 2, /* .debug_aranges */ - 1, /* .debug_frame */ - 2, /* .debug_info */ - 2, /* .debug_line */ - 2, /* .debug_pubnames */ - 0, /* .debug_pubtypes */ - 0 /* .debug_types */ + ".debug_abbrev", + ".debug_info" }; - static const uint16_t dwarf_v3_versions[] = { - 2, /* .debug_aranges */ - 3, /* .debug_frame */ - 3, /* .debug_info */ - 3, /* .debug_line */ - 2, /* .debug_pubnames */ - 2, /* .debug_pubtypes */ - 0 /* .debug_types */ - }; - - static const uint16_t dwarf_v4_versions[] = { - 2, /* .debug_aranges */ - 4, /* .debug_frame */ - 4, /* .debug_info */ - 4, /* .debug_line */ - 2, /* .debug_pubnames */ - 2, /* .debug_pubtypes */ - 4 /* .debug_types */ - }; - - uint16_t current_versions[] = { - 0, /* .debug_aranges */ - 0, /* .debug_frame */ - 0, /* .debug_info */ - 0, /* .debug_line */ - 0, /* .debug_pubnames */ - 0, /* .debug_pubtypes */ - 0 /* .debug_types */ - }; - - result = FMS_UNKNOWN; - - if (parent == NULL) - return FMS_UNKNOWN; - return FMS_UNKNOWN; - *key = strdup("dwarf_v4"); - return FMS_MATCHED; - - /* Lecture des indices présents */ - - for (i = 0; i < ARRAY_SIZE(section_names); i++) - { - if (!g_exe_format_get_section_range_by_name(parent, section_names[i], &range)) - continue; - - if (!read_dwarf_section_header(content, get_mrange_addr(&range), SRE_LITTLE /* FIXME */, &header)) - continue; - - current_versions[i] = header.version; - - } - - /* Détermination d'une version bien identifiée */ - - bool check_dwarf_version(const uint16_t *ref, const uint16_t *cur, size_t count) - { - bool equal; - size_t k; - - 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; - - } - - /** - * Un fichier DWARF sans section sera vu comme un fichier DWARF de - * dernière génération. - * Ce qui n'est pas très grave car rien ne sera chargé par la suite, - * du fait de l'absence de section, donc il n'y aura pas d'incompatibilité. - */ + matched = true; - printf("---dwarf v4\n"); + for (i = 0; i < ARRAY_SIZE(section_names) && matched; i++) + matched = g_exe_format_get_section_range_by_name(format, section_names[i], (mrange_t []) { 0 }); - found = check_dwarf_version(dwarf_v4_versions, current_versions, ARRAY_SIZE(section_names)); - - if (found) - { - result = FMS_MATCHED; - *key = strdup("dwarf_v4"); - } - - if (result == FMS_UNKNOWN) - { - printf("---dwarf v3\n"); - - found = check_dwarf_version(dwarf_v3_versions, current_versions, ARRAY_SIZE(section_names)); - - if (found) - { - result = FMS_MATCHED; - *key = strdup("dwarf_v3"); - } - - } - - if (result == FMS_UNKNOWN) - { - printf("---dwarf v2\n"); - - found = check_dwarf_version(dwarf_v2_versions, current_versions, ARRAY_SIZE(section_names)); - - if (found) - { - result = FMS_MATCHED; - *key = strdup("dwarf_v2"); - } - - } + if (matched) + result = g_dwarf_format_new(format); return result; @@ -229,12 +108,17 @@ G_DEFINE_TYPE(GDwarfFormat, g_dwarf_format, G_TYPE_DBG_FORMAT); static void g_dwarf_format_class_init(GDwarfFormatClass *klass) { GObjectClass *object; /* Autre version de la classe */ + GBinFormatClass *fmt; /* Version en format basique */ object = G_OBJECT_CLASS(klass); object->dispose = (GObjectFinalizeFunc/* ! */)g_dwarf_format_dispose; object->finalize = (GObjectFinalizeFunc)g_dwarf_format_finalize; + fmt = G_BIN_FORMAT_CLASS(klass); + + fmt->analyze = (format_analyze_fc)g_dwarf_format_analyze; + } @@ -289,6 +173,15 @@ static void g_dwarf_format_dispose(GDwarfFormat *format) static void g_dwarf_format_finalize(GDwarfFormat *format) { + size_t i; /* Boucle de parcours */ + + for (i = 0; i < format->info_count; i++) + if (format->info[i] != NULL) + delete_dwarf_die(format->info[i]); + + if (format->info != NULL) + free(format->info); + G_OBJECT_CLASS(g_dwarf_format_parent_class)->finalize(G_OBJECT(format)); } @@ -296,42 +189,56 @@ static void g_dwarf_format_finalize(GDwarfFormat *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. * +* Paramètres : parent = éventuel format exécutable déjà chargé. * + * +* Description : Prend en charge un nouveau format DWARF. * * * -* Retour : Bilan du chargement : réussi ou non ? * +* Retour : Adresse de la structure mise en place ou NULL en cas d'échec.* * * * Remarques : - * * * ******************************************************************************/ -bool g_dwarf_format_load(GDwarfFormat *format, GExeFormat *executable) +GDbgFormat *g_dwarf_format_new(GExeFormat *parent) { - bool result; /* Bilan à faire remonter */ + GDwarfFormat *result; /* Structure à retourner */ + GBinContent *content; /* Contenu binaire à lire */ - result = true; + result = g_object_new(G_TYPE_DWARF_FORMAT, NULL); - g_debuggable_format_attach_executable(G_DBG_FORMAT(format), executable); + G_DBG_FORMAT(result)->executable = parent; + g_object_ref(G_OBJECT(parent)); - printf("Loading abbrev...\n"); + content = G_BIN_FORMAT(parent)->content; - result &= load_all_dwarf_abbreviations(format); + G_BIN_FORMAT(result)->content = content; + g_object_ref(G_OBJECT(content)); - printf("Loading debug info...\n"); + return G_DBG_FORMAT(result); - result &= load_dwarf_debug_information(format); +} - printf("Done!\n"); - result &= load_dwarf_symbols(format); +/****************************************************************************** +* * +* Paramètres : format = format chargé dont l'analyse est lancée. * +* gid = groupe de travail dédié. * +* status = barre de statut à tenir informée. * +* * +* Description : Assure l'interprétation d'un format en différé. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ - printf("Got symbols...\n"); +static bool g_dwarf_format_analyze(GDwarfFormat *format, wgroup_id_t gid, GtkStatusStack *status) +{ + bool result; /* Bilan à retourner */ - exit(0); + result = load_dwarf_debug_information(format, gid, status); return result; } - diff --git a/plugins/dwarf/dwarf.h b/plugins/dwarf/format.h index ad2f008..73933d4 100644 --- a/plugins/dwarf/dwarf.h +++ b/plugins/dwarf/format.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * dwarf.h - prototypes pour le support du format Dwarf * - * Copyright (C) 2009-2017 Cyrille Bagard + * Copyright (C) 2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,17 +21,24 @@ */ -#ifndef _FORMAT_DWARF_DWARF_H -#define _FORMAT_DWARF_DWARF_H +#ifndef _PLUGINS_DWARF_FORMAT_H +#define _PLUGINS_DWARF_FORMAT_H -#include "../../core/formats.h" +#include <glib-object.h> + + +#include <format/debuggable.h> +#include <format/executable.h> + + +#include "def.h" #define G_TYPE_DWARF_FORMAT g_dwarf_format_get_type() -#define G_DWARF_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dwarf_format_get_type(), GDwarfFormat)) -#define G_IS_DWARF_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dwarf_format_get_type())) +#define G_DWARF_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_DWARF_FORMAT, GDwarfFormat)) +#define G_IS_DWARF_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_DWARF_FORMAT)) #define G_DWARF_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DWARF_FORMAT, GDwarfFormatClass)) #define G_IS_DWARF_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DWARF_FORMAT)) #define G_DWARF_FORMAT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DWARF_FORMAT, GDwarfFormatClass)) @@ -44,12 +51,15 @@ typedef struct _GDwarfFormat GDwarfFormat; typedef struct _GDwarfFormatClass GDwarfFormatClass; -/* Indique si le format peut être pris en charge ici. */ -FormatMatchStatus dwarf_is_matching(GBinContent *, GExeFormat *, void *, char **); +/* Valide un contenu comme étant un format Dwarf. */ +GDbgFormat *check_dwarf_format(GExeFormat *); /* Indique le type défini pour un format de débogage DWARF. */ GType g_dwarf_format_get_type(void); +/* Prend en charge un nouveau format DWARF. */ +GDbgFormat *g_dwarf_format_new(GExeFormat *); + -#endif /* _FORMAT_DWARF_DWARF_H */ +#endif /* _PLUGINS_DWARF_FORMAT_H */ diff --git a/plugins/dwarf/info.c b/plugins/dwarf/info.c index 432280e..7a2be44 100644 --- a/plugins/dwarf/info.c +++ b/plugins/dwarf/info.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * info.c - lecture des informations principales du format DWARF * - * Copyright (C) 2008-2017 Cyrille Bagard + * Copyright (C) 2008-2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -24,215 +24,43 @@ #include "info.h" -#include "die.h" -#include "dwarf-int.h" -#include "../debuggable-int.h" - - +#include <i18n.h> +#include <analysis/contents/restricted.h> +#include <core/nproc.h> +#include <glibext/seq.h> +#include <core/global.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); +#include "die.h" +#include "format-int.h" +#include "utils.h" +#define RANGE_ALLOC_BLOCK 100 -/****************************************************************************** -* * -* 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) +/* Rassemblement des informations utiles */ +typedef struct _work_data { - 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); - - - - } + GDwarfFormat *format; /* Format à manipuler */ + mrange_t *ranges; /* Espace des DIE à charger */ +} work_data; - format->info_die = die; - - - lddi_exit: - - return result; - -} +/* Procède au chargement d'un DIE de la section debug_info. */ +static bool extract_dies_from_debug_info(const work_data *, size_t, GtkStatusStack *, activity_id_t); /****************************************************************************** * * * 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> +* gid = groupe de travail impliqué. * + status = barre de statut à tenir informée. * - -#include "abbrev.h" -#include "dwarf-int.h" -#include "utils.h" - - -/* Informations utiles d'une unité de compilation */ -typedef struct _compil_unit -{ - off_t startpos; /* Position de début d'unité */ - off_t endpos; /* Position d'unité suivante */ - - off_t offset; /* Position dans les abréviat° */ - uint8_t ptrsize; /* Taille des adresses mémoire */ - -} compil_unit; - - - -#define _(str) str - - -/* Procède à la lecture d'une unité de compilation. */ -bool read_dwarf_compilation_unit(dwarf_format *, off_t *, compil_unit *); - -/* Récupère toutes les déclarations DWARF utiles trouvées. */ -bool parse_dwarf_compilation_unit(dwarf_format *, off_t *, const compil_unit *); - -/* Enregistre toutes les déclarations de fonction trouvées. */ -dw_dbg_function *look_for_dwarf_subprograms(dwarf_format *, const dw_abbrev *, off_t *, const compil_unit *); - -/* Obtient la description humaine d'un type. */ -char *resolve_dwarf_function_type(dwarf_format *, const dw_abbrev *, const off_t *, const compil_unit *); - - - - -/****************************************************************************** * * -* Paramètres : format = informations de débogage à compléter. * -* * -* Description : Charge les informations trouvées dans un DWARF. * +* Description : Charge les informations depuis une section ".debug_info". * * * * Retour : Bilan de l'opération. * * * @@ -240,614 +68,190 @@ char *resolve_dwarf_function_type(dwarf_format *, const dw_abbrev *, const off_t * * ******************************************************************************/ -bool load_dwarf_information(dwarf_format *format) +bool load_dwarf_debug_information(GDwarfFormat *format, wgroup_id_t gid, GtkStatusStack *status) { bool result; /* Bilan à renvoyer */ - - - - - off_t offset; - off_t start; - off_t size; - - bool test; - - int i; - - - compil_unit cu; - - - - result = true; - - test = find_exe_section(DBG_FORMAT(format)->e_format, ".debug_info", &start, &size, NULL); - - offset = start; - - - printf(" -> offset=%d size=%d\n", offset, size); - - - - for (i = 0; i < size; i++) - { - if (i % 25 == 0) printf("\n"); - printf("0x%02hhx ", DBG_FORMAT(format)->content[offset + i]); - } - - printf("\n"); - - - - while (offset < (start + size) && result) - { - printf("-------------\n"); - - result = read_dwarf_compilation_unit(format, &offset, &cu); - - if (result) - parse_dwarf_compilation_unit(format, &offset, &cu); - - } - - - printf("##############\nRegistered functions:\n"); - - for (i = 0; i < format->dbg_fc_count; i++) - printf(" > [0x%08llx] %s\n", format->dbg_functions[i]->low_pc, format->dbg_functions[i]->prototype); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : format = informations de débogage à effacer. * -* * -* Description : Décharge les informations trouvées dans un DWARF. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void unload_dwarf_information(dwarf_format *format) -{ - - - -} - - -/****************************************************************************** -* * -* Paramètres : format = informations de débogage à compléter. * -* pos = tête de lecture à mettre à jour. [OUT] * -* cu = unité de compilation lue. [OUT] * -* * -* Description : Procède à la lecture d'une unité de compilation. * -* * -* Retour : true en cas de succès de la lecture, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool read_dwarf_compilation_unit(dwarf_format *format, off_t *pos, compil_unit *cu) -{ - off_t ulength; /* Taille de l'unité */ - uint16_t version; /* Version du format DWARF */ - - cu->startpos = *pos; - - if (!read_unit_length(format, pos, &ulength)) - return false; - - cu->endpos = *pos + ulength; - - if (!read_uhalf(format, pos, &version)) - return false; - - if (version > 3) return false; - - if (!read_abbrev_offset(format, pos, &cu->offset)) - return false; - - if (!read_address_size(format, pos, &cu->ptrsize)) - return false; - - return true; - -} - - -/****************************************************************************** -* * -* Paramètres : format = informations de débogage à compléter. * -* pos = tête de lecture à mettre à jour. [OUT] * -* cu = unité de compilation courante. * -* * -* Description : Récupère toutes les déclarations DWARF utiles trouvées. * -* * -* Retour : true en cas de succès de la lecture, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool parse_dwarf_compilation_unit(dwarf_format *format, off_t *pos, const compil_unit *cu) -{ - bool result; /* Bilan à retourner */ - const dw_abbrev *abbrev; /* Abréviation rencontrée */ - dw_dbg_function *function; /* Nouvelle fonction lue */ - - - - result = true; - - while (*pos < cu->endpos && result) + GExeFormat *exe; /* Exécutable associé */ + mrange_t range; /* Couverture d'une section */ + GBinContent *content; /* Contenu binaire à lire */ + GBinContent *restricted; /* Limitation des traitements */ + vmpa2t stop; /* Point d'arrivée à atteindre */ + mrange_t *ranges; /* Séquences de zones à traiter*/ + size_t count; /* Nombre de ces séquences */ + size_t allocated; /* Quantité d'allocations */ + SourceEndian endian; /* Boutisme du format parent */ + vmpa2t iter; /* Tête de lecture mouvante */ + vmpa2t start; /* Sauvegarde de position */ + dw_compil_unit_header header; /* Unité à cerner puis traiter */ + vmpa2t next; /* Départ de l'unité suivante */ + phys_t size; /* Taille complète d'une unité */ + work_data data; /* Données à communiquer */ + guint runs_count; /* Qté d'exécutions parallèles */ + size_t run_size; /* Volume réparti par exécution*/ + GWorkQueue *queue; /* Gestionnaire de différés */ + activity_id_t msg; /* Message de progression */ + guint i; /* Boucle de parcours */ + size_t begin; /* Début de bloc de traitement */ + size_t end; /* Fin d'un bloc de traitement */ + GSeqWork *work; /* Tâche de chargement à lancer*/ + + exe = G_DBG_FORMAT(format)->executable; + + result = g_exe_format_get_section_range_by_name(exe, ".debug_info", &range); + + if (result) { + content = G_BIN_FORMAT(format)->content; + restricted = g_restricted_content_new(content, &range); - printf(" =+> Cur :: 0x%02hhx 0x%02hhx 0x%02hhx 0x%02hhx 0x%02hhx\n", - DBG_FORMAT(format)->content[*pos], - DBG_FORMAT(format)->content[*pos + 1], - DBG_FORMAT(format)->content[*pos + 2], - DBG_FORMAT(format)->content[*pos + 3], - DBG_FORMAT(format)->content[*pos + 4]); - - - - abbrev = find_dwarf_abbreviations(format, &cu->offset, pos); - - if (abbrev == NULL) - break; + compute_mrange_end_addr(&range, &stop); + /* Constitution des zones de travail */ + ranges = NULL; + count = 0; + allocated = 0; - printf(" --> %p\n", abbrev); + endian = g_binary_format_get_endianness(G_BIN_FORMAT(exe)); - printf(" == 0x%02x (matched ? %d)\n", abbrev->tag, abbrev->tag == DWT_SUBPROGRAM); - - - - switch (abbrev->tag) + for (copy_vmpa(&iter, get_mrange_addr(&range)); + result && cmp_vmpa(&iter, &stop) < 0; + copy_vmpa(&iter, &next)) { - case DWT_SUBPROGRAM: - function = look_for_dwarf_subprograms(format, abbrev, pos, cu); - - if (function != NULL) - { - format->dbg_functions = (dw_dbg_function **)realloc(format->dbg_functions, ++format->dbg_fc_count * sizeof(dw_dbg_function *)); - format->dbg_functions[format->dbg_fc_count - 1] = function; - } - else result = false; - - break; - - default: - break; - - } - - - + copy_vmpa(&start, &iter); + result = read_dwarf_compil_unit_header(restricted, &iter, endian, &header, &next); + if (!result) break; + if (count == allocated) + { + allocated += RANGE_ALLOC_BLOCK; + ranges = realloc(ranges, allocated * sizeof(mrange_t)); + } + size = compute_vmpa_diff(&start, &next); + init_mrange(&ranges[count++], &start, size); + } + if (!result) + goto exit; + /* Préparation des réceptacles */ + format->info = calloc(count, sizeof(dw_die *)); + format->info_count = count; - if (!skip_dwarf_abbrev(format, pos, abbrev)) - printf("error skipping :(\n"); - - - } - - - printf(" =+> Next :: 0x%02hhx 0x%02hhx 0x%02hhx 0x%02hhx 0x%02hhx\n", - DBG_FORMAT(format)->content[*pos], - DBG_FORMAT(format)->content[*pos + 1], - DBG_FORMAT(format)->content[*pos + 2], - DBG_FORMAT(format)->content[*pos + 3], - DBG_FORMAT(format)->content[*pos + 4]); - - - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : format = informations de débogage à compléter. * -* abbrev = abréviation trouvée à traiter. * -* pos = tête de lecture à mettre à jour. [OUT] * -* cu = unité de compilation courante. * -* * -* Description : Enregistre toutes les déclarations de fonction trouvées. * -* * -* Retour : Fonction chargée en mémoire ou NULL en cas d'échec. * -* * -* Remarques : - * -* * -******************************************************************************/ - -dw_dbg_function *look_for_dwarf_subprograms(dwarf_format *format, const dw_abbrev *abbrev, off_t *pos, const compil_unit *cu) -{ - dw_dbg_function *result; /* Structure à retourner */ - uint32_t type_pos; /* Décalage p/r au pt courant */ - off_t subpos; /* Sous-position de lecture #1 */ - const dw_abbrev *subabbrev; /* Abréviation fille à lire */ - char *retstr; /* Elément du prototype */ - char *prototype; /* Stockage temporaire */ - size_t proto_len; /* Taille du prototype */ - bool is_pointer; /* Mémorise le type 'pointeur' */ - uint64_t index; /* Index de la fonction */ - bool first_arg; /* Marque le 1er argument */ - off_t subpos2; /* Sous-position de lecture #2 */ - const dw_abbrev *subabbrev2; /* Abréviation fille à lire #2 */ - - result = (dw_dbg_function *)calloc(1, sizeof(dw_dbg_function)); - - /* Récupération des informations de base */ - - if (!read_dwarf_abbrev_attribute(format, pos, false, abbrev, DWA_NAME, &result->name)) - goto lfds_error; - - if (!read_dwarf_abbrev_attribute(format, pos, false, abbrev, DWA_LOW_PC, &result->low_pc)) - goto lfds_error; - - if (!read_dwarf_abbrev_attribute(format, pos, false, abbrev, DWA_HIGH_PC, &result->high_pc)) - goto lfds_error; - - /* Type de la fonction */ - - if (test_dwarf_abbrev_attribute(abbrev, DWA_TYPE)) - { - if (!read_dwarf_abbrev_attribute(format, pos, false, abbrev, DWA_TYPE, &type_pos)) - goto lfds_error; - - subpos = cu->startpos + type_pos; - - subabbrev = find_dwarf_abbreviations(format, &cu->offset, &subpos); - - retstr = resolve_dwarf_function_type(format, subabbrev, &subpos, cu); - - } - else retstr = strdup("void"); - - if (retstr == NULL) - { - proto_len = 3; - prototype = (char *)calloc(proto_len + 1, sizeof(char)); - strcat(prototype, "???"); - - is_pointer = false; - - } - else - { - proto_len = strlen(retstr); - prototype = (char *)calloc(proto_len + 1, sizeof(char)); - strcat(prototype, retstr); - - is_pointer = (retstr[strlen(retstr) - 1] == '*'); - - free(retstr); - - } - - /* On saute l'abréviation de la déclaration de fonction... */ - - subpos = *pos; + data.format = format; + data.ranges = ranges; - if (!read_uleb128(format, &subpos, &index, true)) - goto lfds_error; + /* Lancement des travaux */ - if (!skip_dwarf_abbrev(format, &subpos, abbrev)) - goto lfds_error; + runs_count = get_max_online_threads(); - /* Lecture des différents arguments */ + run_size = count / runs_count; - proto_len += (!is_pointer ? 1 : 0) + strlen(result->name) + 1; - prototype = (char *)realloc(prototype, (proto_len + 1) * sizeof(char)); - if (!is_pointer) strcat(prototype, " "); - strcat(prototype, result->name); - strcat(prototype, "("); + queue = get_work_queue(); - first_arg = true; + msg = gtk_status_stack_add_activity(status, _("Loading all information from the .debug_info section..."), + get_mrange_length(&range)); - while (1) - { - subabbrev = find_dwarf_abbreviations(format, &cu->offset, &subpos); - if (subabbrev == NULL) goto exit_loop; - - switch (subabbrev->tag) + for (i = 0; i < runs_count; i++) { - case DWT_UNSPECIFIED_PARAMETERS: - - /* Virgule de séparation */ - - if (first_arg) first_arg = false; - else - { - proto_len += 2; - prototype = (char *)realloc(prototype, (proto_len + 1) * sizeof(char)); - strcat(prototype, ", "); - } - - /* Marque de l'absence de type */ - - proto_len += 3; - prototype = (char *)realloc(prototype, (proto_len + 1) * sizeof(char)); - strcat(prototype, "..."); - - break; - - case DWT_FORMAL_PARAMETER: - - if (!read_dwarf_abbrev_attribute(format, &subpos, false, subabbrev, DWA_TYPE, &type_pos)) - goto lfds_error; - - subpos2 = cu->startpos + type_pos; - - subabbrev2 = find_dwarf_abbreviations(format, &cu->offset, &subpos2); - - retstr = resolve_dwarf_function_type(format, subabbrev2, &subpos2, cu); - - /* Virgule de séparation */ - - if (first_arg) first_arg = false; - else - { - proto_len += 2; - prototype = (char *)realloc(prototype, (proto_len + 1) * sizeof(char)); - strcat(prototype, ", "); - } + begin = i * run_size; - /* Type de l'argument */ + if ((i + 1) == runs_count) + end = count; + else + end = begin + run_size; - if (retstr == NULL) - { - proto_len += 3; - prototype = (char *)realloc(prototype, (proto_len + 1) * sizeof(char)); - strcat(prototype, "???"); + work = g_seq_work_new_boolean(&data, begin, end, msg, + (seq_work_bool_cb)extract_dies_from_debug_info, &result); - is_pointer = false; + g_work_queue_schedule_work(queue, G_DELAYED_WORK(work), gid); - } - else - { - proto_len += strlen(retstr); - prototype = (char *)realloc(prototype, (proto_len + 1) * sizeof(char)); - strcat(prototype, retstr); - - is_pointer = (retstr[strlen(retstr) - 1] == '*'); - - free(retstr); - - } - - /* Nom de l'argument */ - - if (test_dwarf_abbrev_attribute(abbrev, DWA_NAME)) - { - if (!read_dwarf_abbrev_attribute(format, &subpos, false, subabbrev, DWA_NAME, &retstr)) - goto lfds_error; - } - else retstr = strdup(_("[no name]")); - - if (retstr != NULL) - { - proto_len += strlen(retstr) + (!is_pointer ? 1 : 0) + 1; - prototype = (char *)realloc(prototype, (proto_len + 1) * sizeof(char)); - if (!is_pointer) strcat(prototype, " "); - strcat(prototype, retstr); - - free(retstr); + } - } + g_work_queue_wait_for_completion(queue, gid); - break; + gtk_status_stack_remove_activity(status, msg); - default: - goto exit_loop; - break; + exit: - } + if (ranges != NULL) + free(ranges); - if (!skip_dwarf_abbrev(format, &subpos, subabbrev)) - goto lfds_error; + g_object_unref(G_OBJECT(restricted)); } - exit_loop: - - proto_len += 1; - prototype = (char *)realloc(prototype, (proto_len + 1) * sizeof(char)); - strcat(prototype, ")"); - - result->prototype = prototype; - return result; - lfds_error: - - if (result->name != NULL) free(result->name); - if (result->prototype != NULL) free(result->prototype); - - free(result); - - return NULL; - } /****************************************************************************** * * -* Paramètres : format = informations de débogage à compléter. * -* abbrev = abréviation associée au type. * -* pos = tête de lecture à avoir sous le coude. * -* cu = unité de compilation courante. * +* Paramètres : data = ensemble d'informations utiles à l'opération. * +* i = indice des éléments à traiter. * +* status = barre de statut à tenir informée. * +* id = identifiant du message affiché à l'utilisateur. * * * -* Description : Obtient la description humaine d'un type. * +* Description : Procède au chargement d'un DIE de la section debug_info. * * * -* Retour : Chaîne de caractères en cas de succès, NULL sinon. * +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -char *resolve_dwarf_function_type(dwarf_format *format, const dw_abbrev *abbrev, const off_t *pos, const compil_unit *cu) +static bool extract_dies_from_debug_info(const work_data *data, size_t i, GtkStatusStack *status, activity_id_t id) { - char *result; /* Description à retourner */ - off_t oldpos; /* Conservation de l'indice */ - uint32_t type_pos; /* Sous-type détecté */ - uint64_t index; /* Indice de l'abréviation... */ - const dw_abbrev *subabbrev; /* ... et abréviation associée */ - size_t len; /* Longeur d'un résultat */ - - result = NULL; - oldpos = *pos; - - switch (abbrev->tag) - { - /* 0x04 */ - case DWT_ENUMERATION_TYPE: - - oldpos = *pos; - read_dwarf_abbrev_attribute(format, &oldpos, true /* ??? */, abbrev, DWA_NAME, &result); - - if (result != NULL) - { - len = strlen(result); - - result = (char *)realloc(result, (strlen("enum ") + len + 1) * sizeof(char)); - memmove(&result[strlen("enum ")], result, len); - memcpy(result, "enum ", strlen("enum ")); - - } - - break; - - /* 0x0f */ - case DWT_POINTER_TYPE: - - if (test_dwarf_abbrev_attribute(abbrev, DWA_TYPE)) - { - if (!read_dwarf_abbrev_attribute(format, &oldpos, true, abbrev, DWA_TYPE, &type_pos)) - return NULL; - - oldpos = cu->startpos + type_pos; - - subabbrev = find_dwarf_abbreviations(format, &cu->offset, &oldpos); - - result = resolve_dwarf_function_type(format, subabbrev, &oldpos, cu); - - } - else result = strdup("void"); - - if (result != NULL) - { - len = strlen(result); - - if (result[len - 1] == '*') - { - result = (char *)realloc(result, (len + 2) * sizeof(char)); - result[len] = '*'; - } - else - { - result = (char *)realloc(result, (len + 3) * sizeof(char)); - strcat(result, " *"); - } - - } - - break; - - /* 0x13 */ - case DWT_STRUCTURE_TYPE: - - oldpos = *pos; - read_dwarf_abbrev_attribute(format, &oldpos, true /* ??? */, abbrev, DWA_NAME, &result); - - if (result != NULL) - { - len = strlen(result); - - result = (char *)realloc(result, (strlen("struct ") + len + 1) * sizeof(char)); - memmove(&result[strlen("struct ")], result, len); - memcpy(result, "struct ", strlen("struct ")); - - } - - break; - - /* 0x16 */ - case DWT_TYPEDEF: - oldpos = *pos; - read_dwarf_abbrev_attribute(format, &oldpos, true /* ??? */, abbrev, DWA_NAME, &result); - break; - - /* 0x24 */ - case DWT_BASE_TYPE: - oldpos = *pos; - read_dwarf_abbrev_attribute(format, &oldpos, true /* ??? */, abbrev, DWA_NAME, &result); - break; - - /* 0x26 */ - case DWT_CONST_TYPE: - - - - if (read_dwarf_abbrev_attribute(format, &oldpos, true, abbrev, DWA_TYPE, &type_pos)) - printf(" ## sub type :: 0x%08x\n", type_pos); - else printf(" error: no type\n"); - - oldpos = cu->startpos + type_pos; - - - - + bool result; /* Bilan à retourner */ + GDwarfFormat *format; /* Format en cours d'analyse */ + GBinContent *content; /* Contenu binaire à lire */ + GExeFormat *exe; /* Exécutable associé */ + SourceEndian endian; /* Boutisme du format parent */ + vmpa2t iter; /* Tête de lecture mouvante */ + dw_compil_unit_header header; /* Unité à cerner puis traiter */ + vmpa2t next; /* Départ de l'unité suivante */ + dw_abbrev_brotherhood *abbrevs; /* Série d'abréviations */ + format = data->format; - subabbrev = find_dwarf_abbreviations(format, &cu->offset, &oldpos); - printf("subabbrev == %p\n", subabbrev); + /** + * Comme les informations peuvent aller taper ailleurs dans le binaire + * (par exemple dans la section debug_str pour certaine valeur, on ne peut + * pas restreinte le contenu au seul espace traité. + * + * L'en-tête lui même a déjà été valide, donc on ne s'embête pas à distinguer + * différents cas ici. + */ + content = G_BIN_FORMAT(format)->content; + exe = G_DBG_FORMAT(format)->executable; + endian = g_binary_format_get_endianness(G_BIN_FORMAT(exe)); - result = resolve_dwarf_function_type(format, subabbrev, &oldpos, cu); + copy_vmpa(&iter, get_mrange_addr(&data->ranges[i])); - if (result != NULL) - { - len = strlen(result); + result = read_dwarf_compil_unit_header(content, &iter, endian, &header, &next); + if (!result) goto exit; - result = (char *)realloc(result, (strlen("const ") + len + 1) * sizeof(char)); - memmove(&result[strlen("const ")], result, len); - memcpy(result, "const ", strlen("const ")); + abbrevs = load_all_dwarf_abbreviations(format, &header); + if (abbrevs == NULL) goto exit; - } + result = build_dwarf_die(format, content, &iter, &header, abbrevs, &format->info[i]); - break; + free_all_dwarf_abbreviations(abbrevs); - default: - printf("### NOT HANDLED ### Tag :: 0x%02x\n", abbrev->tag); - break; + gtk_status_stack_update_activity_value(status, id, get_mrange_length(&data->ranges[i])); - } + exit: return result; } -#endif diff --git a/plugins/dwarf/info.h b/plugins/dwarf/info.h index 76220e5..011b880 100644 --- a/plugins/dwarf/info.h +++ b/plugins/dwarf/info.h @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * info.h - prototypes pour la lecture des informations principales du format DWARF * - * Copyright (C) 2008-2017 Cyrille Bagard + * Copyright (C) 2008-2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,43 +21,23 @@ */ -#ifndef _FORMAT_DWARF_INFO_H -#define _FORMAT_DWARF_INFO_H +#ifndef _PLUGINS_DWARF_INFO_H +#define _PLUGINS_DWARF_INFO_H #include <stdbool.h> -#include "dwarf.h" - - - -/* Charge les informations depuis une section ".debug_info". */ -bool load_dwarf_debug_information(GDwarfFormat *); - - - - +#include <glibext/delayed.h> +#include "format.h" -#if 0 -#include <stdbool.h> - - -#include "d_dwarf.h" - - - -/* Charge les informations trouvées dans un DWARF. */ -bool load_dwarf_information(dwarf_format *); - -/* Décharge les informations trouvées dans un DWARF. */ -void unload_dwarf_information(dwarf_format *); -#endif +/* Charge les informations depuis une section ".debug_info". */ +bool load_dwarf_debug_information(GDwarfFormat *, wgroup_id_t, GtkStatusStack *); -#endif /* _FORMAT_DWARF_INFO_H */ +#endif /* _PLUGINS_DWARF_INFO_H */ diff --git a/plugins/dwarf/utils.c b/plugins/dwarf/utils.c index b767970..444d3a6 100644 --- a/plugins/dwarf/utils.c +++ b/plugins/dwarf/utils.c @@ -2,7 +2,7 @@ /* 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 + * Copyright (C) 2008-2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -24,192 +24,109 @@ #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. * +* Paramètres : content = contenu binaire à consulter. * +* pos = position de début de lecture. [OUT] * +* endian = boutisme reconnu dans le format. * +* header = en-tête à déterminer. [OUT] * +* next = position du prochain en-tête. [OUT] * * * -* Description : Lit une valeur Little Endian Base 128 signée. * +* Description : Procède à la lecture de l'en-tête d'un contenu binaire DWARF.* * * * Retour : Bilan de l'opération. * * * -* Remarques : En cas d'échec, la tête de lecture est indéterminée. * +* Remarques : - * * * ******************************************************************************/ -bool read_leb128(dwarf_format *format, off_t *pos, int64_t *value, bool update) +bool read_dwarf_section_header(const GBinContent *content, vmpa2t *pos, SourceEndian endian, dw_section_header *header, vmpa2t *next) { - 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; + bool result; /* Bilan à retourner */ + uint32_t first; /* Premier paquet d'octets */ + bool status; /* Bilan d'opération */ - *value |= (DBG_FORMAT(format)->content[curpos] & 0x7f) << shift; + result = false; - shift += 7; - curpos++; + status = g_binary_content_read_u32(content, pos, endian, &first); + if (!status) goto rdsh_exit; - if ((DBG_FORMAT(format)->content[*pos + i] & 0x80) == 0x00) break; + if (first >= 0xfffffff0 && first != 0xffffffff) + goto rdsh_exit; + if (first == 0xffffffff) + { + result = g_binary_content_read_u64(content, pos, endian, &header->unit_length); + header->is_32b = false; } - - 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++) + else { - /* 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; + result = true; + header->unit_length = first; + header->is_32b = true; + } + if (next != NULL) + { + copy_vmpa(next, pos); + advance_vmpa(next, header->unit_length); } - if (update) *pos = curpos; + result &= g_binary_content_read_u16(content, pos, endian, &header->version); + + rdsh_exit: - return (i < 8); + return result; } /****************************************************************************** * * -* Paramètres : format = informations de débogage à consulter. * -* pos = tête de lecture à mettre à jour. [OUT] * -* value = valeur entière lue. [OUT] * +* Paramètres : content = contenu binaire à consulter. * +* pos = position de début de lecture. [OUT] * +* endian = boutisme reconnu dans le format. * +* header = en-tête à déterminer. [OUT] * +* next = position du prochain en-tête. [OUT] * * * -* Description : Lit une valeur représentant une longueur d'unité. * +* Description : Procède à la lecture de l'en-tête d'une unité de compilation.* * * * 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. * +* Remarques : - * * * ******************************************************************************/ -bool read_unit_length(dwarf_format *format, off_t *pos, off_t *value) +bool read_dwarf_compil_unit_header(GBinContent *content, vmpa2t *pos, SourceEndian endian, dw_compil_unit_header *header, vmpa2t *next) { bool result; /* Bilan à retourner */ - uint32_t val32; /* Entier sur 4 octets */ - uint64_t val64; /* Entier sur 8 octets */ + uint32_t val32; /* Premier paquet d'octets */ + bool status; /* Bilan d'opération */ - /* FIXME : Endian... */ + result = false; - 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; + status = read_dwarf_section_header(content, pos, endian, (dw_section_header *)header, next); + if (!status) goto rdcuh_exit; - *value = val32; + 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 { - result = ((*pos + 4 + 8) <= DBG_FORMAT(format)->length); - - if (result) - { - memcpy(&val64, &DBG_FORMAT(format)->content[*pos + 4], 8); - (*pos) += 4 + 8; - - *value = val64; - - } + status = g_binary_content_read_u64(content, pos, endian, &header->debug_abbrev_offset); + if (!status) goto rdcuh_exit; } - 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 = g_binary_content_read_u8(content, pos, &header->address_size); - result = ((*pos + 2) <= DBG_FORMAT(format)->length); - - if (result) - { - memcpy(value, &DBG_FORMAT(format)->content[*pos], 2); - (*pos) += 2; - } + rdcuh_exit: return result; @@ -218,53 +135,30 @@ bool read_uhalf(dwarf_format *format, off_t *pos, uint16_t *value) /****************************************************************************** * * -* Paramètres : format = informations de débogage à consulter. * -* pos = tête de lecture à mettre à jour. [OUT] * -* value = valeur entière lue. [OUT] * +* Paramètres : content = contenu binaire à consulter. * +* pos = position de début de lecture. [OUT] * +* decl = structure lue à retourner. [OUT] * * * -* Description : Lit une valeur indiquant une position dans les abréviations. * +* Description : Procède à la lecture d'une déclaration d'abréviation DWARF. * * * * 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. * +* Remarques : - * * * ******************************************************************************/ -bool read_abbrev_offset(dwarf_format *format, off_t *pos, off_t *value) +bool read_dwarf_abbrev_decl(const GBinContent *content, vmpa2t *pos, dw_abbrev_decl *decl) { 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; + result = g_binary_content_read_uleb128(content, pos, &decl->code); - } - - } - else + if (result && decl->code > 0) { - result = ((*pos + 8) <= DBG_FORMAT(format)->length); + result = g_binary_content_read_uleb128(content, pos, &decl->tag); if (result) - { - memcpy(&val64, &DBG_FORMAT(format)->content[*pos], 8); - (*pos) += 8; - - *value = val64; - - } + result = g_binary_content_read_u8(content, pos, &decl->has_children); } @@ -275,11 +169,11 @@ bool read_abbrev_offset(dwarf_format *format, off_t *pos, off_t *value) /****************************************************************************** * * -* 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] * +* Paramètres : content = contenu binaire à consulter. * +* pos = position de début de lecture. [OUT] * +* attr = structure lue à retourner. [OUT] * * * -* Description : Lit une valeur indiquant la taille des adresses mémoire. * +* Description : Procède à la lecture d'un attribut d'abréviation DWARF. * * * * Retour : Bilan de l'opération. * * * @@ -287,17 +181,14 @@ bool read_abbrev_offset(dwarf_format *format, off_t *pos, off_t *value) * * ******************************************************************************/ -bool read_address_size(dwarf_format *format, off_t *pos, uint8_t *value) +bool read_dwarf_abbrev_attr(const GBinContent *content, vmpa2t *pos, dw_abbrev_raw_attr *attr) { bool result; /* Bilan à retourner */ - result = ((*pos + 1) <= DBG_FORMAT(format)->length); + result = g_binary_content_read_uleb128(content, pos, &attr->name); if (result) - { - *value = DBG_FORMAT(format)->content[*pos]; - (*pos)++; - } + result = g_binary_content_read_uleb128(content, pos, &attr->form); return result; diff --git a/plugins/dwarf/utils.h b/plugins/dwarf/utils.h index 6727082..ea340bb 100644 --- a/plugins/dwarf/utils.h +++ b/plugins/dwarf/utils.h @@ -2,7 +2,7 @@ /* 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 + * Copyright (C) 2008-2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,36 +21,29 @@ */ -#ifndef _FORMAT_DWARF_UTILS_H -#define _FORMAT_DWARF_UTILS_H +#ifndef _PLUGINS_DWARF_UTILS_H +#define _PLUGINS_DWARF_UTILS_H -#include <stdbool.h> -#include <stdint.h> +#include <analysis/content.h> -#include "d_dwarf.h" +#include "def.h" -/* Lit une valeur Little Endian Base 128 signée. */ -bool read_leb128(dwarf_format *, off_t *, int64_t *, bool); +/* Procède à la lecture de l'en-tête d'un contenu binaire DWARF. */ +bool read_dwarf_section_header(const GBinContent *, vmpa2t *, SourceEndian, dw_section_header *, vmpa2t *); -/* Lit une valeur Little Endian Base 128 non signée. */ -bool read_uleb128(dwarf_format *, off_t *, uint64_t *, bool); +/* 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 *, vmpa2t *); -/* Lit une valeur représentant une longueur d'unité. */ -bool read_unit_length(dwarf_format *, off_t *, off_t *); +/* Procède à la lecture d'une déclaration d'abréviation DWARF. */ +bool read_dwarf_abbrev_decl(const GBinContent *, vmpa2t *, dw_abbrev_decl *); -/* Lit une valeur non signée sur deux octets. */ -bool read_uhalf(dwarf_format *, off_t *, uint16_t *); +/* Procède à la lecture d'un attribut d'abréviation DWARF. */ +bool read_dwarf_abbrev_attr(const GBinContent *, vmpa2t *, dw_abbrev_raw_attr *); -/* Lit une valeur indiquant une position dans les abréviations. */ -bool read_abbrev_offset(dwarf_format *, off_t *, off_t *); -/* Lit une valeur indiquant la taille des adresses mémoire. */ -bool read_address_size(dwarf_format *, off_t *, uint8_t *); - - -#endif /* _FORMAT_DWARF_UTILS_H */ +#endif /* _PLUGINS_DWARF_UTILS_H */ diff --git a/plugins/dwarf/v2/Makefile.am b/plugins/dwarf/v2/Makefile.am index d1fc563..a597686 100644 --- a/plugins/dwarf/v2/Makefile.am +++ b/plugins/dwarf/v2/Makefile.am @@ -1,18 +1,17 @@ -noinst_LTLIBRARIES = libformatdwarfv2.la +noinst_LTLIBRARIES = libdwarfv2.la -libformatdwarfv2_la_SOURCES = \ - dwarf.h dwarf.c \ - form.h form.c +libdwarfv2_la_SOURCES = \ + checks.h checks.c -libformatdwarfv2_la_LDFLAGS = $(LIBGTK_LIBS) +libdwarfv2_la_LDFLAGS = $(LIBGTK_LIBS) -devdir = $(includedir)/chrysalide/$(subdir:src/%=%) +devdir = $(includedir)/chrysalide-$(subdir) -dev_HEADERS = $(libformatdwarfv2_la_SOURCES:%c=) +dev_HEADERS = $(libdwarfv2_la_SOURCES:%c=) -AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) +AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) -I$(top_srcdir)/src AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) diff --git a/plugins/dwarf/d_dwarf.c b/plugins/dwarf/v2/checks.c index 67ab955..4d1e660 100644 --- a/plugins/dwarf/d_dwarf.c +++ b/plugins/dwarf/v2/checks.c @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * d_dwarf.c - support du format DWARF + * checks.c - validations liées au format DWARF v2 * - * Copyright (C) 2008-2017 Cyrille Bagard + * Copyright (C) 2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,54 +21,32 @@ */ -#include "d_dwarf.h" - - -#include <malloc.h> - - -#include "abbrev.h" -#include "dwarf-int.h" -#include "info.h" - - - - +#include "checks.h" /****************************************************************************** * * -* Paramètres : content = contenu binaire à parcourir. * -* length = taille du contenu en question. * -* e_format = gestionnaire global (partie exécutable). * +* Paramètres : decl = structure brute dont le contenu est à valider. * * * -* Description : Prend en charge un nouveau DWARF. * +* Description : Procède à la conversion de base d'une abréviation DWARF. * * * -* Retour : Adresse de la structure mise en place ou NULL en cas d'échec.* +* Retour : Validité confirmée ou non. * * * * Remarques : - * * * ******************************************************************************/ -dwarf_format *load_dwarf(const uint8_t *content, off_t length, exe_format *e_format) +bool check_dwarfv2_abbrev_decl(const dw_abbrev_decl *decl) { - dwarf_format *result; /* Structure à retourner */ - bool test; /* Bilan d'une initialisation */ + bool result; /* Validité à retourner */ - result = (dwarf_format *)calloc(1, sizeof(dwarf_format)); - - DBG_FORMAT(result)->content = content; - DBG_FORMAT(result)->length = length; - - DBG_FORMAT(result)->e_format = e_format; - - result->format = DWF_32_BITS; - - test = load_dwarf_abbreviations(result); - - test = load_dwarf_information(result); + result = (decl->tag >= DW_TAG_array_type && decl->tag <= DW_TAG_volatile_type) + || (decl->tag >= DW_TAG_lo_user && decl->tag <= DW_TAG_hi_user); + if (result) + result = (decl->has_children == DW_CHILDREN_no + || decl->has_children == DW_CHILDREN_yes); return result; @@ -77,37 +55,25 @@ dwarf_format *load_dwarf(const uint8_t *content, off_t length, exe_format *e_for /****************************************************************************** * * -* Paramètres : format = informations chargées à consulter. * -* comments = liste des commentaires à insérer. [OUT] * -* offsets = liste des indices des commentaires. [OUT] * +* Paramètres : decl = structure brute dont le contenu est à valider. * * * -* Description : Récupère tous les commentaires à insérer dans le code. * +* Description : Procède à la conversion d'un attribut d'abréviation DWARF. * * * -* Retour : Nombre d'éléments mis en place. * +* Retour : Validité confirmée ou non. * * * * Remarques : - * * * ******************************************************************************/ -size_t get_dwarf_comments(const dwarf_format *format, const char ***comments, uint64_t **offsets) +bool check_dwarfv2_abbrev_attrib(const dw_abbrev_raw_attr *attr) { - size_t result; /* Quantité à retourner */ - size_t i; /* Boucle de parcours */ - - result = format->dbg_fc_count; - - if (result > 0) - { - *comments = (char **)calloc(result, sizeof(char *)); - *offsets = (uint64_t *)calloc(result, sizeof(uint64_t)); + bool result; /* Validité à retourner */ - for (i = 0; i < result; i++) - { - (*comments)[i] = format->dbg_functions[i]->prototype; - (*offsets)[i] = format->dbg_functions[i]->low_pc; - } + result = (attr->name >= DW_AT_sibling && attr->name <= DW_AT_vtable_elem_location) + || (attr->name >= DW_AT_lo_user && attr->name <= DW_AT_hi_user); - } + if (result) + result = (attr->form >= DW_FORM_addr && attr->form <= DW_FORM_indirect); return result; diff --git a/plugins/dwarf/v4/form.h b/plugins/dwarf/v2/checks.h index 053b693..c0f8030 100644 --- a/plugins/dwarf/v4/form.h +++ b/plugins/dwarf/v2/checks.h @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * form.h - prototypes pour le chargement en mémoire des valeurs d'attributs + * checks.h - prototypes pour les validations liées au format DWARF v2 * - * Copyright (C) 2016-2017 Cyrille Bagard + * Copyright (C) 2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,19 +21,23 @@ */ -#ifndef _FORMAT_DWARF_V4_FORM_H -#define _FORMAT_DWARF_V4_FORM_H +#ifndef _PLUGINS_DWARF_V2_CHECKS_H +#define _PLUGINS_DWARF_V2_CHECKS_H -#include "../dwarf.h" -#include "../dwarf_def.h" -#include "../../../analysis/content.h" +#include <stdbool.h> +#include "../def.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 *); +/* Procède à la conversion de base d'une abréviation DWARF. */ +bool check_dwarfv2_abbrev_decl(const dw_abbrev_decl *); -#endif /* _FORMAT_DWARF_V4_FORM_H */ +/* Procède à la conversion d'un attribut d'abréviation DWARF. */ +bool check_dwarfv2_abbrev_attrib(const dw_abbrev_raw_attr *); + + + +#endif /* _PLUGINS_DWARF_V2_CHECKS_H */ diff --git a/plugins/dwarf/v2/dwarf.c b/plugins/dwarf/v2/dwarf.c deleted file mode 100644 index 8f794bf..0000000 --- a/plugins/dwarf/v2/dwarf.c +++ /dev/null @@ -1,180 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * dwarf.c - support du format DWARF v2 - * - * Copyright (C) 2015-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 "dwarf.h" - - -#include "../dwarf-int.h" - - -#include "form.h" - - - -/* Format de débogage DWARF v2 (instance) */ -struct _GDwarfV2Format -{ - GDwarfFormat parent; /* A laisser en premier */ - -}; - -/* Format de débogage DWARF v2 (classe) */ -struct _GDwarfV2FormatClass -{ - GDwarfFormatClass parent; /* A laisser en premier */ - -}; - - -/* Initialise la classe des formats de débogage DWARF v2. */ -static void g_dwarfv2_format_class_init(GDwarfV2FormatClass *); - -/* Initialise une instance de format de débogage DWARF v2. */ -static void g_dwarfv2_format_init(GDwarfV2Format *); - -/* Supprime toutes les références externes. */ -static void g_dwarfv2_format_dispose(GDwarfV2Format *); - -/* Procède à la libération totale de la mémoire. */ -static void g_dwarfv2_format_finalize(GDwarfV2Format *); - - - -/* Indique le type défini pour un format de débogage DWARF v2. */ -G_DEFINE_TYPE(GDwarfV2Format, g_dwarfv2_format, G_TYPE_DWARF_FORMAT); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des formats de débogage DWARF v2. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -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; - -} - - -/****************************************************************************** -* * -* Paramètres : format = instance à initialiser. * -* * -* Description : Initialise une instance de format de débogage DWARF v2. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dwarfv2_format_init(GDwarfV2Format *format) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : format = instance d'objet GLib à traiter. * -* * -* Description : Supprime toutes les références externes. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dwarfv2_format_dispose(GDwarfV2Format *format) -{ - G_OBJECT_CLASS(g_dwarfv2_format_parent_class)->dispose(G_OBJECT(format)); - -} - - -/****************************************************************************** -* * -* Paramètres : format = instance d'objet GLib à traiter. * -* * -* Description : Procède à la libération totale de la mémoire. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dwarfv2_format_finalize(GDwarfV2Format *format) -{ - G_OBJECT_CLASS(g_dwarfv2_format_parent_class)->finalize(G_OBJECT(format)); - -} - - -/****************************************************************************** -* * -* Paramètres : content = contenu binaire à parcourir. * -* parent = éventuel format exécutable déjà chargé. * - status = barre de statut à tenir informée. * -* * -* Description : Prend en charge un nouveau format DWARF (v2). * -* * -* Retour : Adresse de la structure mise en place ou NULL en cas d'échec.* -* * -* Remarques : - * -* * -******************************************************************************/ - -GBinFormat *g_dwarfv2_format_new(GBinContent *content, GExeFormat *parent, GtkStatusStack *status) -{ - GDwarfV2Format *result; /* Structure à retourner */ - - result = g_object_new(G_TYPE_DWARFV2_FORMAT, NULL); - - - - g_binary_format_set_content(G_BIN_FORMAT(result), content); - - - - return G_BIN_FORMAT(result); - -} diff --git a/plugins/dwarf/v2/dwarf.h b/plugins/dwarf/v2/dwarf.h deleted file mode 100644 index f3b3501..0000000 --- a/plugins/dwarf/v2/dwarf.h +++ /dev/null @@ -1,58 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * dwarf.h - prototypes pour le support du format DWARF v2 - * - * Copyright (C) 2015-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/>. - */ - - -#ifndef _FORMAT_DWARF_V2_DWARF_H -#define _FORMAT_DWARF_V2_DWARF_H - - -#include <glib-object.h> - - -#include "../../../core/formats.h" - - - -#define G_TYPE_DWARFV2_FORMAT g_dwarfv2_format_get_type() -#define G_DWARFV2_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dwarfv2_format_get_type(), GDwarfV2Format)) -#define G_IS_DWARFV2_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dwarfv2_format_get_type())) -#define G_DWARFV2_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DWARFV2_FORMAT, GDwarfV2FormatClass)) -#define G_IS_DWARFV2_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DWARFV2_FORMAT)) -#define G_DWARFV2_FORMAT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DWARFV2_FORMAT, GDwarfV2FormatClass)) - - -/* Format de débogage DWARF v2 (instance) */ -typedef struct _GDwarfV2Format GDwarfV2Format; - -/* Format de débogage DWARF v2 (classe) */ -typedef struct _GDwarfV2FormatClass GDwarfV2FormatClass; - - -/* Indique le type défini pour un format de débogage DWARF v2. */ -GType g_dwarfv2_format_get_type(void); - -/* Prend en charge un nouveau format DWARF (v2). */ -GBinFormat *g_dwarfv2_format_new(GBinContent *, GExeFormat *, GtkStatusStack *); - - - -#endif /* _FORMAT_DWARF_V2_DWARF_H */ diff --git a/plugins/dwarf/v2/form.c b/plugins/dwarf/v2/form.c deleted file mode 100644 index 7e012b7..0000000 --- a/plugins/dwarf/v2/form.c +++ /dev/null @@ -1,276 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * form.c - chargement en mémoire des valeurs d'attributs - * - * Copyright (C) 2016-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 "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)); - - result = g_binary_content_seek(content, &iter, offset); - - if (!result) - break; - - 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/plugins/dwarf/v3/Makefile.am b/plugins/dwarf/v3/Makefile.am index f6c12c3..4bd063b 100644 --- a/plugins/dwarf/v3/Makefile.am +++ b/plugins/dwarf/v3/Makefile.am @@ -1,17 +1,17 @@ -noinst_LTLIBRARIES = libformatdwarfv3.la +noinst_LTLIBRARIES = libdwarfv3.la -libformatdwarfv3_la_SOURCES = \ - dwarf.h dwarf.c +libdwarfv3_la_SOURCES = \ + checks.h checks.c -libformatdwarfv3_la_LDFLAGS = $(LIBGTK_LIBS) +libdwarfv3_la_LDFLAGS = $(LIBGTK_LIBS) -devdir = $(includedir)/chrysalide/$(subdir:src/%=%) +devdir = $(includedir)/chrysalide-$(subdir) -dev_HEADERS = $(libformatdwarfv3_la_SOURCES:%c=) +dev_HEADERS = $(libdwarfv3_la_SOURCES:%c=) -AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) +AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) -I$(top_srcdir)/src AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) diff --git a/plugins/dwarf/v3/checks.c b/plugins/dwarf/v3/checks.c new file mode 100644 index 0000000..39f9aee --- /dev/null +++ b/plugins/dwarf/v3/checks.c @@ -0,0 +1,80 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * checks.c - validations liées au format DWARF v3 + * + * Copyright (C) 2018 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 "checks.h" + + + +/****************************************************************************** +* * +* Paramètres : decl = structure brute dont le contenu est à valider. * +* * +* Description : Procède à la conversion de base d'une abréviation DWARF. * +* * +* Retour : Validité confirmée ou non. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool check_dwarfv3_abbrev_decl(const dw_abbrev_decl *decl) +{ + bool result; /* Validité à retourner */ + + result = (decl->tag >= DW_TAG_array_type && decl->tag <= DW_TAG_shared_type) + || (decl->tag >= DW_TAG_lo_user && decl->tag <= DW_TAG_hi_user); + + if (result) + result = (decl->has_children == DW_CHILDREN_no + || decl->has_children == DW_CHILDREN_yes); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : decl = structure brute dont le contenu est à valider. * +* * +* Description : Procède à la conversion d'un attribut d'abréviation DWARF. * +* * +* Retour : Validité confirmée ou non. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool check_dwarfv3_abbrev_attrib(const dw_abbrev_raw_attr *attr) +{ + bool result; /* Validité à retourner */ + + result = (attr->name >= DW_AT_sibling && attr->name <= DW_AT_recursive) + || (attr->name >= DW_AT_lo_user && attr->name <= DW_AT_hi_user); + + if (result) + result = (attr->form >= DW_FORM_addr && attr->form <= DW_FORM_indirect); + + return result; + +} diff --git a/plugins/dwarf/v2/form.h b/plugins/dwarf/v3/checks.h index a124e67..f9ddbec 100644 --- a/plugins/dwarf/v2/form.h +++ b/plugins/dwarf/v3/checks.h @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * form.h - prototypes pour le chargement en mémoire des valeurs d'attributs + * checks.h - prototypes pour les validations liées au format DWARF v3 * - * Copyright (C) 2016-2017 Cyrille Bagard + * Copyright (C) 2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,19 +21,23 @@ */ -#ifndef _FORMAT_DWARF_V2_FORM_H -#define _FORMAT_DWARF_V2_FORM_H +#ifndef _PLUGINS_DWARF_V3_CHECKS_H +#define _PLUGINS_DWARF_V3_CHECKS_H -#include "../dwarf.h" -#include "../dwarf_def.h" -#include "../../../analysis/content.h" +#include <stdbool.h> +#include "../def.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 *); +/* Procède à la conversion de base d'une abréviation DWARF. */ +bool check_dwarfv3_abbrev_decl(const dw_abbrev_decl *); -#endif /* _FORMAT_DWARF_V2_FORM_H */ +/* Procède à la conversion d'un attribut d'abréviation DWARF. */ +bool check_dwarfv3_abbrev_attrib(const dw_abbrev_raw_attr *); + + + +#endif /* _PLUGINS_DWARF_V3_CHECKS_H */ diff --git a/plugins/dwarf/v3/dwarf.h b/plugins/dwarf/v3/dwarf.h deleted file mode 100644 index 5042b89..0000000 --- a/plugins/dwarf/v3/dwarf.h +++ /dev/null @@ -1,58 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * dwarf.h - prototypes pour le support du format DWARF v3 - * - * Copyright (C) 2015-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/>. - */ - - -#ifndef _FORMAT_DWARF_V3_DWARF_H -#define _FORMAT_DWARF_V3_DWARF_H - - -#include <glib-object.h> - - -#include "../../../core/formats.h" - - - -#define G_TYPE_DWARFV3_FORMAT g_dwarfv3_format_get_type() -#define G_DWARFV3_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dwarfv3_format_get_type(), GDwarfV3Format)) -#define G_IS_DWARFV3_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dwarfv3_format_get_type())) -#define G_DWARFV3_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DWARFV3_FORMAT, GDwarfV3FormatClass)) -#define G_IS_DWARFV3_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DWARFV3_FORMAT)) -#define G_DWARFV3_FORMAT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DWARFV3_FORMAT, GDwarfV3FormatClass)) - - -/* Format de débogage DWARF v3 (instance) */ -typedef struct _GDwarfV3Format GDwarfV3Format; - -/* Format de débogage DWARF v3 (classe) */ -typedef struct _GDwarfV3FormatClass GDwarfV3FormatClass; - - -/* Indique le type défini pour un format de débogage DWARF v3. */ -GType g_dwarfv3_format_get_type(void); - -/* Prend en charge un nouveau format DWARF (v3). */ -GBinFormat *g_dwarfv3_format_new(GBinContent *, GExeFormat *, GtkStatusStack *); - - - -#endif /* _FORMAT_DWARF_V3_DWARF_H */ diff --git a/plugins/dwarf/v4/Makefile.am b/plugins/dwarf/v4/Makefile.am index ca77923..333dfac 100644 --- a/plugins/dwarf/v4/Makefile.am +++ b/plugins/dwarf/v4/Makefile.am @@ -1,18 +1,17 @@ -noinst_LTLIBRARIES = libformatdwarfv4.la +noinst_LTLIBRARIES = libdwarfv4.la -libformatdwarfv4_la_SOURCES = \ - dwarf.h dwarf.c \ - form.h form.c +libdwarfv4_la_SOURCES = \ + checks.h checks.c -libformatdwarfv4_la_LDFLAGS = $(LIBGTK_LIBS) +libdwarfv4_la_LDFLAGS = $(LIBGTK_LIBS) -devdir = $(includedir)/chrysalide/$(subdir:src/%=%) +devdir = $(includedir)/chrysalide-$(subdir) -dev_HEADERS = $(libformatdwarfv4_la_SOURCES:%c=) +dev_HEADERS = $(libdwarfv4_la_SOURCES:%c=) -AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) +AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) -I$(top_srcdir)/src AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) diff --git a/plugins/dwarf/v4/checks.c b/plugins/dwarf/v4/checks.c new file mode 100644 index 0000000..3450287 --- /dev/null +++ b/plugins/dwarf/v4/checks.c @@ -0,0 +1,80 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * checks.c - validations liées au format DWARF v4 + * + * Copyright (C) 2018 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 "checks.h" + + + +/****************************************************************************** +* * +* Paramètres : decl = structure brute dont le contenu est à valider. * +* * +* Description : Procède à la conversion de base d'une abréviation DWARF. * +* * +* Retour : Validité confirmée ou non. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool check_dwarfv4_abbrev_decl(const dw_abbrev_decl *decl) +{ + bool result; /* Validité à retourner */ + + result = (decl->tag >= DW_TAG_array_type && decl->tag <= DW_TAG_template_alias) + || (decl->tag >= DW_TAG_lo_user && decl->tag <= DW_TAG_hi_user); + + if (result) + result = (decl->has_children == DW_CHILDREN_no + || decl->has_children == DW_CHILDREN_yes); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : decl = structure brute dont le contenu est à valider. * +* * +* Description : Procède à la conversion d'un attribut d'abréviation DWARF. * +* * +* Retour : Validité confirmée ou non. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool check_dwarfv4_abbrev_attrib(const dw_abbrev_raw_attr *attr) +{ + bool result; /* Validité à retourner */ + + result = (attr->name >= DW_AT_sibling && attr->name <= DW_AT_linkage_name) + || (attr->name >= DW_AT_lo_user && attr->name <= DW_AT_hi_user); + + if (result) + result = (attr->form >= DW_FORM_addr && attr->form <= DW_FORM_ref_sig8); + + return result; + +} diff --git a/plugins/dwarf/d_dwarf.h b/plugins/dwarf/v4/checks.h index 4b699ca..25b8fc1 100644 --- a/plugins/dwarf/d_dwarf.h +++ b/plugins/dwarf/v4/checks.h @@ -1,8 +1,8 @@ /* Chrysalide - Outil d'analyse de fichiers binaires - * d_dwarf.h - prototypes pour le support du format DWARF + * checks.h - prototypes pour les validations liées au format DWARF v4 * - * Copyright (C) 2008-2017 Cyrille Bagard + * Copyright (C) 2018 Cyrille Bagard * * This file is part of Chrysalide. * @@ -21,30 +21,23 @@ */ -#ifndef _FORMAT_DWARF_DWARF_H -#define _FORMAT_DWARF_DWARF_H +#ifndef _PLUGINS_DWARF_V4_CHECKS_H +#define _PLUGINS_DWARF_V4_CHECKS_H -#include <stdint.h> -#include <sys/types.h> +#include <stdbool.h> -#include "../exe_format.h" +#include "../def.h" -/* Description du format DWARF */ -typedef struct _dwarf_format dwarf_format; +/* Procède à la conversion de base d'une abréviation DWARF. */ +bool check_dwarfv4_abbrev_decl(const dw_abbrev_decl *); +/* Procède à la conversion d'un attribut d'abréviation DWARF. */ +bool check_dwarfv4_abbrev_attrib(const dw_abbrev_raw_attr *); -/* Prend en charge un nouveau DWARF. */ -dwarf_format *load_dwarf(const uint8_t *, off_t, exe_format *); -/* Récupère tous les commentaires à insérer dans le code. */ -size_t get_dwarf_comments(const dwarf_format *, const char ***, uint64_t **); - - - - -#endif /* _FORMAT_DWARF_DWARF_H */ +#endif /* _PLUGINS_DWARF_V4_CHECKS_H */ diff --git a/plugins/dwarf/v4/dwarf.c b/plugins/dwarf/v4/dwarf.c deleted file mode 100644 index a220aff..0000000 --- a/plugins/dwarf/v4/dwarf.c +++ /dev/null @@ -1,182 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * dwarf.c - support du format DWARF v4 - * - * Copyright (C) 2015-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 "dwarf.h" - - -#include "../dwarf-int.h" - - -#include "form.h" - - - -/* Format de débogage DWARF v4 (instance) */ -struct _GDwarfV4Format -{ - GDwarfFormat parent; /* A laisser en premier */ - -}; - -/* Format de débogage DWARF v4 (classe) */ -struct _GDwarfV4FormatClass -{ - GDwarfFormatClass parent; /* A laisser en premier */ - -}; - - -/* Initialise la classe des formats de débogage DWARF v4. */ -static void g_dwarfv4_format_class_init(GDwarfV4FormatClass *); - -/* Initialise une instance de format de débogage DWARF v4. */ -static void g_dwarfv4_format_init(GDwarfV4Format *); - -/* Supprime toutes les références externes. */ -static void g_dwarfv4_format_dispose(GDwarfV4Format *); - -/* Procède à la libération totale de la mémoire. */ -static void g_dwarfv4_format_finalize(GDwarfV4Format *); - - - -/* Indique le type défini pour un format de débogage DWARF v4. */ -G_DEFINE_TYPE(GDwarfV4Format, g_dwarfv4_format, G_TYPE_DWARF_FORMAT); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des formats de débogage DWARF v4. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -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; - -} - - -/****************************************************************************** -* * -* Paramètres : format = instance à initialiser. * -* * -* Description : Initialise une instance de format de débogage DWARF v4. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dwarfv4_format_init(GDwarfV4Format *format) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : format = instance d'objet GLib à traiter. * -* * -* Description : Supprime toutes les références externes. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dwarfv4_format_dispose(GDwarfV4Format *format) -{ - G_OBJECT_CLASS(g_dwarfv4_format_parent_class)->dispose(G_OBJECT(format)); - -} - - -/****************************************************************************** -* * -* Paramètres : format = instance d'objet GLib à traiter. * -* * -* Description : Procède à la libération totale de la mémoire. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_dwarfv4_format_finalize(GDwarfV4Format *format) -{ - G_OBJECT_CLASS(g_dwarfv4_format_parent_class)->finalize(G_OBJECT(format)); - -} - - -/****************************************************************************** -* * -* Paramètres : content = contenu binaire à parcourir. * -* parent = éventuel format exécutable déjà chargé. * - status = barre de statut à tenir informée. * -* * -* Description : Prend en charge un nouveau format DWARF (v4). * -* * -* Retour : Adresse de la structure mise en place ou NULL en cas d'échec.* -* * -* Remarques : - * -* * -******************************************************************************/ - -GBinFormat *g_dwarfv4_format_new(GBinContent *content, GExeFormat *parent, GtkStatusStack *status) -{ - GDwarfV4Format *result; /* Structure à retourner */ - - 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/plugins/dwarf/v4/dwarf.h b/plugins/dwarf/v4/dwarf.h deleted file mode 100644 index 89135e3..0000000 --- a/plugins/dwarf/v4/dwarf.h +++ /dev/null @@ -1,58 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * dwarf.h - prototypes pour le support du format DWARF v4 - * - * Copyright (C) 2015-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/>. - */ - - -#ifndef _FORMAT_DWARF_V4_DWARF_H -#define _FORMAT_DWARF_V4_DWARF_H - - -#include <glib-object.h> - - -#include "../../../core/formats.h" - - - -#define G_TYPE_DWARFV4_FORMAT g_dwarfv4_format_get_type() -#define G_DWARFV4_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dwarfv4_format_get_type(), GDwarfV4Format)) -#define G_IS_DWARFV4_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dwarfv4_format_get_type())) -#define G_DWARFV4_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DWARFV4_FORMAT, GDwarfV4FormatClass)) -#define G_IS_DWARFV4_FORMAT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DWARFV4_FORMAT)) -#define G_DWARFV4_FORMAT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DWARFV4_FORMAT, GDwarfV4FormatClass)) - - -/* Format de débogage DWARF v4 (instance) */ -typedef struct _GDwarfV4Format GDwarfV4Format; - -/* Format de débogage DWARF v4 (classe) */ -typedef struct _GDwarfV4FormatClass GDwarfV4FormatClass; - - -/* Indique le type défini pour un format de débogage DWARF v4. */ -GType g_dwarfv4_format_get_type(void); - -/* Prend en charge un nouveau format DWARF (v4). */ -GBinFormat *g_dwarfv4_format_new(GBinContent *, GExeFormat *, GtkStatusStack *); - - - -#endif /* _FORMAT_DWARF_V4_DWARF_H */ diff --git a/plugins/dwarf/v4/form.c b/plugins/dwarf/v4/form.c deleted file mode 100644 index 80dbf1e..0000000 --- a/plugins/dwarf/v4/form.c +++ /dev/null @@ -1,106 +0,0 @@ - -/* Chrysalide - Outil d'analyse de fichiers binaires - * form.c - chargement en mémoire des valeurs d'attributs - * - * Copyright (C) 2016-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 "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; - -} |