From 7d82b08e9e0a7a22943b843972cd1b8ae1328884 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Mon, 30 Jan 2023 11:03:37 -0500 Subject: [PATCH] gdb/dwarf: dump cooked index contents in cooked_index_functions::dump As I am investigating a crash I see with the cooked index, I thought it would be useful to have a way to dump the index contents. For those not too familiar with it (that includes me), it can help get a feel of what it contains and how it is structured. The cooked_index_functions::dump function is called as part of the "maintenance print objfiles" command. I tried to make the output well structured and indented to help readability, as this prints a lot of text. The dump function first dumps all cooked index entries, like this: [25] ((cooked_index_entry *) 0x621000121220) name: __ioinit canonical: __ioinit DWARF tag: DW_TAG_variable flags: 0x2 [IS_STATIC] DIE offset: 0x21a4 parent: ((cooked_index_entry *) 0x6210000f9610) [std] Then the information about the main symbol: main: ((cooked_index_entry *) 0x621000123b40) [main] And finally the address map contents: [1] ((addrmap *) 0x6210000f7910) [0x0] ((dwarf2_per_cu_data *) 0) [0x118a] ((dwarf2_per_cu_data *) 0x60c000007f00) [0x1cc7] ((dwarf2_per_cu_data *) 0) [0x1cc8] ((dwarf2_per_cu_data *) 0x60c000007f00) [0x1cdf] ((dwarf2_per_cu_data *) 0) [0x1ce0] ((dwarf2_per_cu_data *) 0x60c000007f00) The display of address maps above could probably be improved, to show it more as ranges, but I think this is a reasonable start. Note that this patch depends on Pedro Alves' patch "enum_flags to_string" [1]. If my patch is to be merged before Pedro's series, I will cherry-pick this patch from his series and merge it before mine. [1] https://inbox.sourceware.org/gdb-patches/20221212203101.1034916-8-pedro@palves.net/ Change-Id: Ida13e479fd4c8d21102ddd732241778bc3b6904a --- gdb/dwarf2/cooked-index.c | 93 +++++++++++++++++++++++++++++++++++++++ gdb/dwarf2/cooked-index.h | 7 +++ gdb/dwarf2/read.c | 10 ++++- 3 files changed, 109 insertions(+), 1 deletion(-) diff --git a/gdb/dwarf2/cooked-index.c b/gdb/dwarf2/cooked-index.c index 09d76523419..9dbb844cade 100644 --- a/gdb/dwarf2/cooked-index.c +++ b/gdb/dwarf2/cooked-index.c @@ -20,6 +20,7 @@ #include "defs.h" #include "dwarf2/cooked-index.h" #include "dwarf2/read.h" +#include "dwarf2/stringify.h" #include "cp-support.h" #include "c-lang.h" #include "ada-lang.h" @@ -30,6 +31,22 @@ /* See cooked-index.h. */ +std::string +to_string (cooked_index_flag flags) +{ + static constexpr cooked_index_flag::string_mapping mapping[] = { + MAP_ENUM_FLAG (IS_MAIN), + MAP_ENUM_FLAG (IS_STATIC), + MAP_ENUM_FLAG (IS_ENUM_CLASS), + MAP_ENUM_FLAG (IS_LINKAGE), + MAP_ENUM_FLAG (IS_TYPE_DECLARATION), + }; + + return flags.to_string (mapping); +} + +/* See cooked-index.h. */ + int cooked_index_entry::compare (const char *stra, const char *strb, comparison_mode mode) @@ -451,6 +468,82 @@ cooked_index_vector::get_main () const return result; } +/* See cooked-index.h. */ + +void +cooked_index_vector::dump (gdbarch *arch) const +{ + /* Ensure the index is done building. */ + this->wait (); + + gdb_printf (" entries:\n"); + gdb_printf ("\n"); + + size_t i = 0; + for (const cooked_index_entry *entry : this->all_entries ()) + { + QUIT; + + gdb_printf (" [%zu] ((cooked_index_entry *) %p)\n", i++, entry); + gdb_printf (" name: %s\n", entry->name); + gdb_printf (" canonical: %s\n", entry->canonical); + gdb_printf (" DWARF tag: %s\n", dwarf_tag_name (entry->tag)); + gdb_printf (" flags: %s\n", to_string (entry->flags).c_str ()); + gdb_printf (" DIE offset: 0x%lx\n", + to_underlying (entry->die_offset)); + + if (entry->parent_entry != nullptr) + gdb_printf (" parent: ((cooked_index_entry *) %p) [%s]\n", + entry->parent_entry, entry->parent_entry->name); + else + gdb_printf (" parent: ((cooked_index_entry *) 0)\n"); + + gdb_printf ("\n"); + } + + const cooked_index_entry *main_entry = this->get_main (); + if (main_entry != nullptr) + gdb_printf (" main: ((cooked_index_entry *) %p) [%s]\n", main_entry, + main_entry->name); + else + gdb_printf (" main: ((cooked_index_entry *) 0)\n"); + + gdb_printf ("\n"); + gdb_printf (" address maps:\n"); + gdb_printf ("\n"); + + std::vector addrmaps = this->get_addrmaps (); + for (i = 0; i < addrmaps.size (); ++i) + { + const addrmap &addrmap = *addrmaps[i]; + + gdb_printf (" [%zu] ((addrmap *) %p)\n", i, &addrmap); + gdb_printf ("\n"); + + addrmap.foreach ([arch] (CORE_ADDR start_addr, const void *obj) + { + QUIT; + + const char *start_addr_str = paddress (arch, start_addr); + + if (obj != nullptr) + { + const dwarf2_per_cu_data *per_cu + = static_cast (obj); + gdb_printf (" [%s] ((dwarf2_per_cu_data *) %p)\n", + start_addr_str, per_cu); + } + else + gdb_printf (" [%s] ((dwarf2_per_cu_data *) 0)\n", + start_addr_str); + + return 0; + }); + + gdb_printf ("\n"); + } +} + void _initialize_cooked_index (); void _initialize_cooked_index () diff --git a/gdb/dwarf2/cooked-index.h b/gdb/dwarf2/cooked-index.h index 891659f56e0..fa7d8840d16 100644 --- a/gdb/dwarf2/cooked-index.h +++ b/gdb/dwarf2/cooked-index.h @@ -54,6 +54,10 @@ enum cooked_index_flag_enum : unsigned char }; DEF_ENUM_FLAGS_TYPE (enum cooked_index_flag_enum, cooked_index_flag); +/* Return a string representation of FLAGS. */ + +std::string to_string (cooked_index_flag flags); + /* A cooked_index_entry represents a single item in the index. Note that two entries can be created for the same DIE -- one using the name, and another one using the linkage name, if any. @@ -411,6 +415,9 @@ public: quick_symbol_functions_up make_quick_functions () const override; + /* Dump a human-readable form of the contents of the index. */ + void dump (gdbarch *arch) const; + private: /* The vector of cooked_index objects. This is stored because the diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index 3a1728e9ff9..e8a3e359ada 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -18589,7 +18589,15 @@ struct cooked_index_functions : public dwarf2_base_index_functions void dump (struct objfile *objfile) override { - gdb_printf ("Cooked index in use\n"); + gdb_printf ("Cooked index in use:\n"); + gdb_printf ("\n"); + + dwarf2_per_objfile *per_objfile = get_dwarf2_per_objfile (objfile); + cooked_index_vector *index + = (gdb::checked_static_cast + (per_objfile->per_bfd->index_table.get ())); + + index->dump (objfile->arch ()); } void expand_matching_symbols -- 2.30.2