From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 124822 invoked by alias); 30 Jan 2018 12:35:18 -0000 Mailing-List: contact elfutils-devel-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Post: List-Help: List-Subscribe: Sender: elfutils-devel-owner@sourceware.org Received: (qmail 124770 invoked by uid 89); 30 Jan 2018 12:35:13 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Checked: by ClamAV 0.99.2 on sourceware.org X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.9 required=5.0 tests=BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_LAZY_DOMAIN_SECURITY,KAM_SHORT autolearn=ham version=3.3.2 spammy=hides X-Spam-Status: No, score=-25.9 required=5.0 tests=BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_LAZY_DOMAIN_SECURITY,KAM_SHORT autolearn=ham version=3.3.2 X-Spam-Checker-Version: SpamAssassin 3.3.2 (2011-06-06) on sourceware.org X-Spam-Level: X-HELO: gnu.wildebeest.org Received: from wildebeest.demon.nl (HELO gnu.wildebeest.org) (212.238.236.112) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 30 Jan 2018 12:35:05 +0000 Received: from tarox.wildebeest.org (tarox.wildebeest.org [172.31.17.39]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by gnu.wildebeest.org (Postfix) with ESMTPSA id 23899302BB06; Tue, 30 Jan 2018 13:35:03 +0100 (CET) Received: by tarox.wildebeest.org (Postfix, from userid 1000) id 1EF904034B7F; Tue, 30 Jan 2018 13:35:03 +0100 (CET) From: Mark Wielaard To: elfutils-devel@sourceware.org Cc: Mark Wielaard Subject: [PATCH] libdw: Add new dwarf_get_units function to iterate over all units. Date: Tue, 30 Jan 2018 12:35:00 -0000 Message-Id: <1517315687-3616-1-git-send-email-mark@klomp.org> X-Mailer: git-send-email 1.8.3.1 X-Spam-Flag: NO X-IsSubscribed: yes X-SW-Source: 2018-q1/txt/msg00018.txt.bz2 The dwarf_nextcu and dwarf_next_unit functions provide information to construct the offset to construct the associated CU DIE using dwarf_offdie or dwarf_offdie_types. This requires the user to know beforehand where to DIE data is stored (in the .debug_info or .debug_types section). For type units one also needs to use the type offset to create the actual type DIE. In DWARF5 DIEs can come from even more data locations. And there are also skeleton units which require the user to find the associated split compile unit DIE (which would come from a different file). The new dwarf_get_units function simplifies iterating over the units in a DWARF file. It doesn't require the user to know where the DIE data is stored, it will automagically iterate over all know data sources (sections) returning the Dwarf_CU and the associated Dwarf_Die if requested. If the user requests to know the associated "subdie" it will also be resolved. This implementation returns the correct subdie for type units. A future version will also handle skeleton units and return the associated skeleton DIE and split unit DIE. readelf has been adapted to use the new iterator and print the new DWARF5 unit header information (which it gets through dwarf_cu_die). The new interface hides which section exactly to iterate on (by design). readelf works around that by "cheating". It sets up a Dwarf_CU so that it gets the data from the right section, using the (normally) internal data structure. Signed-off-by: Mark Wielaard --- libdw/ChangeLog | 7 +++ libdw/Makefile.am | 2 +- libdw/dwarf_get_units.c | 112 ++++++++++++++++++++++++++++++++++++++ libdw/libdw.h | 15 ++++++ libdw/libdw.map | 1 + src/ChangeLog | 7 +++ src/readelf.c | 140 ++++++++++++++++++++++++++++++++++++------------ 7 files changed, 248 insertions(+), 36 deletions(-) create mode 100644 libdw/dwarf_get_units.c diff --git a/libdw/ChangeLog b/libdw/ChangeLog index 58c882b..8e3bbef 100644 --- a/libdw/ChangeLog +++ b/libdw/ChangeLog @@ -1,3 +1,10 @@ +2018-01-30 Mark Wielaard + + * Makefile.am (libdw_a_SOURCES): Add dwarf_get_units.c. + * dwarf_get_units.c: New file. + * libdw.h (dwarf_get_units): New function declaration. + * libdw.map (ELFUTILS_0.170): Add dwarf_get_units. + 2018-01-29 Mark Wielaard * dwarf.h (DW_UT_*): Add DWARF Unit Header Types. diff --git a/libdw/Makefile.am b/libdw/Makefile.am index b1da440..8848f14 100644 --- a/libdw/Makefile.am +++ b/libdw/Makefile.am @@ -90,7 +90,7 @@ libdw_a_SOURCES = dwarf_begin.c dwarf_begin_elf.c dwarf_end.c dwarf_getelf.c \ dwarf_getlocation_die.c dwarf_getlocation_attr.c \ dwarf_getalt.c dwarf_setalt.c dwarf_cu_getdwarf.c \ dwarf_cu_die.c dwarf_peel_type.c dwarf_default_lower_bound.c \ - dwarf_die_addr_die.c + dwarf_die_addr_die.c dwarf_get_units.c if MAINTAINER_MODE BUILT_SOURCES = $(srcdir)/known-dwarf.h diff --git a/libdw/dwarf_get_units.c b/libdw/dwarf_get_units.c new file mode 100644 index 0000000..19ff5de --- /dev/null +++ b/libdw/dwarf_get_units.c @@ -0,0 +1,112 @@ +/* Iterate through the CU units for a given Dwarf. + Copyright (C) 2016, 2017 Red Hat, Inc. + This file is part of elfutils. + + This file is free software; you can redistribute it and/or modify + it under the terms of either + + * the GNU Lesser General Public License as published by the Free + Software Foundation; either version 3 of the License, or (at + your option) any later version + + or + + * the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at + your option) any later version + + or both in parallel, as here. + + elfutils 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 copies of the GNU General Public License and + the GNU Lesser General Public License along with this program. If + not, see . */ + + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include + +#include "libdwP.h" + +int +dwarf_get_units (Dwarf *dwarf, Dwarf_CU *cu, Dwarf_CU **next_cu, + Dwarf_Half *version, uint8_t *unit_type, + Dwarf_Die *cudie, Dwarf_Die *subdie) +{ + Dwarf_Off off; + bool v4type; + if (cu == NULL) + { + off = 0; + v4type = false; + } + else + { + off = cu->end; + v4type = cu->sec_idx != IDX_debug_info; + + /* Make sure we got a real (not fake) CU. */ + if (cu->sec_idx != IDX_debug_info && cu->sec_idx != IDX_debug_types) + { + __libdw_seterrno (DWARF_E_INVALID_OFFSET); + return -1; + } + + /* Do we have to switch to the other section, or are we at the end? */ + if (! v4type) + { + if (off >= cu->dbg->sectiondata[IDX_debug_info]->d_size) + { + if (cu->dbg->sectiondata[IDX_debug_types] == NULL) + return 1; + + off = 0; + v4type = true; + } + } + else + if (off >= cu->dbg->sectiondata[IDX_debug_types]->d_size) + return 1; + } + + *next_cu = __libdw_findcu (dwarf, off, v4type); + if (*next_cu == NULL) + return -1; + + Dwarf_CU *next = (*next_cu); + + if (version != NULL) + *version = next->version; + + if (unit_type != NULL) + *unit_type = next->unit_type; + + if (cudie != NULL) + { + if (next->version >= 2 && next->version <= 5 + && next->unit_type >= DW_UT_compile + && next->unit_type <= DW_UT_split_type) + *cudie = CUDIE (next); + else + memset (cudie, '\0', sizeof (Dwarf_Die)); + } + + if (subdie != NULL) + { + if (next->version >= 2 && next->version <= 5 + && (next->unit_type == DW_UT_type + || next->unit_type == DW_UT_split_type)) + *subdie = SUBDIE(next); + else + memset (subdie, '\0', sizeof (Dwarf_Die)); + } + + return 0; +} diff --git a/libdw/libdw.h b/libdw/libdw.h index d85d285..acc3891 100644 --- a/libdw/libdw.h +++ b/libdw/libdw.h @@ -289,6 +289,21 @@ extern int dwarf_next_unit (Dwarf *dwarf, Dwarf_Off off, Dwarf_Off *next_off, __nonnull_attribute__ (3); +/* Gets the next Dwarf_CU (unit), version, unit type and if available + the CU DIE and sub (type) DIE of the unit. Returns 0 on success, + -1 on error or 1 if there are no more units. To start iterating + provide NULL for CU. If version < 5 the unit type is set from the + CU DIE if available (DW_UT_compile for DW_TAG_compile_unit, + DW_UT_type for DW_TAG_type_unit or DW_UT_partial for + DW_TAG_partial_unit), otherwise it is set to zero. If unavailable + (the version or unit type is unknown) the CU DIE is cleared. + Likewise ff the sub DIE isn't isn't available (the unit type is not + DW_UT_type or DW_UT_split_type) the sub DIE tag is cleared. */ +extern int dwarf_get_units (Dwarf *dwarf, Dwarf_CU *cu, Dwarf_CU **next_cu, + Dwarf_Half *version, uint8_t *unit_type, + Dwarf_Die *cudie, Dwarf_Die *subdie) + __nonnull_attribute__ (3); + /* Decode one DWARF CFI entry (CIE or FDE) from the raw section data. The E_IDENT from the originating ELF file indicates the address size and byte order used in the CFI section contained in DATA; diff --git a/libdw/libdw.map b/libdw/libdw.map index cdc63ce..8d12e89 100644 --- a/libdw/libdw.map +++ b/libdw/libdw.map @@ -348,4 +348,5 @@ ELFUTILS_0.170 { ELFUTILS_0.171 { global: dwarf_die_addr_die; + dwarf_get_units; } ELFUTILS_0.170; diff --git a/src/ChangeLog b/src/ChangeLog index a0bb7a2..c724c6a 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,10 @@ +2018-01-30 Mark Wielaard + + * readelf.c (dwarf_unit_string): New function. + (dwarf_unit_name): Likewise. + (print_debug_units): Use dwarf_get_units and dwarf_cu_die instead + of dwarf_next_unit. Print unit type, id and subdie if available. + 2018-01-25 Mark Wielaard * readelf.c (print_debug_ranges_section): Initialize cu to last_cu. diff --git a/src/readelf.c b/src/readelf.c index 6c49d30..4449584 100644 --- a/src/readelf.c +++ b/src/readelf.c @@ -3950,6 +3950,20 @@ dwarf_locexpr_opcode_string (unsigned int code) } +static const char * +dwarf_unit_string (unsigned int type) +{ + switch (type) + { +#define DWARF_ONE_KNOWN_DW_UT(NAME, CODE) case CODE: return #NAME; + DWARF_ALL_KNOWN_DW_UT +#undef DWARF_ONE_KNOWN_DW_UT + default: + return NULL; + } +} + + /* Used by all dwarf_foo_name functions. */ static const char * string_or_unknown (const char *known, unsigned int code, @@ -4089,6 +4103,14 @@ dwarf_discr_list_name (unsigned int code) } +static const char * +dwarf_unit_name (unsigned int type) +{ + const char *ret = dwarf_unit_string (type); + return string_or_unknown (ret, type, DW_UT_lo_user, DW_UT_hi_user, true); +} + + static void print_block (size_t n, const void *block) { @@ -6336,41 +6358,102 @@ print_debug_units (Dwfl_Module *dwflmod, int maxdies = 20; Dwarf_Die *dies = (Dwarf_Die *) xmalloc (maxdies * sizeof (Dwarf_Die)); - Dwarf_Off offset = 0; - /* New compilation unit. */ - size_t cuhl; Dwarf_Half version; + + Dwarf_Die result; Dwarf_Off abbroffset; uint8_t addrsize; uint8_t offsize; - Dwarf_Off nextcu; - uint64_t typesig; - Dwarf_Off typeoff; + uint64_t unit_id; + Dwarf_Off subdie_off; + + int unit_res; + Dwarf_CU *cu; + Dwarf_CU cu_mem; + uint8_t unit_type; + Dwarf_Die cudie; + Dwarf_Die subdie; + + /* We cheat a little because we want to see only the CUs from .debug_info + or .debug_types. We know the Dwarf_CU struct layout. Set it up at + the end of .debug_info if we want .debug_types only. Check the returned + Dwarf_CU is still in the expected section. */ + if (debug_types) + { + cu_mem.dbg = dbg; + cu_mem.end = dbg->sectiondata[IDX_debug_info]->d_size; + cu_mem.sec_idx = IDX_debug_info; + cu = &cu_mem; + } + else + cu = NULL; + next_cu: - if (dwarf_next_unit (dbg, offset, &nextcu, &cuhl, &version, - &abbroffset, &addrsize, &offsize, - debug_types ? &typesig : NULL, - debug_types ? &typeoff : NULL) != 0) + unit_res = dwarf_get_units (dbg, cu, &cu, &version, &unit_type, + &cudie, &subdie); + if (unit_res == 1) + goto do_return; + + if (unit_res == -1) + { + if (!silent) + error (0, 0, gettext ("cannot get next unit: %s"), dwarf_errmsg (-1)); + goto do_return; + } + + if (cu->sec_idx != (size_t) (debug_types ? IDX_debug_types : IDX_debug_info)) goto do_return; + dwarf_cu_die (cu, &result, NULL, &abbroffset, &addrsize, &offsize, + &unit_id, &subdie_off); + if (!silent) { - if (debug_types) + Dwarf_Off offset = cu->start; + if (debug_types && version < 5) printf (gettext (" Type unit at offset %" PRIu64 ":\n" " Version: %" PRIu16 ", Abbreviation section offset: %" PRIu64 ", Address size: %" PRIu8 ", Offset size: %" PRIu8 "\n Type signature: %#" PRIx64 - ", Type offset: %#" PRIx64 "\n"), + ", Type offset: %#" PRIx64 " [%" PRIx64 "]\n"), (uint64_t) offset, version, abbroffset, addrsize, offsize, - typesig, (uint64_t) typeoff); + unit_id, (uint64_t) subdie_off, dwarf_dieoffset (&subdie)); else - printf (gettext (" Compilation unit at offset %" PRIu64 ":\n" - " Version: %" PRIu16 ", Abbreviation section offset: %" - PRIu64 ", Address size: %" PRIu8 - ", Offset size: %" PRIu8 "\n"), - (uint64_t) offset, version, abbroffset, addrsize, offsize); + { + printf (gettext (" Compilation unit at offset %" PRIu64 ":\n" + " Version: %" PRIu16 + ", Abbreviation section offset: %" PRIu64 + ", Address size: %" PRIu8 + ", Offset size: %" PRIu8 "\n"), + (uint64_t) offset, version, abbroffset, addrsize, offsize); + + if (version >= 5) + { + printf (gettext (" Unit type: %s (%" PRIu8 ")"), + dwarf_unit_name (unit_type), unit_type); + if (unit_type == DW_UT_type + || unit_type == DW_UT_skeleton + || unit_type == DW_UT_split_compile + || unit_type == DW_UT_split_type) + printf (", Unit id: 0x%.16" PRIx64 "", unit_id); + if (unit_type == DW_UT_type + || unit_type == DW_UT_split_type) + printf (", Unit DIE off: %#" PRIx64 " [%" PRIx64 "]", + subdie_off, dwarf_dieoffset (&subdie)); + printf ("\n"); + } + } + } + + if (version < 2 || version > 5 + || unit_type < DW_UT_compile || unit_type > DW_UT_split_type) + { + if (!silent) + error (0, 0, gettext ("unknown version (%d) or unit type (%d)"), + version, unit_type); + goto next_cu; } struct attrcb_args args = @@ -6383,25 +6466,13 @@ print_debug_units (Dwfl_Module *dwflmod, .offset_size = offsize }; - offset += cuhl; - int level = 0; - - if (unlikely ((debug_types ? dwarf_offdie_types : dwarf_offdie) - (dbg, offset, &dies[level]) == NULL)) - { - if (!silent) - error (0, 0, gettext ("cannot get DIE at offset %" PRIu64 - " in section '%s': %s"), - (uint64_t) offset, secname, dwarf_errmsg (-1)); - goto do_return; - } - + dies[0] = cudie; args.cu = dies[0].cu; do { - offset = dwarf_dieoffset (&dies[level]); + Dwarf_Off offset = dwarf_dieoffset (&dies[level]); if (unlikely (offset == ~0ul)) { if (!silent) @@ -6466,9 +6537,8 @@ print_debug_units (Dwfl_Module *dwflmod, } while (level >= 0); - offset = nextcu; - if (offset != 0) - goto next_cu; + /* And again... */ + goto next_cu; do_return: free (dies); -- 1.8.3.1