[binutils-gdb] Fix incorrect .gdb_index with new DWARF scanner

[binutils-gdb] Fix incorrect .gdb_index with new DWARF scanner

[Tom Tromey]

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

commit 2afd002ac6acb01763d643686345cc0c6ad564bd
Author: Tom Tromey <tromey@adacore.com>
Date:   Mon Oct 17 12:21:10 2022 -0600

    Fix incorrect .gdb_index with new DWARF scanner
    
    PR symtab/29694 points out a regression caused by the new DWARF
    scanner when the cc-with-gdb-index target board is used.
    
    What happens here is that an older version of gdb will make an index
    describing the "A" type as:
    
    [737] A: 1 [global, type]
    
    whereas the new gdb says:
    
    [1008] A: 0 [global, type]
    
    Here the old one is correct because the A in CU 0 is just a
    declaration without a size:
    
     <1><45>: Abbrev Number: 10 (DW_TAG_structure_type)
        <46>   DW_AT_name        : A
        <48>   DW_AT_declaration : 1
        <48>   DW_AT_sibling     : <0x6d>
    
    This patch fixes the problem by introducing the idea of a "type
    declaration".  I think gdb still needs to recurse into these types,
    searching for methods, but by marking the type itself as a
    declaration, gdb can skip this type during lookups and when writing
    the index.
    
    Regression tested on x86-64 using the cc-with-gdb-index board.
    
    Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=29694

Diff:
---
 gdb/dwarf2/cooked-index.h | 15 +++++++++++++++
 gdb/dwarf2/index-write.c  |  5 +++++
 gdb/dwarf2/read.c         | 22 ++++++++++++++--------
 3 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/gdb/dwarf2/cooked-index.h b/gdb/dwarf2/cooked-index.h
index f3c26480a81..2ea32781be5 100644
--- a/gdb/dwarf2/cooked-index.h
+++ b/gdb/dwarf2/cooked-index.h
@@ -48,6 +48,9 @@ enum cooked_index_flag_enum : unsigned char
   IS_ENUM_CLASS = 4,
   /* True if this entry uses the linkage name.  */
   IS_LINKAGE = 8,
+  /* True if this entry is just for the declaration of a type, not the
+     definition.  */
+  IS_TYPE_DECLARATION = 16,
 };
 DEF_ENUM_FLAGS_TYPE (enum cooked_index_flag_enum, cooked_index_flag);
 
@@ -76,6 +79,10 @@ struct cooked_index_entry : public allocate_on_obstack
   /* 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;
@@ -88,6 +95,10 @@ struct cooked_index_entry : public allocate_on_obstack
   /* Return true if this entry matches DOMAIN.  */
   bool matches (domain_enum domain) const
   {
+    /* Just reject type declarations.  */
+    if ((flags & IS_TYPE_DECLARATION) != 0)
+      return false;
+
     switch (domain)
       {
       case LABEL_DOMAIN:
@@ -106,6 +117,10 @@ struct cooked_index_entry : public allocate_on_obstack
   /* Return true if this entry matches KIND.  */
   bool matches (enum search_domain kind) const
   {
+    /* Just reject type declarations.  */
+    if ((flags & IS_TYPE_DECLARATION) != 0)
+      return false;
+
     switch (kind)
       {
       case VARIABLES_DOMAIN:
diff --git a/gdb/dwarf2/index-write.c b/gdb/dwarf2/index-write.c
index f592734addc..3d215a6307b 100644
--- a/gdb/dwarf2/index-write.c
+++ b/gdb/dwarf2/index-write.c
@@ -1167,6 +1167,11 @@ write_cooked_index (cooked_index_vector *table,
 	     be redundant are rare and not worth supporting.  */
 	  continue;
 	}
+      else if ((entry->flags & IS_TYPE_DECLARATION) != 0)
+	{
+	  /* Don't add type declarations to the index.  */
+	  continue;
+	}
 
       gdb_index_symbol_kind kind;
       if (entry->tag == DW_TAG_subprogram)
diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 7de89dd5923..cde7a5bd01f 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -18191,14 +18191,20 @@ cooked_indexer::scan_attributes (dwarf2_per_cu_data *scanning_per_cu,
      that is ok.  Similarly, we allow an external variable without a
      location; those are resolved via minimal symbols.  */
   if (is_declaration && !for_specification
-      && !(abbrev->tag == DW_TAG_variable && (*flags & IS_STATIC) == 0)
-      && !((abbrev->tag == DW_TAG_class_type
-	    || abbrev->tag == DW_TAG_structure_type
-	    || abbrev->tag == DW_TAG_union_type)
-	   && abbrev->has_children))
-    {
-      *linkage_name = nullptr;
-      *name = nullptr;
+      && !(abbrev->tag == DW_TAG_variable && (*flags & IS_STATIC) == 0))
+    {
+      /* We always want to recurse into some types, but we may not
+	 want to treat them as definitions.  */
+      if ((abbrev->tag == DW_TAG_class_type
+	   || abbrev->tag == DW_TAG_structure_type
+	   || abbrev->tag == DW_TAG_union_type)
+	  && abbrev->has_children)
+	*flags |= IS_TYPE_DECLARATION;
+      else
+	{
+	  *linkage_name = nullptr;
+	  *name = nullptr;
+	}
     }
   else if ((*name == nullptr
 	    || (*linkage_name == nullptr