From b50c861487bb7d71185777193a9246bac81e4f26 Mon Sep 17 00:00:00 2001 From: Keith Seitz Date: Mon, 14 Apr 2014 15:47:15 -0700 Subject: Remove symbol_matches_domain. This fixes PR c++/16253. symbol_matches_domain was permitting searches for a VAR_DOMAIN symbol to also match STRUCT_DOMAIN symbols for languages like C++ where STRUCT_DOMAIN symbols also define a typedef of the same name, e.g., "struct foo {}" introduces a typedef of the name "foo". Problems occur if there exists both a VAR_DOMAIN and STRUCT_DOMAIN symbol of the same name. Then it is essentially a race between which symbol is found first. The other symbol is obscurred. [This is a relatively common idiom: enum e { ... } e;] This patchset moves this "language defines a typedef" logic to lookup_symbol[_in_language], looking first for a symbol in the given domain and falling back to searching STRUCT_DOMAIN when/if appropriate. 2014-04-14 Keith Seitz PR c++/16253 * ada-lang.c (ada_symbol_matches_domain): Moved here and renamed from symbol_matches_domain in symtab.c. All local callers of symbol_matches_domain updated. (standard_lookup): If DOMAIN is VAR_DOMAIN and no symbol is found, search STRUCT_DOMAIN. (ada_find_any_type_symbol): Do not search STRUCT_DOMAIN independently. standard_lookup will do that automatically. * cp-namespace.c (cp_lookup_symbol_nonlocal): Explain when/why VAR_DOMAIN searches may return a STRUCT_DOMAIN match. (cp_lookup_symbol_in_namespace): Likewise. If no VAR_DOMAIN symbol is found, search STRUCT_DOMAIN. (cp_lookup_symbol_exports): Explain when/why VAR_DOMAIN searches may return a STRUCT_DOMAIN match. (lookup_symbol_file): Search for the class name in STRUCT_DOMAIN. * cp-support.c: Include language.h. (inspect_type): Explicitly search STRUCT_DOMAIN before searching VAR_DOMAIN. * psymtab.c (match_partial_symbol): Compare the requested domain with the symbol's domain directly. (lookup_partial_symbol): Likewise. * symtab.c (lookup_symbol_in_language): Explain when/why VAR_DOMAIN searches may return a STRUCT_DOMAIN match. If no VAR_DOMAIN symbol is found, search STRUCT_DOMAIN for appropriate languages. (symbol_matches_domain): Renamed `ada_symbol_matches_domain' and moved to ada-lang.c (lookup_block_symbol): Explain that this function only returns symbol matching the requested DOMAIN. Compare the requested domain with the symbol's domain directly. (iterate_over_symbols): Compare the requested domain with the symbol's domain directly. * symtab.h (symbol_matches_domain): Remove. 2014-04-14 Keith Seitz PR c++/16253 * gdb.cp/var-tag.cc: New file. * gdb.cp/var-tag.exp: New file. * gdb.dwarf2/dw2-ada-ffffffff.exp: Set the language to C++. * gdb.dwarf2/dw2-anon-mptr.exp: Likewise. * gdb.dwarf2/dw2-double-set-die-type.exp: Likewise. * gdb.dwarf2/dw2-inheritance.exp: Likewise. --- gdb/ada-lang.c | 65 ++++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 50 insertions(+), 15 deletions(-) (limited to 'gdb/ada-lang.c') diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index e268eba..279c20e 100644 --- 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 -- cgit v1.1