From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from barracuda.ebox.ca (barracuda.ebox.ca [96.127.255.19]) by sourceware.org (Postfix) with ESMTPS id 11F7F3858D1E for ; Mon, 30 Jan 2023 16:03:40 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 11F7F3858D1E Authentication-Results: sourceware.org; dmarc=fail (p=none dis=none) header.from=efficios.com Authentication-Results: sourceware.org; spf=fail smtp.mailfrom=efficios.com X-ASG-Debug-ID: 1675094618-0c856e762b853cd0001-fS2M51 Received: from smtp.ebox.ca (smtp.ebox.ca [96.127.255.82]) by barracuda.ebox.ca with ESMTP id eLuIDFsaILK9yWDl (version=TLSv1 cipher=AES128-SHA bits=128 verify=NO); Mon, 30 Jan 2023 11:03:38 -0500 (EST) X-Barracuda-Envelope-From: simon.marchi@efficios.com X-Barracuda-RBL-Trusted-Forwarder: 96.127.255.82 Received: from smarchi-efficios.internal.efficios.com (192-222-180-24.qc.cable.ebox.net [192.222.180.24]) by smtp.ebox.ca (Postfix) with ESMTP id 346BE441B21; Mon, 30 Jan 2023 11:03:38 -0500 (EST) From: Simon Marchi X-Barracuda-RBL-IP: 192.222.180.24 X-Barracuda-Effective-Source-IP: 192-222-180-24.qc.cable.ebox.net[192.222.180.24] X-Barracuda-Apparent-Source-IP: 192.222.180.24 To: gdb-patches@sourceware.org Cc: Simon Marchi Subject: [PATCH v2] gdb/dwarf: dump cooked index contents in cooked_index_functions::dump Date: Mon, 30 Jan 2023 11:03:37 -0500 X-ASG-Orig-Subj: [PATCH v2] gdb/dwarf: dump cooked index contents in cooked_index_functions::dump Message-Id: <20230130160337.55890-1-simon.marchi@efficios.com> X-Mailer: git-send-email 2.39.1 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Barracuda-Connect: smtp.ebox.ca[96.127.255.82] X-Barracuda-Start-Time: 1675094618 X-Barracuda-Encrypted: AES128-SHA X-Barracuda-URL: https://96.127.255.19:443/cgi-mod/mark.cgi X-Virus-Scanned: by bsmtpd at ebox.ca X-Barracuda-Scan-Msg-Size: 7250 X-Barracuda-BRTS-Status: 1 X-Barracuda-Spam-Score: 0.40 X-Barracuda-Spam-Status: No, SCORE=0.40 using global scores of TAG_LEVEL=1000.0 QUARANTINE_LEVEL=1000.0 KILL_LEVEL=5.0 tests=BSF_SC0_SA085b X-Barracuda-Spam-Report: Code version 3.2, rules version 3.2.3.104086 Rule breakdown below pts rule name description ---- ---------------------- -------------------------------------------------- 0.40 BSF_SC0_SA085b Custom Rule SA085b X-Spam-Status: No, score=-3498.1 required=5.0 tests=BAYES_00,GIT_PATCH_0,KAM_DMARC_NONE,KAM_DMARC_STATUS,RCVD_IN_DNSWL_LOW,SPF_HELO_NONE,SPF_SOFTFAIL,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: From: Simon Marchi New in v2: - move the implementation to the cooked_index_vector class - use the gdbarch from the objfile - add some QUIT macro calls - add call to wait, to ensure the index is finished 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 646bc76575cd..0ee7afb7b978 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. */ + bool cooked_index_entry::compare (const char *stra, const char *strb, bool completing) @@ -442,6 +459,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 7299a4f77b44..9d9be517c3a9 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. @@ -373,6 +377,9 @@ class cooked_index_vector : public dwarf_scanner_base 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 9d8952a4eb8d..16559133a3d0 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.39.1