1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2003-2016 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"
37 static struct block_symbol
38 cp_lookup_nested_symbol_1 (struct type *container_type,
39 const char *nested_name,
40 const char *concatenated_name,
41 const struct block *block,
42 const domain_enum domain,
43 int basic_lookup, int is_in_anonymous);
45 static struct type *cp_lookup_transparent_type_loop (const char *name,
49 /* Check to see if SYMBOL refers to an object contained within an
50 anonymous namespace; if so, add an appropriate using directive. */
53 cp_scan_for_anonymous_namespaces (const struct symbol *const symbol,
54 struct objfile *const objfile)
56 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
58 const char *name = SYMBOL_DEMANGLED_NAME (symbol);
59 unsigned int previous_component;
60 unsigned int next_component;
62 /* Start with a quick-and-dirty check for mention of "(anonymous
65 if (!cp_is_in_anonymous (name))
68 previous_component = 0;
69 next_component = cp_find_first_component (name + previous_component);
71 while (name[next_component] == ':')
73 if (((next_component - previous_component)
74 == CP_ANONYMOUS_NAMESPACE_LEN)
75 && strncmp (name + previous_component,
76 CP_ANONYMOUS_NAMESPACE_STR,
77 CP_ANONYMOUS_NAMESPACE_LEN) == 0)
79 int dest_len = (previous_component == 0
80 ? 0 : previous_component - 2);
81 int src_len = next_component;
83 char *dest = (char *) alloca (dest_len + 1);
84 char *src = (char *) alloca (src_len + 1);
86 memcpy (dest, name, dest_len);
87 memcpy (src, name, src_len);
89 dest[dest_len] = '\0';
92 /* We've found a component of the name that's an
93 anonymous namespace. So add symbols in it to the
94 namespace given by the previous component if there is
95 one, or to the global namespace if there isn't. */
96 add_using_directive (&local_using_directives,
97 dest, src, NULL, NULL, NULL, 1,
98 &objfile->objfile_obstack);
100 /* The "+ 2" is for the "::". */
101 previous_component = next_component + 2;
102 next_component = (previous_component
103 + cp_find_first_component (name
104 + previous_component));
109 /* Test whether or not NAMESPACE looks like it mentions an anonymous
110 namespace; return nonzero if so. */
113 cp_is_in_anonymous (const char *symbol_name)
115 return (strstr (symbol_name, CP_ANONYMOUS_NAMESPACE_STR)
119 /* Look up NAME in DOMAIN in BLOCK's static block and in global blocks.
120 If IS_IN_ANONYMOUS is nonzero, the symbol in question is located
121 within an anonymous namespace. */
123 static struct block_symbol
124 cp_basic_lookup_symbol (const char *name, const struct block *block,
125 const domain_enum domain, int is_in_anonymous)
127 struct block_symbol sym;
129 sym = lookup_symbol_in_static_block (name, block, domain);
130 if (sym.symbol != NULL)
135 /* Symbols defined in anonymous namespaces have external linkage
136 but should be treated as local to a single file nonetheless.
137 So we only search the current file's global block. */
139 const struct block *global_block = block_global_block (block);
141 if (global_block != NULL)
143 sym.symbol = lookup_symbol_in_block (name, global_block, domain);
144 sym.block = global_block;
148 sym = lookup_global_symbol (name, block, domain);
153 /* Search bare symbol NAME in DOMAIN in BLOCK.
154 NAME is guaranteed to not have any scope (no "::") in its name, though
155 if for example NAME is a template spec then "::" may appear in the
157 If LANGDEF is non-NULL then try to lookup NAME as a primitive type in
158 that language. Normally we wouldn't need LANGDEF but fortran also uses
160 If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
161 if so then also search for NAME in that class. */
163 static struct block_symbol
164 cp_lookup_bare_symbol (const struct language_defn *langdef,
165 const char *name, const struct block *block,
166 const domain_enum domain, int search)
168 struct block_symbol sym;
170 /* Note: We can't do a simple assert for ':' not being in NAME because
171 ':' may be in the args of a template spec. This isn't intended to be
172 a complete test, just cheap and documentary. */
173 if (strchr (name, '<') == NULL && strchr (name, '(') == NULL)
174 gdb_assert (strstr (name, "::") == NULL);
176 sym = lookup_symbol_in_static_block (name, block, domain);
177 if (sym.symbol != NULL)
180 /* If we didn't find a definition for a builtin type in the static block,
181 search for it now. This is actually the right thing to do and can be
182 a massive performance win. E.g., when debugging a program with lots of
183 shared libraries we could search all of them only to find out the
184 builtin type isn't defined in any of them. This is common for types
186 if (langdef != NULL && domain == VAR_DOMAIN)
188 struct gdbarch *gdbarch;
191 gdbarch = target_gdbarch ();
193 gdbarch = block_gdbarch (block);
195 = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
197 if (sym.symbol != NULL)
201 sym = lookup_global_symbol (name, block, domain);
202 if (sym.symbol != NULL)
207 struct block_symbol lang_this;
210 lang_this.symbol = NULL;
213 lang_this = lookup_language_this (langdef, block);
215 if (lang_this.symbol == NULL)
216 return null_block_symbol;
219 type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
220 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
221 This can happen for lambda functions compiled with clang++,
222 which outputs no name for the container class. */
223 if (TYPE_NAME (type) == NULL)
224 return null_block_symbol;
226 /* Look for symbol NAME in this class. */
227 sym = cp_lookup_nested_symbol (type, name, block, domain);
233 /* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
234 BLOCK specifies the context in which to perform the search.
235 NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
236 the length of the entire scope of NAME (up to, but not including, the last
239 Note: At least in the case of Fortran, which also uses this code, there
240 may be no text after the last "::". */
242 static struct block_symbol
243 cp_search_static_and_baseclasses (const char *name,
244 const struct block *block,
245 const domain_enum domain,
246 unsigned int prefix_len,
249 struct block_symbol sym;
250 struct block_symbol klass_sym;
251 struct type *klass_type;
253 /* Check for malformed input. */
254 if (prefix_len + 2 > strlen (name) || name[prefix_len + 1] != ':')
255 return null_block_symbol;
257 /* Find the name of the class and the name of the method, variable, etc. */
259 /* The class name is everything up to and including PREFIX_LEN. */
260 std::string klass (name, prefix_len);
262 /* The rest of the name is everything else past the initial scope
264 std::string nested (name + prefix_len + 2);
266 /* Lookup a class named KLASS. If none is found, there is nothing
267 more that can be done. KLASS could be a namespace, so always look
268 in VAR_DOMAIN. This works for classes too because of
269 symbol_matches_domain (which should be replaced with something else,
270 but it's what we have today). */
271 klass_sym = lookup_global_symbol (klass.c_str (), block, VAR_DOMAIN);
272 if (klass_sym.symbol == NULL)
273 return null_block_symbol;
274 klass_type = SYMBOL_TYPE (klass_sym.symbol);
276 /* Look for a symbol named NESTED in this class.
277 The caller is assumed to have already have done a basic lookup of NAME.
278 So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here. */
279 sym = cp_lookup_nested_symbol_1 (klass_type, nested.c_str (), name,
280 block, domain, 0, is_in_anonymous);
285 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
286 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
287 through base classes for a matching symbol.
289 Note: Part of the complexity is because NAME may itself specify scope.
290 Part of the complexity is also because this handles the case where
291 there is no scoping in which case we also try looking in the class of
292 "this" if we can compute it. */
294 static struct block_symbol
295 cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
296 const struct block *block,
297 const domain_enum domain, int search)
299 char *concatenated_name = NULL;
301 unsigned int prefix_len;
302 struct block_symbol sym;
304 if (the_namespace[0] != '\0')
307 = (char *) alloca (strlen (the_namespace) + 2 + strlen (name) + 1);
308 strcpy (concatenated_name, the_namespace);
309 strcat (concatenated_name, "::");
310 strcat (concatenated_name, name);
311 name = concatenated_name;
314 prefix_len = cp_entire_prefix_len (name);
316 return cp_lookup_bare_symbol (NULL, name, block, domain, search);
318 /* This would be simpler if we just called cp_lookup_nested_symbol
319 at this point. But that would require first looking up the containing
320 class/namespace. Since we're only searching static and global blocks
321 there's often no need to first do that lookup. */
324 = the_namespace[0] != '\0' && cp_is_in_anonymous (the_namespace);
325 sym = cp_basic_lookup_symbol (name, block, domain, is_in_anonymous);
326 if (sym.symbol != NULL)
330 sym = cp_search_static_and_baseclasses (name, block, domain, prefix_len,
336 /* Used for cleanups to reset the "searched" flag in case of an error. */
339 reset_directive_searched (void *data)
341 struct using_direct *direct = (struct using_direct *) data;
342 direct->searched = 0;
345 /* Search for NAME by applying all import statements belonging to
346 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
347 search is restricted to using declarations.
355 If SEARCH_PARENTS the search will include imports which are
356 applicable in parents of SCOPE.
366 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
367 namespaces X and Y will be considered. If SEARCH_PARENTS is false
368 only the import of Y is considered.
370 SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
371 pass 0 for it. Internally we pass 1 when recursing. */
373 static struct block_symbol
374 cp_lookup_symbol_via_imports (const char *scope,
376 const struct block *block,
377 const domain_enum domain,
378 const int search_scope_first,
379 const int declaration_only,
380 const int search_parents)
382 struct using_direct *current;
383 struct block_symbol sym;
386 struct cleanup *searched_cleanup;
391 /* First, try to find the symbol in the given namespace if requested. */
392 if (search_scope_first)
393 sym = cp_lookup_symbol_in_namespace (scope, name,
396 if (sym.symbol != NULL)
399 /* Go through the using directives. If any of them add new names to
400 the namespace we're searching in, see if we can find a match by
403 for (current = block_using (block);
405 current = current->next)
407 const char **excludep;
409 len = strlen (current->import_dest);
410 directive_match = (search_parents
411 ? (startswith (scope, current->import_dest)
414 || scope[len] == '\0'))
415 : strcmp (scope, current->import_dest) == 0);
417 /* If the import destination is the current scope or one of its
418 ancestors then it is applicable. */
419 if (directive_match && !current->searched)
421 /* Mark this import as searched so that the recursive call
422 does not search it again. */
423 current->searched = 1;
424 searched_cleanup = make_cleanup (reset_directive_searched,
427 /* If there is an import of a single declaration, compare the
428 imported declaration (after optional renaming by its alias)
429 with the sought out name. If there is a match pass
430 current->import_src as NAMESPACE to direct the search
431 towards the imported namespace. */
432 if (current->declaration
433 && strcmp (name, current->alias
434 ? current->alias : current->declaration) == 0)
435 sym = cp_lookup_symbol_in_namespace (current->import_src,
436 current->declaration,
439 /* If this is a DECLARATION_ONLY search or a symbol was found
440 or this import statement was an import declaration, the
441 search of this import is complete. */
442 if (declaration_only || sym.symbol != NULL || current->declaration)
444 current->searched = 0;
445 discard_cleanups (searched_cleanup);
447 if (sym.symbol != NULL)
453 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
454 for (excludep = current->excludes; *excludep; excludep++)
455 if (strcmp (name, *excludep) == 0)
459 discard_cleanups (searched_cleanup);
463 if (current->alias != NULL
464 && strcmp (name, current->alias) == 0)
465 /* If the import is creating an alias and the alias matches
466 the sought name. Pass current->import_src as the NAME to
467 direct the search towards the aliased namespace. */
469 sym = cp_lookup_symbol_in_namespace (scope,
473 else if (current->alias == NULL)
475 /* If this import statement creates no alias, pass
476 current->inner as NAMESPACE to direct the search
477 towards the imported namespace. */
478 sym = cp_lookup_symbol_via_imports (current->import_src,
482 current->searched = 0;
483 discard_cleanups (searched_cleanup);
485 if (sym.symbol != NULL)
490 return null_block_symbol;
493 /* Helper function that searches an array of symbols for one named NAME. */
495 static struct symbol *
496 search_symbol_list (const char *name, int num,
497 struct symbol **syms)
501 /* Maybe we should store a dictionary in here instead. */
502 for (i = 0; i < num; ++i)
504 if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
510 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
511 searches through the template parameters of the function and the
515 cp_lookup_symbol_imports_or_template (const char *scope,
517 const struct block *block,
518 const domain_enum domain)
520 struct symbol *function = BLOCK_FUNCTION (block);
521 struct block_symbol result;
523 if (symbol_lookup_debug)
525 fprintf_unfiltered (gdb_stdlog,
526 "cp_lookup_symbol_imports_or_template"
527 " (%s, %s, %s, %s)\n",
528 scope, name, host_address_to_string (block),
529 domain_name (domain));
532 if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
534 /* Search the function's template parameters. */
535 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
537 struct template_symbol *templ
538 = (struct template_symbol *) function;
539 struct symbol *sym = search_symbol_list (name,
540 templ->n_template_arguments,
541 templ->template_arguments);
545 if (symbol_lookup_debug)
547 fprintf_unfiltered (gdb_stdlog,
548 "cp_lookup_symbol_imports_or_template"
550 host_address_to_string (sym));
552 return (struct block_symbol) {sym, block};
556 /* Search the template parameters of the function's defining
558 if (SYMBOL_NATURAL_NAME (function))
560 struct type *context;
561 std::string name_copy (SYMBOL_NATURAL_NAME (function));
562 const struct language_defn *lang = language_def (language_cplus);
563 struct gdbarch *arch = symbol_arch (function);
564 const struct block *parent = BLOCK_SUPERBLOCK (block);
569 unsigned int prefix_len
570 = cp_entire_prefix_len (name_copy.c_str ());
576 name_copy.erase (prefix_len);
577 context = lookup_typename (lang, arch,
586 = search_symbol_list (name,
587 TYPE_N_TEMPLATE_ARGUMENTS (context),
588 TYPE_TEMPLATE_ARGUMENTS (context));
591 if (symbol_lookup_debug)
595 "cp_lookup_symbol_imports_or_template (...) = %s\n",
596 host_address_to_string (sym));
598 return (struct block_symbol) {sym, parent};
604 result = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 1, 1);
605 if (symbol_lookup_debug)
607 fprintf_unfiltered (gdb_stdlog,
608 "cp_lookup_symbol_imports_or_template (...) = %s\n",
609 result.symbol != NULL
610 ? host_address_to_string (result.symbol) : "NULL");
615 /* Search for NAME by applying relevant import statements belonging to BLOCK
616 and its parents. SCOPE is the namespace scope of the context in which the
617 search is being evaluated. */
619 static struct block_symbol
620 cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
621 const struct block *block,
622 const domain_enum domain)
624 struct block_symbol sym;
626 while (block != NULL)
628 sym = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 0, 1);
632 block = BLOCK_SUPERBLOCK (block);
635 return null_block_symbol;
638 /* Searches for NAME in the current namespace, and by applying
639 relevant import statements belonging to BLOCK and its parents.
640 SCOPE is the namespace scope of the context in which the search is
644 cp_lookup_symbol_namespace (const char *scope,
646 const struct block *block,
647 const domain_enum domain)
649 struct block_symbol sym;
651 if (symbol_lookup_debug)
653 fprintf_unfiltered (gdb_stdlog,
654 "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
655 scope, name, host_address_to_string (block),
656 domain_name (domain));
659 /* First, try to find the symbol in the given namespace. */
660 sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);
662 /* Search for name in namespaces imported to this and parent blocks. */
663 if (sym.symbol == NULL)
664 sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
666 if (symbol_lookup_debug)
668 fprintf_unfiltered (gdb_stdlog,
669 "cp_lookup_symbol_namespace (...) = %s\n",
671 ? host_address_to_string (sym.symbol) : "NULL");
676 /* Lookup NAME at namespace scope (or, in C terms, in static and
677 global variables). SCOPE is the namespace that the current
678 function is defined within; only consider namespaces whose length
679 is at least SCOPE_LEN. Other arguments are as in
680 cp_lookup_symbol_nonlocal.
682 For example, if we're within a function A::B::f and looking for a
683 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
684 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
685 but with SCOPE_LEN = 1. And then it calls itself with NAME and
686 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
687 "A::B::x"; if it doesn't find it, then the second call looks for
688 "A::x", and if that call fails, then the first call looks for
691 static struct block_symbol
692 lookup_namespace_scope (const struct language_defn *langdef,
694 const struct block *block,
695 const domain_enum domain,
701 if (scope[scope_len] != '\0')
703 /* Recursively search for names in child namespaces first. */
705 struct block_symbol sym;
706 int new_scope_len = scope_len;
708 /* If the current scope is followed by "::", skip past that. */
709 if (new_scope_len != 0)
711 gdb_assert (scope[new_scope_len] == ':');
714 new_scope_len += cp_find_first_component (scope + new_scope_len);
715 sym = lookup_namespace_scope (langdef, name, block, domain,
716 scope, new_scope_len);
717 if (sym.symbol != NULL)
721 /* Okay, we didn't find a match in our children, so look for the
722 name in the current namespace.
724 If we there is no scope and we know we have a bare symbol, then short
725 circuit everything and call cp_lookup_bare_symbol directly.
726 This isn't an optimization, rather it allows us to pass LANGDEF which
727 is needed for primitive type lookup. The test doesn't have to be
728 perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
729 template symbol with "::" in the argument list) then
730 cp_lookup_symbol_in_namespace will catch it. */
732 if (scope_len == 0 && strchr (name, ':') == NULL)
733 return cp_lookup_bare_symbol (langdef, name, block, domain, 1);
735 the_namespace = (char *) alloca (scope_len + 1);
736 strncpy (the_namespace, scope, scope_len);
737 the_namespace[scope_len] = '\0';
738 return cp_lookup_symbol_in_namespace (the_namespace, name,
742 /* The C++-specific version of name lookup for static and global
743 names. This makes sure that names get looked for in all namespaces
744 that are in scope. NAME is the natural name of the symbol that
745 we're looking for, BLOCK is the block that we're searching within,
746 DOMAIN says what kind of symbols we're looking for. */
749 cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
751 const struct block *block,
752 const domain_enum domain)
754 struct block_symbol sym;
755 const char *scope = block_scope (block);
757 if (symbol_lookup_debug)
759 fprintf_unfiltered (gdb_stdlog,
760 "cp_lookup_symbol_non_local"
761 " (%s, %s (scope %s), %s)\n",
762 name, host_address_to_string (block), scope,
763 domain_name (domain));
766 /* First, try to find the symbol in the given namespace, and all
767 containing namespaces. */
768 sym = lookup_namespace_scope (langdef, name, block, domain, scope, 0);
770 /* Search for name in namespaces imported to this and parent blocks. */
771 if (sym.symbol == NULL)
772 sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
774 if (symbol_lookup_debug)
776 fprintf_unfiltered (gdb_stdlog,
777 "cp_lookup_symbol_nonlocal (...) = %s\n",
779 ? host_address_to_string (sym.symbol)
785 /* Search through the base classes of PARENT_TYPE for a base class
786 named NAME and return its type. If not found, return NULL. */
789 cp_find_type_baseclass_by_name (struct type *parent_type, const char *name)
793 parent_type = check_typedef (parent_type);
794 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
796 struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
797 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
799 if (base_name == NULL)
802 if (streq (base_name, name))
805 type = cp_find_type_baseclass_by_name (type, name);
813 /* Search through the base classes of PARENT_TYPE for a symbol named
814 NAME in block BLOCK. */
816 static struct block_symbol
817 find_symbol_in_baseclass (struct type *parent_type, const char *name,
818 const struct block *block, const domain_enum domain,
822 struct block_symbol sym;
827 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
829 struct type *base_type = TYPE_BASECLASS (parent_type, i);
830 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
832 if (base_name == NULL)
835 std::string concatenated_name = std::string (base_name) + "::" + name;
837 sym = cp_lookup_nested_symbol_1 (base_type, name,
838 concatenated_name.c_str (),
839 block, domain, 1, is_in_anonymous);
840 if (sym.symbol != NULL)
847 /* Helper function to look up NESTED_NAME in CONTAINER_TYPE and in DOMAIN
848 and within the context of BLOCK.
849 NESTED_NAME may have scope ("::").
850 CONTAINER_TYPE needn't have been "check_typedef'd" yet.
851 CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
852 passed as an argument so that callers can control how space for it is
854 If BASIC_LOOKUP is non-zero then perform a basic lookup of
855 CONCATENATED_NAME. See cp_basic_lookup_symbol for details.
856 If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
859 static struct block_symbol
860 cp_lookup_nested_symbol_1 (struct type *container_type,
861 const char *nested_name,
862 const char *concatenated_name,
863 const struct block *block,
864 const domain_enum domain,
865 int basic_lookup, int is_in_anonymous)
867 struct block_symbol sym;
869 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
870 of classes like, say, data or function members. Instead,
871 they're just represented by symbols whose names are
872 qualified by the name of the surrounding class. This is
873 just like members of namespaces; in particular,
874 cp_basic_lookup_symbol works when looking them up. */
878 sym = cp_basic_lookup_symbol (concatenated_name, block, domain,
880 if (sym.symbol != NULL)
884 /* Now search all static file-level symbols. We have to do this for things
885 like typedefs in the class. We do not try to guess any imported
886 namespace as even the fully specified namespace search is already not
887 C++ compliant and more assumptions could make it too magic. */
889 /* First search in this symtab, what we want is possibly there. */
890 sym = lookup_symbol_in_static_block (concatenated_name, block, domain);
891 if (sym.symbol != NULL)
894 /* Nope. We now have to search all static blocks in all objfiles,
895 even if block != NULL, because there's no guarantees as to which
896 symtab the symbol we want is in. Except for symbols defined in
897 anonymous namespaces should be treated as local to a single file,
898 which we just searched. */
899 if (!is_in_anonymous)
901 sym = lookup_static_symbol (concatenated_name, domain);
902 if (sym.symbol != NULL)
906 /* If this is a class with baseclasses, search them next. */
907 container_type = check_typedef (container_type);
908 if (TYPE_N_BASECLASSES (container_type) > 0)
910 sym = find_symbol_in_baseclass (container_type, nested_name, block,
911 domain, is_in_anonymous);
912 if (sym.symbol != NULL)
916 return null_block_symbol;
919 /* Look up a symbol named NESTED_NAME that is nested inside the C++
920 class or namespace given by PARENT_TYPE, from within the context
921 given by BLOCK, and in DOMAIN.
922 Return NULL if there is no such nested symbol. */
925 cp_lookup_nested_symbol (struct type *parent_type,
926 const char *nested_name,
927 const struct block *block,
928 const domain_enum domain)
930 /* type_name_no_tag_or_error provides better error reporting using the
932 struct type *saved_parent_type = parent_type;
934 parent_type = check_typedef (parent_type);
936 if (symbol_lookup_debug)
938 const char *type_name = type_name_no_tag (saved_parent_type);
940 fprintf_unfiltered (gdb_stdlog,
941 "cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
942 type_name != NULL ? type_name : "unnamed",
943 nested_name, host_address_to_string (block),
944 domain_name (domain));
947 switch (TYPE_CODE (parent_type))
949 case TYPE_CODE_STRUCT:
950 case TYPE_CODE_NAMESPACE:
951 case TYPE_CODE_UNION:
953 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
954 specific code to lookup nested symbols in modules, by calling the
955 function pointer la_lookup_symbol_nonlocal, which ends up here. */
956 case TYPE_CODE_MODULE:
959 const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
960 struct block_symbol sym;
961 char *concatenated_name;
964 size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
965 concatenated_name = (char *) alloca (size);
966 xsnprintf (concatenated_name, size, "%s::%s",
967 parent_name, nested_name);
968 is_in_anonymous = cp_is_in_anonymous (concatenated_name);
970 sym = cp_lookup_nested_symbol_1 (parent_type, nested_name,
971 concatenated_name, block, domain,
974 if (symbol_lookup_debug)
976 fprintf_unfiltered (gdb_stdlog,
977 "cp_lookup_nested_symbol (...) = %s\n",
979 ? host_address_to_string (sym.symbol)
986 case TYPE_CODE_METHOD:
987 if (symbol_lookup_debug)
989 fprintf_unfiltered (gdb_stdlog,
990 "cp_lookup_nested_symbol (...) = NULL"
993 return null_block_symbol;
996 internal_error (__FILE__, __LINE__,
997 _("cp_lookup_nested_symbol called "
998 "on a non-aggregate type."));
1002 /* The C++-version of lookup_transparent_type. */
1004 /* FIXME: carlton/2004-01-16: The problem that this is trying to
1005 address is that, unfortunately, sometimes NAME is wrong: it may not
1006 include the name of namespaces enclosing the type in question.
1007 lookup_transparent_type gets called when the type in question
1008 is a declaration, and we're trying to find its definition; but, for
1009 declarations, our type name deduction mechanism doesn't work.
1010 There's nothing we can do to fix this in general, I think, in the
1011 absence of debug information about namespaces (I've filed PR
1012 gdb/1511 about this); until such debug information becomes more
1013 prevalent, one heuristic which sometimes looks is to search for the
1014 definition in namespaces containing the current namespace.
1016 We should delete this functions once the appropriate debug
1017 information becomes more widespread. (GCC 3.4 will be the first
1018 released version of GCC with such information.) */
1021 cp_lookup_transparent_type (const char *name)
1023 /* First, try the honest way of looking up the definition. */
1024 struct type *t = basic_lookup_transparent_type (name);
1030 /* If that doesn't work and we're within a namespace, look there
1032 scope = block_scope (get_selected_block (0));
1034 if (scope[0] == '\0')
1037 return cp_lookup_transparent_type_loop (name, scope, 0);
1040 /* Lookup the type definition associated to NAME in namespaces/classes
1041 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
1042 must be the index of the start of a component of SCOPE. */
1044 static struct type *
1045 cp_lookup_transparent_type_loop (const char *name,
1049 int scope_length = length + cp_find_first_component (scope + length);
1052 /* If the current scope is followed by "::", look in the next
1054 if (scope[scope_length] == ':')
1057 = cp_lookup_transparent_type_loop (name, scope,
1064 full_name = (char *) alloca (scope_length + 2 + strlen (name) + 1);
1065 strncpy (full_name, scope, scope_length);
1066 strncpy (full_name + scope_length, "::", 2);
1067 strcpy (full_name + scope_length + 2, name);
1069 return basic_lookup_transparent_type (full_name);
1072 /* This used to do something but was removed when it became
1076 maintenance_cplus_namespace (char *args, int from_tty)
1078 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1081 /* Provide a prototype to silence -Wmissing-prototypes. */
1082 extern initialize_file_ftype _initialize_cp_namespace;
1085 _initialize_cp_namespace (void)
1087 struct cmd_list_element *cmd;
1089 cmd = add_cmd ("namespace", class_maintenance,
1090 maintenance_cplus_namespace,
1091 _("Deprecated placeholder for removed functionality."),
1092 &maint_cplus_cmd_list);
1093 deprecate_cmd (cmd, NULL);