Remove symbol_matches_domain. This fixes

[deliverable/binutils-gdb.git] / gdb / ada-lang.c

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index e268ebad3aad98ecb1438f037b870cb61b075d61..279c20eee8f0f3a159aee2019b7dd4066a4b5a67 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -4391,6 +4391,20 @@ ada_clear_symbol_cache (void)
   ada_init_symbol_cache (sym_cache);
 }
 
+/* STRUCT_DOMAIN symbols are also typedefs for the type.  This function tests
+   the equivalency of two Ada symbol domain types.  */
+
+static int
+ada_symbol_matches_domain (domain_enum symbol_domain, domain_enum domain)
+{
+  if (symbol_domain == domain
+      || ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
+         && symbol_domain == STRUCT_DOMAIN))
+    return 1;
+
+  return 0;
+}
+
 /* Search our cache for an entry matching NAME and NAMESPACE.
    Return it if found, or NULL otherwise.  */
 
@@ -4492,6 +4506,13 @@ standard_lookup (const char *name, const struct block *block,
   if (lookup_cached_symbol (name, domain, &sym, NULL))
     return sym;
   sym = lookup_symbol_in_language (name, block, domain, language_c, 0);
+
+  /* STRUCT_DOMAIN symbols also define a typedef for the type.  Lookup
+     a STRUCT_DOMAIN symbol if one is requested for VAR_DOMAIN and not
+     found.  */
+  if (sym == NULL && domain == VAR_DOMAIN)
+    sym = lookup_symbol_in_language (name, block, STRUCT_DOMAIN, language_c, 0);
+
   cache_symbol (name, domain, sym, block_found);
   return sym;
 }
@@ -5317,13 +5338,29 @@ add_nonlocal_symbols (struct obstack *obstackp, const char *name,
       data.objfile = objfile;
 
       if (is_wild_match)
-       objfile->sf->qf->map_matching_symbols (objfile, name, domain, global,
-                                              aux_add_nonlocal_symbols, &data,
-                                              wild_match, NULL);
+       {
+         objfile->sf->qf->map_matching_symbols (objfile, name, domain, global,
+                                                aux_add_nonlocal_symbols,
+                                                &data, wild_match, NULL);
+         if (domain == VAR_DOMAIN)
+           objfile->sf->qf->map_matching_symbols (objfile, name,
+                                                  STRUCT_DOMAIN, global,
+                                                  aux_add_nonlocal_symbols,
+                                                  &data, wild_match, NULL);
+       }
       else
-       objfile->sf->qf->map_matching_symbols (objfile, name, domain, global,
-                                              aux_add_nonlocal_symbols, &data,
-                                              full_match, compare_names);
+       {
+         objfile->sf->qf->map_matching_symbols (objfile, name, domain, global,
+                                                aux_add_nonlocal_symbols,
+                                                &data, full_match,
+                                                compare_names);
+         if (domain == VAR_DOMAIN)
+           objfile->sf->qf->map_matching_symbols (objfile, name,
+                                                  STRUCT_DOMAIN, global,
+                                                  aux_add_nonlocal_symbols,
+                                                  &data, full_match,
+                                                  compare_names);
+       }
     }
 
   if (num_defns_collected (obstackp) == 0 && global && !is_wild_match)
@@ -5847,8 +5884,7 @@ ada_add_block_symbols (struct obstack *obstackp,
       for (sym = block_iter_match_first (block, name, wild_match, &iter);
           sym != NULL; sym = block_iter_match_next (name, wild_match, &iter))
       {
-        if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-                                   SYMBOL_DOMAIN (sym), domain)
+        if (ada_symbol_matches_domain (SYMBOL_DOMAIN (sym), domain)
             && wild_match (SYMBOL_LINKAGE_NAME (sym), name) == 0)
           {
            if (SYMBOL_CLASS (sym) == LOC_UNRESOLVED)
@@ -5870,8 +5906,7 @@ ada_add_block_symbols (struct obstack *obstackp,
      for (sym = block_iter_match_first (block, name, full_match, &iter);
          sym != NULL; sym = block_iter_match_next (name, full_match, &iter))
       {
-        if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-                                   SYMBOL_DOMAIN (sym), domain))
+        if (ada_symbol_matches_domain (SYMBOL_DOMAIN (sym), domain))
           {
            if (SYMBOL_CLASS (sym) != LOC_UNRESOLVED)
              {
@@ -5903,8 +5938,7 @@ ada_add_block_symbols (struct obstack *obstackp,
 
       ALL_BLOCK_SYMBOLS (block, iter, sym)
       {
-        if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-                                   SYMBOL_DOMAIN (sym), domain))
+        if (ada_symbol_matches_domain (SYMBOL_DOMAIN (sym), domain))
           {
             int cmp;
 
@@ -7488,11 +7522,12 @@ ada_find_any_type_symbol (const char *name)
   struct symbol *sym;
 
   sym = standard_lookup (name, get_selected_block (NULL), VAR_DOMAIN);
-  if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+  if (sym != NULL
+      && (SYMBOL_DOMAIN (sym) != VAR_DOMAIN
+         || SYMBOL_CLASS (sym) == LOC_TYPEDEF))
     return sym;
 
-  sym = standard_lookup (name, NULL, STRUCT_DOMAIN);
-  return sym;
+  return NULL;
 }
 
 /* Find a type named NAME.  Ignores ambiguity.  This routine will look