From patchwork Fri Jan 27 05:13:17 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 63778 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 93A7E3858C3A for ; Fri, 27 Jan 2023 05:13:51 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 93A7E3858C3A DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1674796431; bh=ynl8IfKUUGGvGTeX030kG0M7zyKTJHcaxPuv2DBIaMA=; h=To:Cc:Subject:Date:List-Id:List-Unsubscribe:List-Archive: List-Post:List-Help:List-Subscribe:From:Reply-To:From; b=kwVvx0GI5cKRqpD3Ht6SXvrlJ19gfgbFWjWPGHKjGtd1bDEEiwvcnvqr4GbHDn3dU G4MnktHGOBaHM1et6jtrycKlJA4buLYJpaxxsRW/S8bDzwF0LpTS0vNo7UG2oo/ISN VxVMozbhGudpWiHqw21DXqSAFifO5MWUXxQMoHyM= X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org 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 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 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) 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 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 X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Simon Marchi via Gdb-patches From: Simon Marchi Reply-To: Simon Marchi Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org Sender: "Gdb-patches" 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(-) base-commit: 48afe8b710712bf131fadbfa3278e512a7034483 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