Remove symbol_matches_domain. This fixes

[deliverable/binutils-gdb.git] / gdb / symtab.c

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 66d16247ee262fadb1b2aeb37af85c2218eb60e5..15ac3d1dceab07838f9db4a69fe1947bb84f4806 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1310,7 +1310,11 @@ demangle_for_lookup (const char *name, enum language lang,
    NAME is a field of the current implied argument `this'.  If so set
    *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
    BLOCK_FOUND is set to the block in which NAME is found (in the case of
-   a field of `this', value_of_this sets BLOCK_FOUND to the proper value.)  */
+   a field of `this', value_of_this sets BLOCK_FOUND to the proper value.)
+
+   If DOMAIN is VAR_DOMAIN and the language permits using tag names for
+   elaborated types, such as classes in C++, this function will search
+   STRUCT_DOMAIN if no matching is found.  */
 
 /* This function (or rather its subordinates) have a bunch of loops and
    it would seem to be attractive to put in some QUIT's (though I'm not really
@@ -1333,6 +1337,23 @@ lookup_symbol_in_language (const char *name, const struct block *block,
 
   returnval = lookup_symbol_aux (modified_name, block, domain, lang,
                                 is_a_field_of_this);
+  if (returnval == NULL)
+    {
+      if (is_a_field_of_this != NULL
+         && is_a_field_of_this->type != NULL)
+       return NULL;
+
+      /* Some languages define typedefs of a type equal to its tag name,
+        e.g., in C++, "struct foo { ... }" also defines a typedef for
+        "foo".  */
+      if (domain == VAR_DOMAIN
+         && (lang == language_cplus || lang == language_java
+             || lang == language_ada || lang == language_d))
+       {
+         returnval = lookup_symbol_aux (modified_name, block, STRUCT_DOMAIN,
+                                        lang, is_a_field_of_this);
+       }
+    }
   do_cleanups (cleanup);
 
   return returnval;
@@ -1907,27 +1928,6 @@ lookup_symbol_global (const char *name,
   return lookup_data.result;
 }
 
-int
-symbol_matches_domain (enum language symbol_language,
-                      domain_enum symbol_domain,
-                      domain_enum domain)
-{
-  /* For C++ "struct foo { ... }" also defines a typedef for "foo".
-     A Java class declaration also defines a typedef for the class.
-     Similarly, any Ada type declaration implicitly defines a typedef.  */
-  if (symbol_language == language_cplus
-      || symbol_language == language_d
-      || symbol_language == language_java
-      || symbol_language == language_ada)
-    {
-      if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
-         && symbol_domain == STRUCT_DOMAIN)
-       return 1;
-    }
-  /* For all other languages, strict match is required.  */
-  return (symbol_domain == domain);
-}
-
 /* Look up a type named NAME in the struct_domain.  The type returned
    must not be opaque -- i.e., must have at least one field
    defined.  */
@@ -2050,7 +2050,12 @@ basic_lookup_transparent_type (const char *name)
    binary search terminates, we drop through and do a straight linear
    search on the symbols.  Each symbol which is marked as being a ObjC/C++
    symbol (language_cplus or language_objc set) has both the encoded and
-   non-encoded names tested for a match.  */
+   non-encoded names tested for a match.
+
+   This function specifically disallows domain mismatches.  If a language
+   defines a typedef for an elaborated type, such as classes in C++,
+   then this function will need to be called twice, once to search
+   VAR_DOMAIN and once to search STRUCT_DOMAIN.  */
 
 struct symbol *
 lookup_block_symbol (const struct block *block, const char *name,
@@ -2065,8 +2070,7 @@ lookup_block_symbol (const struct block *block, const char *name,
           sym != NULL;
           sym = block_iter_name_next (name, &iter))
        {
-         if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-                                    SYMBOL_DOMAIN (sym), domain))
+         if (SYMBOL_DOMAIN (sym) == domain)
            return sym;
        }
       return NULL;
@@ -2085,8 +2089,7 @@ lookup_block_symbol (const struct block *block, const char *name,
           sym != NULL;
           sym = block_iter_name_next (name, &iter))
        {
-         if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-                                    SYMBOL_DOMAIN (sym), domain))
+         if (SYMBOL_DOMAIN (sym) == domain)
            {
              sym_found = sym;
              if (!SYMBOL_IS_ARGUMENT (sym))
@@ -2120,8 +2123,7 @@ iterate_over_symbols (const struct block *block, const char *name,
        sym != NULL;
        sym = block_iter_name_next (name, &iter))
     {
-      if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-                                SYMBOL_DOMAIN (sym), domain))
+      if (SYMBOL_DOMAIN (sym) == domain)
        {
          if (!callback (sym, data))
            return;