gdb: remove attempted type de-duplication when building gdb-index

This commit removes the attempted de-duplication of types when
building the gdb-index.  This commit is the natural extension of this
earlier commit:

  commit aef36dee93
  Date:   Sun Aug 13 14:08:06 2023 +0200

      [gdb/symtab] Don't deduplicate variables in gdb-index

Which removed the de-duplication of variables.  It is worth reading
the earlier commit as all the justifications for that patch also
apply to this one.

Currently, when building the gdb-index we sort the type entries,
moving declarations to the end of the entry list, and non-declarations
to the front.  Then within each group, declarations, and
non-declarations, the index entries are sorted by CU offset.

We then emit the first entry for any given type name.

There are two problems with this.

First, a non-declaration entry could be a definition, but it could
also be a typedef.  Now sure, a typedef is a type definition, but not
necessarily a useful one.

If we have a header file that contains:

  typedef struct foo_t foo_t;

And a CU which makes use of 'foo_t', then the CU will include both a
typedef and a type declaration.  The target of the typedef will be the
declaration.  But notice, the CU will not include a type definition.

If we have two CUs, one which only sees the above typedef and
declaration, and another which sees the typedef and an actual type
definition, then the final list of entries for this type's name will
be:

  1. A typedef entry that points at the declaration.
  2. A typedef entry that points at the definition.
  3. A definition.
  4. A declaration.

Now (4) will get sorted to the end of the entry list.  But the order
of (1), (2), and (3) will depend on the CU offset.  If the CU which
containing the typedef and declaration has the smallest offset,
then (1) will be sorted to the front of the list of entries for this
type name.  Due to the de-duplication code this means that only (1)
will be added to the gdb-index.

After GDB starts and parses the index, if a user references 'foo_t'
GDB will look in the index and find just (1).  GDB loads the CU
containing (1) and finds both the typedef and the declaration.  But
GDB does not find the full type definition.  As a result GDB will
display 'foo_t' as an incomplete type.

This differs from the behaviour when no index is used.  With no index
GDB expands the first CU containing 'foo_t', finds the typedef and
type declaration, decides that this is not good enough and carries on.
GDB will then expand the second CU and find the type's definition, GDB
now has a full understanding of the type, and can print the type
correctly.

We could solve this problem by marking typedefs as a distinct
sub-category of types, just as we do with declarations.  Then we could
sort definitions to the front of the list, then typedefs, and finally,
declarations after that.  This would, I think, mean that we always
prefer emitting a definition for a type, which would resolve this
first problem, or at least, it would resolve it well enough, but it
wouldn't fix the second problem.

The second problem is that the Python API and the 'info types' command
can be used to query all type symbols.  As such, GDB needs to be able
to find all the CUs which contain a given type.  Especially as it is
possible that a type might be defined differently within different
CUs.

NOTE: Obviously a program doing this (defining a type differently in
  different CUs) would need to be mindful of the One Definition Rule,
  but so long as the type doesn't escape outside of a single CU then
  reusing a type name isn't, as I understand it, wrong.  And even if
  it is, the fact that it compiles, and could be a source of bugs,
  means (in my opinion) that GDB should handle this case to enable
  debugging of it.

Even something as simple as 'info types ....' relies on GDB being able
to find multiple entries for a given type in different CUs.  If the
index only contains a single type entry, then this means GDB will see
different things depending on which CUs happen to have been expanded.

Given all of the above, I think that any attempt to remove type
entries from the gdb-index is unsafe and can result in GDB behaving
differently when using the gdb-index compared to using no index.

The solution is to remove the de-duplication code, which is what this
patch does.

Now that we no longer need to sort declarations to the end of the
entry list, I've removed all the code related to the special use of
GDB_INDEX_SYMBOL_KIND_UNUSED5 (which is how we marked declarations),
this cleans things up a little bit.

I've also renamed some of the functions away from minimize, now that
there's no minimization being done.

A problem was revealed by this change.  When running the test
gdb.cp/stub-array-size.exp with the --target_board=cc-with-gdb-index,
I was seeing a failure using gcc 15.1.0.

This test has two CUs, and a type 'A'.  The test description says:

  Test size of arrays of stubbed types (structures where the full
  definition is not immediately available).

Which I don't really understand given the test's source code.  The
type 'A' is defined in a header, which is included in both CUs.
However, the test description does seem to be accurate; in one CU the
type looks like this:

 <1><4a>: Abbrev Number: 8 (DW_TAG_structure_type)
    <4b>   DW_AT_name        : A
    <4d>   DW_AT_declaration : 1
    <4d>   DW_AT_sibling     : <0x6d>
 <2><51>: Abbrev Number: 9 (DW_TAG_subprogram)
    <52>   DW_AT_external    : 1
    <52>   DW_AT_name        : ~A
    <55>   DW_AT_decl_file   : 2
    <56>   DW_AT_decl_line   : 20
    <57>   DW_AT_decl_column : 11
    <58>   DW_AT_linkage_name: (indirect string, offset: 0x103): _ZN1AD4Ev
    <5c>   DW_AT_virtuality  : 1        (virtual)
    <5d>   DW_AT_containing_type: <0x4a>
    <61>   DW_AT_declaration : 1
    <61>   DW_AT_object_pointer: <0x66>
    <65>   DW_AT_inline      : 0        (not inlined)
 <3><66>: Abbrev Number: 10 (DW_TAG_formal_parameter)
    <67>   DW_AT_type        : <0x8c>
    <6b>   DW_AT_artificial  : 1
 <3><6b>: Abbrev Number: 0
 <2><6c>: Abbrev Number: 0

while in the second CU, the type looks like this:

 <1><178>: Abbrev Number: 4 (DW_TAG_structure_type)
    <179>   DW_AT_name        : A
    <17b>   DW_AT_byte_size   : 8
    <17c>   DW_AT_decl_file   : 2
    <17d>   DW_AT_decl_line   : 18
    <17e>   DW_AT_decl_column : 8
    <17f>   DW_AT_containing_type: <0x178>
    <183>   DW_AT_sibling     : <0x1ac>
 <2><187>: Abbrev Number: 5 (DW_TAG_member)
    <188>   DW_AT_name        : (indirect string, offset: 0x19e): _vptr.A
    <18c>   DW_AT_type        : <0x1be>
    <190>   DW_AT_data_member_location: 0
    <191>   DW_AT_artificial  : 1
 <2><191>: Abbrev Number: 6 (DW_TAG_subprogram)
    <192>   DW_AT_external    : 1
    <192>   DW_AT_name        : ~A
    <195>   DW_AT_decl_file   : 1
    <196>   DW_AT_decl_line   : 20
    <197>   DW_AT_decl_column : 1
    <198>   DW_AT_linkage_name: (indirect string, offset: 0x103): _ZN1AD4Ev
    <19c>   DW_AT_virtuality  : 1       (virtual)
    <19d>   DW_AT_containing_type: <0x178>
    <1a1>   DW_AT_declaration : 1
    <1a1>   DW_AT_object_pointer: <0x1a5>
 <3><1a5>: Abbrev Number: 7 (DW_TAG_formal_parameter)
    <1a6>   DW_AT_type        : <0x1cd>
    <1aa>   DW_AT_artificial  : 1
 <3><1aa>: Abbrev Number: 0
 <2><1ab>: Abbrev Number: 0

So, for reasons that I don't understand, the type, despite (as far as
I can see) having its full definition available, is recorded only as
declared in one CU.

The test then performs some actions that rely on 'sizeof(A)' and
expects GDB to correctly figure out the size.  This requires GDB to
find, and expand the CU containing the real definition of 'A'.

Prior to this patch GDB would sort the two type entries for 'A',
placing the declaration second, and then record only one entry, the
definition.  When it came to expansion there was only one thing to
expand, and this is the declaration we needed.  It happens that in
this test the definition is in the second CU, that is, the CU with the
biggest offset.  This means that, if all index entries were considered
equal, the definition entry would be second.  However, currently, due
to the way GDB forces definitions to the front, the entry for the
second CU, the definition, is placed first in the index, and with
de-duplication, this is the only entry added to the index.

After this patch, both the declaration and the definition are placed
in the index, and as the declaration is in the CU at offset 0, the
declaration is added first to the index.

This should be fine.  When looking for 'A' GDB should expand the CU
containing the declaration, see that all we have is a declaration, and
so continue, next expanding the definition, at which point we're done.

However, in read-gdb-index.c, in the function
mapped_gdb_index::build_name_components, there is a work around for
gold bug PR gold/15646.  Ironically, the bug here is that gold was not
removing duplicate index entries, and it is noted that this has a
performance impact on GDB.  A work around for this was added to GDB in
commit:

  commit 8943b87476
  Date:   Tue Nov 12 09:43:17 2013 -0800

      Work around gold/15646.

A test for this was added in:

  commit 40d22035a7
  Date:   Tue May 26 11:35:32 2020 +0200

      [gdb/testsuite] Add test-case gold-gdb-index.exp

And the fix was tweaked in commit:

  commit f030440daa
  Date:   Thu May 28 17:26:22 2020 +0200

      [gdb/symtab] Make gold index workaround more precise

The problem specifically called out in the bug report is that
namespaces can appear in multiple CUs, and that trying to complete
'ns::misspelled' would expand every CU containing namespace 'ns' due
to the duplicate 'ns' type symbols.

The work around that was added in 8943b87476 was to ignore
duplicate global symbols when expanding entries from the index.  In
commit f030440daa this work around was restricted to only ignore
duplicate type entries.  This restriction was required to allow the
earlier de-duplication patch aef36dee93 to function correctly.

Now that I'm taking the work started in aef36dee93 to its
logical conclusion, and allowing duplicate type entries, the work
around of ignoring duplicate global type symbols is no longer needed,
and can be removed.

The associated test for this, added in 40d22035a7, is also
removed in this commit.

To be clear; the performance issue mentioned in PR gold/15646 is now
back again.  But my claim is that gold was right all along to include
the duplicate index entries, and any performance hit we see as a
result, though unfortunate, is just a consequence of doing it right.

That doesn't mean there's not room for optimisation and improvement in
the future, though I don't have any immediate ideas, or plans in this
area.  It's just we can't throw out a bunch of index entries that are
critical, and claim this as a performance optimisation.

I am seeing some failure with this patch when using the board file
dwarf5-fission-debug-types.  These failures all have the error:

  DWARF Error: wrong unit_type in unit header (is DW_UT_skeleton, should be DW_UT_type) [in module ....]

However, I ran the whole testsuite with this board, and this error
crops up often, so I don't think this is something specific to my
patch, so I'm choosing to ignore this.

Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=15646
Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=15035

Approved-By: Tom Tromey <tom@tromey.com>

gdb/NEWS

@@ -43,6 +43,11 @@
   current executable if the current executable has a 'target:' prefix,
   or if the current executable is within the sysroot.
 
+* GDB now adds all type symbols to the .gdb_index section.  The index
+  version number has not increased as a consequence of this change.
+  This fixes an issue where GDB could fail to find a type when relying
+  on the index.  Any existing indexes should be regenerated.
+
 * New targets
 
 GNU/Linux/MicroBlaze (gdbserver) microblazeel-*linux*

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_UNUSED5); \
+		&& (value) < GDB_INDEX_SYMBOL_KIND_UNUSED5); \
     GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
   } while (0)
 
@@ -184,9 +184,8 @@ struct symtab_index_entry
      of this name.  */
   std::vector<offset_type> cu_indices;
 
-  /* Minimize CU_INDICES, sorting them and removing duplicates as
-     appropriate.  */
-  void minimize ();
+  /* Sort CU_INDICES.  */
+  void sort ();
 };
 
 /* The symbol table.  This is a power-of-2-sized hash table.  */
@@ -198,16 +197,16 @@ struct mapped_symtab
   }
 
   /* If there are no elements in the symbol table, then reduce the table
-     size to zero.  Otherwise call symtab_index_entry::minimize each entry
+     size to zero.  Otherwise call symtab_index_entry::sort each entry
      in the symbol table.  */
 
-  void minimize ()
+  void minimize_and_sort ()
   {
     if (m_element_count == 0)
       m_data.resize (0);
 
     for (symtab_index_entry &item : m_data)
-      item.minimize ();
+      item.sort ();
   }
 
   /* Add an entry to SYMTAB.  NAME is the name of the symbol.  CU_INDEX is
@@ -417,69 +416,19 @@ mapped_symtab::add_index_entry (const char *name, int is_static,
 /* See symtab_index_entry.  */
 
 void
-symtab_index_entry::minimize ()
+symtab_index_entry::sort ()
 {
   if (name == nullptr || cu_indices.empty ())
     return;
 
-  /* 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.  */
+  /* Sort the entries based on the CU offset.  */
   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
-     implicit due to the sort.  This choice is done because it's
-     similar to what gdb historically did for partial symbols.  */
-  gdb::unordered_set<offset_type> seen;
-  from = std::remove_if (cu_indices.begin (), cu_indices.end (),
-			 [&] (offset_type val)
-    {
-      gdb_index_symbol_kind kind = GDB_INDEX_SYMBOL_KIND_VALUE (val);
-      if (kind != GDB_INDEX_SYMBOL_KIND_TYPE)
-	return false;
-
-      val &= ~GDB_INDEX_CU_MASK;
-      return !seen.insert (val).second;
-    });
-  cu_indices.erase (from, cu_indices.end ());
 }
 
 /* A form of 'const char *' suitable for container keys.  Only the
@@ -1307,16 +1256,7 @@ write_cooked_index (cooked_index *table,
 	       || entry->tag == DW_TAG_enumerator)
 	kind = GDB_INDEX_SYMBOL_KIND_VARIABLE;
       else if (tag_is_type (entry->tag))
-	{
-	  /* 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);
-	}
+	kind = GDB_INDEX_SYMBOL_KIND_TYPE;
       else
 	kind = GDB_INDEX_SYMBOL_KIND_OTHER;
 
@@ -1458,7 +1398,7 @@ write_gdbindex (dwarf2_per_bfd *per_bfd, cooked_index *table,
 
   /* Now that we've processed all symbols we can shrink their cu_indices
      lists.  */
-  symtab.minimize ();
+  symtab.minimize_and_sort ();
 
   data_buf symtab_vec, constant_pool;
 

gdb/dwarf2/read-gdb-index.c

@@ -262,7 +262,6 @@ mapped_gdb_index::build_name_components (dwarf2_per_objfile *per_objfile)
       std::vector<cooked_index_entry *> these_entries;
       offset_view vec (constant_pool.slice (symbol_vec_index (idx)));
       offset_type vec_len = vec[0];
-      bool global_seen = false;
       for (offset_type vec_idx = 0; vec_idx < vec_len; ++vec_idx)
 	{
 	  offset_type cu_index_and_attrs = vec[vec_idx + 1];
@@ -302,11 +301,6 @@ mapped_gdb_index::build_name_components (dwarf2_per_objfile *per_objfile)
 		tag = (dwarf_tag) DW_TAG_GDB_INDEX_TYPE;
 	      else
 		{
-		  /* Work around gold/15646.  */
-		  if (global_seen)
-		    continue;
-		  global_seen = true;
-
 		  tag = DW_TAG_structure_type;
 		  this_lang = language_cplus;
 		}

gdb/testsuite/gdb.base/gdb-index-many-types-1.c

@@ -1,6 +1,6 @@
 /* This testcase is part of GDB, the GNU debugger.
 
-   Copyright 2020-2025 Free Software Foundation, Inc.
+   Copyright 2025 Free Software Foundation, Inc.
 
    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
@@ -15,15 +15,34 @@
    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 "gold-gdb-index.h"
-
-namespace N1
-{
-  void foo () { C1::baz (); }
-}
+#include "gdb-index-many-types.h"
 
 int
 main ()
 {
+  foo_func_a (0);
+  foo_func_b (0);
+  bar_func_a (0);
+  bar_func_b (0);
+  baz_func_a (0);
+  baz_func_b (0);
   return 0;
 }
+
+void
+foo_func_c (foo_t *obj)
+{
+  (void) obj;
+}
+
+void
+bar_func_c (bar_t *obj)
+{
+  (void) obj;
+}
+
+void
+baz_func_c (baz_t *obj)
+{
+  (void) obj;
+}

gdb/testsuite/gdb.base/gdb-index-many-types-2.c

@@ -1,6 +1,6 @@
 /* This testcase is part of GDB, the GNU debugger.
 
-   Copyright 2020-2025 Free Software Foundation, Inc.
+   Copyright 2025 Free Software Foundation, Inc.
 
    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
@@ -15,9 +15,42 @@
    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 "gold-gdb-index.h"
+#include "gdb-index-many-types.h"
 
-namespace N1
+typedef struct foo_t
 {
-  void bar () { C1::baz (); }
+  int foo_t_1;
+  int foo_t_2;
+} foo_t;
+
+typedef struct woof_t
+{
+  int woof_t_1;
+  int woof_t_2;
+} woof_t;
+
+static void
+woof_func (woof_t *obj)
+{
+  (void) obj;
+}
+
+void
+foo_func_a (foo_t *obj)
+{
+  woof_func (0);
+  (void) obj;
+}
+
+void
+baz_func_a (baz_t *obj)
+{
+  (void) obj;
+}
+
+void
+bar_func_a (bar_t *obj)
+{
+  woof_func (0);
+  (void) obj;
 }

gdb/testsuite/gdb.base/gdb-index-many-types-3.c

@@ -1,6 +1,6 @@
 /* This testcase is part of GDB, the GNU debugger.
 
-   Copyright 2020-2025 Free Software Foundation, Inc.
+   Copyright 2025 Free Software Foundation, Inc.
 
    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
@@ -15,11 +15,42 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
-namespace N1
+#include "gdb-index-many-types.h"
+
+typedef struct woof_t
 {
-  class C1
-  {
-   public:
-    static void baz () {}
-  };
+  double woof_t_3;
+  double woof_t_4;
+} woof_t;
+
+static void
+woof_func (woof_t *obj)
+{
+  (void) obj;
+}
+
+typedef struct bar_t
+{
+  int bar_t_1;
+  int bar_t_2;
+} bar_t;
+
+void
+bar_func_b (bar_t *obj)
+{
+  woof_func (0);
+  (void) obj;
+}
+
+void
+baz_func_b (baz_t *obj)
+{
+  (void) obj;
+}
+
+void
+foo_func_b (foo_t *obj)
+{
+  woof_func (0);
+  (void) obj;
 }

gdb/testsuite/gdb.base/gdb-index-many-types.exp

@@ -0,0 +1,157 @@
+# Copyright 2025 Free Software Foundation, Inc.
+#
+# 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/>.
+
+# Check that adding an index to an executable (both a gdb index and a
+# dwarf-5 index are tested), doesn't prevent GDB from seeing the
+# expected types.
+
+standard_testfile -1.c -2.c -3.c .h
+
+# One of the tests uses this Python file.  The test_* proc checks that
+# GDB supports Python tests.  Some of the other procs don't use this
+# Python file.
+set pyfile [gdb_remote_download host ${srcdir}/${subdir}/${testfile}.py]
+
+if {[build_executable "building" $testfile \
+	 [list $srcfile $srcfile2 $srcfile3]] == -1} {
+    return
+}
+
+# Run 'info types TYPENAME', expect to see an entry from FILENAME for
+# the line matching PATTERN.
+proc check_info_types { testfile typename filename pattern } {
+    with_test_prefix "$filename '$pattern'" {
+	clean_restart $testfile
+
+	set line_num [gdb_get_line_number $pattern $filename]
+	gdb_test "info types $typename" \
+	    "File \[^\r\n\]+/${filename}:(?:\r\n${::decimal}:\[^\r\n\]+)*\r\n${line_num}:\[^\r\n\]+.*"
+    }
+}
+
+# Start GDB with FILENAME, and examine some of the types.  This proc
+# might seem to be using clean_restart a little too much, but we need
+# to be really careful here.  As we examine one type, e.g. foo_t, this
+# might cause GDB to fully parse a CU, which then means examining
+# bar_t gives the expected result.  When, if we'd first looked for
+# bar_t, then (due to an index bug) we might not have found the
+# correct type definition.
+#
+# The only way we can be sure that an earlier test isn't going to
+# trigger CU expansion is to restart GDB before every query.
+proc run_test { filename } {
+    # Print all the types for which there is only one representation.
+    foreach type { foo_t bar_t baz_t } {
+	clean_restart $filename
+	gdb_test "ptype $type" \
+	    [multi_line \
+		 "type = struct $type {" \
+		 "\\s+int ${type}_1;" \
+		 "\\s+int ${type}_2;" \
+		 "}"]
+    }
+
+    # There are two different versions of woof_t.  For now, when using
+    # `ptype` GDB will just display the first one it finds, which could
+    # legitimately be either.
+    set woof_int_re [multi_line \
+			 "type = struct woof_t {" \
+			 "\\s+int woof_t_1;" \
+			 "\\s+int woof_t_2;" \
+			 "}"]
+    set woof_double_re [multi_line \
+			    "type = struct woof_t {" \
+			    "\\s+double woof_t_3;" \
+			    "\\s+double woof_t_4;" \
+			    "}"]
+    clean_restart $filename
+    gdb_test_multiple "ptype woof_t" "" {
+	-re -wrap $woof_int_re {
+	    pass $gdb_test_name
+	}
+	-re -wrap $woof_double_re {
+	    pass $gdb_test_name
+	}
+    }
+
+    # Check for declarations and definitions of some types.
+    check_info_types $filename foo_t $::srcfile2 "typedef struct foo_t"
+    check_info_types $filename foo_t $::srcfile4 "typedef struct foo_t foo_t;"
+    check_info_types $filename bar_t $::srcfile3 "typedef struct bar_t"
+    check_info_types $filename bar_t $::srcfile4 "typedef struct bar_t bar_t;"
+    check_info_types $filename baz_t $::srcfile4 "typedef struct baz_t"
+    check_info_types $filename baz_t $::srcfile4 "\} baz_t;"
+    check_info_types $filename woof_t $::srcfile2 "typedef struct woof_t"
+    check_info_types $filename woof_t $::srcfile3 "typedef struct woof_t"
+
+    # Use Python to look for type symbols.
+    if { [allow_python_tests] } {
+	foreach_with_prefix type { foo_t bar_t baz_t } {
+	    clean_restart $filename
+	    gdb_test_no_output "source $::pyfile" "import python scripts"
+	    gdb_test "py-show-type $type" \
+		[multi_line \
+		     "Looking for type '$type':" \
+		     "  Found 3 type symbols" \
+		     "    1: struct $type \\{ int ${type}_1; int ${type}_2; \\}" \
+		     "    2: struct $type \\{ int ${type}_1; int ${type}_2; \\}" \
+		     "    3: struct $type \\{ int ${type}_1; int ${type}_2; \\}"]
+	}
+
+	clean_restart $filename
+	gdb_test_no_output "source $::pyfile" "import python scripts"
+	gdb_test "py-show-type woof_t" \
+	    [multi_line \
+		 "Looking for type 'woof_t':" \
+		 "  Found 2 type symbols" \
+		 "    1: struct woof_t \\{ (?:int|double) woof_t_(?:1|3); (?:int|double) woof_t_(?:2|4); \\}" \
+		 "    2: struct woof_t \\{ (?:int|double) woof_t_(?:1|3); (?:int|double) woof_t_(?:2|4); \\}"]
+
+    }
+}
+
+with_test_prefix "no index" {
+    run_test $testfile
+}
+
+# The previous call to 'run_test' will have left GDB active.  Check if
+# BINFILE already has an index.  If it does then we must be running
+# with one of the boardfiles that adds an index.  We could possibly
+# try to remove the index, but for now, just don't run the following
+# parts which rely on adding an index.
+set index_type [get_index_type $binfile "check debug style"]
+if { $index_type ne "cooked" } {
+    unsupported "cannot test without a cooked index"
+    return
+}
+
+foreach_with_prefix index_type { gdb dwarf5 } {
+    set binfile_with_index ${binfile}-idx-${index_type}
+
+    remote_exec build "cp $binfile $binfile_with_index"
+
+    if { $index_type eq "gdb" } {
+	set style ""
+    } else {
+	set style "-dwarf-5"
+    }
+
+    if {[ensure_gdb_index $binfile_with_index $style] != 1} {
+	unsupported "couldn't add $index_type index"
+	return
+    }
+
+    run_test [file tail $binfile_with_index]
+}

gdb/testsuite/gdb.base/gdb-index-many-types.h

@@ -0,0 +1,42 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2025 Free Software Foundation, Inc.
+
+   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_INDEX_MANY_TYPES_H
+#define GDB_INDEX_MANY_TYPES_H
+
+typedef struct foo_t foo_t;
+typedef struct bar_t bar_t;
+
+extern void foo_func_a (foo_t *obj);
+extern void foo_func_b (foo_t *obj);
+extern void foo_func_c (foo_t *obj);
+
+extern void bar_func_a (bar_t *obj);
+extern void bar_func_b (bar_t *obj);
+extern void bar_func_c (bar_t *obj);
+
+typedef struct baz_t
+{
+  int baz_t_1;
+  int baz_t_2;
+} baz_t;
+
+extern void baz_func_a (baz_t *obj);
+extern void baz_func_b (baz_t *obj);
+extern void baz_func_c (baz_t *obj);
+
+#endif /* GDB_INDEX_MANY_TYPES_H */

gdb/testsuite/gdb.base/gdb-index-many-types.py

@@ -0,0 +1,54 @@
+# Copyright 2025 Free Software Foundation, Inc.
+#
+# 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/>.
+
+
+class TypeViewer(gdb.Command):
+    """A command which takes a string and looks up types with that name.
+
+    The types are expected to all be structs.  This command prints a
+    basic representation of the struct.  This is only going to work when
+    used with the types defined in the gdb-index-many-types test source
+    files."""
+
+    def __init__(self):
+        super().__init__("py-show-type", gdb.COMMAND_USER)
+
+    def invoke(self, args, from_tty):
+        argv = gdb.string_to_argv(args)
+        if argv[0] == "":
+            raise gdb.GdbError("missing argument")
+        print("Looking for type '" + argv[0] + "':")
+        syms = gdb.lookup_static_symbols(argv[0], gdb.SYMBOL_TYPE_DOMAIN)
+        count = len(syms)
+        print("  Found %d type symbol%s" % (count, "" if count == 1 else "s"))
+        for i, s in enumerate(syms, start=1):
+            t = s.type
+            if t is None:
+                print("    %d: No type." % i)
+            else:
+                fields = "struct " + argv[0] + " {"
+                try:
+                    for f in t.fields():
+                        if len(fields) > 0:
+                            fields = fields + " "
+                        fields = fields + "%s %s;" % (str(f.type), f.name)
+                except:
+                    pass
+                fields = fields + " }"
+
+                print("    %d: %s" % (i, fields))
+
+
+TypeViewer()

gdb/testsuite/gdb.base/gold-gdb-index.exp

@@ -1,51 +0,0 @@
-# Copyright 2020-2025 Free Software Foundation, Inc.
-
-# 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/>.  */
-
-# This tests the gdb workaround for PR binutils/15646.
-
-standard_testfile .c gold-gdb-index-2.c
-
-if { [have_fuse_ld_gold] == 0} {
-    return -1
-}
-
-if {[prepare_for_testing "failed to prepare" $testfile "$srcfile $srcfile2" \
-	 {debug c++ additional_flags=-fuse-ld=gold \
-	      ldflags=-Wl,--gdb-index \
-	      additional_flags=-ggnu-pubnames}]} {
-    return -1
-}
-
-if { [have_index $binfile] != "gdb_index" } {
-    return -1
-}
-
-if {![runto_main]} {
-    return 0
-}
-
-gdb_test_no_output "nosharedlibrary"
-
-gdb_test_no_output "set breakpoint pending off"
-gdb_test "break N1::misspelled" "Function \"N1::misspelled\" not defined\."
-
-gdb_test_multiple "maint info symtabs" "" {
-    -re -wrap "\{ symtab \[^\r\n\]*gold-gdb-index-2.c.*" {
-	fail $gdb_test_name
-    }
-    -re -wrap "" {
-	pass $gdb_test_name
-    }
-}