1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2003-2015 Free Software Foundation, Inc.
4 Contributed by David Carlton and by Kealia, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "cp-support.h"
23 #include "gdb_obstack.h"
29 #include "dictionary.h"
34 #include "namespace.h"
36 static struct block_symbol
37 cp_lookup_nested_symbol_1 (struct type *container_type,
38 const char *nested_name,
39 const char *concatenated_name,
40 const struct block *block,
41 const domain_enum domain,
42 int basic_lookup, int is_in_anonymous);
44 static struct type *cp_lookup_transparent_type_loop (const char *name,
48 /* Check to see if SYMBOL refers to an object contained within an
49 anonymous namespace; if so, add an appropriate using directive. */
52 cp_scan_for_anonymous_namespaces (const struct symbol *const symbol,
53 struct objfile *const objfile)
55 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
57 const char *name = SYMBOL_DEMANGLED_NAME (symbol);
58 unsigned int previous_component;
59 unsigned int next_component;
61 /* Start with a quick-and-dirty check for mention of "(anonymous
64 if (!cp_is_in_anonymous (name))
67 previous_component = 0;
68 next_component = cp_find_first_component (name + previous_component);
70 while (name[next_component] == ':')
72 if (((next_component - previous_component)
73 == CP_ANONYMOUS_NAMESPACE_LEN)
74 && strncmp (name + previous_component,
75 CP_ANONYMOUS_NAMESPACE_STR,
76 CP_ANONYMOUS_NAMESPACE_LEN) == 0)
78 int dest_len = (previous_component == 0
79 ? 0 : previous_component - 2);
80 int src_len = next_component;
82 char *dest = (char *) alloca (dest_len + 1);
83 char *src = (char *) alloca (src_len + 1);
85 memcpy (dest, name, dest_len);
86 memcpy (src, name, src_len);
88 dest[dest_len] = '\0';
91 /* We've found a component of the name that's an
92 anonymous namespace. So add symbols in it to the
93 namespace given by the previous component if there is
94 one, or to the global namespace if there isn't. */
95 add_using_directive (&local_using_directives,
96 dest, src, NULL, NULL, NULL, 1,
97 &objfile->objfile_obstack);
99 /* The "+ 2" is for the "::". */
100 previous_component = next_component + 2;
101 next_component = (previous_component
102 + cp_find_first_component (name
103 + previous_component));
108 /* Test whether or not NAMESPACE looks like it mentions an anonymous
109 namespace; return nonzero if so. */
112 cp_is_in_anonymous (const char *symbol_name)
114 return (strstr (symbol_name, CP_ANONYMOUS_NAMESPACE_STR)
118 /* Look up NAME in DOMAIN in BLOCK's static block and in global blocks.
119 If IS_IN_ANONYMOUS is nonzero, the symbol in question is located
120 within an anonymous namespace. */
122 static struct block_symbol
123 cp_basic_lookup_symbol (const char *name, const struct block *block,
124 const domain_enum domain, int is_in_anonymous)
126 struct block_symbol sym;
128 sym = lookup_symbol_in_static_block (name, block, domain);
129 if (sym.symbol != NULL)
134 /* Symbols defined in anonymous namespaces have external linkage
135 but should be treated as local to a single file nonetheless.
136 So we only search the current file's global block. */
138 const struct block *global_block = block_global_block (block);
140 if (global_block != NULL)
142 sym.symbol = lookup_symbol_in_block (name, global_block, domain);
143 sym.block = global_block;
147 sym = lookup_global_symbol (name, block, domain);
152 /* Search bare symbol NAME in DOMAIN in BLOCK.
153 NAME is guaranteed to not have any scope (no "::") in its name, though
154 if for example NAME is a template spec then "::" may appear in the
156 If LANGDEF is non-NULL then try to lookup NAME as a primitive type in
157 that language. Normally we wouldn't need LANGDEF but fortran also uses
159 If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
160 if so then also search for NAME in that class. */
162 static struct block_symbol
163 cp_lookup_bare_symbol (const struct language_defn *langdef,
164 const char *name, const struct block *block,
165 const domain_enum domain, int search)
167 struct block_symbol sym;
169 /* Note: We can't do a simple assert for ':' not being in NAME because
170 ':' may be in the args of a template spec. This isn't intended to be
171 a complete test, just cheap and documentary. */
172 if (strchr (name, '<') == NULL && strchr (name, '(') == NULL)
173 gdb_assert (strchr (name, ':') == NULL);
175 sym = lookup_symbol_in_static_block (name, block, domain);
176 if (sym.symbol != NULL)
179 /* If we didn't find a definition for a builtin type in the static block,
180 search for it now. This is actually the right thing to do and can be
181 a massive performance win. E.g., when debugging a program with lots of
182 shared libraries we could search all of them only to find out the
183 builtin type isn't defined in any of them. This is common for types
185 if (langdef != NULL && domain == VAR_DOMAIN)
187 struct gdbarch *gdbarch;
190 gdbarch = target_gdbarch ();
192 gdbarch = block_gdbarch (block);
194 = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
196 if (sym.symbol != NULL)
200 sym = lookup_global_symbol (name, block, domain);
201 if (sym.symbol != NULL)
206 struct block_symbol lang_this;
209 lang_this = lookup_language_this (language_def (language_cplus), block);
210 if (lang_this.symbol == NULL)
211 return null_block_symbol;
213 type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
214 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
215 This can happen for lambda functions compiled with clang++,
216 which outputs no name for the container class. */
217 if (TYPE_NAME (type) == NULL)
218 return null_block_symbol;
220 /* Look for symbol NAME in this class. */
221 sym = cp_lookup_nested_symbol (type, name, block, domain);
227 /* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
228 BLOCK specifies the context in which to perform the search.
229 NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
230 the length of the entire scope of NAME (up to, but not including, the last
233 Note: At least in the case of Fortran, which also uses this code, there
234 may be no text after the last "::". */
236 static struct block_symbol
237 cp_search_static_and_baseclasses (const char *name,
238 const struct block *block,
239 const domain_enum domain,
240 unsigned int prefix_len,
243 struct block_symbol sym;
244 char *klass, *nested;
245 struct cleanup *cleanup;
246 struct block_symbol klass_sym;
247 struct type *klass_type;
249 /* The test here uses <= instead of < because Fortran also uses this,
250 and the module.exp testcase will pass "modmany::" for NAME here. */
251 gdb_assert (prefix_len + 2 <= strlen (name));
252 gdb_assert (name[prefix_len + 1] == ':');
254 /* Find the name of the class and the name of the method, variable, etc. */
256 /* The class name is everything up to and including PREFIX_LEN. */
257 klass = savestring (name, prefix_len);
259 /* The rest of the name is everything else past the initial scope
261 nested = xstrdup (name + prefix_len + 2);
263 /* Add cleanups to free memory for these strings. */
264 cleanup = make_cleanup (xfree, klass);
265 make_cleanup (xfree, nested);
267 /* Lookup a class named KLASS. If none is found, there is nothing
268 more that can be done. KLASS could be a namespace, so always look
269 in VAR_DOMAIN. This works for classes too because of
270 symbol_matches_domain (which should be replaced with something else,
271 but it's what we have today). */
272 klass_sym = lookup_global_symbol (klass, block, VAR_DOMAIN);
273 if (klass_sym.symbol == NULL)
275 do_cleanups (cleanup);
276 return null_block_symbol;
278 klass_type = SYMBOL_TYPE (klass_sym.symbol);
280 /* Look for a symbol named NESTED in this class.
281 The caller is assumed to have already have done a basic lookup of NAME.
282 So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here. */
283 sym = cp_lookup_nested_symbol_1 (klass_type, nested, name, block, domain,
286 do_cleanups (cleanup);
290 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
291 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
292 through base classes for a matching symbol.
294 Note: Part of the complexity is because NAME may itself specify scope.
295 Part of the complexity is also because this handles the case where
296 there is no scoping in which case we also try looking in the class of
297 "this" if we can compute it. */
299 static struct block_symbol
300 cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
301 const struct block *block,
302 const domain_enum domain, int search)
304 char *concatenated_name = NULL;
306 unsigned int prefix_len;
307 struct block_symbol sym;
309 if (the_namespace[0] != '\0')
312 = (char *) alloca (strlen (the_namespace) + 2 + strlen (name) + 1);
313 strcpy (concatenated_name, the_namespace);
314 strcat (concatenated_name, "::");
315 strcat (concatenated_name, name);
316 name = concatenated_name;
319 prefix_len = cp_entire_prefix_len (name);
321 return cp_lookup_bare_symbol (NULL, name, block, domain, search);
323 /* This would be simpler if we just called cp_lookup_nested_symbol
324 at this point. But that would require first looking up the containing
325 class/namespace. Since we're only searching static and global blocks
326 there's often no need to first do that lookup. */
329 = the_namespace[0] != '\0' && cp_is_in_anonymous (the_namespace);
330 sym = cp_basic_lookup_symbol (name, block, domain, is_in_anonymous);
331 if (sym.symbol != NULL)
335 sym = cp_search_static_and_baseclasses (name, block, domain, prefix_len,
341 /* Used for cleanups to reset the "searched" flag in case of an error. */
344 reset_directive_searched (void *data)
346 struct using_direct *direct = (struct using_direct *) data;
347 direct->searched = 0;
350 /* Search for NAME by applying all import statements belonging to
351 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
352 search is restricted to using declarations.
360 If SEARCH_PARENTS the search will include imports which are
361 applicable in parents of SCOPE.
371 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
372 namespaces X and Y will be considered. If SEARCH_PARENTS is false
373 only the import of Y is considered.
375 SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
376 pass 0 for it. Internally we pass 1 when recursing. */
378 static struct block_symbol
379 cp_lookup_symbol_via_imports (const char *scope,
381 const struct block *block,
382 const domain_enum domain,
383 const int search_scope_first,
384 const int declaration_only,
385 const int search_parents)
387 struct using_direct *current;
388 struct block_symbol sym;
391 struct cleanup *searched_cleanup;
396 /* First, try to find the symbol in the given namespace if requested. */
397 if (search_scope_first)
398 sym = cp_lookup_symbol_in_namespace (scope, name,
401 if (sym.symbol != NULL)
404 /* Go through the using directives. If any of them add new names to
405 the namespace we're searching in, see if we can find a match by
408 for (current = block_using (block);
410 current = current->next)
412 const char **excludep;
414 len = strlen (current->import_dest);
415 directive_match = (search_parents
416 ? (startswith (scope, current->import_dest)
419 || scope[len] == '\0'))
420 : strcmp (scope, current->import_dest) == 0);
422 /* If the import destination is the current scope or one of its
423 ancestors then it is applicable. */
424 if (directive_match && !current->searched)
426 /* Mark this import as searched so that the recursive call
427 does not search it again. */
428 current->searched = 1;
429 searched_cleanup = make_cleanup (reset_directive_searched,
432 /* If there is an import of a single declaration, compare the
433 imported declaration (after optional renaming by its alias)
434 with the sought out name. If there is a match pass
435 current->import_src as NAMESPACE to direct the search
436 towards the imported namespace. */
437 if (current->declaration
438 && strcmp (name, current->alias
439 ? current->alias : current->declaration) == 0)
440 sym = cp_lookup_symbol_in_namespace (current->import_src,
441 current->declaration,
444 /* If this is a DECLARATION_ONLY search or a symbol was found
445 or this import statement was an import declaration, the
446 search of this import is complete. */
447 if (declaration_only || sym.symbol != NULL || current->declaration)
449 current->searched = 0;
450 discard_cleanups (searched_cleanup);
452 if (sym.symbol != NULL)
458 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
459 for (excludep = current->excludes; *excludep; excludep++)
460 if (strcmp (name, *excludep) == 0)
464 discard_cleanups (searched_cleanup);
468 if (current->alias != NULL
469 && strcmp (name, current->alias) == 0)
470 /* If the import is creating an alias and the alias matches
471 the sought name. Pass current->import_src as the NAME to
472 direct the search towards the aliased namespace. */
474 sym = cp_lookup_symbol_in_namespace (scope,
478 else if (current->alias == NULL)
480 /* If this import statement creates no alias, pass
481 current->inner as NAMESPACE to direct the search
482 towards the imported namespace. */
483 sym = cp_lookup_symbol_via_imports (current->import_src,
487 current->searched = 0;
488 discard_cleanups (searched_cleanup);
490 if (sym.symbol != NULL)
495 return null_block_symbol;
498 /* Helper function that searches an array of symbols for one named NAME. */
500 static struct symbol *
501 search_symbol_list (const char *name, int num,
502 struct symbol **syms)
506 /* Maybe we should store a dictionary in here instead. */
507 for (i = 0; i < num; ++i)
509 if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
515 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
516 searches through the template parameters of the function and the
520 cp_lookup_symbol_imports_or_template (const char *scope,
522 const struct block *block,
523 const domain_enum domain)
525 struct symbol *function = BLOCK_FUNCTION (block);
526 struct block_symbol result;
528 if (symbol_lookup_debug)
530 fprintf_unfiltered (gdb_stdlog,
531 "cp_lookup_symbol_imports_or_template"
532 " (%s, %s, %s, %s)\n",
533 scope, name, host_address_to_string (block),
534 domain_name (domain));
537 if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
539 /* Search the function's template parameters. */
540 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
542 struct template_symbol *templ
543 = (struct template_symbol *) function;
544 struct symbol *sym = search_symbol_list (name,
545 templ->n_template_arguments,
546 templ->template_arguments);
550 if (symbol_lookup_debug)
552 fprintf_unfiltered (gdb_stdlog,
553 "cp_lookup_symbol_imports_or_template"
555 host_address_to_string (sym));
557 return (struct block_symbol) {sym, block};
561 /* Search the template parameters of the function's defining
563 if (SYMBOL_NATURAL_NAME (function))
565 struct type *context;
566 char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
567 struct cleanup *cleanups = make_cleanup (xfree, name_copy);
568 const struct language_defn *lang = language_def (language_cplus);
569 struct gdbarch *arch = symbol_arch (function);
570 const struct block *parent = BLOCK_SUPERBLOCK (block);
575 unsigned int prefix_len = cp_entire_prefix_len (name_copy);
581 name_copy[prefix_len] = '\0';
582 context = lookup_typename (lang, arch,
591 = search_symbol_list (name,
592 TYPE_N_TEMPLATE_ARGUMENTS (context),
593 TYPE_TEMPLATE_ARGUMENTS (context));
596 do_cleanups (cleanups);
597 if (symbol_lookup_debug)
601 "cp_lookup_symbol_imports_or_template (...) = %s\n",
602 host_address_to_string (sym));
604 return (struct block_symbol) {sym, parent};
608 do_cleanups (cleanups);
612 result = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 1, 1);
613 if (symbol_lookup_debug)
615 fprintf_unfiltered (gdb_stdlog,
616 "cp_lookup_symbol_imports_or_template (...) = %s\n",
617 result.symbol != NULL
618 ? host_address_to_string (result.symbol) : "NULL");
623 /* Search for NAME by applying relevant import statements belonging to BLOCK
624 and its parents. SCOPE is the namespace scope of the context in which the
625 search is being evaluated. */
627 static struct block_symbol
628 cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
629 const struct block *block,
630 const domain_enum domain)
632 struct block_symbol sym;
634 while (block != NULL)
636 sym = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 0, 1);
640 block = BLOCK_SUPERBLOCK (block);
643 return null_block_symbol;
646 /* Searches for NAME in the current namespace, and by applying
647 relevant import statements belonging to BLOCK and its parents.
648 SCOPE is the namespace scope of the context in which the search is
652 cp_lookup_symbol_namespace (const char *scope,
654 const struct block *block,
655 const domain_enum domain)
657 struct block_symbol sym;
659 if (symbol_lookup_debug)
661 fprintf_unfiltered (gdb_stdlog,
662 "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
663 scope, name, host_address_to_string (block),
664 domain_name (domain));
667 /* First, try to find the symbol in the given namespace. */
668 sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);
670 /* Search for name in namespaces imported to this and parent blocks. */
671 if (sym.symbol == NULL)
672 sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
674 if (symbol_lookup_debug)
676 fprintf_unfiltered (gdb_stdlog,
677 "cp_lookup_symbol_namespace (...) = %s\n",
679 ? host_address_to_string (sym.symbol) : "NULL");
684 /* Lookup NAME at namespace scope (or, in C terms, in static and
685 global variables). SCOPE is the namespace that the current
686 function is defined within; only consider namespaces whose length
687 is at least SCOPE_LEN. Other arguments are as in
688 cp_lookup_symbol_nonlocal.
690 For example, if we're within a function A::B::f and looking for a
691 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
692 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
693 but with SCOPE_LEN = 1. And then it calls itself with NAME and
694 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
695 "A::B::x"; if it doesn't find it, then the second call looks for
696 "A::x", and if that call fails, then the first call looks for
699 static struct block_symbol
700 lookup_namespace_scope (const struct language_defn *langdef,
702 const struct block *block,
703 const domain_enum domain,
709 if (scope[scope_len] != '\0')
711 /* Recursively search for names in child namespaces first. */
713 struct block_symbol sym;
714 int new_scope_len = scope_len;
716 /* If the current scope is followed by "::", skip past that. */
717 if (new_scope_len != 0)
719 gdb_assert (scope[new_scope_len] == ':');
722 new_scope_len += cp_find_first_component (scope + new_scope_len);
723 sym = lookup_namespace_scope (langdef, name, block, domain,
724 scope, new_scope_len);
725 if (sym.symbol != NULL)
729 /* Okay, we didn't find a match in our children, so look for the
730 name in the current namespace.
732 If we there is no scope and we know we have a bare symbol, then short
733 circuit everything and call cp_lookup_bare_symbol directly.
734 This isn't an optimization, rather it allows us to pass LANGDEF which
735 is needed for primitive type lookup. The test doesn't have to be
736 perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
737 template symbol with "::" in the argument list) then
738 cp_lookup_symbol_in_namespace will catch it. */
740 if (scope_len == 0 && strchr (name, ':') == NULL)
741 return cp_lookup_bare_symbol (langdef, name, block, domain, 1);
743 the_namespace = (char *) alloca (scope_len + 1);
744 strncpy (the_namespace, scope, scope_len);
745 the_namespace[scope_len] = '\0';
746 return cp_lookup_symbol_in_namespace (the_namespace, name,
750 /* The C++-specific version of name lookup for static and global
751 names. This makes sure that names get looked for in all namespaces
752 that are in scope. NAME is the natural name of the symbol that
753 we're looking for, BLOCK is the block that we're searching within,
754 DOMAIN says what kind of symbols we're looking for. */
757 cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
759 const struct block *block,
760 const domain_enum domain)
762 struct block_symbol sym;
763 const char *scope = block_scope (block);
765 if (symbol_lookup_debug)
767 fprintf_unfiltered (gdb_stdlog,
768 "cp_lookup_symbol_non_local"
769 " (%s, %s (scope %s), %s)\n",
770 name, host_address_to_string (block), scope,
771 domain_name (domain));
774 /* First, try to find the symbol in the given namespace, and all
775 containing namespaces. */
776 sym = lookup_namespace_scope (langdef, name, block, domain, scope, 0);
778 /* Search for name in namespaces imported to this and parent blocks. */
779 if (sym.symbol == NULL)
780 sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
782 if (symbol_lookup_debug)
784 fprintf_unfiltered (gdb_stdlog,
785 "cp_lookup_symbol_nonlocal (...) = %s\n",
787 ? host_address_to_string (sym.symbol)
793 /* Search through the base classes of PARENT_TYPE for a base class
794 named NAME and return its type. If not found, return NULL. */
797 cp_find_type_baseclass_by_name (struct type *parent_type, const char *name)
801 parent_type = check_typedef (parent_type);
802 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
804 struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
805 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
807 if (base_name == NULL)
810 if (streq (base_name, name))
813 type = cp_find_type_baseclass_by_name (type, name);
821 /* Search through the base classes of PARENT_TYPE for a symbol named
822 NAME in block BLOCK. */
824 static struct block_symbol
825 find_symbol_in_baseclass (struct type *parent_type, const char *name,
826 const struct block *block, const domain_enum domain,
830 struct block_symbol sym;
831 struct cleanup *cleanup;
832 char *concatenated_name;
836 concatenated_name = NULL;
837 cleanup = make_cleanup (free_current_contents, &concatenated_name);
839 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
842 struct type *base_type = TYPE_BASECLASS (parent_type, i);
843 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
845 if (base_name == NULL)
848 len = strlen (base_name) + 2 + strlen (name) + 1;
849 concatenated_name = (char *) xrealloc (concatenated_name, len);
850 xsnprintf (concatenated_name, len, "%s::%s", base_name, name);
852 sym = cp_lookup_nested_symbol_1 (base_type, name, concatenated_name,
853 block, domain, 1, is_in_anonymous);
854 if (sym.symbol != NULL)
858 do_cleanups (cleanup);
862 /* Helper function to look up NESTED_NAME in CONTAINER_TYPE and in DOMAIN
863 and within the context of BLOCK.
864 NESTED_NAME may have scope ("::").
865 CONTAINER_TYPE needn't have been "check_typedef'd" yet.
866 CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
867 passed as an argument so that callers can control how space for it is
869 If BASIC_LOOKUP is non-zero then perform a basic lookup of
870 CONCATENATED_NAME. See cp_basic_lookup_symbol for details.
871 If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
874 static struct block_symbol
875 cp_lookup_nested_symbol_1 (struct type *container_type,
876 const char *nested_name,
877 const char *concatenated_name,
878 const struct block *block,
879 const domain_enum domain,
880 int basic_lookup, int is_in_anonymous)
882 struct block_symbol sym;
884 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
885 of classes like, say, data or function members. Instead,
886 they're just represented by symbols whose names are
887 qualified by the name of the surrounding class. This is
888 just like members of namespaces; in particular,
889 cp_basic_lookup_symbol works when looking them up. */
893 sym = cp_basic_lookup_symbol (concatenated_name, block, domain,
895 if (sym.symbol != NULL)
899 /* Now search all static file-level symbols. We have to do this for things
900 like typedefs in the class. We do not try to guess any imported
901 namespace as even the fully specified namespace search is already not
902 C++ compliant and more assumptions could make it too magic. */
904 /* First search in this symtab, what we want is possibly there. */
905 sym = lookup_symbol_in_static_block (concatenated_name, block, domain);
906 if (sym.symbol != NULL)
909 /* Nope. We now have to search all static blocks in all objfiles,
910 even if block != NULL, because there's no guarantees as to which
911 symtab the symbol we want is in. Except for symbols defined in
912 anonymous namespaces should be treated as local to a single file,
913 which we just searched. */
914 if (!is_in_anonymous)
916 sym = lookup_static_symbol (concatenated_name, domain);
917 if (sym.symbol != NULL)
921 /* If this is a class with baseclasses, search them next. */
922 container_type = check_typedef (container_type);
923 if (TYPE_N_BASECLASSES (container_type) > 0)
925 sym = find_symbol_in_baseclass (container_type, nested_name, block,
926 domain, is_in_anonymous);
927 if (sym.symbol != NULL)
931 return null_block_symbol;
934 /* Look up a symbol named NESTED_NAME that is nested inside the C++
935 class or namespace given by PARENT_TYPE, from within the context
936 given by BLOCK, and in DOMAIN.
937 Return NULL if there is no such nested symbol. */
940 cp_lookup_nested_symbol (struct type *parent_type,
941 const char *nested_name,
942 const struct block *block,
943 const domain_enum domain)
945 /* type_name_no_tag_or_error provides better error reporting using the
947 struct type *saved_parent_type = parent_type;
949 parent_type = check_typedef (parent_type);
951 if (symbol_lookup_debug)
953 const char *type_name = type_name_no_tag (saved_parent_type);
955 fprintf_unfiltered (gdb_stdlog,
956 "cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
957 type_name != NULL ? type_name : "unnamed",
958 nested_name, host_address_to_string (block),
959 domain_name (domain));
962 switch (TYPE_CODE (parent_type))
964 case TYPE_CODE_STRUCT:
965 case TYPE_CODE_NAMESPACE:
966 case TYPE_CODE_UNION:
968 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
969 specific code to lookup nested symbols in modules, by calling the
970 function pointer la_lookup_symbol_nonlocal, which ends up here. */
971 case TYPE_CODE_MODULE:
974 const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
975 struct block_symbol sym;
976 char *concatenated_name;
979 size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
980 concatenated_name = (char *) alloca (size);
981 xsnprintf (concatenated_name, size, "%s::%s",
982 parent_name, nested_name);
983 is_in_anonymous = cp_is_in_anonymous (concatenated_name);
985 sym = cp_lookup_nested_symbol_1 (parent_type, nested_name,
986 concatenated_name, block, domain,
989 if (symbol_lookup_debug)
991 fprintf_unfiltered (gdb_stdlog,
992 "cp_lookup_nested_symbol (...) = %s\n",
994 ? host_address_to_string (sym.symbol)
1000 case TYPE_CODE_FUNC:
1001 case TYPE_CODE_METHOD:
1002 if (symbol_lookup_debug)
1004 fprintf_unfiltered (gdb_stdlog,
1005 "cp_lookup_nested_symbol (...) = NULL"
1006 " (func/method)\n");
1008 return null_block_symbol;
1011 internal_error (__FILE__, __LINE__,
1012 _("cp_lookup_nested_symbol called "
1013 "on a non-aggregate type."));
1017 /* The C++-version of lookup_transparent_type. */
1019 /* FIXME: carlton/2004-01-16: The problem that this is trying to
1020 address is that, unfortunately, sometimes NAME is wrong: it may not
1021 include the name of namespaces enclosing the type in question.
1022 lookup_transparent_type gets called when the type in question
1023 is a declaration, and we're trying to find its definition; but, for
1024 declarations, our type name deduction mechanism doesn't work.
1025 There's nothing we can do to fix this in general, I think, in the
1026 absence of debug information about namespaces (I've filed PR
1027 gdb/1511 about this); until such debug information becomes more
1028 prevalent, one heuristic which sometimes looks is to search for the
1029 definition in namespaces containing the current namespace.
1031 We should delete this functions once the appropriate debug
1032 information becomes more widespread. (GCC 3.4 will be the first
1033 released version of GCC with such information.) */
1036 cp_lookup_transparent_type (const char *name)
1038 /* First, try the honest way of looking up the definition. */
1039 struct type *t = basic_lookup_transparent_type (name);
1045 /* If that doesn't work and we're within a namespace, look there
1047 scope = block_scope (get_selected_block (0));
1049 if (scope[0] == '\0')
1052 return cp_lookup_transparent_type_loop (name, scope, 0);
1055 /* Lookup the type definition associated to NAME in namespaces/classes
1056 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
1057 must be the index of the start of a component of SCOPE. */
1059 static struct type *
1060 cp_lookup_transparent_type_loop (const char *name,
1064 int scope_length = length + cp_find_first_component (scope + length);
1067 /* If the current scope is followed by "::", look in the next
1069 if (scope[scope_length] == ':')
1072 = cp_lookup_transparent_type_loop (name, scope,
1079 full_name = (char *) alloca (scope_length + 2 + strlen (name) + 1);
1080 strncpy (full_name, scope, scope_length);
1081 strncpy (full_name + scope_length, "::", 2);
1082 strcpy (full_name + scope_length + 2, name);
1084 return basic_lookup_transparent_type (full_name);
1087 /* This used to do something but was removed when it became
1091 maintenance_cplus_namespace (char *args, int from_tty)
1093 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1096 /* Provide a prototype to silence -Wmissing-prototypes. */
1097 extern initialize_file_ftype _initialize_cp_namespace;
1100 _initialize_cp_namespace (void)
1102 struct cmd_list_element *cmd;
1104 cmd = add_cmd ("namespace", class_maintenance,
1105 maintenance_cplus_namespace,
1106 _("Deprecated placeholder for removed functionality."),
1107 &maint_cplus_cmd_list);
1108 deprecate_cmd (cmd, NULL);