diff options
Diffstat (limited to 'gdb/dwarf2')
| -rw-r--r-- | gdb/dwarf2/abbrev-table-cache.h | 3 | ||||
| -rw-r--r-- | gdb/dwarf2/aranges.c | 10 | ||||
| -rw-r--r-- | gdb/dwarf2/attribute.h | 4 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index-entry.c | 242 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index-entry.h | 258 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index-shard.c | 331 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index-shard.h | 134 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index-storage.c | 84 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index-storage.h | 131 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index-worker.c | 255 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index-worker.h | 305 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index.c | 693 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-index.h | 499 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-indexer.c | 6 | ||||
| -rw-r--r-- | gdb/dwarf2/cooked-indexer.h | 8 | ||||
| -rw-r--r-- | gdb/dwarf2/die.c | 4 | ||||
| -rw-r--r-- | gdb/dwarf2/die.h | 12 | ||||
| -rw-r--r-- | gdb/dwarf2/loc.c | 12 | ||||
| -rw-r--r-- | gdb/dwarf2/parent-map.c | 2 | ||||
| -rw-r--r-- | gdb/dwarf2/read-debug-names.c | 69 | ||||
| -rw-r--r-- | gdb/dwarf2/read.c | 482 | ||||
| -rw-r--r-- | gdb/dwarf2/read.h | 17 |
22 files changed, 1817 insertions, 1744 deletions
diff --git a/gdb/dwarf2/abbrev-table-cache.h b/gdb/dwarf2/abbrev-table-cache.h index 8469948..d99fb8d 100644 --- a/gdb/dwarf2/abbrev-table-cache.h +++ b/gdb/dwarf2/abbrev-table-cache.h @@ -30,6 +30,9 @@ public: abbrev_table_cache () = default; DISABLE_COPY_AND_ASSIGN (abbrev_table_cache); + abbrev_table_cache (abbrev_table_cache &&) = default; + abbrev_table_cache &operator= (abbrev_table_cache &&) = default; + /* Find an abbrev table coming from the abbrev section SECTION at offset OFFSET. Return the table, or nullptr if it has not yet been registered. */ diff --git a/gdb/dwarf2/aranges.c b/gdb/dwarf2/aranges.c index 7016eee..ac530ab 100644 --- a/gdb/dwarf2/aranges.c +++ b/gdb/dwarf2/aranges.c @@ -59,6 +59,7 @@ read_addrmap_from_aranges (dwarf2_per_objfile *per_objfile, gdb::unordered_set<sect_offset> debug_info_offset_seen; const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch); + const int signed_addr_p = bfd_get_sign_extend_vma (abfd); const gdb_byte *addr = section->buffer; while (addr < section->buffer + section->size) { @@ -167,8 +168,13 @@ read_addrmap_from_aranges (dwarf2_per_objfile *per_objfile, plongest (entry_addr - section->buffer)); return false; } - ULONGEST start = extract_unsigned_integer (addr, address_size, - dwarf5_byte_order); + ULONGEST start; + if (signed_addr_p) + start = extract_signed_integer (addr, address_size, + dwarf5_byte_order); + else + start = extract_unsigned_integer (addr, address_size, + dwarf5_byte_order); addr += address_size; ULONGEST length = extract_unsigned_integer (addr, address_size, dwarf5_byte_order); diff --git a/gdb/dwarf2/attribute.h b/gdb/dwarf2/attribute.h index 4dce04d..ce6c563 100644 --- a/gdb/dwarf2/attribute.h +++ b/gdb/dwarf2/attribute.h @@ -105,8 +105,8 @@ struct attribute /* Return an unsigned constant value. This only handles constant forms (i.e., form_is_constant -- and not the extended list of "unsigned" forms) and assumes an unsigned value is desired. This - can intended for use with DWARF-defined enumerations like DW_CC_* - or DW_INL_*, but also in situations where a nonnegative constant + can be used with DWARF-defined enumerations like DW_CC_* or + DW_INL_*, but also in situations where a nonnegative constant integer is specified by DWARF. If a signed form and negative value is used, or if a non-constant diff --git a/gdb/dwarf2/cooked-index-entry.c b/gdb/dwarf2/cooked-index-entry.c new file mode 100644 index 0000000..3e322f1 --- /dev/null +++ b/gdb/dwarf2/cooked-index-entry.c @@ -0,0 +1,242 @@ +/* Entry in the cooked index + + Copyright (C) 2022-2024 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program 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 a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#include "dwarf2/cooked-index-entry.h" +#include "dwarf2/tag.h" +#include "gdbsupport/gdb-safe-ctype.h" +#include "gdbsupport/selftest.h" + +/* See cooked-index-entry.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_LINKAGE), + MAP_ENUM_FLAG (IS_TYPE_DECLARATION), + MAP_ENUM_FLAG (IS_PARENT_DEFERRED), + }; + + return flags.to_string (mapping); +} + +/* See cooked-index-entry.h. */ + +int +cooked_index_entry::compare (const char *stra, const char *strb, + comparison_mode mode) +{ +#if defined (__GNUC__) && !defined (__clang__) && __GNUC__ <= 7 + /* Work around error with gcc 7.5.0. */ + auto munge = [] (char c) -> unsigned char +#else + auto munge = [] (char c) constexpr -> unsigned char +#endif + { + /* Treat '<' as if it ended the string. This lets something + like "func<t>" match "func<t<int>>". See the "Breakpoints in + template functions" section in the manual. */ + if (c == '<') + return '\0'; + return TOLOWER ((unsigned char) c); + }; + + unsigned char a = munge (*stra); + unsigned char b = munge (*strb); + + while (a != '\0' && b != '\0' && a == b) + { + a = munge (*++stra); + b = munge (*++strb); + } + + if (a == b) + return 0; + + /* When completing, if STRB ends earlier than STRA, consider them as + equal. */ + if (mode == COMPLETE && b == '\0') + return 0; + + return a < b ? -1 : 1; +} + +#if GDB_SELF_TEST + +namespace { + +void +test_compare () +{ + /* Convenience aliases. */ + const auto mode_compare = cooked_index_entry::MATCH; + const auto mode_sort = cooked_index_entry::SORT; + const auto mode_complete = cooked_index_entry::COMPLETE; + + SELF_CHECK (cooked_index_entry::compare ("abcd", "abcd", + mode_compare) == 0); + SELF_CHECK (cooked_index_entry::compare ("abcd", "abcd", + mode_complete) == 0); + + SELF_CHECK (cooked_index_entry::compare ("abcd", "ABCDE", + mode_compare) < 0); + SELF_CHECK (cooked_index_entry::compare ("ABCDE", "abcd", + mode_compare) > 0); + SELF_CHECK (cooked_index_entry::compare ("abcd", "ABCDE", + mode_complete) < 0); + SELF_CHECK (cooked_index_entry::compare ("ABCDE", "abcd", + mode_complete) == 0); + + SELF_CHECK (cooked_index_entry::compare ("name", "name<>", + mode_compare) == 0); + SELF_CHECK (cooked_index_entry::compare ("name<>", "name", + mode_compare) == 0); + SELF_CHECK (cooked_index_entry::compare ("name", "name<>", + mode_complete) == 0); + SELF_CHECK (cooked_index_entry::compare ("name<>", "name", + mode_complete) == 0); + + SELF_CHECK (cooked_index_entry::compare ("name<arg>", "name<arg>", + mode_compare) == 0); + SELF_CHECK (cooked_index_entry::compare ("name<arg>", "name<ag>", + mode_compare) == 0); + SELF_CHECK (cooked_index_entry::compare ("name<arg>", "name<arg>", + mode_complete) == 0); + SELF_CHECK (cooked_index_entry::compare ("name<arg>", "name<ag>", + mode_complete) == 0); + + SELF_CHECK (cooked_index_entry::compare ("name<arg<more>>", + "name<arg<more>>", + mode_compare) == 0); + SELF_CHECK (cooked_index_entry::compare ("name<arg>", + "name<arg<more>>", + mode_compare) == 0); + + SELF_CHECK (cooked_index_entry::compare ("name", "name<arg<more>>", + mode_compare) == 0); + SELF_CHECK (cooked_index_entry::compare ("name<arg<more>>", "name", + mode_compare) == 0); + SELF_CHECK (cooked_index_entry::compare ("name<arg<more>>", "name<arg<", + mode_compare) == 0); + SELF_CHECK (cooked_index_entry::compare ("name<arg<more>>", "name<arg<", + mode_complete) == 0); + + SELF_CHECK (cooked_index_entry::compare ("", "abcd", mode_compare) < 0); + SELF_CHECK (cooked_index_entry::compare ("", "abcd", mode_complete) < 0); + SELF_CHECK (cooked_index_entry::compare ("abcd", "", mode_compare) > 0); + SELF_CHECK (cooked_index_entry::compare ("abcd", "", mode_complete) == 0); + + SELF_CHECK (cooked_index_entry::compare ("func", "func<type>", + mode_sort) == 0); + SELF_CHECK (cooked_index_entry::compare ("func<type>", "func1", + mode_sort) < 0); +} + +} /* anonymous namespace */ + +#endif /* GDB_SELF_TEST */ + +/* See cooked-index-entry.h. */ + +bool +cooked_index_entry::matches (domain_search_flags kind) const +{ + /* Just reject type declarations. */ + if ((flags & IS_TYPE_DECLARATION) != 0) + return false; + + return tag_matches_domain (tag, kind, lang); +} + +/* See cooked-index-entry.h. */ + +const char * +cooked_index_entry::full_name (struct obstack *storage, + cooked_index_full_name_flag name_flags, + const char *default_sep) const +{ + const char *local_name = ((name_flags & FOR_MAIN) != 0) ? name : canonical; + + if ((flags & IS_LINKAGE) != 0 || get_parent () == nullptr) + return local_name; + + const char *sep = default_sep; + switch (lang) + { + case language_cplus: + case language_rust: + case language_fortran: + sep = "::"; + break; + + case language_ada: + if ((name_flags & FOR_ADA_LINKAGE_NAME) != 0) + { + sep = "__"; + break; + } + [[fallthrough]]; + case language_go: + case language_d: + sep = "."; + break; + + default: + if (sep == nullptr) + return local_name; + break; + } + + /* The FOR_ADA_LINKAGE_NAME flag should only affect Ada entries, so + disable it here if we don't need it. */ + if (lang != language_ada) + name_flags &= ~FOR_ADA_LINKAGE_NAME; + + get_parent ()->write_scope (storage, sep, name_flags); + obstack_grow0 (storage, local_name, strlen (local_name)); + return (const char *) obstack_finish (storage); +} + +/* See cooked-index-entry.h. */ + +void +cooked_index_entry::write_scope (struct obstack *storage, + const char *sep, + cooked_index_full_name_flag flags) const +{ + if (get_parent () != nullptr) + get_parent ()->write_scope (storage, sep, flags); + /* When computing the Ada linkage name, the entry might not have + been canonicalized yet, so use the 'name'. */ + const char *local_name = ((flags & (FOR_MAIN | FOR_ADA_LINKAGE_NAME)) != 0 + ? name + : canonical); + obstack_grow (storage, local_name, strlen (local_name)); + obstack_grow (storage, sep, strlen (sep)); +} + +void _initialize_dwarf2_entry (); +void _initialize_dwarf2_entry () +{ +#if GDB_SELF_TEST + selftests::register_test ("cooked_index_entry::compare", test_compare); +#endif +} diff --git a/gdb/dwarf2/cooked-index-entry.h b/gdb/dwarf2/cooked-index-entry.h new file mode 100644 index 0000000..bb47e32 --- /dev/null +++ b/gdb/dwarf2/cooked-index-entry.h @@ -0,0 +1,258 @@ +/* Entry in the cooked index + + Copyright (C) 2022-2024 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program 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 a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#ifndef GDB_DWARF2_COOKED_INDEX_ENTRY_H +#define GDB_DWARF2_COOKED_INDEX_ENTRY_H + +#include "dwarf2/parent-map.h" +#include "dwarf2/types.h" +#include "symtab.h" +#include "gdbsupport/gdb_obstack.h" +#include "quick-symbol.h" + +/* Flags that describe an entry in the index. */ +enum cooked_index_flag_enum : unsigned char +{ + /* True if this entry is the program's "main". */ + IS_MAIN = 1, + /* True if this entry represents a "static" object. */ + IS_STATIC = 2, + /* True if this entry uses the linkage name. */ + IS_LINKAGE = 4, + /* True if this entry is just for the declaration of a type, not the + definition. */ + IS_TYPE_DECLARATION = 8, + /* True is parent_entry.deferred has a value rather than parent_entry + .resolved. */ + IS_PARENT_DEFERRED = 16, + /* True if this entry was synthesized by gdb (as opposed to coming + directly from the DWARF). */ + IS_SYNTHESIZED = 32, +}; +DEF_ENUM_FLAGS_TYPE (enum cooked_index_flag_enum, cooked_index_flag); + +/* Flags used when requesting the full name of an entry. */ +enum cooked_index_full_name_enum : unsigned char +{ + /* Set when requesting the name of "main". See the method for the + full description. */ + FOR_MAIN = 1, + /* Set when requesting the linkage name for an Ada entry. */ + FOR_ADA_LINKAGE_NAME = 2, +}; +DEF_ENUM_FLAGS_TYPE (enum cooked_index_full_name_enum, cooked_index_full_name_flag); + +/* Type representing either a resolved or deferred cooked_index_entry. */ + +union cooked_index_entry_ref +{ + cooked_index_entry_ref (parent_map::addr_type deferred_) + { + deferred = deferred_; + } + + cooked_index_entry_ref (const cooked_index_entry *resolved_) + { + resolved = resolved_; + } + + const cooked_index_entry *resolved; + parent_map::addr_type deferred; +}; + +/* 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. + + This is an "open" class and the members are all directly + accessible. It is read-only after the index has been fully read + and processed. */ +struct cooked_index_entry : public allocate_on_obstack<cooked_index_entry> +{ + cooked_index_entry (sect_offset die_offset_, enum dwarf_tag tag_, + cooked_index_flag flags_, + enum language lang_, const char *name_, + cooked_index_entry_ref parent_entry_, + dwarf2_per_cu *per_cu_) + : name (name_), + tag (tag_), + flags (flags_), + lang (lang_), + die_offset (die_offset_), + per_cu (per_cu_), + m_parent_entry (parent_entry_) + { + } + + /* Return true if this entry matches SEARCH_FLAGS. */ + bool matches (block_search_flags search_flags) const + { + /* Just reject type declarations. */ + if ((flags & IS_TYPE_DECLARATION) != 0) + return false; + + if ((search_flags & SEARCH_STATIC_BLOCK) != 0 + && (flags & IS_STATIC) != 0) + return true; + if ((search_flags & SEARCH_GLOBAL_BLOCK) != 0 + && (flags & IS_STATIC) == 0) + return true; + return false; + } + + /* Return true if this entry matches KIND. */ + bool matches (domain_search_flags kind) const; + + /* Construct the fully-qualified name of this entry and return a + pointer to it. If allocation is needed, it will be done on + STORAGE. + + FLAGS affects the result. If the FOR_MAIN flag is set, we are + computing the name of the "main" entry -- one marked + DW_AT_main_subprogram. This matters for avoiding name + canonicalization and also a related race (if "main" computation + is done during finalization). + + If the FOR_ADA_LINKAGE_NAME flag is set, then Ada-language + symbols will have their "linkage-style" name computed. The + default is source-style. + + If the language doesn't prescribe a separator, one can be + specified using DEFAULT_SEP. */ + const char *full_name (struct obstack *storage, + cooked_index_full_name_flag name_flags = 0, + const char *default_sep = nullptr) const; + + /* Comparison modes for the 'compare' function. See the function + for a description. */ + enum comparison_mode + { + MATCH, + SORT, + COMPLETE, + }; + + /* Compare two strings, case-insensitively. Return -1 if STRA is + less than STRB, 0 if they are equal, and 1 if STRA is greater. + + When comparing, '<' is considered to be less than all other + printable characters. This ensures that "t<x>" sorts before + "t1", which is necessary when looking up "t". This '<' handling + is to ensure that certain C++ lookups work correctly. It is + inexact, and applied regardless of the search language, but this + is ok because callers of this code do more precise filtering + according to their needs. This is also why using a + case-insensitive comparison works even for languages that are + case sensitive. + + MODE controls how the comparison proceeds. + + MODE==SORT is used when sorting and the only special '<' handling + that it does is to ensure that '<' sorts before all other + printable characters. This ensures that the resulting ordering + will be binary-searchable. + + MODE==MATCH is used when searching for a symbol. In this case, + STRB must always be the search name, and STRA must be the name in + the index that is under consideration. In compare mode, early + termination of STRB may match STRA -- for example, "t<int>" and + "t" will be considered to be equal. (However, if A=="t" and + B=="t<int>", then this will not consider them as equal.) + + MODE==COMPLETE is used when searching for a symbol for + completion. In this case, STRB must always be the search name, + and STRA must be the name in the index that is under + consideration. In completion mode, early termination of STRB + always results in a match. */ + static int compare (const char *stra, const char *strb, + comparison_mode mode); + + /* Compare two entries by canonical name. */ + bool operator< (const cooked_index_entry &other) const + { + return compare (canonical, other.canonical, SORT) < 0; + } + + /* Set parent entry to PARENT. */ + void set_parent (const cooked_index_entry *parent) + { + gdb_assert ((flags & IS_PARENT_DEFERRED) == 0); + m_parent_entry.resolved = parent; + } + + /* Resolve deferred parent entry to PARENT. */ + void resolve_parent (const cooked_index_entry *parent) + { + gdb_assert ((flags & IS_PARENT_DEFERRED) != 0); + flags = flags & ~IS_PARENT_DEFERRED; + m_parent_entry.resolved = parent; + } + + /* Return parent entry. */ + const cooked_index_entry *get_parent () const + { + gdb_assert ((flags & IS_PARENT_DEFERRED) == 0); + return m_parent_entry.resolved; + } + + /* Return deferred parent entry. */ + parent_map::addr_type get_deferred_parent () const + { + gdb_assert ((flags & IS_PARENT_DEFERRED) != 0); + return m_parent_entry.deferred; + } + + /* The name as it appears in DWARF. This always points into one of + the mapped DWARF sections. Note that this may be the name or the + linkage name -- two entries are created for DIEs which have both + attributes. */ + const char *name; + /* The canonical name. This may be equal to NAME. */ + const char *canonical = nullptr; + /* The DWARF tag. */ + enum dwarf_tag tag; + /* Any flags attached to this entry. */ + cooked_index_flag flags; + /* The language of this symbol. */ + ENUM_BITFIELD (language) lang : LANGUAGE_BITS; + /* The offset of this DIE. */ + sect_offset die_offset; + /* The CU from which this entry originates. */ + dwarf2_per_cu *per_cu; + +private: + + /* A helper method for full_name. Emits the full scope of this + object, followed by the separator, to STORAGE. If this entry has + a parent, its write_scope method is called first. See full_name + for a description of the FLAGS parameter. */ + void write_scope (struct obstack *storage, const char *sep, + cooked_index_full_name_flag flags) const; + + /* The parent entry. This is NULL for top-level entries. + Otherwise, it points to the parent entry, such as a namespace or + class. */ + cooked_index_entry_ref m_parent_entry; +}; + +#endif /* GDB_DWARF2_COOKED_INDEX_ENTRY_H */ diff --git a/gdb/dwarf2/cooked-index-shard.c b/gdb/dwarf2/cooked-index-shard.c new file mode 100644 index 0000000..683feb2 --- /dev/null +++ b/gdb/dwarf2/cooked-index-shard.c @@ -0,0 +1,331 @@ +/* Shards for the cooked index + + Copyright (C) 2022-2024 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program 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 a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#include "dwarf2/cooked-index-shard.h" +#include "dwarf2/tag.h" +#include "dwarf2/index-common.h" +#include "cp-support.h" +#include "c-lang.h" +#include "ada-lang.h" + +/* Return true if a plain "main" could be the main program for this + language. Languages that are known to use some other mechanism are + excluded here. */ + +static bool +language_may_use_plain_main (enum language lang) +{ + /* No need to handle "unknown" here. */ + return (lang == language_c + || lang == language_objc + || lang == language_cplus + || lang == language_m2 + || lang == language_asm + || lang == language_opencl + || lang == language_minimal); +} + +/* See cooked-index-shard.h. */ + +cooked_index_entry * +cooked_index_shard::create (sect_offset die_offset, + enum dwarf_tag tag, + cooked_index_flag flags, + enum language lang, + const char *name, + cooked_index_entry_ref parent_entry, + dwarf2_per_cu *per_cu) +{ + if (tag == DW_TAG_module || tag == DW_TAG_namespace) + flags &= ~IS_STATIC; + else if (lang == language_cplus + && (tag == DW_TAG_class_type + || tag == DW_TAG_interface_type + || tag == DW_TAG_structure_type + || tag == DW_TAG_union_type + || tag == DW_TAG_enumeration_type + || tag == DW_TAG_enumerator)) + flags &= ~IS_STATIC; + else if (tag_is_type (tag)) + flags |= IS_STATIC; + + return new (&m_storage) cooked_index_entry (die_offset, tag, flags, + lang, name, parent_entry, + per_cu); +} + +/* See cooked-index-shard.h. */ + +cooked_index_entry * +cooked_index_shard::add (sect_offset die_offset, enum dwarf_tag tag, + cooked_index_flag flags, enum language lang, + const char *name, cooked_index_entry_ref parent_entry, + dwarf2_per_cu *per_cu) +{ + cooked_index_entry *result = create (die_offset, tag, flags, lang, name, + parent_entry, per_cu); + m_entries.push_back (result); + + /* An explicitly-tagged main program should always override the + implicit "main" discovery. */ + if ((flags & IS_MAIN) != 0) + m_main = result; + else if ((flags & IS_PARENT_DEFERRED) == 0 + && parent_entry.resolved == nullptr + && m_main == nullptr + && language_may_use_plain_main (lang) + && strcmp (name, "main") == 0) + m_main = result; + + return result; +} + +/* See cooked-index-shard.h. */ + +void +cooked_index_shard::handle_gnat_encoded_entry + (cooked_index_entry *entry, + htab_t gnat_entries, + std::vector<cooked_index_entry *> &new_entries) +{ + /* We decode Ada names in a particular way: operators and wide + characters are left as-is. This is done to make name matching a + bit simpler; and for wide characters, it means the choice of Ada + source charset does not affect the indexer directly. */ + std::string canonical = ada_decode (entry->name, false, false, false); + if (canonical.empty ()) + { + entry->canonical = entry->name; + return; + } + std::vector<std::string_view> names = split_name (canonical.c_str (), + split_style::DOT_STYLE); + std::string_view tail = names.back (); + names.pop_back (); + + const cooked_index_entry *parent = nullptr; + for (const auto &name : names) + { + uint32_t hashval = dwarf5_djb_hash (name); + void **slot = htab_find_slot_with_hash (gnat_entries, &name, + hashval, INSERT); + /* CUs are processed in order, so we only need to check the most + recent entry. */ + cooked_index_entry *last = (cooked_index_entry *) *slot; + if (last == nullptr || last->per_cu != entry->per_cu) + { + const char *new_name = m_names.insert (name); + last = create (entry->die_offset, DW_TAG_module, + IS_SYNTHESIZED, language_ada, new_name, parent, + entry->per_cu); + last->canonical = last->name; + new_entries.push_back (last); + *slot = last; + } + + parent = last; + } + + entry->set_parent (parent); + entry->canonical = m_names.insert (tail); +} + +/* Hash a cooked index entry by name pointer value. + + We can use pointer equality here because names come from .debug_str, which + will normally be unique-ified by the linker. Also, duplicates are relatively + harmless -- they just mean a bit of extra memory is used. */ + +struct cooked_index_entry_name_ptr_hash +{ + using is_avalanching = void; + + std::uint64_t operator () (const cooked_index_entry *entry) const noexcept + { + return ankerl::unordered_dense::hash<const char *> () (entry->name); + } +}; + +/* Compare cooked index entries by name pointer value. */ + +struct cooked_index_entry_name_ptr_eq +{ + bool operator () (const cooked_index_entry *a, + const cooked_index_entry *b) const noexcept + { + return a->name == b->name; + } +}; + +/* See cooked-index-shard.h. */ + +void +cooked_index_shard::finalize (const parent_map_map *parent_maps) +{ + gdb::unordered_set<const cooked_index_entry *, + cooked_index_entry_name_ptr_hash, + cooked_index_entry_name_ptr_eq> seen_names; + + auto hash_entry = [] (const void *e) + { + const cooked_index_entry *entry = (const cooked_index_entry *) e; + return dwarf5_djb_hash (entry->canonical); + }; + + auto eq_entry = [] (const void *a, const void *b) -> int + { + const cooked_index_entry *ae = (const cooked_index_entry *) a; + const std::string_view *sv = (const std::string_view *) b; + return (strlen (ae->canonical) == sv->length () + && strncasecmp (ae->canonical, sv->data (), sv->length ()) == 0); + }; + + htab_up gnat_entries (htab_create_alloc (10, hash_entry, eq_entry, + nullptr, xcalloc, xfree)); + std::vector<cooked_index_entry *> new_gnat_entries; + + for (cooked_index_entry *entry : m_entries) + { + if ((entry->flags & IS_PARENT_DEFERRED) != 0) + { + const cooked_index_entry *new_parent + = parent_maps->find (entry->get_deferred_parent ()); + entry->resolve_parent (new_parent); + } + + /* Note that this code must be kept in sync with + language_requires_canonicalization. */ + gdb_assert (entry->canonical == nullptr); + if ((entry->flags & IS_LINKAGE) != 0) + entry->canonical = entry->name; + else if (entry->lang == language_ada) + { + /* Newer versions of GNAT emit DW_TAG_module and use a + hierarchical structure. In this case, we don't need to + do any extra work. This can be detected by looking for a + GNAT-encoded name. */ + if (strstr (entry->name, "__") == nullptr) + { + entry->canonical = entry->name; + + /* If the entry does not have a parent, then there's + nothing extra to do here -- the entry itself is + sufficient. + + However, if it does have a parent, we have to + synthesize an entry with the full name. This is + unfortunate, but it's necessary due to how some of + the Ada name-lookup code currently works. For + example, without this, ada_get_tsd_type will + fail. + + Eventually it would be good to change the Ada lookup + code, and then remove these entries (and supporting + code in cooked_index_entry::full_name). */ + if (entry->get_parent () != nullptr) + { + const char *fullname + = entry->full_name (&m_storage, FOR_ADA_LINKAGE_NAME); + cooked_index_entry *linkage = create (entry->die_offset, + entry->tag, + (entry->flags + | IS_LINKAGE + | IS_SYNTHESIZED), + language_ada, + fullname, + nullptr, + entry->per_cu); + linkage->canonical = fullname; + new_gnat_entries.push_back (linkage); + } + } + else + handle_gnat_encoded_entry (entry, gnat_entries.get (), + new_gnat_entries); + } + else if (entry->lang == language_cplus || entry->lang == language_c) + { + auto [it, inserted] = seen_names.insert (entry); + + if (inserted) + { + /* No entry with that name was present, compute the canonical + name. */ + gdb::unique_xmalloc_ptr<char> canon_name + = (entry->lang == language_cplus + ? cp_canonicalize_string (entry->name) + : c_canonicalize_name (entry->name)); + if (canon_name == nullptr) + entry->canonical = entry->name; + else + entry->canonical = m_names.insert (std::move (canon_name)); + } + else + { + /* An entry with that name was present, re-use its canonical + name. */ + entry->canonical = (*it)->canonical; + } + } + else + entry->canonical = entry->name; + } + + /* Make sure any new Ada entries end up in the results. This isn't + done when creating these new entries to avoid invalidating the + m_entries iterator used in the foreach above. */ + m_entries.insert (m_entries.end (), new_gnat_entries.begin (), + new_gnat_entries.end ()); + + m_entries.shrink_to_fit (); + std::sort (m_entries.begin (), m_entries.end (), + [] (const cooked_index_entry *a, const cooked_index_entry *b) + { + return *a < *b; + }); +} + +/* See cooked-index-shard.h. */ + +cooked_index_shard::range +cooked_index_shard::find (const std::string &name, bool completing) const +{ + struct comparator + { + cooked_index_entry::comparison_mode mode; + + bool operator() (const cooked_index_entry *entry, + const char *name) const noexcept + { + return cooked_index_entry::compare (entry->canonical, name, mode) < 0; + } + + bool operator() (const char *name, + const cooked_index_entry *entry) const noexcept + { + return cooked_index_entry::compare (entry->canonical, name, mode) > 0; + } + }; + + return std::make_from_tuple<range> + (std::equal_range (m_entries.cbegin (), m_entries.cend (), name.c_str (), + comparator { (completing + ? cooked_index_entry::COMPLETE + : cooked_index_entry::MATCH) })); +} diff --git a/gdb/dwarf2/cooked-index-shard.h b/gdb/dwarf2/cooked-index-shard.h new file mode 100644 index 0000000..eb80926 --- /dev/null +++ b/gdb/dwarf2/cooked-index-shard.h @@ -0,0 +1,134 @@ +/* Shards for the cooked index + + Copyright (C) 2022-2024 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program 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 a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#ifndef GDB_DWARF2_COOKED_INDEX_SHARD_H +#define GDB_DWARF2_COOKED_INDEX_SHARD_H + +#include "dwarf2/cooked-index-entry.h" +#include "dwarf2/types.h" +#include "gdbsupport/gdb_obstack.h" +#include "addrmap.h" +#include "gdbsupport/iterator-range.h" +#include "gdbsupport/string-set.h" + +/* An index of interesting DIEs. This is "cooked", in contrast to a + mapped .debug_names or .gdb_index, which are "raw". An entry in + the index is of type cooked_index_entry. + + Operations on the index are described below. They are chosen to + make it relatively simple to implement the symtab "quick" + methods. */ +class cooked_index_shard +{ +public: + cooked_index_shard () = default; + DISABLE_COPY_AND_ASSIGN (cooked_index_shard); + + /* Create a new cooked_index_entry and register it with this object. + Entries are owned by this object. The new item is returned. */ + cooked_index_entry *add (sect_offset die_offset, enum dwarf_tag tag, + cooked_index_flag flags, enum language lang, + const char *name, + cooked_index_entry_ref parent_entry, + dwarf2_per_cu *per_cu); + + /* Install a new fixed addrmap from the given mutable addrmap. */ + void install_addrmap (addrmap_mutable *map) + { + gdb_assert (m_addrmap == nullptr); + m_addrmap = new (&m_storage) addrmap_fixed (&m_storage, map); + } + + friend class cooked_index; + + /* A simple range over part of m_entries. */ + typedef iterator_range<std::vector<cooked_index_entry *>::const_iterator> + range; + + /* Return a range of all the entries. */ + range all_entries () const + { + return { m_entries.cbegin (), m_entries.cend () }; + } + + /* Look up an entry by name. Returns a range of all matching + results. If COMPLETING is true, then a larger range, suitable + for completion, will be returned. */ + range find (const std::string &name, bool completing) const; + +private: + + /* Return the entry that is believed to represent the program's + "main". This will return NULL if no such entry is available. */ + const cooked_index_entry *get_main () const + { + return m_main; + } + + /* Look up ADDR in the address map, and return either the + corresponding CU, or nullptr if the address could not be + found. */ + dwarf2_per_cu *lookup (unrelocated_addr addr) + { + if (m_addrmap == nullptr) + return nullptr; + + return (static_cast<dwarf2_per_cu *> (m_addrmap->find ((CORE_ADDR) addr))); + } + + /* Create a new cooked_index_entry and register it with this object. + Entries are owned by this object. The new item is returned. */ + cooked_index_entry *create (sect_offset die_offset, + enum dwarf_tag tag, + cooked_index_flag flags, + enum language lang, + const char *name, + cooked_index_entry_ref parent_entry, + dwarf2_per_cu *per_cu); + + /* When GNAT emits mangled ("encoded") names in the DWARF, and does + not emit the module structure, we still need this structuring to + do lookups. This function recreates that information for an + existing entry, modifying ENTRY as appropriate. Any new entries + are added to NEW_ENTRIES. */ + void handle_gnat_encoded_entry + (cooked_index_entry *entry, htab_t gnat_entries, + std::vector<cooked_index_entry *> &new_entries); + + /* Finalize the index. This should be called a single time, when + the index has been fully populated. It enters all the entries + into the internal table and fixes up all missing parent links. + This may be invoked in a worker thread. */ + void finalize (const parent_map_map *parent_maps); + + /* Storage for the entries. */ + auto_obstack m_storage; + /* List of all entries. */ + std::vector<cooked_index_entry *> m_entries; + /* If we found an entry with 'is_main' set, store it here. */ + cooked_index_entry *m_main = nullptr; + /* The addrmap. This maps address ranges to dwarf2_per_cu objects. */ + addrmap_fixed *m_addrmap = nullptr; + /* Storage for canonical names. */ + gdb::string_set m_names; +}; + +using cooked_index_shard_up = std::unique_ptr<cooked_index_shard>; + +#endif /* GDB_DWARF2_COOKED_INDEX_SHARD_H */ diff --git a/gdb/dwarf2/cooked-index-storage.c b/gdb/dwarf2/cooked-index-storage.c deleted file mode 100644 index 9c05cf5..0000000 --- a/gdb/dwarf2/cooked-index-storage.c +++ /dev/null @@ -1,84 +0,0 @@ -/* DWARF index storage - - Copyright (C) 2022-2025 Free Software Foundation, Inc. - - This file is part of GDB. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program 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 a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. */ - -#include "dwarf2/cooked-index-storage.h" - -/* See cooked-index-storage.h. */ - -cooked_index_storage::cooked_index_storage () - : m_shard (new cooked_index_shard) -{ -} - -/* See cooked-index-storage.h. */ - -cutu_reader * -cooked_index_storage::get_reader (dwarf2_per_cu *per_cu) -{ - auto it = m_reader_hash.find (*per_cu); - return it != m_reader_hash.end () ? it->get () : nullptr; -} - -/* See cooked-index-storage.h. */ - -cutu_reader * -cooked_index_storage::preserve (cutu_reader_up reader) -{ - m_abbrev_table_cache.add (reader->release_abbrev_table ()); - - auto [it, inserted] = m_reader_hash.insert (std::move (reader)); - gdb_assert (inserted); - - return it->get(); -} - -/* See cooked-index-storage.h. */ - -std::uint64_t -cooked_index_storage::cutu_reader_hash::operator() - (const cutu_reader_up &reader) const noexcept -{ - return (*this) (*reader->cu ()->per_cu); -} - -/* See cooked-index-storage.h. */ - -std::uint64_t -cooked_index_storage::cutu_reader_hash::operator() (const dwarf2_per_cu &per_cu) - const noexcept -{ - return per_cu.index; -} - -/* See cooked-index-storage.h. */ - -bool -cooked_index_storage::cutu_reader_eq::operator() (const cutu_reader_up &a, - const cutu_reader_up &b) const noexcept -{ - return (*this) (*a->cu ()->per_cu, b); -} - -/* See cooked-index-storage.h. */ - -bool cooked_index_storage::cutu_reader_eq::operator() - (const dwarf2_per_cu &per_cu, const cutu_reader_up &reader) const noexcept -{ - return per_cu.index == reader->cu ()->per_cu->index; -} diff --git a/gdb/dwarf2/cooked-index-storage.h b/gdb/dwarf2/cooked-index-storage.h deleted file mode 100644 index 449fbe1..0000000 --- a/gdb/dwarf2/cooked-index-storage.h +++ /dev/null @@ -1,131 +0,0 @@ -/* DWARF index storage - - Copyright (C) 2022-2025 Free Software Foundation, Inc. - - This file is part of GDB. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program 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 a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. */ - -#ifndef GDB_DWARF2_COOKED_INDEX_STORAGE_H -#define GDB_DWARF2_COOKED_INDEX_STORAGE_H - -#include "dwarf2/abbrev-table-cache.h" -#include "dwarf2/cooked-index.h" -#include "dwarf2/types.h" - -struct cutu_reader; -struct dwarf2_per_cu; - -using cutu_reader_up = std::unique_ptr<cutu_reader>; - -/* An instance of this is created when scanning DWARF to create a - cooked index. */ - -class cooked_index_storage -{ -public: - - cooked_index_storage (); - DISABLE_COPY_AND_ASSIGN (cooked_index_storage); - - /* Return the current abbrev table_cache. */ - const abbrev_table_cache &get_abbrev_table_cache () const - { return m_abbrev_table_cache; } - - /* Return the DIE reader corresponding to PER_CU. If no such reader - has been registered, return NULL. */ - cutu_reader *get_reader (dwarf2_per_cu *per_cu); - - /* Preserve READER by storing it in the local hash table. */ - cutu_reader *preserve (cutu_reader_up reader); - - /* Add an entry to the index. The arguments describe the entry; see - cooked-index.h. The new entry is returned. */ - cooked_index_entry *add (sect_offset die_offset, enum dwarf_tag tag, - cooked_index_flag flags, - const char *name, - cooked_index_entry_ref parent_entry, - dwarf2_per_cu *per_cu) - { - return m_shard->add (die_offset, tag, flags, per_cu->lang (), - name, parent_entry, per_cu); - } - - /* Install the current addrmap into the shard being constructed, - then transfer ownership of the index to the caller. */ - cooked_index_shard_up release () - { - m_shard->install_addrmap (&m_addrmap); - return std::move (m_shard); - } - - /* Return the mutable addrmap that is currently being created. */ - addrmap_mutable *get_addrmap () - { - return &m_addrmap; - } - - /* Return the parent_map that is currently being created. */ - parent_map *get_parent_map () - { - return &m_parent_map; - } - - /* Return the parent_map that is currently being created. Ownership - is passed to the caller. */ - parent_map release_parent_map () - { - return std::move (m_parent_map); - } - -private: - /* The abbrev table cache used by this indexer. */ - abbrev_table_cache m_abbrev_table_cache; - - /* Hash function for a cutu_reader. */ - struct cutu_reader_hash - { - using is_transparent = void; - - std::uint64_t operator() (const cutu_reader_up &reader) const noexcept; - std::uint64_t operator() (const dwarf2_per_cu &per_cu) const noexcept; - }; - - /* Equality function for cutu_reader. */ - struct cutu_reader_eq - { - using is_transparent = void; - - bool operator() (const cutu_reader_up &a, - const cutu_reader_up &b) const noexcept; - - bool operator() (const dwarf2_per_cu &per_cu, - const cutu_reader_up &reader) const noexcept; - }; - - /* A hash table of cutu_reader objects. */ - gdb::unordered_set<cutu_reader_up, cutu_reader_hash, cutu_reader_eq> - m_reader_hash; - - /* The index shard that is being constructed. */ - cooked_index_shard_up m_shard; - - /* Parent map for each CU that is read. */ - parent_map m_parent_map; - - /* A writeable addrmap being constructed by this scanner. */ - addrmap_mutable m_addrmap; -}; - -#endif /* GDB_DWARF2_COOKED_INDEX_STORAGE_H */ diff --git a/gdb/dwarf2/cooked-index-worker.c b/gdb/dwarf2/cooked-index-worker.c new file mode 100644 index 0000000..da51a8c --- /dev/null +++ b/gdb/dwarf2/cooked-index-worker.c @@ -0,0 +1,255 @@ +/* DWARF index storage + + Copyright (C) 2022-2025 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program 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 a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#include "dwarf2/cooked-index-worker.h" +#include "dwarf2/cooked-index.h" +#include "gdbsupport/thread-pool.h" +#include "run-on-main-thread.h" +#include "event-top.h" +#include "exceptions.h" + +/* See cooked-index-worker.h. */ + +cooked_index_worker_result::cooked_index_worker_result () + : m_shard (new cooked_index_shard) +{ +} + +/* See cooked-index-worker.h. */ + +cutu_reader * +cooked_index_worker_result::get_reader (dwarf2_per_cu *per_cu) +{ + auto it = m_reader_hash.find (*per_cu); + return it != m_reader_hash.end () ? it->get () : nullptr; +} + +/* See cooked-index-worker.h. */ + +cutu_reader * +cooked_index_worker_result::preserve (cutu_reader_up reader) +{ + m_abbrev_table_cache.add (reader->release_abbrev_table ()); + + auto [it, inserted] = m_reader_hash.insert (std::move (reader)); + gdb_assert (inserted); + + return it->get(); +} + +/* See cooked-index-worker.h. */ + +std::uint64_t +cooked_index_worker_result::cutu_reader_hash::operator() + (const cutu_reader_up &reader) const noexcept +{ + return (*this) (*reader->cu ()->per_cu); +} + +/* See cooked-index-worker.h. */ + +std::uint64_t +cooked_index_worker_result::cutu_reader_hash::operator() (const dwarf2_per_cu &per_cu) + const noexcept +{ + return per_cu.index; +} + +/* See cooked-index-worker.h. */ + +bool +cooked_index_worker_result::cutu_reader_eq::operator() (const cutu_reader_up &a, + const cutu_reader_up &b) const noexcept +{ + return (*this) (*a->cu ()->per_cu, b); +} + +/* See cooked-index-worker.h. */ + +bool cooked_index_worker_result::cutu_reader_eq::operator() + (const dwarf2_per_cu &per_cu, const cutu_reader_up &reader) const noexcept +{ + return per_cu.index == reader->cu ()->per_cu->index; +} + +/* See cooked-index-worker.h. */ + +void +cooked_index_worker_result::emit_complaints_and_exceptions + (gdb::unordered_set<gdb_exception> &seen_exceptions) +{ + gdb_assert (is_main_thread ()); + + re_emit_complaints (m_complaints); + + /* Only show a given exception a single time. */ + for (auto &one_exc : m_exceptions) + if (seen_exceptions.insert (one_exc).second) + exception_print (gdb_stderr, one_exc); +} + +/* See cooked-index-worker.h. */ + +void +cooked_index_worker::start () +{ + gdb::thread_pool::g_thread_pool->post_task ([this] () + { + try + { + do_reading (); + } + catch (const gdb_exception &exc) + { + m_failed = exc; + set (cooked_state::CACHE_DONE); + } + + bfd_thread_cleanup (); + }); +} + +/* See cooked-index-worker.h. */ + +bool +cooked_index_worker::wait (cooked_state desired_state, bool allow_quit) +{ + bool done; +#if CXX_STD_THREAD + { + std::unique_lock<std::mutex> lock (m_mutex); + + /* This may be called from a non-main thread -- this functionality + is needed for the index cache -- but in this case we require + that the desired state already have been attained. */ + gdb_assert (is_main_thread () || desired_state <= m_state); + + while (desired_state > m_state) + { + if (allow_quit) + { + std::chrono::milliseconds duration { 15 }; + if (m_cond.wait_for (lock, duration) == std::cv_status::timeout) + QUIT; + } + else + m_cond.wait (lock); + } + done = m_state == cooked_state::CACHE_DONE; + } +#else + /* Without threads, all the work is done immediately on the main + thread, and there is never anything to wait for. */ + done = desired_state == cooked_state::CACHE_DONE; +#endif /* CXX_STD_THREAD */ + + /* Only the main thread is allowed to report complaints and the + like. */ + if (!is_main_thread ()) + return false; + + if (m_reported) + return done; + m_reported = true; + + /* Emit warnings first, maybe they were emitted before an exception + (if any) was thrown. */ + m_warnings.emit (); + + if (m_failed.has_value ()) + { + /* do_reading failed -- report it. */ + exception_print (gdb_stderr, *m_failed); + m_failed.reset (); + return done; + } + + /* Only show a given exception a single time. */ + gdb::unordered_set<gdb_exception> seen_exceptions; + for (auto &one_result : m_results) + one_result.emit_complaints_and_exceptions (seen_exceptions); + + print_stats (); + + struct objfile *objfile = m_per_objfile->objfile; + dwarf2_per_bfd *per_bfd = m_per_objfile->per_bfd; + cooked_index *table + = (gdb::checked_static_cast<cooked_index *> + (per_bfd->index_table.get ())); + + auto_obstack temp_storage; + enum language lang = language_unknown; + const char *main_name = table->get_main_name (&temp_storage, &lang); + if (main_name != nullptr) + set_objfile_main_name (objfile, main_name, lang); + + /* dwarf_read_debug_printf ("Done building psymtabs of %s", */ + /* objfile_name (objfile)); */ + + return done; +} + +/* See cooked-index-worker.h. */ + +void +cooked_index_worker::set (cooked_state desired_state) +{ + gdb_assert (desired_state != cooked_state::INITIAL); + +#if CXX_STD_THREAD + std::lock_guard<std::mutex> guard (m_mutex); + gdb_assert (desired_state > m_state); + m_state = desired_state; + m_cond.notify_one (); +#else + /* Without threads, all the work is done immediately on the main + thread, and there is never anything to do. */ +#endif /* CXX_STD_THREAD */ +} + +/* See cooked-index-worker.h. */ + +void +cooked_index_worker::write_to_cache (const cooked_index *idx) +{ + if (idx != nullptr) + { + /* Writing to the index cache may cause a warning to be emitted. + See PR symtab/30837. This arranges to capture all such + warnings. This is safe because we know the deferred_warnings + object isn't in use by any other thread at this point. */ + scoped_restore_warning_hook defer (&m_warnings); + m_cache_store.store (); + } +} + +/* See cooked-index-worker.h. */ + +void +cooked_index_worker::done_reading () +{ + for (auto &one_result : m_results) + m_all_parents_map.add_map (*one_result.get_parent_map ()); + + dwarf2_per_bfd *per_bfd = m_per_objfile->per_bfd; + cooked_index *table + = (gdb::checked_static_cast<cooked_index *> + (per_bfd->index_table.get ())); + table->set_contents (); +} diff --git a/gdb/dwarf2/cooked-index-worker.h b/gdb/dwarf2/cooked-index-worker.h new file mode 100644 index 0000000..df5c31d --- /dev/null +++ b/gdb/dwarf2/cooked-index-worker.h @@ -0,0 +1,305 @@ +/* DWARF index storage + + Copyright (C) 2022-2025 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program 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 a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#ifndef GDB_DWARF2_COOKED_INDEX_WORKER_H +#define GDB_DWARF2_COOKED_INDEX_WORKER_H + +#include "dwarf2/abbrev-table-cache.h" +#include "dwarf2/cooked-index-entry.h" +#include "dwarf2/cooked-index-shard.h" +#include "dwarf2/types.h" +#include "dwarf2/read.h" + +#if CXX_STD_THREAD +#include <mutex> +#include <condition_variable> +#endif /* CXX_STD_THREAD */ + +using cutu_reader_up = std::unique_ptr<cutu_reader>; + +/* An instance of this is created when scanning DWARF to create a + cooked index. This class is the result of a single task to store + results while working -- that is, it is an implementation detail of + the threads managed by cooked_index_worker. Once scanning is done, + selected parts of the state here are stored into the shard, and + then these temporary objects are destroyed. */ + +class cooked_index_worker_result +{ +public: + + cooked_index_worker_result (); + DISABLE_COPY_AND_ASSIGN (cooked_index_worker_result); + + cooked_index_worker_result (cooked_index_worker_result &&) = default; + cooked_index_worker_result &operator= (cooked_index_worker_result &&) + = default; + + /* Return the current abbrev table_cache. */ + const abbrev_table_cache &get_abbrev_table_cache () const + { return m_abbrev_table_cache; } + + /* Return the DIE reader corresponding to PER_CU. If no such reader + has been registered, return NULL. */ + cutu_reader *get_reader (dwarf2_per_cu *per_cu); + + /* Preserve READER by storing it in the local hash table. */ + cutu_reader *preserve (cutu_reader_up reader); + + /* Add an entry to the index. The arguments describe the entry; see + cooked-index.h. The new entry is returned. */ + cooked_index_entry *add (sect_offset die_offset, enum dwarf_tag tag, + cooked_index_flag flags, + const char *name, + cooked_index_entry_ref parent_entry, + dwarf2_per_cu *per_cu) + { + return m_shard->add (die_offset, tag, flags, per_cu->lang (), + name, parent_entry, per_cu); + } + + /* Overload that allows the language to be specified. */ + cooked_index_entry *add (sect_offset die_offset, enum dwarf_tag tag, + cooked_index_flag flags, enum language lang, + const char *name, + cooked_index_entry_ref parent_entry, + dwarf2_per_cu *per_cu) + { + return m_shard->add (die_offset, tag, flags, lang, + name, parent_entry, per_cu); + } + + /* Install the current addrmap into the shard being constructed, + then transfer ownership of the index to the caller. */ + cooked_index_shard_up release_shard () + { + m_shard->install_addrmap (&m_addrmap); + /* This isn't needed any more. */ + m_addrmap.clear (); + return std::move (m_shard); + } + + /* Return the mutable addrmap that is currently being created. */ + addrmap_mutable *get_addrmap () + { + return &m_addrmap; + } + + /* Return the parent_map that is currently being created. */ + parent_map *get_parent_map () + { + return &m_parent_map; + } + + /* Add an exception to the list of exceptions caught while reading. + These are passed forward and printed by the main thread. */ + void note_error (gdb_exception &&except) + { + m_exceptions.push_back (std::move (except)); + } + + /* Called when the thread using this object is done with its work. + This stores any complaints for later emission, and it clears some + data that won't be needed again. */ + void done_reading (complaint_collection &&complaints) + { + /* Hang on to the complaints. */ + m_complaints = std::move (complaints); + /* Discard things that are no longer needed. */ + m_reader_hash.clear (); + } + + /* Called to emit any stored complaints or exceptions. This can + only be called on the main thread. */ + void emit_complaints_and_exceptions + (gdb::unordered_set<gdb_exception> &seen_exceptions); + +private: + /* The abbrev table cache used by this indexer. */ + abbrev_table_cache m_abbrev_table_cache; + + /* Hash function for a cutu_reader. */ + struct cutu_reader_hash + { + using is_transparent = void; + + std::uint64_t operator() (const cutu_reader_up &reader) const noexcept; + std::uint64_t operator() (const dwarf2_per_cu &per_cu) const noexcept; + }; + + /* Equality function for cutu_reader. */ + struct cutu_reader_eq + { + using is_transparent = void; + + bool operator() (const cutu_reader_up &a, + const cutu_reader_up &b) const noexcept; + + bool operator() (const dwarf2_per_cu &per_cu, + const cutu_reader_up &reader) const noexcept; + }; + + /* A hash table of cutu_reader objects. */ + gdb::unordered_set<cutu_reader_up, cutu_reader_hash, cutu_reader_eq> + m_reader_hash; + + /* The index shard that is being constructed. */ + cooked_index_shard_up m_shard; + + /* Parent map for each CU that is read. */ + parent_map m_parent_map; + + /* A writeable addrmap being constructed by this scanner. */ + addrmap_mutable m_addrmap; + + /* The issued complaints. Only set after done_reading is + called. */ + complaint_collection m_complaints; + + /* Exceptions that we're storing to emit later. */ + std::vector<gdb_exception> m_exceptions; +}; + +/* The possible states of the index. See the explanatory comment + before cooked_index for more details. */ +enum class cooked_state +{ + /* The default state. This is not a valid argument to 'wait'. */ + INITIAL, + /* The initial scan has completed. The name of "main" is now + available (if known). The addrmaps are usable now. + Finalization has started but is not complete. */ + MAIN_AVAILABLE, + /* Finalization has completed. This means the index is fully + available for queries. */ + FINALIZED, + /* Writing to the index cache has finished. */ + CACHE_DONE, +}; + +/* An object of this type controls the scanning of the DWARF. It + schedules the worker tasks and tracks the current state. Once + scanning is done, this object is discarded. + + This is an abstract base class that defines the basic behavior of + scanners. Separate concrete implementations exist for scanning + .debug_names and .debug_info. */ + +class cooked_index_worker +{ +public: + + explicit cooked_index_worker (dwarf2_per_objfile *per_objfile) + : m_per_objfile (per_objfile), + m_cache_store (global_index_cache, per_objfile->per_bfd) + { } + virtual ~cooked_index_worker () + { } + DISABLE_COPY_AND_ASSIGN (cooked_index_worker); + + /* Start reading. */ + void start (); + + /* Wait for a particular state to be achieved. If ALLOW_QUIT is + true, then the loop will check the QUIT flag. Normally this + method may only be called from the main thread; however, it can + be called from a worker thread provided that the desired state + has already been attained. (This oddity is used by the index + cache writer.) */ + bool wait (cooked_state desired_state, bool allow_quit); + + /* Release all shards from the results. */ + std::vector<cooked_index_shard_up> release_shards () + { + std::vector<cooked_index_shard_up> result; + for (auto &one_result : m_results) + result.push_back (one_result.release_shard ()); + result.shrink_to_fit (); + return result; + } + + /* Return the object holding all the parent maps. */ + const parent_map_map *get_parent_map_map () const + { + return &m_all_parents_map; + } + +protected: + + /* Let cooked_index call the 'set' and 'write_to_cache' methods. */ + friend class cooked_index; + + /* Set the current state. */ + void set (cooked_state desired_state); + + /* Write to the index cache. */ + void write_to_cache (const cooked_index *idx); + + /* Helper function that does the work of reading. This must be able + to be run in a worker thread without problems. */ + virtual void do_reading () = 0; + + /* Helper function that should be called when done reading. This + assumes that m_results is filled in, and will initialize + m_all_parents_map and end by calling + cooked_index::set_contents. */ + virtual void done_reading (); + + /* A callback that can print stats, if needed. This is called when + transitioning to the 'MAIN_AVAILABLE' state. */ + virtual void print_stats () + { } + + /* The per-objfile object. */ + dwarf2_per_objfile *m_per_objfile; + /* Result of each worker task. */ + std::vector<cooked_index_worker_result> m_results; + /* Any warnings emitted. For the time being at least, this only + needed in do_reading, not in every worker. Note that + deferred_warnings uses gdb_stderr in its constructor, and this + should only be done from the main thread. This is enforced in + the cooked_index_worker constructor. */ + deferred_warnings m_warnings; + + /* A map of all parent maps. Used during finalization to fix up + parent relationships. */ + parent_map_map m_all_parents_map; + +#if CXX_STD_THREAD + /* Current state of this object. */ + cooked_state m_state = cooked_state::INITIAL; + /* Mutex and condition variable used to synchronize. */ + std::mutex m_mutex; + std::condition_variable m_cond; +#endif /* CXX_STD_THREAD */ + /* This flag indicates whether any complaints or exceptions that + arose during scanning have been reported by 'wait'. This may + only be modified on the main thread. */ + bool m_reported = false; + /* If set, an exception occurred during reading; in this case the + scanning is stopped and this exception will later be reported by + the 'wait' method. */ + std::optional<gdb_exception> m_failed; + /* An object used to write to the index cache. */ + index_cache_store_context m_cache_store; +}; + +using cooked_index_worker_up = std::unique_ptr<cooked_index_worker>; + +#endif /* GDB_DWARF2_COOKED_INDEX_WORKER_H */ diff --git a/gdb/dwarf2/cooked-index.c b/gdb/dwarf2/cooked-index.c index 724615f..0f20b07 100644 --- a/gdb/dwarf2/cooked-index.c +++ b/gdb/dwarf2/cooked-index.c @@ -18,25 +18,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "dwarf2/cooked-index.h" -#include "dwarf2/index-common.h" #include "dwarf2/read.h" #include "dwarf2/stringify.h" -#include "dwarf2/index-cache.h" -#include "cp-support.h" -#include "c-lang.h" -#include "ada-lang.h" -#include "dwarf2/tag.h" #include "event-top.h" -#include "exceptions.h" -#include "split-name.h" #include "observable.h" #include "run-on-main-thread.h" -#include <algorithm> -#include "gdbsupport/gdb-safe-ctype.h" -#include "gdbsupport/selftest.h" #include "gdbsupport/task-group.h" -#include "gdbsupport/thread-pool.h" -#include <chrono> #include "cli/cli-cmds.h" /* We don't want gdb to exit while it is in the process of writing to @@ -44,25 +31,12 @@ here, and then these are all waited for before exit proceeds. */ static gdb::unordered_set<cooked_index *> active_vectors; -/* 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_LINKAGE), - MAP_ENUM_FLAG (IS_TYPE_DECLARATION), - MAP_ENUM_FLAG (IS_PARENT_DEFERRED), - }; - - return flags.to_string (mapping); -} - -/* See cooked-index.h. */ +/* Return true if LANG requires canonicalization. This is used + primarily to work around an issue computing the name of "main". + This function must be kept in sync with + cooked_index_shard::finalize. */ -bool +static bool language_requires_canonicalization (enum language lang) { return (lang == language_ada @@ -70,648 +44,6 @@ language_requires_canonicalization (enum language lang) || lang == language_cplus); } -/* Return true if a plain "main" could be the main program for this - language. Languages that are known to use some other mechanism are - excluded here. */ - -static bool -language_may_use_plain_main (enum language lang) -{ - /* No need to handle "unknown" here. */ - return (lang == language_c - || lang == language_objc - || lang == language_cplus - || lang == language_m2 - || lang == language_asm - || lang == language_opencl - || lang == language_minimal); -} - -/* See cooked-index.h. */ - -int -cooked_index_entry::compare (const char *stra, const char *strb, - comparison_mode mode) -{ -#if defined (__GNUC__) && !defined (__clang__) && __GNUC__ <= 7 - /* Work around error with gcc 7.5.0. */ - auto munge = [] (char c) -> unsigned char -#else - auto munge = [] (char c) constexpr -> unsigned char -#endif - { - /* Treat '<' as if it ended the string. This lets something - like "func<t>" match "func<t<int>>". See the "Breakpoints in - template functions" section in the manual. */ - if (c == '<') - return '\0'; - return TOLOWER ((unsigned char) c); - }; - - unsigned char a = munge (*stra); - unsigned char b = munge (*strb); - - while (a != '\0' && b != '\0' && a == b) - { - a = munge (*++stra); - b = munge (*++strb); - } - - if (a == b) - return 0; - - /* When completing, if STRB ends earlier than STRA, consider them as - equal. */ - if (mode == COMPLETE || (mode == MATCH && a == munge ('<'))) - { - if (b == '\0') - return 0; - } - - return a < b ? -1 : 1; -} - -#if GDB_SELF_TEST - -namespace { - -void -test_compare () -{ - /* Convenience aliases. */ - const auto mode_compare = cooked_index_entry::MATCH; - const auto mode_sort = cooked_index_entry::SORT; - const auto mode_complete = cooked_index_entry::COMPLETE; - - SELF_CHECK (cooked_index_entry::compare ("abcd", "abcd", - mode_compare) == 0); - SELF_CHECK (cooked_index_entry::compare ("abcd", "abcd", - mode_complete) == 0); - - SELF_CHECK (cooked_index_entry::compare ("abcd", "ABCDE", - mode_compare) < 0); - SELF_CHECK (cooked_index_entry::compare ("ABCDE", "abcd", - mode_compare) > 0); - SELF_CHECK (cooked_index_entry::compare ("abcd", "ABCDE", - mode_complete) < 0); - SELF_CHECK (cooked_index_entry::compare ("ABCDE", "abcd", - mode_complete) == 0); - - SELF_CHECK (cooked_index_entry::compare ("name", "name<>", - mode_compare) == 0); - SELF_CHECK (cooked_index_entry::compare ("name<>", "name", - mode_compare) == 0); - SELF_CHECK (cooked_index_entry::compare ("name", "name<>", - mode_complete) == 0); - SELF_CHECK (cooked_index_entry::compare ("name<>", "name", - mode_complete) == 0); - - SELF_CHECK (cooked_index_entry::compare ("name<arg>", "name<arg>", - mode_compare) == 0); - SELF_CHECK (cooked_index_entry::compare ("name<arg>", "name<ag>", - mode_compare) == 0); - SELF_CHECK (cooked_index_entry::compare ("name<arg>", "name<arg>", - mode_complete) == 0); - SELF_CHECK (cooked_index_entry::compare ("name<arg>", "name<ag>", - mode_complete) == 0); - - SELF_CHECK (cooked_index_entry::compare ("name<arg<more>>", - "name<arg<more>>", - mode_compare) == 0); - SELF_CHECK (cooked_index_entry::compare ("name<arg>", - "name<arg<more>>", - mode_compare) == 0); - - SELF_CHECK (cooked_index_entry::compare ("name", "name<arg<more>>", - mode_compare) == 0); - SELF_CHECK (cooked_index_entry::compare ("name<arg<more>>", "name", - mode_compare) == 0); - SELF_CHECK (cooked_index_entry::compare ("name<arg<more>>", "name<arg<", - mode_compare) == 0); - SELF_CHECK (cooked_index_entry::compare ("name<arg<more>>", "name<arg<", - mode_complete) == 0); - - SELF_CHECK (cooked_index_entry::compare ("", "abcd", mode_compare) < 0); - SELF_CHECK (cooked_index_entry::compare ("", "abcd", mode_complete) < 0); - SELF_CHECK (cooked_index_entry::compare ("abcd", "", mode_compare) > 0); - SELF_CHECK (cooked_index_entry::compare ("abcd", "", mode_complete) == 0); - - SELF_CHECK (cooked_index_entry::compare ("func", "func<type>", - mode_sort) == 0); - SELF_CHECK (cooked_index_entry::compare ("func<type>", "func1", - mode_sort) < 0); -} - -} /* anonymous namespace */ - -#endif /* GDB_SELF_TEST */ - -/* See cooked-index.h. */ - -bool -cooked_index_entry::matches (domain_search_flags kind) const -{ - /* Just reject type declarations. */ - if ((flags & IS_TYPE_DECLARATION) != 0) - return false; - - return tag_matches_domain (tag, kind, lang); -} - -/* See cooked-index.h. */ - -const char * -cooked_index_entry::full_name (struct obstack *storage, - cooked_index_full_name_flag name_flags, - const char *default_sep) const -{ - const char *local_name = ((name_flags & FOR_MAIN) != 0) ? name : canonical; - - if ((flags & IS_LINKAGE) != 0 || get_parent () == nullptr) - return local_name; - - const char *sep = default_sep; - switch (lang) - { - case language_cplus: - case language_rust: - case language_fortran: - sep = "::"; - break; - - case language_ada: - if ((name_flags & FOR_ADA_LINKAGE_NAME) != 0) - { - sep = "__"; - break; - } - [[fallthrough]]; - case language_go: - case language_d: - sep = "."; - break; - - default: - if (sep == nullptr) - return local_name; - break; - } - - /* The FOR_ADA_LINKAGE_NAME flag should only affect Ada entries, so - disable it here if we don't need it. */ - if (lang != language_ada) - name_flags &= ~FOR_ADA_LINKAGE_NAME; - - get_parent ()->write_scope (storage, sep, name_flags); - obstack_grow0 (storage, local_name, strlen (local_name)); - return (const char *) obstack_finish (storage); -} - -/* See cooked-index.h. */ - -void -cooked_index_entry::write_scope (struct obstack *storage, - const char *sep, - cooked_index_full_name_flag flags) const -{ - if (get_parent () != nullptr) - get_parent ()->write_scope (storage, sep, flags); - /* When computing the Ada linkage name, the entry might not have - been canonicalized yet, so use the 'name'. */ - const char *local_name = ((flags & (FOR_MAIN | FOR_ADA_LINKAGE_NAME)) != 0 - ? name - : canonical); - obstack_grow (storage, local_name, strlen (local_name)); - obstack_grow (storage, sep, strlen (sep)); -} - -/* See cooked-index.h. */ - -cooked_index_entry * -cooked_index_shard::create (sect_offset die_offset, - enum dwarf_tag tag, - cooked_index_flag flags, - enum language lang, - const char *name, - cooked_index_entry_ref parent_entry, - dwarf2_per_cu *per_cu) -{ - if (tag == DW_TAG_module || tag == DW_TAG_namespace) - flags &= ~IS_STATIC; - else if (lang == language_cplus - && (tag == DW_TAG_class_type - || tag == DW_TAG_interface_type - || tag == DW_TAG_structure_type - || tag == DW_TAG_union_type - || tag == DW_TAG_enumeration_type - || tag == DW_TAG_enumerator)) - flags &= ~IS_STATIC; - else if (tag_is_type (tag)) - flags |= IS_STATIC; - - return new (&m_storage) cooked_index_entry (die_offset, tag, flags, - lang, name, parent_entry, - per_cu); -} - -/* See cooked-index.h. */ - -cooked_index_entry * -cooked_index_shard::add (sect_offset die_offset, enum dwarf_tag tag, - cooked_index_flag flags, enum language lang, - const char *name, cooked_index_entry_ref parent_entry, - dwarf2_per_cu *per_cu) -{ - cooked_index_entry *result = create (die_offset, tag, flags, lang, name, - parent_entry, per_cu); - m_entries.push_back (result); - - /* An explicitly-tagged main program should always override the - implicit "main" discovery. */ - if ((flags & IS_MAIN) != 0) - m_main = result; - else if ((flags & IS_PARENT_DEFERRED) == 0 - && parent_entry.resolved == nullptr - && m_main == nullptr - && language_may_use_plain_main (lang) - && strcmp (name, "main") == 0) - m_main = result; - - return result; -} - -/* See cooked-index.h. */ - -void -cooked_index_shard::handle_gnat_encoded_entry - (cooked_index_entry *entry, - htab_t gnat_entries, - std::vector<cooked_index_entry *> &new_entries) -{ - /* We decode Ada names in a particular way: operators and wide - characters are left as-is. This is done to make name matching a - bit simpler; and for wide characters, it means the choice of Ada - source charset does not affect the indexer directly. */ - std::string canonical = ada_decode (entry->name, false, false, false); - if (canonical.empty ()) - { - entry->canonical = entry->name; - return; - } - std::vector<std::string_view> names = split_name (canonical.c_str (), - split_style::DOT_STYLE); - std::string_view tail = names.back (); - names.pop_back (); - - const cooked_index_entry *parent = nullptr; - for (const auto &name : names) - { - uint32_t hashval = dwarf5_djb_hash (name); - void **slot = htab_find_slot_with_hash (gnat_entries, &name, - hashval, INSERT); - /* CUs are processed in order, so we only need to check the most - recent entry. */ - cooked_index_entry *last = (cooked_index_entry *) *slot; - if (last == nullptr || last->per_cu != entry->per_cu) - { - const char *new_name = m_names.insert (name); - last = create (entry->die_offset, DW_TAG_module, - IS_SYNTHESIZED, language_ada, new_name, parent, - entry->per_cu); - last->canonical = last->name; - new_entries.push_back (last); - *slot = last; - } - - parent = last; - } - - entry->set_parent (parent); - entry->canonical = m_names.insert (tail); -} - -/* Hash a cooked index entry by name pointer value. - - We can use pointer equality here because names come from .debug_str, which - will normally be unique-ified by the linker. Also, duplicates are relatively - harmless -- they just mean a bit of extra memory is used. */ - -struct cooked_index_entry_name_ptr_hash -{ - using is_avalanching = void; - - std::uint64_t operator () (const cooked_index_entry *entry) const noexcept - { - return ankerl::unordered_dense::hash<const char *> () (entry->name); - } -}; - -/* Compare cooked index entries by name pointer value. */ - -struct cooked_index_entry_name_ptr_eq -{ - bool operator () (const cooked_index_entry *a, - const cooked_index_entry *b) const noexcept - { - return a->name == b->name; - } -}; - -/* See cooked-index.h. */ - -void -cooked_index_shard::finalize (const parent_map_map *parent_maps) -{ - gdb::unordered_set<const cooked_index_entry *, - cooked_index_entry_name_ptr_hash, - cooked_index_entry_name_ptr_eq> seen_names; - - auto hash_entry = [] (const void *e) - { - const cooked_index_entry *entry = (const cooked_index_entry *) e; - return dwarf5_djb_hash (entry->canonical); - }; - - auto eq_entry = [] (const void *a, const void *b) -> int - { - const cooked_index_entry *ae = (const cooked_index_entry *) a; - const std::string_view *sv = (const std::string_view *) b; - return (strlen (ae->canonical) == sv->length () - && strncasecmp (ae->canonical, sv->data (), sv->length ()) == 0); - }; - - htab_up gnat_entries (htab_create_alloc (10, hash_entry, eq_entry, - nullptr, xcalloc, xfree)); - std::vector<cooked_index_entry *> new_gnat_entries; - - for (cooked_index_entry *entry : m_entries) - { - if ((entry->flags & IS_PARENT_DEFERRED) != 0) - { - const cooked_index_entry *new_parent - = parent_maps->find (entry->get_deferred_parent ()); - entry->resolve_parent (new_parent); - } - - /* Note that this code must be kept in sync with - language_requires_canonicalization. */ - gdb_assert (entry->canonical == nullptr); - if ((entry->flags & IS_LINKAGE) != 0) - entry->canonical = entry->name; - else if (entry->lang == language_ada) - { - /* Newer versions of GNAT emit DW_TAG_module and use a - hierarchical structure. In this case, we don't need to - do any extra work. This can be detected by looking for a - GNAT-encoded name. */ - if (strstr (entry->name, "__") == nullptr) - { - entry->canonical = entry->name; - - /* If the entry does not have a parent, then there's - nothing extra to do here -- the entry itself is - sufficient. - - However, if it does have a parent, we have to - synthesize an entry with the full name. This is - unfortunate, but it's necessary due to how some of - the Ada name-lookup code currently works. For - example, without this, ada_get_tsd_type will - fail. - - Eventually it would be good to change the Ada lookup - code, and then remove these entries (and supporting - code in cooked_index_entry::full_name). */ - if (entry->get_parent () != nullptr) - { - const char *fullname - = entry->full_name (&m_storage, FOR_ADA_LINKAGE_NAME); - cooked_index_entry *linkage = create (entry->die_offset, - entry->tag, - (entry->flags - | IS_LINKAGE - | IS_SYNTHESIZED), - language_ada, - fullname, - nullptr, - entry->per_cu); - linkage->canonical = fullname; - new_gnat_entries.push_back (linkage); - } - } - else - handle_gnat_encoded_entry (entry, gnat_entries.get (), - new_gnat_entries); - } - else if (entry->lang == language_cplus || entry->lang == language_c) - { - auto [it, inserted] = seen_names.insert (entry); - - if (inserted) - { - /* No entry with that name was present, compute the canonical - name. */ - gdb::unique_xmalloc_ptr<char> canon_name - = (entry->lang == language_cplus - ? cp_canonicalize_string (entry->name) - : c_canonicalize_name (entry->name)); - if (canon_name == nullptr) - entry->canonical = entry->name; - else - entry->canonical = m_names.insert (std::move (canon_name)); - } - else - { - /* An entry with that name was present, re-use its canonical - name. */ - entry->canonical = (*it)->canonical; - } - } - else - entry->canonical = entry->name; - } - - /* Make sure any new Ada entries end up in the results. This isn't - done when creating these new entries to avoid invalidating the - m_entries iterator used in the foreach above. */ - m_entries.insert (m_entries.end (), new_gnat_entries.begin (), - new_gnat_entries.end ()); - - m_entries.shrink_to_fit (); - std::sort (m_entries.begin (), m_entries.end (), - [] (const cooked_index_entry *a, const cooked_index_entry *b) - { - return *a < *b; - }); -} - -/* See cooked-index.h. */ - -cooked_index_shard::range -cooked_index_shard::find (const std::string &name, bool completing) const -{ - cooked_index_entry::comparison_mode mode = (completing - ? cooked_index_entry::COMPLETE - : cooked_index_entry::MATCH); - - auto lower = std::lower_bound (m_entries.cbegin (), m_entries.cend (), name, - [=] (const cooked_index_entry *entry, - const std::string &n) - { - return cooked_index_entry::compare (entry->canonical, n.c_str (), mode) < 0; - }); - - auto upper = std::upper_bound (m_entries.cbegin (), m_entries.cend (), name, - [=] (const std::string &n, - const cooked_index_entry *entry) - { - return cooked_index_entry::compare (entry->canonical, n.c_str (), mode) > 0; - }); - - return range (lower, upper); -} - -/* See cooked-index.h. */ - -void -cooked_index_worker::start () -{ - gdb::thread_pool::g_thread_pool->post_task ([this] () - { - try - { - do_reading (); - } - catch (const gdb_exception &exc) - { - m_failed = exc; - set (cooked_state::CACHE_DONE); - } - - bfd_thread_cleanup (); - }); -} - -/* See cooked-index.h. */ - -bool -cooked_index_worker::wait (cooked_state desired_state, bool allow_quit) -{ - bool done; -#if CXX_STD_THREAD - { - std::unique_lock<std::mutex> lock (m_mutex); - - /* This may be called from a non-main thread -- this functionality - is needed for the index cache -- but in this case we require - that the desired state already have been attained. */ - gdb_assert (is_main_thread () || desired_state <= m_state); - - while (desired_state > m_state) - { - if (allow_quit) - { - std::chrono::milliseconds duration { 15 }; - if (m_cond.wait_for (lock, duration) == std::cv_status::timeout) - QUIT; - } - else - m_cond.wait (lock); - } - done = m_state == cooked_state::CACHE_DONE; - } -#else - /* Without threads, all the work is done immediately on the main - thread, and there is never anything to wait for. */ - done = desired_state == cooked_state::CACHE_DONE; -#endif /* CXX_STD_THREAD */ - - /* Only the main thread is allowed to report complaints and the - like. */ - if (!is_main_thread ()) - return false; - - if (m_reported) - return done; - m_reported = true; - - /* Emit warnings first, maybe they were emitted before an exception - (if any) was thrown. */ - m_warnings.emit (); - - if (m_failed.has_value ()) - { - /* do_reading failed -- report it. */ - exception_print (gdb_stderr, *m_failed); - m_failed.reset (); - return done; - } - - /* Only show a given exception a single time. */ - gdb::unordered_set<gdb_exception> seen_exceptions; - for (auto &one_result : m_results) - { - re_emit_complaints (std::get<1> (one_result)); - for (auto &one_exc : std::get<2> (one_result)) - if (seen_exceptions.insert (one_exc).second) - exception_print (gdb_stderr, one_exc); - } - - print_stats (); - - struct objfile *objfile = m_per_objfile->objfile; - dwarf2_per_bfd *per_bfd = m_per_objfile->per_bfd; - cooked_index *table - = (gdb::checked_static_cast<cooked_index *> - (per_bfd->index_table.get ())); - - auto_obstack temp_storage; - enum language lang = language_unknown; - const char *main_name = table->get_main_name (&temp_storage, &lang); - if (main_name != nullptr) - set_objfile_main_name (objfile, main_name, lang); - - /* dwarf_read_debug_printf ("Done building psymtabs of %s", */ - /* objfile_name (objfile)); */ - - return done; -} - -/* See cooked-index.h. */ - -void -cooked_index_worker::set (cooked_state desired_state) -{ - gdb_assert (desired_state != cooked_state::INITIAL); - -#if CXX_STD_THREAD - std::lock_guard<std::mutex> guard (m_mutex); - gdb_assert (desired_state > m_state); - m_state = desired_state; - m_cond.notify_one (); -#else - /* Without threads, all the work is done immediately on the main - thread, and there is never anything to do. */ -#endif /* CXX_STD_THREAD */ -} - -/* See cooked-index.h. */ - -void -cooked_index_worker::write_to_cache (const cooked_index *idx, - deferred_warnings *warn) const -{ - if (idx != nullptr) - { - /* Writing to the index cache may cause a warning to be emitted. - See PR symtab/30837. This arranges to capture all such - warnings. This is safe because we know the deferred_warnings - object isn't in use by any other thread at this point. */ - scoped_restore_warning_hook defer (warn); - m_cache_store.store (); - } -} - cooked_index::cooked_index (cooked_index_worker_up &&worker) : m_state (std::move (worker)) { @@ -746,12 +78,10 @@ cooked_index::wait (cooked_state desired_state, bool allow_quit) } void -cooked_index::set_contents (std::vector<cooked_index_shard_up> &&shards, - deferred_warnings *warn, - const parent_map_map *parent_maps) +cooked_index::set_contents () { gdb_assert (m_shards.empty ()); - m_shards = std::move (shards); + m_shards = m_state->release_shards (); m_state->set (cooked_state::MAIN_AVAILABLE); @@ -760,16 +90,17 @@ cooked_index::set_contents (std::vector<cooked_index_shard_up> &&shards, finalization. However, that would take a slot in the global thread pool, and if enough such tasks were submitted at once, it would cause a livelock. */ - gdb::task_group finalizers ([this, warn] () + gdb::task_group finalizers ([this] () { m_state->set (cooked_state::FINALIZED); - m_state->write_to_cache (index_for_writing (), warn); + m_state->write_to_cache (index_for_writing ()); m_state->set (cooked_state::CACHE_DONE); }); for (auto &shard : m_shards) { auto this_shard = shard.get (); + const parent_map_map *parent_maps = m_state->get_parent_map_map (); finalizers.add_task ([=] () { this_shard->finalize (parent_maps); }); } @@ -994,10 +325,6 @@ void _initialize_cooked_index (); void _initialize_cooked_index () { -#if GDB_SELF_TEST - selftests::register_test ("cooked_index_entry::compare", test_compare); -#endif - add_cmd ("wait-for-index-cache", class_maintenance, maintenance_wait_for_index_cache, _("\ Wait until all pending writes to the index cache have completed.\n\ diff --git a/gdb/dwarf2/cooked-index.h b/gdb/dwarf2/cooked-index.h index 56c84bd..384938e 100644 --- a/gdb/dwarf2/cooked-index.h +++ b/gdb/dwarf2/cooked-index.h @@ -20,490 +20,16 @@ #ifndef GDB_DWARF2_COOKED_INDEX_H #define GDB_DWARF2_COOKED_INDEX_H -#include "dwarf2.h" -#include "dwarf2/types.h" +#include "dwarf2/cooked-index-entry.h" #include "symtab.h" -#include "hashtab.h" #include "quick-symbol.h" -#include "gdbsupport/gdb_obstack.h" #include "addrmap.h" -#include "gdbsupport/iterator-range.h" #include "dwarf2/mapped-index.h" #include "dwarf2/read.h" #include "dwarf2/parent-map.h" #include "gdbsupport/range-chain.h" -#include "gdbsupport/string-set.h" -#include "complaints.h" - -#if CXX_STD_THREAD -#include <mutex> -#include <condition_variable> -#endif /* CXX_STD_THREAD */ - -struct dwarf2_per_cu; -struct dwarf2_per_bfd; -struct index_cache_store_context; -struct cooked_index_entry; - -/* Flags that describe an entry in the index. */ -enum cooked_index_flag_enum : unsigned char -{ - /* True if this entry is the program's "main". */ - IS_MAIN = 1, - /* True if this entry represents a "static" object. */ - IS_STATIC = 2, - /* True if this entry uses the linkage name. */ - IS_LINKAGE = 4, - /* True if this entry is just for the declaration of a type, not the - definition. */ - IS_TYPE_DECLARATION = 8, - /* True is parent_entry.deferred has a value rather than parent_entry - .resolved. */ - IS_PARENT_DEFERRED = 16, - /* True if this entry was synthesized by gdb (as opposed to coming - directly from the DWARF). */ - IS_SYNTHESIZED = 32, -}; -DEF_ENUM_FLAGS_TYPE (enum cooked_index_flag_enum, cooked_index_flag); - -/* Flags used when requesting the full name of an entry. */ -enum cooked_index_full_name_enum : unsigned char -{ - /* Set when requesting the name of "main". See the method for the - full description. */ - FOR_MAIN = 1, - /* Set when requesting the linkage name for an Ada entry. */ - FOR_ADA_LINKAGE_NAME = 2, -}; -DEF_ENUM_FLAGS_TYPE (enum cooked_index_full_name_enum, cooked_index_full_name_flag); - -/* Type representing either a resolved or deferred cooked_index_entry. */ - -union cooked_index_entry_ref -{ - cooked_index_entry_ref (parent_map::addr_type deferred_) - { - deferred = deferred_; - } - - cooked_index_entry_ref (const cooked_index_entry *resolved_) - { - resolved = resolved_; - } - - const cooked_index_entry *resolved; - parent_map::addr_type deferred; -}; - -/* Return a string representation of FLAGS. */ - -std::string to_string (cooked_index_flag flags); - -/* Return true if LANG requires canonicalization. This is used - primarily to work around an issue computing the name of "main". - This function must be kept in sync with - cooked_index_shard::finalize. */ - -extern bool language_requires_canonicalization (enum language lang); - -/* 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. - - This is an "open" class and the members are all directly - accessible. It is read-only after the index has been fully read - and processed. */ -struct cooked_index_entry : public allocate_on_obstack<cooked_index_entry> -{ - cooked_index_entry (sect_offset die_offset_, enum dwarf_tag tag_, - cooked_index_flag flags_, - enum language lang_, const char *name_, - cooked_index_entry_ref parent_entry_, - dwarf2_per_cu *per_cu_) - : name (name_), - tag (tag_), - flags (flags_), - lang (lang_), - die_offset (die_offset_), - per_cu (per_cu_), - m_parent_entry (parent_entry_) - { - } - - /* Return true if this entry matches SEARCH_FLAGS. */ - bool matches (block_search_flags search_flags) const - { - /* Just reject type declarations. */ - if ((flags & IS_TYPE_DECLARATION) != 0) - return false; - - if ((search_flags & SEARCH_STATIC_BLOCK) != 0 - && (flags & IS_STATIC) != 0) - return true; - if ((search_flags & SEARCH_GLOBAL_BLOCK) != 0 - && (flags & IS_STATIC) == 0) - return true; - return false; - } - - /* Return true if this entry matches KIND. */ - bool matches (domain_search_flags kind) const; - - /* Construct the fully-qualified name of this entry and return a - pointer to it. If allocation is needed, it will be done on - STORAGE. - - FLAGS affects the result. If the FOR_MAIN flag is set, we are - computing the name of the "main" entry -- one marked - DW_AT_main_subprogram. This matters for avoiding name - canonicalization and also a related race (if "main" computation - is done during finalization). - - If the FOR_ADA_LINKAGE_NAME flag is set, then Ada-language - symbols will have their "linkage-style" name computed. The - default is source-style. - - If the language doesn't prescribe a separator, one can be - specified using DEFAULT_SEP. */ - const char *full_name (struct obstack *storage, - cooked_index_full_name_flag name_flags = 0, - const char *default_sep = nullptr) const; - - /* Comparison modes for the 'compare' function. See the function - for a description. */ - enum comparison_mode - { - MATCH, - SORT, - COMPLETE, - }; - - /* Compare two strings, case-insensitively. Return -1 if STRA is - less than STRB, 0 if they are equal, and 1 if STRA is greater. - - When comparing, '<' is considered to be less than all other - printable characters. This ensures that "t<x>" sorts before - "t1", which is necessary when looking up "t". This '<' handling - is to ensure that certain C++ lookups work correctly. It is - inexact, and applied regardless of the search language, but this - is ok because callers of this code do more precise filtering - according to their needs. This is also why using a - case-insensitive comparison works even for languages that are - case sensitive. - - MODE controls how the comparison proceeds. - - MODE==SORT is used when sorting and the only special '<' handling - that it does is to ensure that '<' sorts before all other - printable characters. This ensures that the resulting ordering - will be binary-searchable. - - MODE==MATCH is used when searching for a symbol. In this case, - STRB must always be the search name, and STRA must be the name in - the index that is under consideration. In compare mode, early - termination of STRB may match STRA -- for example, "t<int>" and - "t" will be considered to be equal. (However, if A=="t" and - B=="t<int>", then this will not consider them as equal.) - - MODE==COMPLETE is used when searching for a symbol for - completion. In this case, STRB must always be the search name, - and STRA must be the name in the index that is under - consideration. In completion mode, early termination of STRB - always results in a match. */ - static int compare (const char *stra, const char *strb, - comparison_mode mode); - - /* Compare two entries by canonical name. */ - bool operator< (const cooked_index_entry &other) const - { - return compare (canonical, other.canonical, SORT) < 0; - } - - /* Set parent entry to PARENT. */ - void set_parent (const cooked_index_entry *parent) - { - gdb_assert ((flags & IS_PARENT_DEFERRED) == 0); - m_parent_entry.resolved = parent; - } - - /* Resolve deferred parent entry to PARENT. */ - void resolve_parent (const cooked_index_entry *parent) - { - gdb_assert ((flags & IS_PARENT_DEFERRED) != 0); - flags = flags & ~IS_PARENT_DEFERRED; - m_parent_entry.resolved = parent; - } - - /* Return parent entry. */ - const cooked_index_entry *get_parent () const - { - gdb_assert ((flags & IS_PARENT_DEFERRED) == 0); - return m_parent_entry.resolved; - } - - /* Return deferred parent entry. */ - parent_map::addr_type get_deferred_parent () const - { - gdb_assert ((flags & IS_PARENT_DEFERRED) != 0); - return m_parent_entry.deferred; - } - - /* The name as it appears in DWARF. This always points into one of - the mapped DWARF sections. Note that this may be the name or the - linkage name -- two entries are created for DIEs which have both - attributes. */ - const char *name; - /* The canonical name. This may be equal to NAME. */ - const char *canonical = nullptr; - /* The DWARF tag. */ - enum dwarf_tag tag; - /* Any flags attached to this entry. */ - cooked_index_flag flags; - /* The language of this symbol. */ - ENUM_BITFIELD (language) lang : LANGUAGE_BITS; - /* The offset of this DIE. */ - sect_offset die_offset; - /* The CU from which this entry originates. */ - dwarf2_per_cu *per_cu; - -private: - - /* A helper method for full_name. Emits the full scope of this - object, followed by the separator, to STORAGE. If this entry has - a parent, its write_scope method is called first. See full_name - for a description of the FLAGS parameter. */ - void write_scope (struct obstack *storage, const char *sep, - cooked_index_full_name_flag flags) const; - - /* The parent entry. This is NULL for top-level entries. - Otherwise, it points to the parent entry, such as a namespace or - class. */ - cooked_index_entry_ref m_parent_entry; -}; - -class cooked_index; - -/* An index of interesting DIEs. This is "cooked", in contrast to a - mapped .debug_names or .gdb_index, which are "raw". An entry in - the index is of type cooked_index_entry. - - Operations on the index are described below. They are chosen to - make it relatively simple to implement the symtab "quick" - methods. */ -class cooked_index_shard -{ -public: - cooked_index_shard () = default; - DISABLE_COPY_AND_ASSIGN (cooked_index_shard); - - /* Create a new cooked_index_entry and register it with this object. - Entries are owned by this object. The new item is returned. */ - cooked_index_entry *add (sect_offset die_offset, enum dwarf_tag tag, - cooked_index_flag flags, enum language lang, - const char *name, - cooked_index_entry_ref parent_entry, - dwarf2_per_cu *per_cu); - - /* Install a new fixed addrmap from the given mutable addrmap. */ - void install_addrmap (addrmap_mutable *map) - { - gdb_assert (m_addrmap == nullptr); - m_addrmap = new (&m_storage) addrmap_fixed (&m_storage, map); - } - - friend class cooked_index; - - /* A simple range over part of m_entries. */ - typedef iterator_range<std::vector<cooked_index_entry *>::const_iterator> - range; - - /* Return a range of all the entries. */ - range all_entries () const - { - return { m_entries.cbegin (), m_entries.cend () }; - } - - /* Look up an entry by name. Returns a range of all matching - results. If COMPLETING is true, then a larger range, suitable - for completion, will be returned. */ - range find (const std::string &name, bool completing) const; - -private: - - /* Return the entry that is believed to represent the program's - "main". This will return NULL if no such entry is available. */ - const cooked_index_entry *get_main () const - { - return m_main; - } - - /* Look up ADDR in the address map, and return either the - corresponding CU, or nullptr if the address could not be - found. */ - dwarf2_per_cu *lookup (unrelocated_addr addr) - { - if (m_addrmap == nullptr) - return nullptr; - - return (static_cast<dwarf2_per_cu *> (m_addrmap->find ((CORE_ADDR) addr))); - } - - /* Create a new cooked_index_entry and register it with this object. - Entries are owned by this object. The new item is returned. */ - cooked_index_entry *create (sect_offset die_offset, - enum dwarf_tag tag, - cooked_index_flag flags, - enum language lang, - const char *name, - cooked_index_entry_ref parent_entry, - dwarf2_per_cu *per_cu); - - /* When GNAT emits mangled ("encoded") names in the DWARF, and does - not emit the module structure, we still need this structuring to - do lookups. This function recreates that information for an - existing entry, modifying ENTRY as appropriate. Any new entries - are added to NEW_ENTRIES. */ - void handle_gnat_encoded_entry - (cooked_index_entry *entry, htab_t gnat_entries, - std::vector<cooked_index_entry *> &new_entries); - - /* Finalize the index. This should be called a single time, when - the index has been fully populated. It enters all the entries - into the internal table and fixes up all missing parent links. - This may be invoked in a worker thread. */ - void finalize (const parent_map_map *parent_maps); - - /* Storage for the entries. */ - auto_obstack m_storage; - /* List of all entries. */ - std::vector<cooked_index_entry *> m_entries; - /* If we found an entry with 'is_main' set, store it here. */ - cooked_index_entry *m_main = nullptr; - /* The addrmap. This maps address ranges to dwarf2_per_cu objects. */ - addrmap_fixed *m_addrmap = nullptr; - /* Storage for canonical names. */ - gdb::string_set m_names; -}; - -using cooked_index_shard_up = std::unique_ptr<cooked_index_shard>; - -/* The possible states of the index. See the explanatory comment - before cooked_index for more details. */ -enum class cooked_state -{ - /* The default state. This is not a valid argument to 'wait'. */ - INITIAL, - /* The initial scan has completed. The name of "main" is now - available (if known). The addrmaps are usable now. - Finalization has started but is not complete. */ - MAIN_AVAILABLE, - /* Finalization has completed. This means the index is fully - available for queries. */ - FINALIZED, - /* Writing to the index cache has finished. */ - CACHE_DONE, -}; - -/* An object of this type controls the scanning of the DWARF. It - schedules the worker tasks and tracks the current state. Once - scanning is done, this object is discarded. - - This is an abstract base class that defines the basic behavior of - scanners. Separate concrete implementations exist for scanning - .debug_names and .debug_info. */ - -class cooked_index_worker -{ -public: - - explicit cooked_index_worker (dwarf2_per_objfile *per_objfile) - : m_per_objfile (per_objfile), - m_cache_store (global_index_cache, per_objfile->per_bfd) - { } - virtual ~cooked_index_worker () - { } - DISABLE_COPY_AND_ASSIGN (cooked_index_worker); - - /* Start reading. */ - void start (); - - /* Wait for a particular state to be achieved. If ALLOW_QUIT is - true, then the loop will check the QUIT flag. Normally this - method may only be called from the main thread; however, it can - be called from a worker thread provided that the desired state - has already been attained. (This oddity is used by the index - cache writer.) */ - bool wait (cooked_state desired_state, bool allow_quit); - -protected: - - /* Let cooked_index call the 'set' and 'write_to_cache' methods. */ - friend class cooked_index; - - /* Set the current state. */ - void set (cooked_state desired_state); - - /* Write to the index cache. */ - void write_to_cache (const cooked_index *idx, - deferred_warnings *warn) const; - - /* Helper function that does the work of reading. This must be able - to be run in a worker thread without problems. */ - virtual void do_reading () = 0; - - /* A callback that can print stats, if needed. This is called when - transitioning to the 'MAIN_AVAILABLE' state. */ - virtual void print_stats () - { } - - /* Each thread returns a tuple holding a cooked index, any collected - complaints, a vector of errors that should be printed, and a - parent map. - - The errors are retained because GDB's I/O system is not - thread-safe. run_on_main_thread could be used, but that would - mean the messages are printed after the prompt, which looks - weird. */ - using result_type = std::tuple<cooked_index_shard_up, - complaint_collection, - std::vector<gdb_exception>, - parent_map>; - - /* The per-objfile object. */ - dwarf2_per_objfile *m_per_objfile; - /* Result of each worker task. */ - std::vector<result_type> m_results; - /* Any warnings emitted. This is not in 'result_type' because (for - the time being at least), it's only needed in do_reading, not in - every worker. Note that deferred_warnings uses gdb_stderr in its - constructor, and this should only be done from the main thread. - This is enforced in the cooked_index_worker constructor. */ - deferred_warnings m_warnings; - - /* A map of all parent maps. Used during finalization to fix up - parent relationships. */ - parent_map_map m_all_parents_map; - -#if CXX_STD_THREAD - /* Current state of this object. */ - cooked_state m_state = cooked_state::INITIAL; - /* Mutex and condition variable used to synchronize. */ - std::mutex m_mutex; - std::condition_variable m_cond; -#endif /* CXX_STD_THREAD */ - /* This flag indicates whether any complaints or exceptions that - arose during scanning have been reported by 'wait'. This may - only be modified on the main thread. */ - bool m_reported = false; - /* If set, an exception occurred during reading; in this case the - scanning is stopped and this exception will later be reported by - the 'wait' method. */ - std::optional<gdb_exception> m_failed; - /* An object used to write to the index cache. */ - index_cache_store_context m_cache_store; -}; - -using cooked_index_worker_up = std::unique_ptr<cooked_index_worker>; +#include "dwarf2/cooked-index-shard.h" +#include "dwarf2/cooked-index-worker.h" /* The main index of DIEs. @@ -515,6 +41,14 @@ using cooked_index_worker_up = std::unique_ptr<cooked_index_worker>; possible. This combination should help hide the effort from the user to the maximum possible degree. + There are a number of different objects involved in this process. + Most of them are temporary -- they are created to handle different + phases of scanning, then discarded when possible. The "steady + state" objects are index itself (cooked_index, below), which holds + the entries (cooked_index_entry), and the implementation of the + "quick" API (e.g., cooked_index_functions, though there are + other variants). + . Main Thread | Worker Threads ============================================================ . dwarf2_initialize_objfile @@ -546,6 +80,7 @@ using cooked_index_worker_up = std::unique_ptr<cooked_index_worker>; . v . maybe write to index cache . state = CACHE_DONE + . ~cooked_index_worker . . . if main thread calls... @@ -570,14 +105,8 @@ public: void start_reading () override; /* Called by cooked_index_worker to set the contents of this index - and transition to the MAIN_AVAILABLE state. WARN is used to - collect any warnings that may arise when writing to the cache. - PARENT_MAPS is used when resolving pending parent links. - PARENT_MAPS may be NULL if there are no IS_PARENT_DEFERRED - entries in VEC. */ - void set_contents (std::vector<cooked_index_shard_up> &&vec, - deferred_warnings *warn, - const parent_map_map *parent_maps); + and transition to the MAIN_AVAILABLE state. */ + void set_contents (); /* A range over a vector of subranges. */ using range = range_chain<cooked_index_shard::range>; diff --git a/gdb/dwarf2/cooked-indexer.c b/gdb/dwarf2/cooked-indexer.c index 3b80cd6..1f3a235 100644 --- a/gdb/dwarf2/cooked-indexer.c +++ b/gdb/dwarf2/cooked-indexer.c @@ -18,12 +18,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "dwarf2/cooked-indexer.h" -#include "dwarf2/cooked-index-storage.h" +#include "dwarf2/cooked-index-worker.h" #include "dwarf2/error.h" /* See cooked-indexer.h. */ -cooked_indexer::cooked_indexer (cooked_index_storage *storage, +cooked_indexer::cooked_indexer (cooked_index_worker_result *storage, dwarf2_per_cu *per_cu, enum language language) : m_index_storage (storage), m_per_cu (per_cu), @@ -109,7 +109,7 @@ cooked_indexer::ensure_cu_exists (cutu_reader *reader, cutu_reader *result = m_index_storage->get_reader (per_cu); if (result == nullptr) { - cutu_reader new_reader (per_cu, per_objfile, nullptr, nullptr, false, + cutu_reader new_reader (*per_cu, *per_objfile, nullptr, nullptr, false, language_minimal, &m_index_storage->get_abbrev_table_cache ()); diff --git a/gdb/dwarf2/cooked-indexer.h b/gdb/dwarf2/cooked-indexer.h index 93626a9..904c55f 100644 --- a/gdb/dwarf2/cooked-indexer.h +++ b/gdb/dwarf2/cooked-indexer.h @@ -20,13 +20,13 @@ #ifndef GDB_DWARF2_COOKED_INDEXER_H #define GDB_DWARF2_COOKED_INDEXER_H -#include "dwarf2/cooked-index.h" +#include "dwarf2/cooked-index-entry.h" #include "dwarf2/parent-map.h" #include "dwarf2/types.h" #include <variant> struct abbrev_info; -struct cooked_index_storage; +struct cooked_index_worker_result; struct cutu_reader; struct dwarf2_per_cu; struct dwarf2_per_objfile; @@ -36,7 +36,7 @@ struct dwarf2_per_objfile; class cooked_indexer { public: - cooked_indexer (cooked_index_storage *storage, dwarf2_per_cu *per_cu, + cooked_indexer (cooked_index_worker_result *storage, dwarf2_per_cu *per_cu, enum language language); DISABLE_COPY_AND_ASSIGN (cooked_indexer); @@ -103,7 +103,7 @@ private: bool fully); /* The storage object, where the results are kept. */ - cooked_index_storage *m_index_storage; + cooked_index_worker_result *m_index_storage; /* The CU that we are reading on behalf of. This object might be asked to index one CU but to treat the results as if they come from some including CU; in this case the including CU would be diff --git a/gdb/dwarf2/die.c b/gdb/dwarf2/die.c index 500d7bf..9437c2f 100644 --- a/gdb/dwarf2/die.c +++ b/gdb/dwarf2/die.c @@ -184,9 +184,9 @@ dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die) } } - if (die->sibling != NULL && level > 0) + if (die->next != NULL && level > 0) { - dump_die_1 (f, level, max_level, die->sibling); + dump_die_1 (f, level, max_level, die->next); } } diff --git a/gdb/dwarf2/die.h b/gdb/dwarf2/die.h index 770964e..cffb5cb 100644 --- a/gdb/dwarf2/die.h +++ b/gdb/dwarf2/die.h @@ -22,6 +22,7 @@ #include "complaints.h" #include "dwarf2/attribute.h" +#include "gdbsupport/next-iterator.h" /* This data structure holds a complete die structure. */ struct die_info @@ -103,6 +104,13 @@ struct die_info return 0; } + /* Return a range suitable for iterating over the children of this + DIE. */ + next_range<die_info> children () const + { + return next_range<die_info> (child); + } + /* DWARF-2 tag for this DIE. */ ENUM_BITFIELD(dwarf_tag) tag : 16; @@ -128,9 +136,9 @@ struct die_info /* The dies in a compilation unit form an n-ary tree. PARENT points to this die's parent; CHILD points to the first child of this node; and all the children of a given node are chained - together via their SIBLING fields. */ + together via their NEXT fields. */ struct die_info *child; /* Its first child, if any. */ - struct die_info *sibling; /* Its next sibling, if any. */ + struct die_info *next; /* Its next sibling, if any. */ struct die_info *parent; /* Its parent, if any. */ /* An array of attributes, with NUM_ATTRS elements. There may be diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c index 7c12c0d..8f66694 100644 --- a/gdb/dwarf2/loc.c +++ b/gdb/dwarf2/loc.c @@ -1784,6 +1784,7 @@ dwarf2_compile_property_to_c (string_file *stream, CORE_ADDR pc, struct symbol *sym) { +#if defined (HAVE_COMPILE) const dwarf2_property_baton *baton = prop->baton (); const gdb_byte *data; size_t size; @@ -1810,6 +1811,9 @@ dwarf2_compile_property_to_c (string_file *stream, gdbarch, registers_used, per_cu->addr_size (), data, data + size, per_cu, per_objfile); +#else + gdb_assert_not_reached ("Compile support was disabled"); +#endif } /* Compute the correct symbol_needs_kind value for the location @@ -3852,6 +3856,7 @@ locexpr_generate_c_location (struct symbol *sym, string_file *stream, std::vector<bool> ®isters_used, CORE_ADDR pc, const char *result_name) { +#if defined (HAVE_COMPILE) struct dwarf2_locexpr_baton *dlbaton = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (sym); unsigned int addr_size = dlbaton->per_cu->addr_size (); @@ -3863,6 +3868,9 @@ locexpr_generate_c_location (struct symbol *sym, string_file *stream, sym, pc, gdbarch, registers_used, addr_size, dlbaton->data, dlbaton->data + dlbaton->size, dlbaton->per_cu, dlbaton->per_objfile); +#else + gdb_assert_not_reached ("Compile support was disabled"); +#endif } /* The set of location functions used with the DWARF-2 expression @@ -4088,6 +4096,7 @@ loclist_generate_c_location (struct symbol *sym, string_file *stream, std::vector<bool> ®isters_used, CORE_ADDR pc, const char *result_name) { +#if defined (HAVE_COMPILE) struct dwarf2_loclist_baton *dlbaton = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (sym); unsigned int addr_size = dlbaton->per_cu->addr_size (); @@ -4103,6 +4112,9 @@ loclist_generate_c_location (struct symbol *sym, string_file *stream, data, data + size, dlbaton->per_cu, dlbaton->per_objfile); +#else + gdb_assert_not_reached ("Compile support was disabled"); +#endif } /* The set of location functions used with the DWARF-2 expression diff --git a/gdb/dwarf2/parent-map.c b/gdb/dwarf2/parent-map.c index d029a76..6f290c1 100644 --- a/gdb/dwarf2/parent-map.c +++ b/gdb/dwarf2/parent-map.c @@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ -#include "dwarf2/cooked-index.h" +#include "dwarf2/cooked-index-entry.h" #include "dwarf2/read.h" #include "dwarf2/parent-map.h" diff --git a/gdb/dwarf2/read-debug-names.c b/gdb/dwarf2/read-debug-names.c index edac713..96a8ad3 100644 --- a/gdb/dwarf2/read-debug-names.c +++ b/gdb/dwarf2/read-debug-names.c @@ -114,11 +114,12 @@ struct mapped_debug_names_reader gdb::unordered_map<ULONGEST, index_val> abbrev_map; - /* Even though the scanning of .debug_names and creation of the cooked index - entries is done serially, we create multiple shards so that the - finalization step can be parallelized. The shards are filled in a round - robin fashion. */ - std::vector<cooked_index_shard_up> shards; + /* Even though the scanning of .debug_names and creation of the + cooked index entries is done serially, we create multiple shards + so that the finalization step can be parallelized. The shards + are filled in a round robin fashion. It's convenient to use a + result object rather than an actual shard. */ + std::vector<cooked_index_worker_result> indices; /* Next shard to insert an entry in. */ int next_shard = 0; @@ -290,11 +291,11 @@ mapped_debug_names_reader::scan_one_entry (const char *name, if (per_cu != nullptr) { *result - = shards[next_shard]->add (die_offset, (dwarf_tag) indexval.dwarf_tag, + = indices[next_shard].add (die_offset, (dwarf_tag) indexval.dwarf_tag, flags, lang, name, nullptr, per_cu); ++next_shard; - if (next_shard == shards.size ()) + if (next_shard == indices.size ()) next_shard = 0; entry_pool_offsets_to_entries.emplace (offset_in_entry_pool, *result); @@ -414,29 +415,31 @@ void cooked_index_worker_debug_names::do_reading () { complaint_interceptor complaint_handler; - std::vector<gdb_exception> exceptions; + try { m_map.scan_all_names (); } - catch (const gdb_exception &exc) + catch (gdb_exception &exc) { - exceptions.push_back (std::move (exc)); + /* Arbitrarily put all exceptions into the first result. */ + m_map.indices[0].note_error (std::move (exc)); } - m_results.emplace_back (nullptr, - complaint_handler.release (), - std::move (exceptions), - parent_map ()); - - dwarf2_per_bfd *per_bfd = m_per_objfile->per_bfd; - cooked_index *table - = (gdb::checked_static_cast<cooked_index *> - (per_bfd->index_table.get ())); + bool first = true; + for (auto &iter : m_map.indices) + { + if (first) + { + iter.done_reading (complaint_handler.release ()); + first = false; + } + else + iter.done_reading ({}); + } - /* Note that this code never uses IS_PARENT_DEFERRED, so it is safe - to pass nullptr here. */ - table->set_contents (std::move (m_map.shards), &m_warnings, nullptr); + m_results = std::move (m_map.indices); + done_reading (); bfd_thread_cleanup (); } @@ -838,24 +841,26 @@ do_dwarf2_read_debug_names (dwarf2_per_objfile *per_objfile) } per_bfd->debug_aranges.read (per_objfile->objfile); - addrmap_mutable addrmap; + + /* There is a single address map for the whole index (coming from + .debug_aranges). We only need to install it into a single shard + for it to get searched by cooked_index. So, we make the first + result object here, so we can store the addrmap, then move it + into place later. */ + cooked_index_worker_result first; deferred_warnings warnings; read_addrmap_from_aranges (per_objfile, &per_bfd->debug_aranges, - &addrmap, &warnings); + first.get_addrmap (), &warnings); warnings.emit (); const auto n_workers = std::max<std::size_t> (gdb::thread_pool::g_thread_pool->thread_count (), 1); - /* Create as many index shard as there are worker threads. */ - for (int i = 0; i < n_workers; ++i) - map.shards.emplace_back (std::make_unique<cooked_index_shard> ()); - - /* There is a single address map for the whole index (coming from - .debug_aranges). We only need to install it into a single shard for it to - get searched by cooked_index. */ - map.shards[0]->install_addrmap (&addrmap); + /* Create as many index shard as there are worker threads, + preserving the first one. */ + map.indices.push_back (std::move (first)); + map.indices.resize (n_workers); auto cidn = (std::make_unique<cooked_index_worker_debug_names> (per_objfile, std::move (map))); diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index b9040a5..71fd352 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -32,7 +32,7 @@ #include "dwarf2/aranges.h" #include "dwarf2/attribute.h" #include "dwarf2/comp-unit-head.h" -#include "dwarf2/cooked-index-storage.h" +#include "dwarf2/cooked-index-worker.h" #include "dwarf2/cooked-indexer.h" #include "dwarf2/cu.h" #include "dwarf2/index-cache.h" @@ -728,7 +728,7 @@ show_dwarf_synchronous (struct ui_file *file, int from_tty, /* local function prototypes */ static void build_type_psymtabs_reader (cutu_reader *reader, - cooked_index_storage *storage); + cooked_index_worker_result *storage); static void var_decode_location (struct attribute *attr, struct symbol *sym, @@ -1791,7 +1791,7 @@ dw2_get_file_names (dwarf2_per_cu *this_cu, dwarf2_per_objfile *per_objfile) if (this_cu->files_read) return this_cu->file_names; - cutu_reader reader (this_cu, per_objfile, nullptr, + cutu_reader reader (*this_cu, *per_objfile, nullptr, per_objfile->get_cu (this_cu), true, language_minimal, nullptr); if (!reader.is_dummy ()) @@ -2710,8 +2710,7 @@ cutu_reader::init_cu_die_reader (dwarf2_cu *cu, dwarf2_section_info *section, void cutu_reader::read_cutu_die_from_dwo (dwarf2_cu *cu, dwo_unit *dwo_unit, die_info *stub_comp_unit_die, - const char *stub_comp_dir, - abbrev_table_up *result_dwo_abbrev_table) + const char *stub_comp_dir) { dwarf2_per_objfile *per_objfile = cu->per_objfile; dwarf2_per_cu *per_cu = cu->per_cu; @@ -2829,10 +2828,18 @@ cutu_reader::read_cutu_die_from_dwo (dwarf2_cu *cu, dwo_unit *dwo_unit, } dwo_abbrev_section->read (objfile); - *result_dwo_abbrev_table + m_dwo_abbrev_table = abbrev_table::read (dwo_abbrev_section, cu->header.abbrev_sect_off); this->init_cu_die_reader (cu, section, dwo_unit->dwo_file, - result_dwo_abbrev_table->get ()); + m_dwo_abbrev_table.get ()); + + /* Skip dummy compilation units. */ + if (m_info_ptr >= begin_info_ptr + dwo_unit->length + || peek_abbrev_code (abfd, m_info_ptr) == 0) + { + m_dummy_p = true; + return; + } /* Read in the die, filling in the attributes from the stub. This has the benefit of simplifying the rest of the code - all the @@ -2841,11 +2848,6 @@ cutu_reader::read_cutu_die_from_dwo (dwarf2_cu *cu, dwo_unit *dwo_unit, m_top_level_die = this->read_toplevel_die (gdb::make_array_view (attributes, next_attr_idx)); - - /* Skip dummy compilation units. */ - if (m_info_ptr >= begin_info_ptr + dwo_unit->length - || peek_abbrev_code (abfd, m_info_ptr) == 0) - m_dummy_p = true; } /* Return the signature of the compile unit, if found. In DWARF 4 and before, @@ -2864,8 +2866,12 @@ lookup_dwo_id (struct dwarf2_cu *cu, struct die_info* comp_unit_die) } /* Subroutine of cutu_reader to simplify it. - Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU. - Returns NULL if the specified DWO unit cannot be found. */ + Look up the DWO unit specified by COMP_UNIT_DIE of CU. + + DWO_NAME is the name (DW_AT_dwo_name) of the DWO unit already read from + COMP_UNIT_DIE. + + Returns nullptr if the specified DWO unit cannot be found. */ static struct dwo_unit * lookup_dwo_unit (dwarf2_cu *cu, die_info *comp_unit_die, const char *dwo_name) @@ -2883,8 +2889,6 @@ lookup_dwo_unit (dwarf2_cu *cu, die_info *comp_unit_die, const char *dwo_name) gdb_assert (cu != NULL); - /* Yeah, we look dwo_name up again, but it simplifies the code. */ - dwo_name = dwarf2_dwo_name (comp_unit_die, cu); comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu); if (per_cu->is_debug_types) @@ -2946,8 +2950,7 @@ cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu *this_cu, could share abbrev tables. */ read_cutu_die_from_dwo (cu, sig_type->dwo_unit, NULL /* stub_comp_unit_die */, - sig_type->dwo_unit->dwo_file->comp_dir, - &m_dwo_abbrev_table); + sig_type->dwo_unit->dwo_file->comp_dir); prepare_one_comp_unit (cu, pretend_language); } @@ -2961,16 +2964,16 @@ cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu *this_cu, If EXISTING_CU is non-NULL, then use it. Otherwise, a new CU is allocated. */ -cutu_reader::cutu_reader (dwarf2_per_cu *this_cu, - dwarf2_per_objfile *per_objfile, +cutu_reader::cutu_reader (dwarf2_per_cu &this_cu, + dwarf2_per_objfile &per_objfile, const struct abbrev_table *abbrev_table, dwarf2_cu *existing_cu, bool skip_partial, enum language pretend_language, - const abbrev_table_cache *cache) + const abbrev_table_cache *abbrev_cache) { - struct objfile *objfile = per_objfile->objfile; - struct dwarf2_section_info *section = this_cu->section; + struct objfile *objfile = per_objfile.objfile; + struct dwarf2_section_info *section = this_cu.section; bfd *abfd = section->get_bfd_owner (); const gdb_byte *begin_info_ptr; struct signatured_type *sig_type = NULL; @@ -2982,17 +2985,17 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu, if (dwarf_die_debug) gdb_printf (gdb_stdlog, "Reading %s unit at offset %s\n", - this_cu->is_debug_types ? "type" : "comp", - sect_offset_str (this_cu->sect_off)); + this_cu.is_debug_types ? "type" : "comp", + sect_offset_str (this_cu.sect_off)); /* If we're reading a TU directly from a DWO file, including a virtual DWO file (instead of going through the stub), short-circuit all of this. */ - if (this_cu->reading_dwo_directly) + if (this_cu.reading_dwo_directly) { /* Narrow down the scope of possibilities to have to understand. */ - gdb_assert (this_cu->is_debug_types); + gdb_assert (this_cu.is_debug_types); gdb_assert (abbrev_table == NULL); - init_tu_and_read_dwo_dies (this_cu, per_objfile, existing_cu, + init_tu_and_read_dwo_dies (&this_cu, &per_objfile, existing_cu, pretend_language); return; } @@ -3001,9 +3004,9 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu, section->read (objfile); begin_info_ptr = m_info_ptr - = section->buffer + to_underlying (this_cu->sect_off); + = section->buffer + to_underlying (this_cu.sect_off); - abbrev_section = get_abbrev_section_for_cu (this_cu); + abbrev_section = get_abbrev_section_for_cu (&this_cu); dwarf2_cu *cu; @@ -3027,9 +3030,9 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu, indexer. This assert is avoided in this case because (1) it is irrelevant, and (2) the get_cu method is not thread-safe. */ - gdb_assert (cache != nullptr - || per_objfile->get_cu (this_cu) == nullptr); - m_new_cu = std::make_unique<dwarf2_cu> (this_cu, per_objfile); + gdb_assert (abbrev_cache != nullptr + || per_objfile.get_cu (&this_cu) == nullptr); + m_new_cu = std::make_unique<dwarf2_cu> (&this_cu, &per_objfile); cu = m_new_cu.get (); } @@ -3041,43 +3044,43 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu, } else { - if (this_cu->is_debug_types) + if (this_cu.is_debug_types) { m_info_ptr - = read_and_check_comp_unit_head (per_objfile, &cu->header, section, + = read_and_check_comp_unit_head (&per_objfile, &cu->header, section, abbrev_section, m_info_ptr, rcuh_kind::TYPE); /* Since per_cu is the first member of struct signatured_type, we can go from a pointer to one to a pointer to the other. */ - sig_type = (struct signatured_type *) this_cu; + sig_type = (struct signatured_type *) &this_cu; gdb_assert (sig_type->signature == cu->header.signature); gdb_assert (sig_type->type_offset_in_tu == cu->header.type_cu_offset_in_tu); - gdb_assert (this_cu->sect_off == cu->header.sect_off); + gdb_assert (this_cu.sect_off == cu->header.sect_off); /* LENGTH has not been set yet for type units if we're using .gdb_index. */ - this_cu->set_length (cu->header.get_length_with_initial ()); + this_cu.set_length (cu->header.get_length_with_initial ()); /* Establish the type offset that can be used to lookup the type. */ sig_type->type_offset_in_section = - this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu); + this_cu.sect_off + to_underlying (sig_type->type_offset_in_tu); } else { m_info_ptr - = read_and_check_comp_unit_head (per_objfile, &cu->header, section, + = read_and_check_comp_unit_head (&per_objfile, &cu->header, section, abbrev_section, m_info_ptr, rcuh_kind::COMPILE); - gdb_assert (this_cu->sect_off == cu->header.sect_off); - this_cu->set_length (cu->header.get_length_with_initial ()); + gdb_assert (this_cu.sect_off == cu->header.sect_off); + this_cu.set_length (cu->header.get_length_with_initial ()); } } /* Skip dummy compilation units. */ - if (m_info_ptr >= begin_info_ptr + this_cu->length () + if (m_info_ptr >= begin_info_ptr + this_cu.length () || peek_abbrev_code (abfd, m_info_ptr) == 0) m_dummy_p = true; else @@ -3089,9 +3092,9 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu, gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off); else { - if (cache != nullptr) - abbrev_table = cache->find (abbrev_section, - cu->header.abbrev_sect_off); + if (abbrev_cache != nullptr) + abbrev_table = abbrev_cache->find (abbrev_section, + cu->header.abbrev_sect_off); if (abbrev_table == nullptr) { abbrev_section->read (objfile); @@ -3129,14 +3132,13 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu, { complaint (_("compilation unit with DW_AT_GNU_dwo_name" " has children (offset %s) [in module %s]"), - sect_offset_str (this_cu->sect_off), + sect_offset_str (this_cu.sect_off), bfd_get_filename (abfd)); } dwo_unit = lookup_dwo_unit (cu, m_top_level_die, dwo_name); if (dwo_unit != NULL) - read_cutu_die_from_dwo (cu, dwo_unit, m_top_level_die, nullptr, - &m_dwo_abbrev_table); + read_cutu_die_from_dwo (cu, dwo_unit, m_top_level_die, nullptr); else { /* Yikes, we couldn't find the rest of the DIE, we only have @@ -3165,65 +3167,57 @@ cutu_reader::release_cu () return std::move (m_new_cu); } -/* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name) - if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is - assumed to have already done the lookup to find the DWO file). - - The caller is required to fill in THIS_CU->section, THIS_CU->offset, and - THIS_CU->is_debug_types, but nothing else. +/* This constructor exists for the special case of reading many units in a row + from a given known DWO file. - We fill in THIS_CU->length. + THIS_CU is a special dwarf2_per_cu to represent where to read the unit from, + in the DWO file. The caller is required to fill THIS_CU::SECTION, + THIS_CU::SECT_OFF, and THIS_CU::IS_DEBUG_TYPES. This constructor will fill + in the length. THIS_CU::SECTION must point to a section from the DWO file, + which is normally not the case for regular dwarf2_per_cu uses. - THIS_CU->cu is always freed when done. - This is done in order to not leave THIS_CU->cu in a state where we have - to care whether it refers to the "main" CU or the DWO CU. + PARENT_CU is the CU created when reading the skeleton unit, and is used to + provide a default value for str_offsets_base and addr_base. */ - When parent_cu is passed, it is used to provide a default value for - str_offsets_base and addr_base from the parent. */ - -cutu_reader::cutu_reader (dwarf2_per_cu *this_cu, - dwarf2_per_objfile *per_objfile, - enum language pretend_language, - struct dwarf2_cu *parent_cu, - struct dwo_file *dwo_file) +cutu_reader::cutu_reader (dwarf2_per_cu &this_cu, + dwarf2_per_objfile &per_objfile, + language pretend_language, dwarf2_cu &parent_cu, + dwo_file &dwo_file) { - struct objfile *objfile = per_objfile->objfile; - struct dwarf2_section_info *section = this_cu->section; + struct objfile *objfile = per_objfile.objfile; + struct dwarf2_section_info *section = this_cu.section; bfd *abfd = section->get_bfd_owner (); - gdb_assert (parent_cu != nullptr); - gdb_assert (dwo_file != nullptr); - if (dwarf_die_debug) gdb_printf (gdb_stdlog, "Reading %s unit at offset %s\n", - this_cu->is_debug_types ? "type" : "comp", - sect_offset_str (this_cu->sect_off)); + this_cu.is_debug_types ? "type" : "comp", + sect_offset_str (this_cu.sect_off)); - gdb_assert (per_objfile->get_cu (this_cu) == nullptr); + gdb_assert (per_objfile.get_cu (&this_cu) == nullptr); - dwarf2_section_info *abbrev_section = &dwo_file->sections.abbrev; + dwarf2_section_info *abbrev_section = &dwo_file.sections.abbrev; /* This is cheap if the section is already read in. */ section->read (objfile); - m_new_cu = std::make_unique<dwarf2_cu> (this_cu, per_objfile); + m_new_cu = std::make_unique<dwarf2_cu> (&this_cu, &per_objfile); - m_info_ptr = section->buffer + to_underlying (this_cu->sect_off); + m_info_ptr = section->buffer + to_underlying (this_cu.sect_off); const gdb_byte *begin_info_ptr = m_info_ptr; m_info_ptr - = read_and_check_comp_unit_head (per_objfile, &m_new_cu->header, section, + = read_and_check_comp_unit_head (&per_objfile, &m_new_cu->header, section, abbrev_section, m_info_ptr, - (this_cu->is_debug_types + (this_cu.is_debug_types ? rcuh_kind::TYPE : rcuh_kind::COMPILE)); - m_new_cu->str_offsets_base = parent_cu->str_offsets_base; - m_new_cu->addr_base = parent_cu->addr_base; + m_new_cu->str_offsets_base = parent_cu.str_offsets_base; + m_new_cu->addr_base = parent_cu.addr_base; - this_cu->set_length (m_new_cu->header.get_length_with_initial ()); + this_cu.set_length (m_new_cu->header.get_length_with_initial ()); /* Skip dummy compilation units. */ - if (m_info_ptr >= begin_info_ptr + this_cu->length () + if (m_info_ptr >= begin_info_ptr + this_cu.length () || peek_abbrev_code (abfd, m_info_ptr) == 0) m_dummy_p = true; else @@ -3233,7 +3227,7 @@ cutu_reader::cutu_reader (dwarf2_per_cu *this_cu, = abbrev_table::read (abbrev_section, m_new_cu->header.abbrev_sect_off); - this->init_cu_die_reader (m_new_cu.get (), section, dwo_file, + this->init_cu_die_reader (m_new_cu.get (), section, &dwo_file, m_abbrev_table_holder.get ()); m_top_level_die = this->read_toplevel_die (); } @@ -3295,12 +3289,12 @@ get_type_unit_group_key (struct dwarf2_cu *cu, const struct attribute *stmt_list static void process_psymtab_comp_unit (dwarf2_per_cu *this_cu, dwarf2_per_objfile *per_objfile, - cooked_index_storage *storage) + cooked_index_worker_result *storage) { cutu_reader *reader = storage->get_reader (this_cu); if (reader == nullptr) { - cutu_reader new_reader (this_cu, per_objfile, nullptr, nullptr, false, + cutu_reader new_reader (*this_cu, *per_objfile, nullptr, nullptr, false, language_minimal, &storage->get_abbrev_table_cache ()); @@ -3332,7 +3326,7 @@ process_psymtab_comp_unit (dwarf2_per_cu *this_cu, static void build_type_psymtabs_reader (cutu_reader *reader, - cooked_index_storage *storage) + cooked_index_worker_result *storage) { struct dwarf2_cu *cu = reader->cu (); dwarf2_per_cu *per_cu = cu->per_cu; @@ -3385,7 +3379,7 @@ struct tu_abbrev_offset static void build_type_psymtabs (dwarf2_per_objfile *per_objfile, - cooked_index_storage *storage) + cooked_index_worker_result *storage) { struct tu_stats *tu_stats = &per_objfile->per_bfd->tu_stats; abbrev_table_up abbrev_table; @@ -3447,7 +3441,7 @@ build_type_psymtabs (dwarf2_per_objfile *per_objfile, ++tu_stats->nr_uniq_abbrev_tables; } - cutu_reader reader (tu.sig_type, per_objfile, + cutu_reader reader (*tu.sig_type, *per_objfile, abbrev_table.get (), nullptr, false, language_minimal); if (!reader.is_dummy ()) @@ -3482,7 +3476,7 @@ print_tu_stats (dwarf2_per_objfile *per_objfile) static void process_skeletonless_type_unit (dwo_unit *dwo_unit, dwarf2_per_objfile *per_objfile, - cooked_index_storage *storage) + cooked_index_worker_result *storage) { dwarf2_per_bfd *per_bfd = per_objfile->per_bfd; @@ -3501,7 +3495,7 @@ process_skeletonless_type_unit (dwo_unit *dwo_unit, fill_in_sig_entry_from_dwo_entry (per_objfile, *sig_type_it, dwo_unit); /* This does the job that build_type_psymtabs would have done. */ - cutu_reader reader (*sig_type_it, per_objfile, nullptr, nullptr, false, + cutu_reader reader (**sig_type_it, *per_objfile, nullptr, nullptr, false, language_minimal); if (!reader.is_dummy ()) build_type_psymtabs_reader (&reader, storage); @@ -3513,7 +3507,7 @@ process_skeletonless_type_unit (dwo_unit *dwo_unit, static void process_skeletonless_type_units (dwarf2_per_objfile *per_objfile, - cooked_index_storage *storage) + cooked_index_worker_result *storage) { /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */ if (get_dwp_file (per_objfile) == nullptr) @@ -3559,7 +3553,7 @@ private: /* After the last DWARF-reading task has finished, this function does the remaining work to finish the scan. */ - void done_reading (); + void done_reading () override; /* An iterator for the comp units. */ using unit_iterator = std::vector<dwarf2_per_cu_up>::iterator; @@ -3573,12 +3567,13 @@ private: /* A storage object for "leftovers" -- see the 'start' method, but essentially things not parsed during the normal CU parsing passes. */ - cooked_index_storage m_index_storage; + cooked_index_worker_result m_index_storage; }; void -cooked_index_worker_debug_info::process_cus (size_t task_number, unit_iterator first, - unit_iterator end) +cooked_index_worker_debug_info::process_cus (size_t task_number, + unit_iterator first, + unit_iterator end) { SCOPE_EXIT { bfd_thread_cleanup (); }; @@ -3586,7 +3581,7 @@ cooked_index_worker_debug_info::process_cus (size_t task_number, unit_iterator f complaint_interceptor complaint_handler; std::vector<gdb_exception> errors; - cooked_index_storage thread_storage; + cooked_index_worker_result thread_storage; for (auto inner = first; inner != end; ++inner) { dwarf2_per_cu *per_cu = inner->get (); @@ -3597,43 +3592,24 @@ cooked_index_worker_debug_info::process_cus (size_t task_number, unit_iterator f } catch (gdb_exception &except) { - errors.push_back (std::move (except)); + thread_storage.note_error (std::move (except)); } } - m_results[task_number] = result_type (thread_storage.release (), - complaint_handler.release (), - std::move (errors), - thread_storage.release_parent_map ()); + thread_storage.done_reading (complaint_handler.release ()); + m_results[task_number] = std::move (thread_storage); } void cooked_index_worker_debug_info::done_reading () { - /* Only handle the scanning results here. Complaints and exceptions - can only be dealt with on the main thread. */ - std::vector<cooked_index_shard_up> shards; - - for (auto &one_result : m_results) - { - shards.push_back (std::move (std::get<0> (one_result))); - m_all_parents_map.add_map (std::get<3> (one_result)); - } - /* This has to wait until we read the CUs, we need the list of DWOs. */ process_skeletonless_type_units (m_per_objfile, &m_index_storage); - shards.push_back (m_index_storage.release ()); - shards.shrink_to_fit (); - - m_all_parents_map.add_map (m_index_storage.release_parent_map ()); + m_results.push_back (std::move (m_index_storage)); - dwarf2_per_bfd *per_bfd = m_per_objfile->per_bfd; - cooked_index *table - = (gdb::checked_static_cast<cooked_index *> - (per_bfd->index_table.get ())); - table->set_contents (std::move (shards), &m_warnings, - &m_all_parents_map); + /* Call into the base class. */ + cooked_index_worker::done_reading (); } void @@ -4223,7 +4199,7 @@ load_full_comp_unit (dwarf2_per_cu *this_cu, dwarf2_per_objfile *per_objfile, gdb_assert (! this_cu->is_debug_types); gdb_assert (per_objfile->get_cu (this_cu) == nullptr); - cutu_reader reader (this_cu, per_objfile, nullptr, nullptr, skip_partial, + cutu_reader reader (*this_cu, *per_objfile, nullptr, nullptr, skip_partial, pretend_language); if (reader.is_dummy ()) return; @@ -5456,12 +5432,11 @@ dwarf2_compute_name (const char *name, if (lang == language_cplus && strchr (name, '<') == NULL) { struct attribute *attr; - struct die_info *child; int first = 1; die->building_fullname = 1; - for (child = die->child; child != NULL; child = child->sibling) + for (die_info *child : die->children ()) { struct type *type; LONGEST value; @@ -5825,7 +5800,7 @@ read_import_statement (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->per_objfile->objfile; struct attribute *import_attr; - struct die_info *imported_die, *child_die; + struct die_info *imported_die; struct dwarf2_cu *imported_cu; const char *imported_name; const char *imported_name_prefix; @@ -5908,10 +5883,8 @@ read_import_statement (struct die_info *die, struct dwarf2_cu *cu) else canonical_name = imported_name; - if (die->tag == DW_TAG_imported_module - && cu->lang () == language_fortran) - for (child_die = die->child; child_die && child_die->tag; - child_die = child_die->sibling) + if (die->tag == DW_TAG_imported_module && cu->lang () == language_fortran) + for (die_info *child_die : die->children ()) { /* DWARF-4: A Fortran use statement with a “rename list” may be represented by an imported module entry with an import attribute @@ -6098,7 +6071,6 @@ read_file_scope (struct die_info *die, struct dwarf2_cu *cu) struct objfile *objfile = per_objfile->objfile; CORE_ADDR lowpc; struct attribute *attr; - struct die_info *child_die; unrelocated_addr unrel_low, unrel_high; get_scope_pc_bounds (die, &unrel_low, &unrel_high, cu); @@ -6145,15 +6117,9 @@ read_file_scope (struct die_info *die, struct dwarf2_cu *cu) handle_DW_AT_stmt_list (die, cu, fnd, unrel_low, unrel_low != unrel_high); /* Process all dies in compilation unit. */ - if (die->child != NULL) - { - child_die = die->child; - while (child_die && child_die->tag) - { - process_die (child_die, cu); - child_die = child_die->sibling; - } - } + for (die_info *child_die : die->children ()) + process_die (child_die, cu); + per_objfile->sym_cu = nullptr; /* Decode macro information, if present. Dwarf 2 macro information @@ -6309,22 +6275,13 @@ dwarf2_cu::setup_type_unit_groups (struct die_info *die) static void read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu) { - struct die_info *child_die; - /* Initialize (or reinitialize) the machinery for building symtabs. We do this before processing child DIEs, so that the line header table is available for DW_AT_decl_file. */ cu->setup_type_unit_groups (die); - if (die->child != NULL) - { - child_die = die->child; - while (child_die && child_die->tag) - { - process_die (child_die, cu); - child_die = child_die->sibling; - } - } + for (die_info *child_die : die->children ()) + process_die (child_die, cu); } /* DWO/DWP files. @@ -6377,8 +6334,8 @@ create_cus_hash_table (dwarf2_cu *cu, dwo_file &dwo_file) /* The length of the CU gets set by the cutu_reader just below. */ dwarf2_per_cu per_cu (per_bfd, §ion, sect_off, 0 /* length */, false /* is_dwz */); - cutu_reader reader (&per_cu, per_objfile, language_minimal, - cu, &dwo_file); + cutu_reader reader (per_cu, *per_objfile, language_minimal, + *cu, dwo_file); info_ptr += per_cu.length (); @@ -8210,8 +8167,8 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu) break; } - concrete_child = concrete_child->sibling; - abstract_child = abstract_child->sibling; + concrete_child = concrete_child->next; + abstract_child = abstract_child->next; } /* Walk the origin's children in parallel to the concrete children. @@ -8224,9 +8181,7 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu) std::vector<sect_offset> offsets; - for (die_info *child_die = die->child; - child_die && child_die->tag; - child_die = child_die->sibling) + for (die_info *child_die : die->children ()) { /* We are trying to process concrete instance entries: DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but @@ -8238,7 +8193,7 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu) { if (are_isomorphic) corresponding_abstract_child - = corresponding_abstract_child->sibling; + = corresponding_abstract_child->next; continue; } @@ -8296,7 +8251,7 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu) } if (are_isomorphic) - corresponding_abstract_child = corresponding_abstract_child->sibling; + corresponding_abstract_child = corresponding_abstract_child->next; } if (!offsets.empty ()) @@ -8314,8 +8269,7 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu) } auto offsets_it = offsets.begin (); - die_info *origin_child_die = origin_die->child; - while (origin_child_die != nullptr && origin_child_die->tag != 0) + for (die_info *origin_child_die : origin_die->children ()) { /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */ while (offsets_it < offsets.end () @@ -8332,8 +8286,6 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu) if (!origin_child_die->in_process) process_die (origin_child_die, origin_cu); } - - origin_child_die = origin_child_die->sibling; } origin_cu->list_in_scope = origin_previous_list_in_scope; @@ -8424,7 +8376,6 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) struct context_stack *newobj; CORE_ADDR lowpc; CORE_ADDR highpc; - struct die_info *child_die; struct attribute *attr, *call_line, *call_file; const char *name; struct block *block; @@ -8501,7 +8452,7 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) /* If we have any template arguments, then we must allocate a different sort of symbol. */ - for (child_die = die->child; child_die; child_die = child_die->sibling) + for (die_info *child_die : die->children ()) { if (child_die->tag == DW_TAG_template_type_param || child_die->tag == DW_TAG_template_value_param) @@ -8539,23 +8490,18 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) cu->list_in_scope = cu->get_builder ()->get_local_symbols (); - if (die->child != NULL) + for (die_info *child_die : die->children ()) { - child_die = die->child; - while (child_die && child_die->tag) + if (child_die->tag == DW_TAG_template_type_param + || child_die->tag == DW_TAG_template_value_param) { - if (child_die->tag == DW_TAG_template_type_param - || child_die->tag == DW_TAG_template_value_param) - { - struct symbol *arg = new_symbol (child_die, NULL, cu); + struct symbol *arg = new_symbol (child_die, NULL, cu); - if (arg != NULL) - template_args.push_back (arg); - } - else - process_die (child_die, cu); - child_die = child_die->sibling; + if (arg != NULL) + template_args.push_back (arg); } + else + process_die (child_die, cu); } inherit_abstract_dies (die, cu); @@ -8571,13 +8517,9 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) while (spec_die) { - child_die = spec_die->child; - while (child_die && child_die->tag) - { - if (child_die->tag == DW_TAG_imported_module) - process_die (child_die, spec_cu); - child_die = child_die->sibling; - } + for (die_info *child_die : spec_die->children ()) + if (child_die->tag == DW_TAG_imported_module) + process_die (child_die, spec_cu); /* In some cases, GCC generates specification DIEs that themselves contain DW_AT_specification attributes. */ @@ -8646,7 +8588,6 @@ read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu) { dwarf2_per_objfile *per_objfile = cu->per_objfile; CORE_ADDR lowpc, highpc; - struct die_info *child_die; /* Ignore blocks with missing or invalid low and high pc attributes. */ /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges @@ -8661,9 +8602,7 @@ read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu) /* DW_TAG_lexical_block has no attributes, process its children as if there was no wrapping by that DW_TAG_lexical_block. GCC does no longer produces such DWARF since GCC r224161. */ - for (child_die = die->child; - child_die != NULL && child_die->tag; - child_die = child_die->sibling) + for (die_info *child_die : die->children ()) { /* We might already be processing this DIE. This can happen in an unusual circumstance -- where a subroutine A @@ -8682,15 +8621,9 @@ read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu) highpc = per_objfile->relocate (unrel_high); cu->get_builder ()->push_context (0, lowpc); - if (die->child != NULL) - { - child_die = die->child; - while (child_die && child_die->tag) - { - process_die (child_die, cu); - child_die = child_die->sibling; - } - } + for (die_info *child_die : die->children ()) + process_die (child_die, cu); + inherit_abstract_dies (die, cu); struct context_stack cstk = cu->get_builder ()->pop_context (); @@ -8733,7 +8666,6 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) struct gdbarch *gdbarch = objfile->arch (); struct attribute *attr; int nparams; - struct die_info *child_die; attr = dwarf2_attr (die, DW_AT_call_return_pc, cu); if (attr == NULL) @@ -8754,8 +8686,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) /* Count parameters at the caller. */ nparams = 0; - for (child_die = die->child; child_die && child_die->tag; - child_die = child_die->sibling) + for (die_info *child_die : die->children ()) { if (child_die->tag != DW_TAG_call_site_parameter && child_die->tag != DW_TAG_GNU_call_site_parameter) @@ -8924,9 +8855,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) "block nor reference, for DIE %s [in module %s]"), sect_offset_str (die->sect_off), objfile_name (objfile)); - for (child_die = die->child; - child_die && child_die->tag; - child_die = child_die->sibling) + for (die_info *child_die : die->children ()) { struct call_site_parameter *parameter; struct attribute *loc, *origin; @@ -9646,7 +9575,6 @@ dwarf2_get_subprogram_pc_bounds (struct die_info *die, struct dwarf2_cu *cu) { unrelocated_addr low, high; - struct die_info *child = die->child; if (dwarf2_get_pc_bounds (die, &low, &high, cu, nullptr, nullptr) >= PC_BOUNDS_RANGES) @@ -9664,12 +9592,11 @@ dwarf2_get_subprogram_pc_bounds (struct die_info *die, subprograms, then check their pc bounds. Likewise, we need to check lexical blocks as well, as they may also contain subprogram definitions. */ - while (child && child->tag) + for (die_info *child : die->children ()) { if (child->tag == DW_TAG_subprogram || child->tag == DW_TAG_lexical_block) dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu); - child = child->sibling; } } @@ -9695,9 +9622,7 @@ get_scope_pc_bounds (struct die_info *die, } else { - struct die_info *child = die->child; - - while (child && child->tag) + for (die_info *child : die->children ()) { switch (child->tag) { case DW_TAG_subprogram: @@ -9725,8 +9650,6 @@ get_scope_pc_bounds (struct die_info *die, /* Ignore. */ break; } - - child = child->sibling; } } @@ -11277,9 +11200,7 @@ handle_variant_part (struct die_info *die, struct type *type, objfile_name (cu->per_objfile->objfile)); } - for (die_info *child_die = die->child; - child_die != NULL; - child_die = child_die->sibling) + for (die_info *child_die : die->children ()) handle_struct_member_die (child_die, type, fi, template_args, cu); } @@ -11330,9 +11251,7 @@ handle_variant (struct die_info *die, struct type *type, else variant.discriminant_value = discr->constant_value (0); - for (die_info *variant_child = die->child; - variant_child != NULL; - variant_child = variant_child->sibling) + for (die_info *variant_child : die->children ()) handle_struct_member_die (variant_child, type, fi, template_args, cu); variant.last_field = fi->fields.size (); @@ -11401,7 +11320,6 @@ static void process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->per_objfile->objfile; - struct die_info *child_die; struct type *type; type = get_die_type (die, cu); @@ -11414,13 +11332,8 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) struct field_info fi; std::vector<struct symbol *> template_args; - child_die = die->child; - - while (child_die && child_die->tag) - { - handle_struct_member_die (child_die, type, &fi, &template_args, cu); - child_die = child_die->sibling; - } + for (die_info *child_die : die->children ()) + handle_struct_member_die (child_die, type, &fi, &template_args, cu); /* Attach template arguments to type. */ if (!template_args.empty ()) @@ -11558,9 +11471,7 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) current die is a declaration. Normally, of course, a declaration won't have any children at all. */ - child_die = die->child; - - while (child_die != NULL && child_die->tag) + for (die_info *child_die : die->children ()) { if (child_die->tag == DW_TAG_member || child_die->tag == DW_TAG_variable @@ -11572,8 +11483,6 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) } else process_die (child_die, cu); - - child_die = child_die->sibling; } /* Do not consider external references. According to the DWARF standard, @@ -11673,16 +11582,13 @@ update_enumeration_type_from_children (struct die_info *die, struct type *type, struct dwarf2_cu *cu) { - struct die_info *child_die; int unsigned_enum = 1; int flag_enum = 1; auto_obstack obstack; std::vector<struct field> fields; - for (child_die = die->child; - child_die != NULL && child_die->tag; - child_die = child_die->sibling) + for (die_info *child_die : die->children ()) { struct attribute *attr; LONGEST value; @@ -11840,10 +11746,7 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) if (die->child != NULL) { - struct die_info *child_die; - - child_die = die->child; - while (child_die && child_die->tag) + for (die_info *child_die : die->children ()) { if (child_die->tag != DW_TAG_enumerator) { @@ -11851,8 +11754,6 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) } else new_symbol (child_die, this_type, cu); - - child_die = child_die->sibling; } } @@ -12033,9 +11934,7 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu, int bounds_offset = -1; int max_align = -1; std::vector<struct field> range_fields; - for (struct die_info *child_die = die->child; - child_die; - child_die = child_die->sibling) + for (die_info *child_die : die->children ()) { if (child_die->tag == DW_TAG_subrange_type) { @@ -12136,7 +12035,6 @@ static struct type * read_array_type (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->per_objfile->objfile; - struct die_info *child_die; struct type *type; struct type *element_type, *range_type, *index_type; struct attribute *attr; @@ -12191,8 +12089,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) } std::vector<struct type *> range_types; - child_die = die->child; - while (child_die && child_die->tag) + for (die_info *child_die : die->children ()) { if (child_die->tag == DW_TAG_subrange_type || child_die->tag == DW_TAG_generic_subrange) @@ -12206,7 +12103,6 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) range_types.push_back (child_type); } } - child_die = child_die->sibling; } if (range_types.empty ()) @@ -12473,15 +12369,12 @@ read_common_block (struct die_info *die, struct dwarf2_cu *cu) if (die->child != NULL) { struct objfile *objfile = cu->per_objfile->objfile; - struct die_info *child_die; - size_t n_entries = 0, size; + size_t size; struct common_block *common_block; struct symbol *sym; - for (child_die = die->child; - child_die && child_die->tag; - child_die = child_die->sibling) - ++n_entries; + auto range = die->children (); + size_t n_entries = std::distance (range.begin (), range.end ()); size = (sizeof (struct common_block) + (n_entries - 1) * sizeof (struct symbol *)); @@ -12491,9 +12384,7 @@ read_common_block (struct die_info *die, struct dwarf2_cu *cu) memset (common_block->contents, 0, n_entries * sizeof (struct symbol *)); common_block->n_entries = 0; - for (child_die = die->child; - child_die && child_die->tag; - child_die = child_die->sibling) + for (die_info *child_die : die->children ()) { /* Create the symbol in the DW_TAG_common_block block in the current symbol scope. */ @@ -12616,13 +12507,8 @@ read_namespace (struct die_info *die, struct dwarf2_cu *cu) if (die->child != NULL) { - struct die_info *child_die = die->child; - - while (child_die && child_die->tag) - { - process_die (child_die, cu); - child_die = child_die->sibling; - } + for (die_info *child_die : die->children ()) + process_die (child_die, cu); } } @@ -12660,17 +12546,13 @@ read_module_type (struct die_info *die, struct dwarf2_cu *cu) static void read_module (struct die_info *die, struct dwarf2_cu *cu) { - struct die_info *child_die = die->child; struct type *type; type = read_type_die (die, cu); new_symbol (die, type, cu); - while (child_die && child_die->tag) - { - process_die (child_die, cu); - child_die = child_die->sibling; - } + for (die_info *child_die : die->children ()) + process_die (child_die, cu); } /* Return the name of the namespace represented by DIE. Set @@ -13168,22 +13050,18 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) if (die->child != NULL) { struct type *void_type = builtin_type (objfile)->builtin_void; - struct die_info *child_die; int nparams, iparams; /* Count the number of parameters. FIXME: GDB currently ignores vararg functions, but knows about vararg member functions. */ nparams = 0; - child_die = die->child; - while (child_die && child_die->tag) + for (die_info *child_die : die->children ()) { if (child_die->tag == DW_TAG_formal_parameter) nparams++; else if (child_die->tag == DW_TAG_unspecified_parameters) ftype->set_has_varargs (true); - - child_die = child_die->sibling; } /* Allocate storage for parameters and fill them in. */ @@ -13195,8 +13073,7 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) ftype->field (iparams).set_type (void_type); iparams = 0; - child_die = die->child; - while (child_die && child_die->tag) + for (die_info *child_die : die->children ()) { if (child_die->tag == DW_TAG_formal_parameter) { @@ -13253,7 +13130,6 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) ftype->field (iparams).set_type (arg_type); iparams++; } - child_die = child_die->sibling; } } @@ -14350,7 +14226,7 @@ read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu) return set_die_type (die, type, cu); } -/* Read a single die and all its descendents. Set the die's sibling +/* Read a single die and all its descendents. Set the die's next field to NULL; set other fields in the die correctly, and set all of the descendents' fields correctly. PARENT is the parent of the die in question. */ @@ -14371,7 +14247,7 @@ cutu_reader::read_die_and_children (die_info *parent) else die->child = nullptr; - die->sibling = nullptr; + die->next = nullptr; die->parent = parent; return die; } @@ -14396,7 +14272,7 @@ cutu_reader::read_die_and_siblings (die_info *parent) if (first_die == nullptr) first_die = die; else - last_sibling->sibling = die; + last_sibling->next = die; last_sibling = die; } @@ -14435,7 +14311,7 @@ cutu_reader::read_all_dies () and updating die_info::num_attrs. Return a newly allocated die with its information, except for its - child, sibling, and parent fields. */ + child, next, and parent fields. */ die_info * cutu_reader::read_full_die (int num_extra_attrs, bool allow_reprocess) @@ -14479,7 +14355,7 @@ cutu_reader::read_full_die (int num_extra_attrs, bool allow_reprocess) /* Read a die and all its attributes. Return a newly allocated die with its information, except for its - child, sibling, and parent fields. */ + child, next, and parent fields. */ die_info * cutu_reader::read_toplevel_die (gdb::array_view<attribute *> extra_attrs) @@ -15423,7 +15299,7 @@ dwarf2_read_addr_index (dwarf2_per_cu *per_cu, dwarf2_per_objfile *per_objfile, } else { - cutu_reader reader (per_cu, per_objfile, nullptr, nullptr, false, + cutu_reader reader (*per_cu, *per_objfile, nullptr, nullptr, false, language_minimal); addr_base = reader.cu ()->addr_base; addr_size = reader.cu ()->header.addr_size; @@ -17767,7 +17643,6 @@ guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu) { struct die_info *spec_die; struct dwarf2_cu *spec_cu; - struct die_info *child; struct objfile *objfile = cu->per_objfile->objfile; spec_cu = cu; @@ -17778,9 +17653,7 @@ guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu) cu = spec_cu; } - for (child = die->child; - child != NULL; - child = child->sibling) + for (die_info *child : die->children ()) { if (child->tag == DW_TAG_subprogram) { @@ -18106,18 +17979,19 @@ unnamed_template_tag_name (die_info *die, dwarf2_cu *cu) arrive at our entry. */ size_t nth_unnamed = 0; - die_info *child = die->parent->child; - while (child != die) - { - gdb_assert (child != nullptr); - if (child->tag == DW_TAG_template_type_param - || child->tag == DW_TAG_template_value_param) - { - if (dwarf2_attr (child, DW_AT_name, cu) == nullptr) - ++nth_unnamed; - } - child = child->sibling; - } + for (die_info *child : die->parent->children ()) + { + if (child == die) + break; + + gdb_assert (child != nullptr); + if (child->tag == DW_TAG_template_type_param + || child->tag == DW_TAG_template_value_param) + { + if (dwarf2_attr (child, DW_AT_name, cu) == nullptr) + ++nth_unnamed; + } + } const std::string name_str = "<unnamed" + std::to_string (nth_unnamed) + ">"; return cu->per_objfile->objfile->intern (name_str.c_str ()); @@ -18925,7 +18799,7 @@ read_signatured_type (signatured_type *sig_type, gdb_assert (sig_type->is_debug_types); gdb_assert (per_objfile->get_cu (sig_type) == nullptr); - cutu_reader reader (sig_type, per_objfile, nullptr, nullptr, false, + cutu_reader reader (*sig_type, *per_objfile, nullptr, nullptr, false, language_minimal); if (!reader.is_dummy ()) @@ -19438,7 +19312,7 @@ dwarf2_per_cu::ensure_lang (dwarf2_per_objfile *per_objfile) /* Constructing this object will set the language as a side effect. */ - cutu_reader reader (this, per_objfile, nullptr, per_objfile->get_cu (this), + cutu_reader reader (*this, *per_objfile, nullptr, per_objfile->get_cu (this), true, language_minimal, nullptr); } diff --git a/gdb/dwarf2/read.h b/gdb/dwarf2/read.h index ba2dd07..b13e42d 100644 --- a/gdb/dwarf2/read.h +++ b/gdb/dwarf2/read.h @@ -921,19 +921,19 @@ class cutu_reader { public: - cutu_reader (dwarf2_per_cu *this_cu, - dwarf2_per_objfile *per_objfile, + cutu_reader (dwarf2_per_cu &this_cu, + dwarf2_per_objfile &per_objfile, const struct abbrev_table *abbrev_table, dwarf2_cu *existing_cu, bool skip_partial, enum language pretend_language, - const abbrev_table_cache *cache = nullptr); + const abbrev_table_cache *abbrev_cache = nullptr); - cutu_reader (dwarf2_per_cu *this_cu, - dwarf2_per_objfile *per_objfile, + cutu_reader (dwarf2_per_cu &this_cu, + dwarf2_per_objfile &per_objfile, enum language pretend_language, - struct dwarf2_cu *parent_cu, - struct dwo_file *dwo_file); + struct dwarf2_cu &parent_cu, + struct dwo_file &dwo_file); DISABLE_COPY_AND_ASSIGN (cutu_reader); @@ -1003,8 +1003,7 @@ private: void read_cutu_die_from_dwo (dwarf2_cu *cu, dwo_unit *dwo_unit, die_info *stub_comp_unit_die, - const char *stub_comp_dir, - abbrev_table_up *result_dwo_abbrev_table); + const char *stub_comp_dir); void prepare_one_comp_unit (struct dwarf2_cu *cu, enum language pretend_language); |