[binutils-gdb] Introduce DWARF abbrev cache

[Tom Tromey <tromey@sourceware.org>]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=8c83177441405ace08650d9d36f76311009c2ed3

commit 8c83177441405ace08650d9d36f76311009c2ed3
Author: Tom Tromey <tom@tromey.com>
Date:   Mon Nov 2 17:35:51 2020 -0700

    Introduce DWARF abbrev cache
    
    The replacement for the DWARF psymbol reader works in a somewhat
    different way.  The current reader reads and stores all the DIEs that
    might be interesting.  Then, if it is missing a DIE, it re-scans the
    CU and reads them all.  This approach is used for both intra- and
    inter-CU references.
    
    I instrumented the partial DIE hash to see how frequently it was used:
    
        [  0] -> 1538165
        [  1] ->    4912
        [  2] ->   96102
        [  3] ->     175
        [  4] ->     244
    
    That is, most DIEs are never used, and some are looked up twice -- but
    this is just an artifact of the implementation of
    partial_die_info::fixup, which may do two lookups.
    
    Based on this, the new implementation doesn't try to store any DIEs,
    but instead just re-scans them on demand.  In order to do this,
    though, it is convenient to have a cache of DWARF abbrevs.  This way,
    if a second CU is needed to resolve an inter-CU reference, the abbrevs
    for that CU need only be computed a single time.

Diff:
---
 gdb/Makefile.in           |  1 +
 gdb/dwarf2/abbrev-cache.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++
 gdb/dwarf2/abbrev-cache.h | 58 ++++++++++++++++++++++++++++++++++++++++++
 gdb/dwarf2/abbrev.c       |  5 ++--
 gdb/dwarf2/abbrev.h       |  4 ++-
 5 files changed, 130 insertions(+), 3 deletions(-)

diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 110c157896d..1374f295f8a 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -1044,6 +1044,7 @@ COMMON_SFILES = \
 	displaced-stepping.c \
 	dummy-frame.c \
 	dwarf2/abbrev.c \
+	dwarf2/abbrev-cache.c \
 	dwarf2/attribute.c \
 	dwarf2/comp-unit-head.c \
 	dwarf2/cu.c \
diff --git a/gdb/dwarf2/abbrev-cache.c b/gdb/dwarf2/abbrev-cache.c
new file mode 100644
index 00000000000..2168f92dd9d
--- /dev/null
+++ b/gdb/dwarf2/abbrev-cache.c
@@ -0,0 +1,65 @@
+/* DWARF 2 abbrev table cache
+
+   Copyright (C) 2022 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 "defs.h"
+#include "dwarf2/read.h"
+#include "dwarf2/abbrev-cache.h"
+
+/* Hash function for an abbrev table.  */
+
+hashval_t
+abbrev_cache::hash_table (const void *item)
+{
+  const struct abbrev_table *table = (const struct abbrev_table *) item;
+  return to_underlying (table->sect_off);
+}
+
+/* Comparison function for abbrev table.  */
+
+int
+abbrev_cache::eq_table (const void *lhs, const void *rhs)
+{
+  const struct abbrev_table *l_table = (const struct abbrev_table *) lhs;
+  const search_key *key = (const search_key *) rhs;
+  return (l_table->section == key->section
+	  && l_table->sect_off == key->offset);
+}
+
+abbrev_cache::abbrev_cache ()
+  : m_tables (htab_create_alloc (20, hash_table, eq_table,
+				 htab_delete_entry<abbrev_table>,
+				 xcalloc, xfree))
+{
+}
+
+void
+abbrev_cache::add (abbrev_table_up table)
+{
+  /* We allow this as a convenience to the caller.  */
+  if (table == nullptr)
+    return;
+
+  search_key key = { table->section, table->sect_off };
+  void **slot = htab_find_slot_with_hash (m_tables.get (), &key,
+					  to_underlying (table->sect_off),
+					  INSERT);
+  /* If this one already existed, then it should have been reused.  */
+  gdb_assert (*slot == nullptr);
+  *slot = (void *) table.release ();
+}
diff --git a/gdb/dwarf2/abbrev-cache.h b/gdb/dwarf2/abbrev-cache.h
new file mode 100644
index 00000000000..7af28cd8181
--- /dev/null
+++ b/gdb/dwarf2/abbrev-cache.h
@@ -0,0 +1,58 @@
+/* DWARF abbrev table cache
+
+   Copyright (C) 2022 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_ABBREV_CACHE_H
+#define GDB_DWARF2_ABBREV_CACHE_H
+
+#include "dwarf2/abbrev.h"
+#include <unordered_set>
+#include "gdbtypes.h"
+
+class abbrev_cache
+{
+public:
+  abbrev_cache ();
+  DISABLE_COPY_AND_ASSIGN (abbrev_cache);
+
+  abbrev_table *find (struct dwarf2_section_info *section, sect_offset offset)
+  {
+    search_key key = { section, offset };
+
+    return (abbrev_table *) htab_find_with_hash (m_tables.get (), &key,
+						 to_underlying (offset));
+  }
+
+  void add (abbrev_table_up table);
+
+private:
+
+  static hashval_t hash_table (const void *item);
+  static int eq_table (const void *lhs, const void *rhs);
+
+  struct search_key
+  {
+    struct dwarf2_section_info *section;
+    sect_offset offset;
+  };
+
+  /* Hash table of abbrev tables.  */
+  htab_up m_tables;
+};
+
+#endif /* GDB_DWARF2_ABBREV_CACHE_H */
diff --git a/gdb/dwarf2/abbrev.c b/gdb/dwarf2/abbrev.c
index 1dd0818c382..4b65e6b5309 100644
--- a/gdb/dwarf2/abbrev.c
+++ b/gdb/dwarf2/abbrev.c
@@ -58,8 +58,9 @@ eq_abbrev (const void *lhs, const void *rhs)
    dies from a section we read in all abbreviations and install them
    in a hash table.  */
 
-abbrev_table::abbrev_table (sect_offset off)
+abbrev_table::abbrev_table (sect_offset off, struct dwarf2_section_info *sect)
   : sect_off (off),
+    section (sect),
     m_abbrevs (htab_create_alloc (20, hash_abbrev, eq_abbrev,
 				  nullptr, xcalloc, xfree))
 {
@@ -85,7 +86,7 @@ abbrev_table::read (struct dwarf2_section_info *section,
   const gdb_byte *abbrev_ptr;
   struct abbrev_info *cur_abbrev;
 
-  abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
+  abbrev_table_up abbrev_table (new struct abbrev_table (sect_off, section));
   struct obstack *obstack = &abbrev_table->m_abbrev_obstack;
 
   /* Caller must ensure this.  */
diff --git a/gdb/dwarf2/abbrev.h b/gdb/dwarf2/abbrev.h
index 414296796e3..b5fa76ad514 100644
--- a/gdb/dwarf2/abbrev.h
+++ b/gdb/dwarf2/abbrev.h
@@ -85,9 +85,11 @@ struct abbrev_table
      This is used as a sanity check when the table is used.  */
   const sect_offset sect_off;
 
+  struct dwarf2_section_info *section;
+
 private:
 
-  explicit abbrev_table (sect_offset off);
+  abbrev_table (sect_offset off, struct dwarf2_section_info *sect);
 
   DISABLE_COPY_AND_ASSIGN (abbrev_table);