gdb: rewrite how per language primitive types are managed

Consider the following GDB session:

  $ gdb
  (gdb) set language c
  (gdb) ptype void
  type = void
  (gdb) set language fortran
  (gdb) ptype void
  No symbol table is loaded.  Use the "file" command.
  (gdb)

With no symbol file loaded GDB and the language set to C GDB knows
about the type void, while when the language is set to Fortran GDB
doesn't know about the void, why is that?

In f-lang.c, f_language::language_arch_info, we do have this line:

  lai->primitive_type_vector [f_primitive_type_void]
    = builtin->builtin_void;

where we add the void type to the list of primitive types that GDB
should always know about, so what's going wrong?

It turns out that the primitive types are stored in a C style array,
indexed by an enum, so Fortran uses `enum f_primitive_types'.  The
array is allocated and populated in each languages language_arch_info
member function.  The array is allocated with an extra entry at the
end which is left as a NULL value, and this indicates the end of the
array of types.

Unfortunately for Fortran, a type is not assigned for each element in
the enum.  As a result the final populated array has gaps in it, gaps
which are initialised to NULL, and so every time we iterate over the
list (for Fortran) we stop early, and never reach the void type.

This has been the case since 2007 when this functionality was added to
GDB in commit cad351d11d6c3f6487cd.

Obviously I could just fix Fortran by ensuring that either the enum is
trimmed, or we create types for the missing types.  However, I think a
better approach would be to move to C++ data structures and removed
the fixed enum indexing into the array approach.

After this commit the primitive types are pushed into a vector, and
GDB just iterates over the vector in the obvious way when it needs to
hunt for a type.  After this commit all the currently defined
primitive types can be found when the language is set to Fortran, for
example:

  $ gdb
  (gdb) set language fortran
  (gdb) ptype void
  type = void
  (gdb)

A new test checks this functionality.

I didn't see any other languages with similar issues, but I could have
missed something.

gdb/ChangeLog:

	* ada-exp.y (find_primitive_type): Make parameter const.
	* ada-lang.c (enum ada_primitive_types): Delete.
	(ada_language::language_arch_info): Update.
	* c-lang.c (enum c_primitive_types): Delete.
	(c_language_arch_info): Update.
	(enum cplus_primitive_types): Delete.
	(cplus_language::language_arch_info): Update.
	* d-lang.c (enum d_primitive_types): Delete.
	(d_language::language_arch_info): Update.
	* f-lang.c (enum f_primitive_types): Delete.
	(f_language::language_arch_info): Update.
	* go-lang.c (enum go_primitive_types): Delete.
	(go_language::language_arch_info): Update.
	* language.c (auto_or_unknown_language::language_arch_info):
	Update.
	(language_gdbarch_post_init): Use obstack_new, use array indexing.
	(language_string_char_type): Add header comment, call function in
	language_arch_info.
	(language_bool_type): Likewise
	(language_arch_info::bool_type): Define.
	(language_lookup_primitive_type_1): Delete.
	(language_lookup_primitive_type): Rewrite as a templated function
	to call function in language_arch_info, then instantiate twice.
	(language_arch_info::type_and_symbol::alloc_type_symbol): Define.
	(language_arch_info::lookup_primitive_type_and_symbol): Define.
	(language_arch_info::lookup_primitive_type): Define twice with
	different signatures.
	(language_arch_info::lookup_primitive_type_as_symbol): Define.
	(language_lookup_primitive_type_as_symbol): Rewrite to call a
	member function in language_arch_info.
	* language.h (language_arch_info): Complete rewrite.
	(language_lookup_primitive_type): Make templated.
	* m2-lang.c (enum m2_primitive_types): Delete.
	(m2_language::language_arch_info): Update.
	* opencl-lang.c (OCL_P_TYPE): Delete.
	(enum opencl_primitive_types): Delete.
	(opencl_type_data): Delete.
	(builtin_opencl_type): Delete.
	(lookup_opencl_vector_type): Update.
	(opencl_language::language_arch_info): Update, lots of content
	moved from...
	(build_opencl_types): ...here.  This function is now deleted.
	(_initialize_opencl_language): Delete.
	* p-lang.c (enum pascal_primitive_types): Delete.
	(pascal_language::language_arch_info): Update.
	* rust-lang.c (enum rust_primitive_types): Delete.
	(rust_language::language_arch_info): Update.

gdb/testsuite/ChangeLog:

	* gdb.fortran/types.exp: Add more tests.

1 files changed, 105 insertions, 100 deletions

diff --git a/gdb/language.c b/gdb/language.c
index 1a0e20e..579cf91 100644
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -797,10 +797,8 @@ public:
   void language_arch_info (struct gdbarch *gdbarch,
 			   struct language_arch_info *lai) const override
   {
-    lai->string_char_type = builtin_type (gdbarch)->builtin_char;
-    lai->bool_type_default = builtin_type (gdbarch)->builtin_int;
-    lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
-						       struct type *);
+    lai->set_string_char_type (builtin_type (gdbarch)->builtin_char);
+    lai->set_bool_type (builtin_type (gdbarch)->builtin_int);
   }
 
   /* See language.h.  */
@@ -985,102 +983,71 @@ struct language_gdbarch
 static void *
 language_gdbarch_post_init (struct gdbarch *gdbarch)
 {
-  struct language_gdbarch *l;
-
-  l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
+  struct language_gdbarch *l
+    = obstack_new<struct language_gdbarch> (gdbarch_obstack (gdbarch));
   for (const auto &lang : language_defn::languages)
     {
       gdb_assert (lang != nullptr);
-      lang->language_arch_info (gdbarch,
-				l->arch_info + lang->la_language);
+      lang->language_arch_info (gdbarch, &l->arch_info[lang->la_language]);
     }
 
   return l;
 }
 
+/* See language.h.  */
+
 struct type *
 language_string_char_type (const struct language_defn *la,
 			   struct gdbarch *gdbarch)
 {
   struct language_gdbarch *ld
     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
-
-  return ld->arch_info[la->la_language].string_char_type;
+  return ld->arch_info[la->la_language].string_char_type ();
 }
 
+/* See language.h.  */
+
 struct type *
 language_bool_type (const struct language_defn *la,
 		    struct gdbarch *gdbarch)
 {
   struct language_gdbarch *ld
     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
+  return ld->arch_info[la->la_language].bool_type ();
+}
+
+/* See language.h.  */
 
-  if (ld->arch_info[la->la_language].bool_type_symbol)
+struct type *
+language_arch_info::bool_type () const
+{
+  if (m_bool_type_name != nullptr)
     {
       struct symbol *sym;
 
-      sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
-			   NULL, VAR_DOMAIN, NULL).symbol;
-      if (sym)
+      sym = lookup_symbol (m_bool_type_name, NULL, VAR_DOMAIN, NULL).symbol;
+      if (sym != nullptr)
 	{
 	  struct type *type = SYMBOL_TYPE (sym);
-
-	  if (type && type->code () == TYPE_CODE_BOOL)
+	  if (type != nullptr && type->code () == TYPE_CODE_BOOL)
 	    return type;
 	}
     }
 
-  return ld->arch_info[la->la_language].bool_type_default;
-}
-
-/* Helper function for primitive type lookup.  */
-
-static struct type **
-language_lookup_primitive_type_1 (const struct language_arch_info *lai,
-				  const char *name)
-{
-  struct type **p;
-
-  for (p = lai->primitive_type_vector; (*p) != NULL; p++)
-    {
-      if (strcmp ((*p)->name (), name) == 0)
-	return p;
-    }
-  return NULL;
+  return m_bool_type_default;
 }
 
 /* See language.h.  */
 
-struct type *
-language_lookup_primitive_type (const struct language_defn *la,
-				struct gdbarch *gdbarch,
-				const char *name)
-{
-  struct language_gdbarch *ld =
-    (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
-  struct type **typep;
-
-  typep = language_lookup_primitive_type_1 (&ld->arch_info[la->la_language],
-					    name);
-  if (typep == NULL)
-    return NULL;
-  return *typep;
-}
-
-/* Helper function for type lookup as a symbol.
-   Create the symbol corresponding to type TYPE in language LANG.  */
-
-static struct symbol *
-language_alloc_type_symbol (enum language lang, struct type *type)
+struct symbol *
+language_arch_info::type_and_symbol::alloc_type_symbol
+	(enum language lang, struct type *type)
 {
   struct symbol *symbol;
   struct gdbarch *gdbarch;
-
   gdb_assert (!TYPE_OBJFILE_OWNED (type));
-
   gdbarch = TYPE_OWNER (type).gdbarch;
   symbol = new (gdbarch_obstack (gdbarch)) struct symbol ();
-
   symbol->m_name = type->name ();
   symbol->set_language (lang, nullptr);
   symbol->owner.arch = gdbarch;
@@ -1089,41 +1056,88 @@ language_alloc_type_symbol (enum language lang, struct type *type)
   SYMBOL_TYPE (symbol) = type;
   SYMBOL_DOMAIN (symbol) = VAR_DOMAIN;
   SYMBOL_ACLASS_INDEX (symbol) = LOC_TYPEDEF;
-
   return symbol;
 }
 
-/* Initialize the primitive type symbols of language LD.
-   The primitive type vector must have already been initialized.  */
+/* See language.h.  */
 
-static void
-language_init_primitive_type_symbols (struct language_arch_info *lai,
-				      const struct language_defn *la,
-				      struct gdbarch *gdbarch)
+language_arch_info::type_and_symbol *
+language_arch_info::lookup_primitive_type_and_symbol (const char *name)
 {
-  int n;
+  for (struct type_and_symbol &tas : primitive_types_and_symbols)
+    {
+      if (strcmp (tas.type ()->name (), name) == 0)
+	return &tas;
+    }
 
-  gdb_assert (lai->primitive_type_vector != NULL);
+  return nullptr;
+}
+
+/* See language.h.  */
 
-  for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
-    continue;
+struct type *
+language_arch_info::lookup_primitive_type (const char *name)
+{
+  type_and_symbol *tas = lookup_primitive_type_and_symbol (name);
+  if (tas != nullptr)
+    return tas->type ();
+  return nullptr;
+}
 
-  lai->primitive_type_symbols
-    = GDBARCH_OBSTACK_CALLOC (gdbarch, n + 1, struct symbol *);
+/* See language.h.  */
 
-  for (n = 0; lai->primitive_type_vector[n] != NULL; ++n)
+struct type *
+language_arch_info::lookup_primitive_type
+	(std::function<bool (struct type *)> filter)
+{
+  for (struct type_and_symbol &tas : primitive_types_and_symbols)
     {
-      lai->primitive_type_symbols[n]
-	= language_alloc_type_symbol (la->la_language,
-				      lai->primitive_type_vector[n]);
+      if (filter (tas.type ()))
+	return tas.type ();
     }
 
-  /* Note: The result of symbol lookup is normally a symbol *and* the block
-     it was found in.  Builtin types don't live in blocks.  We *could* give
-     them one, but there is no current need so to keep things simple symbol
-     lookup is extended to allow for BLOCK_FOUND to be NULL.  */
+  return nullptr;
+}
+
+/* See language.h.  */
+
+struct symbol *
+language_arch_info::lookup_primitive_type_as_symbol (const char *name,
+						     enum language lang)
+{
+  type_and_symbol *tas = lookup_primitive_type_and_symbol (name);
+  if (tas != nullptr)
+    return tas->symbol (lang);
+  return nullptr;
+}
+
+/* See language.h.  */
+
+template<typename T>
+struct type *
+language_lookup_primitive_type (const struct language_defn *la,
+				struct gdbarch *gdbarch,
+				T arg)
+{
+  struct language_gdbarch *ld =
+    (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
+  return ld->arch_info[la->la_language].lookup_primitive_type (arg);
 }
 
+/* Template instantiation.  */
+
+template struct type *
+language_lookup_primitive_type (const struct language_defn *la,
+				struct gdbarch *gdbarch,
+				const char *arg);
+
+/* Template instantiation.  */
+
+template struct type *
+language_lookup_primitive_type (const struct language_defn *la,
+				struct gdbarch *gdbarch,
+				std::function<bool (struct type *)> arg);
+
 /* See language.h.  */
 
 struct symbol *
@@ -1134,33 +1148,24 @@ language_lookup_primitive_type_as_symbol (const struct language_defn *la,
   struct language_gdbarch *ld
     = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
   struct language_arch_info *lai = &ld->arch_info[la->la_language];
-  struct type **typep;
-  struct symbol *sym;
 
   if (symbol_lookup_debug)
-    {
-      fprintf_unfiltered (gdb_stdlog,
-			  "language_lookup_primitive_type_as_symbol"
-			  " (%s, %s, %s)",
-			  la->name (), host_address_to_string (gdbarch), name);
-    }
-
-  typep = language_lookup_primitive_type_1 (lai, name);
-  if (typep == NULL)
-    {
-      if (symbol_lookup_debug)
-	fprintf_unfiltered (gdb_stdlog, " = NULL\n");
-      return NULL;
-    }
-
-  /* The set of symbols is lazily initialized.  */
-  if (lai->primitive_type_symbols == NULL)
-    language_init_primitive_type_symbols (lai, la, gdbarch);
+    fprintf_unfiltered (gdb_stdlog,
+			"language_lookup_primitive_type_as_symbol"
+			" (%s, %s, %s)",
+			la->name (), host_address_to_string (gdbarch), name);
 
-  sym = lai->primitive_type_symbols[typep - lai->primitive_type_vector];
+  struct symbol *sym
+    = lai->lookup_primitive_type_as_symbol (name, la->la_language);
 
   if (symbol_lookup_debug)
     fprintf_unfiltered (gdb_stdlog, " = %s\n", host_address_to_string (sym));
+
+  /* Note: The result of symbol lookup is normally a symbol *and* the block
+     it was found in.  Builtin types don't live in blocks.  We *could* give
+     them one, but there is no current need so to keep things simple symbol
+     lookup is extended to allow for BLOCK_FOUND to be NULL.  */
+
   return sym;
 }