1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2003-2014 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"
35 static struct type *cp_lookup_transparent_type_loop (const char *name,
39 /* Check to see if SYMBOL refers to an object contained within an
40 anonymous namespace; if so, add an appropriate using directive. */
43 cp_scan_for_anonymous_namespaces (const struct symbol *const symbol,
44 struct objfile *const objfile)
46 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
48 const char *name = SYMBOL_DEMANGLED_NAME (symbol);
49 unsigned int previous_component;
50 unsigned int next_component;
52 /* Start with a quick-and-dirty check for mention of "(anonymous
55 if (!cp_is_anonymous (name))
58 previous_component = 0;
59 next_component = cp_find_first_component (name + previous_component);
61 while (name[next_component] == ':')
63 if (((next_component - previous_component)
64 == CP_ANONYMOUS_NAMESPACE_LEN)
65 && strncmp (name + previous_component,
66 CP_ANONYMOUS_NAMESPACE_STR,
67 CP_ANONYMOUS_NAMESPACE_LEN) == 0)
69 int dest_len = (previous_component == 0
70 ? 0 : previous_component - 2);
71 int src_len = next_component;
73 char *dest = alloca (dest_len + 1);
74 char *src = alloca (src_len + 1);
76 memcpy (dest, name, dest_len);
77 memcpy (src, name, src_len);
79 dest[dest_len] = '\0';
82 /* We've found a component of the name that's an
83 anonymous namespace. So add symbols in it to the
84 namespace given by the previous component if there is
85 one, or to the global namespace if there isn't. */
86 cp_add_using_directive (dest, src, NULL, NULL, NULL, 1,
87 &objfile->objfile_obstack);
89 /* The "+ 2" is for the "::". */
90 previous_component = next_component + 2;
91 next_component = (previous_component
92 + cp_find_first_component (name
93 + previous_component));
99 /* Add a using directive to using_directives. If the using directive
100 in question has already been added, don't add it twice.
102 Create a new struct using_direct which imports the namespace SRC
103 into the scope DEST. ALIAS is the name of the imported namespace
104 in the current scope. If ALIAS is NULL then the namespace is known
105 by its original name. DECLARATION is the name if the imported
106 varable if this is a declaration import (Eg. using A::x), otherwise
107 it is NULL. EXCLUDES is a list of names not to import from an
108 imported module or NULL. If COPY_NAMES is non-zero, then the
109 arguments are copied into newly allocated memory so they can be
110 temporaries. For EXCLUDES the VEC pointers are copied but the
111 pointed to characters are not copied. */
114 cp_add_using_directive (const char *dest,
117 const char *declaration,
118 VEC (const_char_ptr) *excludes,
120 struct obstack *obstack)
122 struct using_direct *current;
123 struct using_direct *new;
125 /* Has it already been added? */
127 for (current = using_directives; current != NULL; current = current->next)
132 if (strcmp (current->import_src, src) != 0)
134 if (strcmp (current->import_dest, dest) != 0)
136 if ((alias == NULL && current->alias != NULL)
137 || (alias != NULL && current->alias == NULL)
138 || (alias != NULL && current->alias != NULL
139 && strcmp (alias, current->alias) != 0))
141 if ((declaration == NULL && current->declaration != NULL)
142 || (declaration != NULL && current->declaration == NULL)
143 || (declaration != NULL && current->declaration != NULL
144 && strcmp (declaration, current->declaration) != 0))
147 /* Compare the contents of EXCLUDES. */
148 for (ix = 0; VEC_iterate (const_char_ptr, excludes, ix, param); ix++)
149 if (current->excludes[ix] == NULL
150 || strcmp (param, current->excludes[ix]) != 0)
152 if (ix < VEC_length (const_char_ptr, excludes)
153 || current->excludes[ix] != NULL)
156 /* Parameters exactly match CURRENT. */
160 new = obstack_alloc (obstack, (sizeof (*new)
161 + (VEC_length (const_char_ptr, excludes)
162 * sizeof (*new->excludes))));
163 memset (new, 0, sizeof (*new));
167 new->import_src = obstack_copy0 (obstack, src, strlen (src));
168 new->import_dest = obstack_copy0 (obstack, dest, strlen (dest));
172 new->import_src = src;
173 new->import_dest = dest;
176 if (alias != NULL && copy_names)
177 new->alias = obstack_copy0 (obstack, alias, strlen (alias));
181 if (declaration != NULL && copy_names)
182 new->declaration = obstack_copy0 (obstack,
183 declaration, strlen (declaration));
185 new->declaration = declaration;
187 memcpy (new->excludes, VEC_address (const_char_ptr, excludes),
188 VEC_length (const_char_ptr, excludes) * sizeof (*new->excludes));
189 new->excludes[VEC_length (const_char_ptr, excludes)] = NULL;
191 new->next = using_directives;
192 using_directives = new;
195 /* Test whether or not NAMESPACE looks like it mentions an anonymous
196 namespace; return nonzero if so. */
199 cp_is_anonymous (const char *namespace)
201 return (strstr (namespace, CP_ANONYMOUS_NAMESPACE_STR)
205 /* Look up NAME in BLOCK's static block and in global blocks. If
206 ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
207 within an anonymous namespace. If SEARCH is non-zero, search through
208 base classes for a matching symbol. Other arguments are as in
209 cp_lookup_symbol_nonlocal. */
211 static struct symbol *
212 lookup_symbol_file (const char *name,
213 const struct block *block,
214 const domain_enum domain,
215 int anonymous_namespace, int search)
217 struct symbol *sym = NULL;
219 sym = lookup_symbol_in_static_block (name, block, domain);
223 if (anonymous_namespace)
225 /* Symbols defined in anonymous namespaces have external linkage
226 but should be treated as local to a single file nonetheless.
227 So we only search the current file's global block. */
229 const struct block *global_block = block_global_block (block);
231 if (global_block != NULL)
232 sym = lookup_symbol_in_block (name, global_block, domain);
236 sym = lookup_global_symbol (name, block, domain);
244 char *klass, *nested;
245 unsigned int prefix_len;
246 struct cleanup *cleanup;
247 struct symbol *klass_sym;
249 /* A simple lookup failed. Check if the symbol was defined in
252 cleanup = make_cleanup (null_cleanup, NULL);
254 /* Find the name of the class and the name of the method,
256 prefix_len = cp_entire_prefix_len (name);
258 /* If no prefix was found, search "this". */
264 this = lookup_language_this (language_def (language_cplus), block);
267 do_cleanups (cleanup);
271 type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
272 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
273 This can happen for lambda functions compiled with clang++,
274 which outputs no name for the container class. */
275 if (TYPE_NAME (type) == NULL)
277 klass = xstrdup (TYPE_NAME (type));
278 nested = xstrdup (name);
282 /* The class name is everything up to and including PREFIX_LEN. */
283 klass = savestring (name, prefix_len);
285 /* The rest of the name is everything else past the initial scope
287 nested = xstrdup (name + prefix_len + 2);
290 /* Add cleanups to free memory for these strings. */
291 make_cleanup (xfree, klass);
292 make_cleanup (xfree, nested);
294 /* Lookup a class named KLASS. If none is found, there is nothing
295 more that can be done. */
296 klass_sym = lookup_global_symbol (klass, block, domain);
297 if (klass_sym == NULL)
299 do_cleanups (cleanup);
303 /* Look for a symbol named NESTED in this class. */
304 sym = cp_lookup_nested_symbol (SYMBOL_TYPE (klass_sym), nested, block);
305 do_cleanups (cleanup);
311 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
312 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
313 through base classes for a matching symbol. */
315 static struct symbol *
316 cp_lookup_symbol_in_namespace (const char *namespace,
318 const struct block *block,
319 const domain_enum domain, int search)
321 if (namespace[0] == '\0')
323 return lookup_symbol_file (name, block, domain, 0, search);
327 char *concatenated_name = alloca (strlen (namespace) + 2
328 + strlen (name) + 1);
330 strcpy (concatenated_name, namespace);
331 strcat (concatenated_name, "::");
332 strcat (concatenated_name, name);
333 return lookup_symbol_file (concatenated_name, block, domain,
334 cp_is_anonymous (namespace), search);
338 /* Used for cleanups to reset the "searched" flag incase
342 reset_directive_searched (void *data)
344 struct using_direct *direct = data;
345 direct->searched = 0;
348 /* Search for NAME by applying all import statements belonging to
349 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
350 search is restricted to using declarations.
358 If SEARCH_PARENTS the search will include imports which are
359 applicable in parents of SCOPE.
369 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
370 namespaces X and Y will be considered. If SEARCH_PARENTS is false
371 only the import of Y is considered. */
373 static struct symbol *
374 cp_lookup_symbol_imports (const char *scope,
376 const struct block *block,
377 const domain_enum domain,
378 const int declaration_only,
379 const int search_parents)
381 struct using_direct *current;
382 struct symbol *sym = NULL;
385 struct cleanup *searched_cleanup;
387 /* First, try to find the symbol in the given namespace. */
388 if (!declaration_only)
389 sym = cp_lookup_symbol_in_namespace (scope, name,
395 /* Go through the using directives. If any of them add new names to
396 the namespace we're searching in, see if we can find a match by
399 for (current = block_using (block);
401 current = current->next)
403 const char **excludep;
405 len = strlen (current->import_dest);
406 directive_match = (search_parents
407 ? (strncmp (scope, current->import_dest,
408 strlen (current->import_dest)) == 0
411 || scope[len] == '\0'))
412 : strcmp (scope, current->import_dest) == 0);
414 /* If the import destination is the current scope or one of its
415 ancestors then it is applicable. */
416 if (directive_match && !current->searched)
418 /* Mark this import as searched so that the recursive call
419 does not search it again. */
420 current->searched = 1;
421 searched_cleanup = make_cleanup (reset_directive_searched,
424 /* If there is an import of a single declaration, compare the
425 imported declaration (after optional renaming by its alias)
426 with the sought out name. If there is a match pass
427 current->import_src as NAMESPACE to direct the search
428 towards the imported namespace. */
429 if (current->declaration
430 && strcmp (name, current->alias
431 ? current->alias : current->declaration) == 0)
432 sym = cp_lookup_symbol_in_namespace (current->import_src,
433 current->declaration,
436 /* If this is a DECLARATION_ONLY search or a symbol was found
437 or this import statement was an import declaration, the
438 search of this import is complete. */
439 if (declaration_only || sym != NULL || current->declaration)
441 current->searched = 0;
442 discard_cleanups (searched_cleanup);
450 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
451 for (excludep = current->excludes; *excludep; excludep++)
452 if (strcmp (name, *excludep) == 0)
456 discard_cleanups (searched_cleanup);
460 if (current->alias != NULL
461 && strcmp (name, current->alias) == 0)
462 /* If the import is creating an alias and the alias matches
463 the sought name. Pass current->import_src as the NAME to
464 direct the search towards the aliased namespace. */
466 sym = cp_lookup_symbol_in_namespace (scope,
470 else if (current->alias == NULL)
472 /* If this import statement creates no alias, pass
473 current->inner as NAMESPACE to direct the search
474 towards the imported namespace. */
475 sym = cp_lookup_symbol_imports (current->import_src,
479 current->searched = 0;
480 discard_cleanups (searched_cleanup);
490 /* Helper function that searches an array of symbols for one named
493 static struct symbol *
494 search_symbol_list (const char *name, int num,
495 struct symbol **syms)
499 /* Maybe we should store a dictionary in here instead. */
500 for (i = 0; i < num; ++i)
502 if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
508 /* Like cp_lookup_symbol_imports, but if BLOCK is a function, it
509 searches through the template parameters of the function and the
513 cp_lookup_symbol_imports_or_template (const char *scope,
515 const struct block *block,
516 const domain_enum domain)
518 struct symbol *function = BLOCK_FUNCTION (block);
520 if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
522 /* Search the function's template parameters. */
523 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
525 struct template_symbol *templ
526 = (struct template_symbol *) function;
527 struct symbol *result;
529 result = search_symbol_list (name,
530 templ->n_template_arguments,
531 templ->template_arguments);
536 /* Search the template parameters of the function's defining
538 if (SYMBOL_NATURAL_NAME (function))
540 struct type *context;
541 char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
542 struct cleanup *cleanups = make_cleanup (xfree, name_copy);
543 const struct language_defn *lang = language_def (language_cplus);
545 = get_objfile_arch (SYMBOL_OBJFILE (function));
546 const struct block *parent = BLOCK_SUPERBLOCK (block);
550 struct symbol *result;
551 unsigned int prefix_len = cp_entire_prefix_len (name_copy);
557 name_copy[prefix_len] = '\0';
558 context = lookup_typename (lang, arch,
567 = search_symbol_list (name,
568 TYPE_N_TEMPLATE_ARGUMENTS (context),
569 TYPE_TEMPLATE_ARGUMENTS (context));
572 do_cleanups (cleanups);
577 do_cleanups (cleanups);
581 return cp_lookup_symbol_imports (scope, name, block, domain, 1, 1);
584 /* Searches for NAME in the current namespace, and by applying
585 relevant import statements belonging to BLOCK and its parents.
586 SCOPE is the namespace scope of the context in which the search is
590 cp_lookup_symbol_namespace (const char *scope,
592 const struct block *block,
593 const domain_enum domain)
597 /* First, try to find the symbol in the given namespace. */
598 sym = cp_lookup_symbol_in_namespace (scope, name,
603 /* Search for name in namespaces imported to this and parent
605 while (block != NULL)
607 sym = cp_lookup_symbol_imports (scope, name, block,
613 block = BLOCK_SUPERBLOCK (block);
619 /* Lookup NAME at namespace scope (or, in C terms, in static and
620 global variables). SCOPE is the namespace that the current
621 function is defined within; only consider namespaces whose length
622 is at least SCOPE_LEN. Other arguments are as in
623 cp_lookup_symbol_nonlocal.
625 For example, if we're within a function A::B::f and looking for a
626 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
627 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
628 but with SCOPE_LEN = 1. And then it calls itself with NAME and
629 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
630 "A::B::x"; if it doesn't find it, then the second call looks for
631 "A::x", and if that call fails, then the first call looks for
634 static struct symbol *
635 lookup_namespace_scope (const char *name,
636 const struct block *block,
637 const domain_enum domain,
643 if (scope[scope_len] != '\0')
645 /* Recursively search for names in child namespaces first. */
648 int new_scope_len = scope_len;
650 /* If the current scope is followed by "::", skip past that. */
651 if (new_scope_len != 0)
653 gdb_assert (scope[new_scope_len] == ':');
656 new_scope_len += cp_find_first_component (scope + new_scope_len);
657 sym = lookup_namespace_scope (name, block, domain,
658 scope, new_scope_len);
663 /* Okay, we didn't find a match in our children, so look for the
664 name in the current namespace. */
666 namespace = alloca (scope_len + 1);
667 strncpy (namespace, scope, scope_len);
668 namespace[scope_len] = '\0';
669 return cp_lookup_symbol_in_namespace (namespace, name,
673 /* The C++-specific version of name lookup for static and global
674 names. This makes sure that names get looked for in all namespaces
675 that are in scope. NAME is the natural name of the symbol that
676 we're looking for, BLOCK is the block that we're searching within,
677 DOMAIN says what kind of symbols we're looking for. */
680 cp_lookup_symbol_nonlocal (const char *name,
681 const struct block *block,
682 const domain_enum domain)
685 const char *scope = block_scope (block);
687 sym = lookup_namespace_scope (name, block,
692 return cp_lookup_symbol_namespace (scope, name,
696 /* Search through the base classes of PARENT_TYPE for a base class
697 named NAME and return its type. If not found, return NULL. */
700 find_type_baseclass_by_name (struct type *parent_type, const char *name)
704 CHECK_TYPEDEF (parent_type);
705 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
707 struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
708 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
710 if (base_name == NULL)
713 if (streq (base_name, name))
716 type = find_type_baseclass_by_name (type, name);
724 /* Search through the base classes of PARENT_TYPE for a symbol named
725 NAME in block BLOCK. */
727 static struct symbol *
728 find_symbol_in_baseclass (struct type *parent_type, const char *name,
729 const struct block *block)
733 struct cleanup *cleanup;
734 char *concatenated_name;
737 concatenated_name = NULL;
738 cleanup = make_cleanup (free_current_contents, &concatenated_name);
739 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
742 struct type *base_type = TYPE_BASECLASS (parent_type, i);
743 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
745 if (base_name == NULL)
748 /* Search this particular base class. */
749 sym = cp_lookup_symbol_in_namespace (base_name, name, block,
754 /* Now search all static file-level symbols. We have to do this for
755 things like typedefs in the class. First search in this symtab,
756 what we want is possibly there. */
757 len = strlen (base_name) + 2 + strlen (name) + 1;
758 concatenated_name = xrealloc (concatenated_name, len);
759 xsnprintf (concatenated_name, len, "%s::%s", base_name, name);
760 sym = lookup_symbol_in_static_block (concatenated_name, block,
765 /* Nope. We now have to search all static blocks in all objfiles,
766 even if block != NULL, because there's no guarantees as to which
767 symtab the symbol we want is in. */
768 sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
772 /* If this class has base classes, search them next. */
773 CHECK_TYPEDEF (base_type);
774 if (TYPE_N_BASECLASSES (base_type) > 0)
776 sym = find_symbol_in_baseclass (base_type, name, block);
782 do_cleanups (cleanup);
786 /* Look up a symbol named NESTED_NAME that is nested inside the C++
787 class or namespace given by PARENT_TYPE, from within the context
788 given by BLOCK. Return NULL if there is no such nested type. */
791 cp_lookup_nested_symbol (struct type *parent_type,
792 const char *nested_name,
793 const struct block *block)
795 /* type_name_no_tag_required provides better error reporting using the
797 struct type *saved_parent_type = parent_type;
799 CHECK_TYPEDEF (parent_type);
801 switch (TYPE_CODE (parent_type))
803 case TYPE_CODE_STRUCT:
804 case TYPE_CODE_NAMESPACE:
805 case TYPE_CODE_UNION:
807 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
808 specific code to lookup nested symbols in modules, by calling the
809 function pointer la_lookup_symbol_nonlocal, which ends up here. */
810 case TYPE_CODE_MODULE:
812 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
813 of classes like, say, data or function members. Instead,
814 they're just represented by symbols whose names are
815 qualified by the name of the surrounding class. This is
816 just like members of namespaces; in particular,
817 lookup_symbol_namespace works when looking them up. */
820 const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
822 = cp_lookup_symbol_in_namespace (parent_name, nested_name,
823 block, VAR_DOMAIN, 0);
824 char *concatenated_name;
829 /* Now search all static file-level symbols. We have to do this
830 for things like typedefs in the class. We do not try to
831 guess any imported namespace as even the fully specified
832 namespace search is already not C++ compliant and more
833 assumptions could make it too magic. */
835 size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
836 concatenated_name = alloca (size);
837 xsnprintf (concatenated_name, size, "%s::%s",
838 parent_name, nested_name);
839 sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
843 /* If no matching symbols were found, try searching any
845 return find_symbol_in_baseclass (parent_type, nested_name, block);
849 case TYPE_CODE_METHOD:
853 internal_error (__FILE__, __LINE__,
854 _("cp_lookup_nested_symbol called "
855 "on a non-aggregate type."));
859 /* The C++-version of lookup_transparent_type. */
861 /* FIXME: carlton/2004-01-16: The problem that this is trying to
862 address is that, unfortunately, sometimes NAME is wrong: it may not
863 include the name of namespaces enclosing the type in question.
864 lookup_transparent_type gets called when the type in question
865 is a declaration, and we're trying to find its definition; but, for
866 declarations, our type name deduction mechanism doesn't work.
867 There's nothing we can do to fix this in general, I think, in the
868 absence of debug information about namespaces (I've filed PR
869 gdb/1511 about this); until such debug information becomes more
870 prevalent, one heuristic which sometimes looks is to search for the
871 definition in namespaces containing the current namespace.
873 We should delete this functions once the appropriate debug
874 information becomes more widespread. (GCC 3.4 will be the first
875 released version of GCC with such information.) */
878 cp_lookup_transparent_type (const char *name)
880 /* First, try the honest way of looking up the definition. */
881 struct type *t = basic_lookup_transparent_type (name);
887 /* If that doesn't work and we're within a namespace, look there
889 scope = block_scope (get_selected_block (0));
891 if (scope[0] == '\0')
894 return cp_lookup_transparent_type_loop (name, scope, 0);
897 /* Lookup the type definition associated to NAME in namespaces/classes
898 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
899 must be the index of the start of a component of SCOPE. */
902 cp_lookup_transparent_type_loop (const char *name,
906 int scope_length = length + cp_find_first_component (scope + length);
909 /* If the current scope is followed by "::", look in the next
911 if (scope[scope_length] == ':')
914 = cp_lookup_transparent_type_loop (name, scope,
921 full_name = alloca (scope_length + 2 + strlen (name) + 1);
922 strncpy (full_name, scope, scope_length);
923 strncpy (full_name + scope_length, "::", 2);
924 strcpy (full_name + scope_length + 2, name);
926 return basic_lookup_transparent_type (full_name);
929 /* This used to do something but was removed when it became
933 maintenance_cplus_namespace (char *args, int from_tty)
935 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
938 /* Provide a prototype to silence -Wmissing-prototypes. */
939 extern initialize_file_ftype _initialize_cp_namespace;
942 _initialize_cp_namespace (void)
944 struct cmd_list_element *cmd;
946 cmd = add_cmd ("namespace", class_maintenance,
947 maintenance_cplus_namespace,
948 _("Deprecated placeholder for removed functionality."),
949 &maint_cplus_cmd_list);
950 deprecate_cmd (cmd, NULL);