From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.polymtl.ca (smtp.polymtl.ca [132.207.4.11]) by sourceware.org (Postfix) with ESMTPS id A40383858D20 for ; Fri, 27 Jan 2023 05:13:24 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org A40383858D20 Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=polymtl.ca Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=polymtl.ca Received: from simark.ca (simark.ca [158.69.221.121]) (authenticated bits=0) by smtp.polymtl.ca (8.14.7/8.14.7) with ESMTP id 30R5DIwp013026 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 27 Jan 2023 00:13:22 -0500 DKIM-Filter: OpenDKIM Filter v2.11.0 smtp.polymtl.ca 30R5DIwp013026 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=polymtl.ca; s=default; t=1674796403; bh=ynl8IfKUUGGvGTeX030kG0M7zyKTJHcaxPuv2DBIaMA=; h=From:To:Cc:Subject:Date:From; b=CQCGGirCiy0bymrgoiD4HzzqnYE7C8YIy0/iGVsPtZrrY0ttz1GbEDNkAl5wzgWSx oJSUrDrLhqOwDV6Vuk9kmaH4EvbOten7ky/6/x8U3ZeWSvTsiUPsYhIaZOGoeIsczc b4MtXO9Nhu4yPTc8wmPhkgfRyptkR4KYKRUuEurU= Received: from simark.localdomain (unknown [217.28.27.60]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPSA id CBDDC1E110; Fri, 27 Jan 2023 00:13:17 -0500 (EST) From: Simon Marchi To: gdb-patches@sourceware.org Cc: Simon Marchi Subject: [PATCH] gdb/dwarf: dump cooked index contents in cooked_index_functions::dump Date: Fri, 27 Jan 2023 00:13:17 -0500 Message-Id: <20230127051317.700077-1-simon.marchi@polymtl.ca> X-Mailer: git-send-email 2.39.0 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Poly-FromMTA: (simark.ca [158.69.221.121]) at Fri, 27 Jan 2023 05:13:18 +0000 X-Spam-Status: No, score=-3189.2 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_PASS,TXREP,T_SPF_TEMPERROR 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 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 | 16 +++++++++ gdb/dwarf2/cooked-index.h | 4 +++ gdb/dwarf2/read.c | 74 ++++++++++++++++++++++++++++++++++++++- 3 files changed, 93 insertions(+), 1 deletion(-) diff --git a/gdb/dwarf2/cooked-index.c b/gdb/dwarf2/cooked-index.c index 09b3fd70b262..0dc1c6e2516c 100644 --- a/gdb/dwarf2/cooked-index.c +++ b/gdb/dwarf2/cooked-index.c @@ -30,6 +30,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) diff --git a/gdb/dwarf2/cooked-index.h b/gdb/dwarf2/cooked-index.h index 55eaf9955ab7..7a2e85ecf699 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. diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index cd937f24ee74..73aafbed80b4 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -93,6 +93,7 @@ #include "split-name.h" #include "gdbsupport/parallel-for.h" #include "gdbsupport/thread-pool.h" +#include "inferior.h" /* When == 1, print basic high level tracing messages. When > 1, be more verbose. @@ -18588,7 +18589,78 @@ 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 *table + = (gdb::checked_static_cast + (per_objfile->per_bfd->index_table.get ())); + + gdb_printf (" entries:\n"); + gdb_printf ("\n"); + + size_t i = 0; + for (const cooked_index_entry *entry : table->all_entries ()) + { + 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 = table->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 = table->get_addrmaps (); + for (i = 0; i < addrmaps.size (); ++i) + { + addrmap &addrmap = *addrmaps[i]; + + gdb_printf (" [%zu] ((addrmap *) %p)\n", i, &addrmap); + gdb_printf ("\n"); + + addrmap.foreach ([] (CORE_ADDR start_addr, void *obj) + { + const char *start_addr_str + = paddress (current_inferior ()->gdbarch, start_addr); + + if (obj != nullptr) + { + const dwarf2_per_cu_data *per_cu + = (const dwarf2_per_cu_data *) 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 expand_matching_symbols base-commit: 48afe8b710712bf131fadbfa3278e512a7034483 -- 2.39.0