From: Tom Tromey <tom@tromey.com>
Date: Tue, 11 Feb 2025 18:48:09 +0000 (-0700)
Subject: Emit some type declarations in .gdb_index
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=0fa4f62568b1deeb071c4a6ae8a1671c8ec7ba6e;p=thirdparty%2Fbinutils-gdb.git

Emit some type declarations in .gdb_index

If you run struct-decl.exp with the .gdb_index board, you will see
that "the_type" is not emitted in the index.  This would cause a
failure in this series.  The fix is to ensure that certain necessary
type declarations are emitted.

However, a naive fix here will regress stub-array-size.exp, where a
type declaration and a type definition are both seen -- but the
declaration is seen first and causes a failure.  This is handled by
adding some code (including a mild hack) to filter out type
declarations when a corresponding type definition is seen.

Acked-By: Simon Marchi <simon.marchi@efficios.com>
---

diff --git a/gdb/dwarf2/index-write.c b/gdb/dwarf2/index-write.c
index d5b198ba347..bd14cb9eace 100644
--- a/gdb/dwarf2/index-write.c
+++ b/gdb/dwarf2/index-write.c
@@ -55,7 +55,7 @@
 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
   do { \
     gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
-		&& (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
+		&& (value) <= GDB_INDEX_SYMBOL_KIND_UNUSED5); \
     GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
   } while (0)
 
@@ -422,10 +422,47 @@ symtab_index_entry::minimize ()
   if (name == nullptr || cu_indices.empty ())
     return;
 
-  std::sort (cu_indices.begin (), cu_indices.end ());
+  /* We sort the indexes in a funny way: GDB_INDEX_SYMBOL_KIND_UNUSED5
+     is always sorted last; then otherwise we sort by numeric value.
+     This ensures that we prefer the definition when both a definition
+     and a declaration (stub type) are seen.  */
+  std::sort (cu_indices.begin (), cu_indices.end (),
+	     [] (offset_type vala, offset_type valb)
+	       {
+		 auto kinda = GDB_INDEX_SYMBOL_KIND_VALUE (vala);
+		 auto kindb = GDB_INDEX_SYMBOL_KIND_VALUE (valb);
+		 if (kinda != kindb)
+		   {
+		     /* Declaration sorts last.  */
+		     if (kinda == GDB_INDEX_SYMBOL_KIND_UNUSED5)
+		       return false;
+		     if (kindb == GDB_INDEX_SYMBOL_KIND_UNUSED5)
+		       return true;
+		   }
+		 return vala < valb;
+	       });
   auto from = std::unique (cu_indices.begin (), cu_indices.end ());
   cu_indices.erase (from, cu_indices.end ());
 
+  /* Rewrite GDB_INDEX_SYMBOL_KIND_UNUSED5.  This ensures that a type
+     declaration will be deleted by the subsequent squashing step, if
+     warranted.  */
+  for (auto &val : cu_indices)
+    {
+      gdb_index_symbol_kind kind = GDB_INDEX_SYMBOL_KIND_VALUE (val);
+      if (kind != GDB_INDEX_SYMBOL_KIND_UNUSED5)
+	continue;
+
+      offset_type newval = 0;
+      DW2_GDB_INDEX_CU_SET_VALUE (newval, GDB_INDEX_CU_VALUE (val));
+      DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE
+	(newval, GDB_INDEX_SYMBOL_STATIC_VALUE (val));
+      DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (newval,
+					   GDB_INDEX_SYMBOL_KIND_TYPE);
+
+      val = newval;
+    }
+
   /* We don't want to enter a type more than once, so
      remove any such duplicates from the list as well.  When doing
      this, we want to keep the entry from the first CU -- but this is
@@ -1212,6 +1249,21 @@ write_cooked_index (cooked_index *table,
 		    const cu_index_map &cu_index_htab,
 		    struct mapped_symtab *symtab)
 {
+  gdb::unordered_set<const cooked_index_entry *> required_decl_entries;
+  for (const cooked_index_entry *entry : table->all_entries ())
+    {
+      /* Any type declaration that is used as a (non-trivial) parent
+	 entry must be written out.  */
+      if ((entry->flags & IS_TYPE_DECLARATION) == 0)
+	{
+	  for (const cooked_index_entry *parent = entry->get_parent ();
+	       parent != nullptr;
+	       parent = parent->get_parent ())
+	    if ((parent->flags & IS_TYPE_DECLARATION) != 0)
+	      required_decl_entries.insert (parent);
+	}
+    }
+
   for (const cooked_index_entry *entry : table->all_entries ())
     {
       const auto it = cu_index_htab.find (entry->per_cu);
@@ -1237,11 +1289,10 @@ write_cooked_index (cooked_index *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;
-	}
+      /* Don't add most type declarations to the index.  */
+      else if ((entry->flags & IS_TYPE_DECLARATION) != 0
+	       && !required_decl_entries.contains (entry))
+	continue;
 
       gdb_index_symbol_kind kind;
       if (entry->tag == DW_TAG_subprogram
@@ -1252,7 +1303,16 @@ write_cooked_index (cooked_index *table,
 	       || entry->tag == DW_TAG_enumerator)
 	kind = GDB_INDEX_SYMBOL_KIND_VARIABLE;
       else if (tag_is_type (entry->tag))
-	kind = GDB_INDEX_SYMBOL_KIND_TYPE;
+	{
+	  /* If we added a type declaration, we want to note this
+	     fact for later, because we don't want a type declaration
+	     to cause the real definition to be omitted from the
+	     index.  GDB_INDEX_SYMBOL_KIND_UNUSED5 is used here, but
+	     rewritten later before the index is written.  */
+	  kind = ((entry->flags & IS_TYPE_DECLARATION) == 0
+		  ? GDB_INDEX_SYMBOL_KIND_TYPE
+		  : GDB_INDEX_SYMBOL_KIND_UNUSED5);
+	}
       else
 	kind = GDB_INDEX_SYMBOL_KIND_OTHER;