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 symbol *lookup_namespace_scope (const char *name,
36 const struct block *block,
37 const domain_enum domain,
41 static struct type *cp_lookup_transparent_type_loop (const char *name,
45 /* Check to see if SYMBOL refers to an object contained within an
46 anonymous namespace; if so, add an appropriate using directive. */
49 cp_scan_for_anonymous_namespaces (const struct symbol *const symbol,
50 struct objfile *const objfile)
52 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
54 const char *name = SYMBOL_DEMANGLED_NAME (symbol);
55 unsigned int previous_component;
56 unsigned int next_component;
58 /* Start with a quick-and-dirty check for mention of "(anonymous
61 if (!cp_is_anonymous (name))
64 previous_component = 0;
65 next_component = cp_find_first_component (name + previous_component);
67 while (name[next_component] == ':')
69 if (((next_component - previous_component)
70 == CP_ANONYMOUS_NAMESPACE_LEN)
71 && strncmp (name + previous_component,
72 CP_ANONYMOUS_NAMESPACE_STR,
73 CP_ANONYMOUS_NAMESPACE_LEN) == 0)
75 int dest_len = (previous_component == 0
76 ? 0 : previous_component - 2);
77 int src_len = next_component;
79 char *dest = alloca (dest_len + 1);
80 char *src = alloca (src_len + 1);
82 memcpy (dest, name, dest_len);
83 memcpy (src, name, src_len);
85 dest[dest_len] = '\0';
88 /* We've found a component of the name that's an
89 anonymous namespace. So add symbols in it to the
90 namespace given by the previous component if there is
91 one, or to the global namespace if there isn't. */
92 cp_add_using_directive (dest, src, NULL, NULL, NULL, 1,
93 &objfile->objfile_obstack);
95 /* The "+ 2" is for the "::". */
96 previous_component = next_component + 2;
97 next_component = (previous_component
98 + cp_find_first_component (name
99 + previous_component));
105 /* Add a using directive to using_directives. If the using directive
106 in question has already been added, don't add it twice.
108 Create a new struct using_direct which imports the namespace SRC
109 into the scope DEST. ALIAS is the name of the imported namespace
110 in the current scope. If ALIAS is NULL then the namespace is known
111 by its original name. DECLARATION is the name if the imported
112 varable if this is a declaration import (Eg. using A::x), otherwise
113 it is NULL. EXCLUDES is a list of names not to import from an
114 imported module or NULL. If COPY_NAMES is non-zero, then the
115 arguments are copied into newly allocated memory so they can be
116 temporaries. For EXCLUDES the VEC pointers are copied but the
117 pointed to characters are not copied. */
120 cp_add_using_directive (const char *dest,
123 const char *declaration,
124 VEC (const_char_ptr) *excludes,
126 struct obstack *obstack)
128 struct using_direct *current;
129 struct using_direct *new;
131 /* Has it already been added? */
133 for (current = using_directives; current != NULL; current = current->next)
138 if (strcmp (current->import_src, src) != 0)
140 if (strcmp (current->import_dest, dest) != 0)
142 if ((alias == NULL && current->alias != NULL)
143 || (alias != NULL && current->alias == NULL)
144 || (alias != NULL && current->alias != NULL
145 && strcmp (alias, current->alias) != 0))
147 if ((declaration == NULL && current->declaration != NULL)
148 || (declaration != NULL && current->declaration == NULL)
149 || (declaration != NULL && current->declaration != NULL
150 && strcmp (declaration, current->declaration) != 0))
153 /* Compare the contents of EXCLUDES. */
154 for (ix = 0; VEC_iterate (const_char_ptr, excludes, ix, param); ix++)
155 if (current->excludes[ix] == NULL
156 || strcmp (param, current->excludes[ix]) != 0)
158 if (ix < VEC_length (const_char_ptr, excludes)
159 || current->excludes[ix] != NULL)
162 /* Parameters exactly match CURRENT. */
166 new = obstack_alloc (obstack, (sizeof (*new)
167 + (VEC_length (const_char_ptr, excludes)
168 * sizeof (*new->excludes))));
169 memset (new, 0, sizeof (*new));
173 new->import_src = obstack_copy0 (obstack, src, strlen (src));
174 new->import_dest = obstack_copy0 (obstack, dest, strlen (dest));
178 new->import_src = src;
179 new->import_dest = dest;
182 if (alias != NULL && copy_names)
183 new->alias = obstack_copy0 (obstack, alias, strlen (alias));
187 if (declaration != NULL && copy_names)
188 new->declaration = obstack_copy0 (obstack,
189 declaration, strlen (declaration));
191 new->declaration = declaration;
193 memcpy (new->excludes, VEC_address (const_char_ptr, excludes),
194 VEC_length (const_char_ptr, excludes) * sizeof (*new->excludes));
195 new->excludes[VEC_length (const_char_ptr, excludes)] = NULL;
197 new->next = using_directives;
198 using_directives = new;
201 /* Test whether or not NAMESPACE looks like it mentions an anonymous
202 namespace; return nonzero if so. */
205 cp_is_anonymous (const char *namespace)
207 return (strstr (namespace, CP_ANONYMOUS_NAMESPACE_STR)
211 /* The C++-specific version of name lookup for static and global
212 names. This makes sure that names get looked for in all namespaces
213 that are in scope. NAME is the natural name of the symbol that
214 we're looking for, BLOCK is the block that we're searching within,
215 DOMAIN says what kind of symbols we're looking for. */
218 cp_lookup_symbol_nonlocal (const char *name,
219 const struct block *block,
220 const domain_enum domain)
223 const char *scope = block_scope (block);
225 sym = lookup_namespace_scope (name, block,
230 return cp_lookup_symbol_namespace (scope, name,
234 /* Look up NAME in BLOCK's static block and in global blocks. If
235 ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
236 within an anonymous namespace. If SEARCH is non-zero, search through
237 base classes for a matching symbol. Other arguments are as in
238 cp_lookup_symbol_nonlocal. */
240 static struct symbol *
241 lookup_symbol_file (const char *name,
242 const struct block *block,
243 const domain_enum domain,
244 int anonymous_namespace, int search)
246 struct symbol *sym = NULL;
248 sym = lookup_symbol_in_static_block (name, block, domain);
252 if (anonymous_namespace)
254 /* Symbols defined in anonymous namespaces have external linkage
255 but should be treated as local to a single file nonetheless.
256 So we only search the current file's global block. */
258 const struct block *global_block = block_global_block (block);
260 if (global_block != NULL)
261 sym = lookup_symbol_in_block (name, global_block, domain);
265 sym = lookup_global_symbol (name, block, domain);
273 char *klass, *nested;
274 unsigned int prefix_len;
275 struct cleanup *cleanup;
276 struct symbol *klass_sym;
278 /* A simple lookup failed. Check if the symbol was defined in
281 cleanup = make_cleanup (null_cleanup, NULL);
283 /* Find the name of the class and the name of the method,
285 prefix_len = cp_entire_prefix_len (name);
287 /* If no prefix was found, search "this". */
293 this = lookup_language_this (language_def (language_cplus), block);
296 do_cleanups (cleanup);
300 type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
301 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
302 This can happen for lambda functions compiled with clang++,
303 which outputs no name for the container class. */
304 if (TYPE_NAME (type) == NULL)
306 klass = xstrdup (TYPE_NAME (type));
307 nested = xstrdup (name);
311 /* The class name is everything up to and including PREFIX_LEN. */
312 klass = savestring (name, prefix_len);
314 /* The rest of the name is everything else past the initial scope
316 nested = xstrdup (name + prefix_len + 2);
319 /* Add cleanups to free memory for these strings. */
320 make_cleanup (xfree, klass);
321 make_cleanup (xfree, nested);
323 /* Lookup a class named KLASS. If none is found, there is nothing
324 more that can be done. */
325 klass_sym = lookup_global_symbol (klass, block, domain);
326 if (klass_sym == NULL)
328 do_cleanups (cleanup);
332 /* Look for a symbol named NESTED in this class. */
333 sym = cp_lookup_nested_symbol (SYMBOL_TYPE (klass_sym), nested, block);
334 do_cleanups (cleanup);
340 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
341 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
342 through base classes for a matching symbol. */
344 static struct symbol *
345 cp_lookup_symbol_in_namespace (const char *namespace,
347 const struct block *block,
348 const domain_enum domain, int search)
350 if (namespace[0] == '\0')
352 return lookup_symbol_file (name, block, domain, 0, search);
356 char *concatenated_name = alloca (strlen (namespace) + 2
357 + strlen (name) + 1);
359 strcpy (concatenated_name, namespace);
360 strcat (concatenated_name, "::");
361 strcat (concatenated_name, name);
362 return lookup_symbol_file (concatenated_name, block, domain,
363 cp_is_anonymous (namespace), search);
367 /* Used for cleanups to reset the "searched" flag incase
371 reset_directive_searched (void *data)
373 struct using_direct *direct = data;
374 direct->searched = 0;
377 /* Search for NAME by applying all import statements belonging to
378 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
379 search is restricted to using declarations.
387 If SEARCH_PARENTS the search will include imports which are
388 applicable in parents of SCOPE.
398 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
399 namespaces X and Y will be considered. If SEARCH_PARENTS is false
400 only the import of Y is considered. */
402 static struct symbol *
403 cp_lookup_symbol_imports (const char *scope,
405 const struct block *block,
406 const domain_enum domain,
407 const int declaration_only,
408 const int search_parents)
410 struct using_direct *current;
411 struct symbol *sym = NULL;
414 struct cleanup *searched_cleanup;
416 /* First, try to find the symbol in the given namespace. */
417 if (!declaration_only)
418 sym = cp_lookup_symbol_in_namespace (scope, name,
424 /* Go through the using directives. If any of them add new names to
425 the namespace we're searching in, see if we can find a match by
428 for (current = block_using (block);
430 current = current->next)
432 const char **excludep;
434 len = strlen (current->import_dest);
435 directive_match = (search_parents
436 ? (strncmp (scope, current->import_dest,
437 strlen (current->import_dest)) == 0
440 || scope[len] == '\0'))
441 : strcmp (scope, current->import_dest) == 0);
443 /* If the import destination is the current scope or one of its
444 ancestors then it is applicable. */
445 if (directive_match && !current->searched)
447 /* Mark this import as searched so that the recursive call
448 does not search it again. */
449 current->searched = 1;
450 searched_cleanup = make_cleanup (reset_directive_searched,
453 /* If there is an import of a single declaration, compare the
454 imported declaration (after optional renaming by its alias)
455 with the sought out name. If there is a match pass
456 current->import_src as NAMESPACE to direct the search
457 towards the imported namespace. */
458 if (current->declaration
459 && strcmp (name, current->alias
460 ? current->alias : current->declaration) == 0)
461 sym = cp_lookup_symbol_in_namespace (current->import_src,
462 current->declaration,
465 /* If this is a DECLARATION_ONLY search or a symbol was found
466 or this import statement was an import declaration, the
467 search of this import is complete. */
468 if (declaration_only || sym != NULL || current->declaration)
470 current->searched = 0;
471 discard_cleanups (searched_cleanup);
479 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
480 for (excludep = current->excludes; *excludep; excludep++)
481 if (strcmp (name, *excludep) == 0)
485 discard_cleanups (searched_cleanup);
489 if (current->alias != NULL
490 && strcmp (name, current->alias) == 0)
491 /* If the import is creating an alias and the alias matches
492 the sought name. Pass current->import_src as the NAME to
493 direct the search towards the aliased namespace. */
495 sym = cp_lookup_symbol_in_namespace (scope,
499 else if (current->alias == NULL)
501 /* If this import statement creates no alias, pass
502 current->inner as NAMESPACE to direct the search
503 towards the imported namespace. */
504 sym = cp_lookup_symbol_imports (current->import_src,
508 current->searched = 0;
509 discard_cleanups (searched_cleanup);
519 /* Helper function that searches an array of symbols for one named
522 static struct symbol *
523 search_symbol_list (const char *name, int num,
524 struct symbol **syms)
528 /* Maybe we should store a dictionary in here instead. */
529 for (i = 0; i < num; ++i)
531 if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
537 /* Like cp_lookup_symbol_imports, but if BLOCK is a function, it
538 searches through the template parameters of the function and the
542 cp_lookup_symbol_imports_or_template (const char *scope,
544 const struct block *block,
545 const domain_enum domain)
547 struct symbol *function = BLOCK_FUNCTION (block);
549 if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
551 /* Search the function's template parameters. */
552 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
554 struct template_symbol *templ
555 = (struct template_symbol *) function;
556 struct symbol *result;
558 result = search_symbol_list (name,
559 templ->n_template_arguments,
560 templ->template_arguments);
565 /* Search the template parameters of the function's defining
567 if (SYMBOL_NATURAL_NAME (function))
569 struct type *context;
570 char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
571 struct cleanup *cleanups = make_cleanup (xfree, name_copy);
572 const struct language_defn *lang = language_def (language_cplus);
574 = get_objfile_arch (SYMBOL_OBJFILE (function));
575 const struct block *parent = BLOCK_SUPERBLOCK (block);
579 struct symbol *result;
580 unsigned int prefix_len = cp_entire_prefix_len (name_copy);
586 name_copy[prefix_len] = '\0';
587 context = lookup_typename (lang, arch,
596 = search_symbol_list (name,
597 TYPE_N_TEMPLATE_ARGUMENTS (context),
598 TYPE_TEMPLATE_ARGUMENTS (context));
601 do_cleanups (cleanups);
606 do_cleanups (cleanups);
610 return cp_lookup_symbol_imports (scope, name, block, domain, 1, 1);
613 /* Searches for NAME in the current namespace, and by applying
614 relevant import statements belonging to BLOCK and its parents.
615 SCOPE is the namespace scope of the context in which the search is
619 cp_lookup_symbol_namespace (const char *scope,
621 const struct block *block,
622 const domain_enum domain)
626 /* First, try to find the symbol in the given namespace. */
627 sym = cp_lookup_symbol_in_namespace (scope, name,
632 /* Search for name in namespaces imported to this and parent
634 while (block != NULL)
636 sym = cp_lookup_symbol_imports (scope, name, block,
642 block = BLOCK_SUPERBLOCK (block);
648 /* Lookup NAME at namespace scope (or, in C terms, in static and
649 global variables). SCOPE is the namespace that the current
650 function is defined within; only consider namespaces whose length
651 is at least SCOPE_LEN. Other arguments are as in
652 cp_lookup_symbol_nonlocal.
654 For example, if we're within a function A::B::f and looking for a
655 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
656 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
657 but with SCOPE_LEN = 1. And then it calls itself with NAME and
658 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
659 "A::B::x"; if it doesn't find it, then the second call looks for
660 "A::x", and if that call fails, then the first call looks for
663 static struct symbol *
664 lookup_namespace_scope (const char *name,
665 const struct block *block,
666 const domain_enum domain,
672 if (scope[scope_len] != '\0')
674 /* Recursively search for names in child namespaces first. */
677 int new_scope_len = scope_len;
679 /* If the current scope is followed by "::", skip past that. */
680 if (new_scope_len != 0)
682 gdb_assert (scope[new_scope_len] == ':');
685 new_scope_len += cp_find_first_component (scope + new_scope_len);
686 sym = lookup_namespace_scope (name, block, domain,
687 scope, new_scope_len);
692 /* Okay, we didn't find a match in our children, so look for the
693 name in the current namespace. */
695 namespace = alloca (scope_len + 1);
696 strncpy (namespace, scope, scope_len);
697 namespace[scope_len] = '\0';
698 return cp_lookup_symbol_in_namespace (namespace, name,
702 /* Search through the base classes of PARENT_TYPE for a base class
703 named NAME and return its type. If not found, return NULL. */
706 find_type_baseclass_by_name (struct type *parent_type, const char *name)
710 CHECK_TYPEDEF (parent_type);
711 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
713 struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
714 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
716 if (base_name == NULL)
719 if (streq (base_name, name))
722 type = find_type_baseclass_by_name (type, name);
730 /* Search through the base classes of PARENT_TYPE for a symbol named
731 NAME in block BLOCK. */
733 static struct symbol *
734 find_symbol_in_baseclass (struct type *parent_type, const char *name,
735 const struct block *block)
739 struct cleanup *cleanup;
740 char *concatenated_name;
743 concatenated_name = NULL;
744 cleanup = make_cleanup (free_current_contents, &concatenated_name);
745 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
748 struct type *base_type = TYPE_BASECLASS (parent_type, i);
749 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
751 if (base_name == NULL)
754 /* Search this particular base class. */
755 sym = cp_lookup_symbol_in_namespace (base_name, name, block,
760 /* Now search all static file-level symbols. We have to do this for
761 things like typedefs in the class. First search in this symtab,
762 what we want is possibly there. */
763 len = strlen (base_name) + 2 + strlen (name) + 1;
764 concatenated_name = xrealloc (concatenated_name, len);
765 xsnprintf (concatenated_name, len, "%s::%s", base_name, name);
766 sym = lookup_symbol_in_static_block (concatenated_name, block,
771 /* Nope. We now have to search all static blocks in all objfiles,
772 even if block != NULL, because there's no guarantees as to which
773 symtab the symbol we want is in. */
774 sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
778 /* If this class has base classes, search them next. */
779 CHECK_TYPEDEF (base_type);
780 if (TYPE_N_BASECLASSES (base_type) > 0)
782 sym = find_symbol_in_baseclass (base_type, name, block);
788 do_cleanups (cleanup);
792 /* Look up a symbol named NESTED_NAME that is nested inside the C++
793 class or namespace given by PARENT_TYPE, from within the context
794 given by BLOCK. Return NULL if there is no such nested type. */
797 cp_lookup_nested_symbol (struct type *parent_type,
798 const char *nested_name,
799 const struct block *block)
801 /* type_name_no_tag_required provides better error reporting using the
803 struct type *saved_parent_type = parent_type;
805 CHECK_TYPEDEF (parent_type);
807 switch (TYPE_CODE (parent_type))
809 case TYPE_CODE_STRUCT:
810 case TYPE_CODE_NAMESPACE:
811 case TYPE_CODE_UNION:
813 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
814 specific code to lookup nested symbols in modules, by calling the
815 function pointer la_lookup_symbol_nonlocal, which ends up here. */
816 case TYPE_CODE_MODULE:
818 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
819 of classes like, say, data or function members. Instead,
820 they're just represented by symbols whose names are
821 qualified by the name of the surrounding class. This is
822 just like members of namespaces; in particular,
823 lookup_symbol_namespace works when looking them up. */
826 const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
828 = cp_lookup_symbol_in_namespace (parent_name, nested_name,
829 block, VAR_DOMAIN, 0);
830 char *concatenated_name;
835 /* Now search all static file-level symbols. We have to do this
836 for things like typedefs in the class. We do not try to
837 guess any imported namespace as even the fully specified
838 namespace search is already not C++ compliant and more
839 assumptions could make it too magic. */
841 size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
842 concatenated_name = alloca (size);
843 xsnprintf (concatenated_name, size, "%s::%s",
844 parent_name, nested_name);
845 sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
849 /* If no matching symbols were found, try searching any
851 return find_symbol_in_baseclass (parent_type, nested_name, block);
855 case TYPE_CODE_METHOD:
859 internal_error (__FILE__, __LINE__,
860 _("cp_lookup_nested_symbol called "
861 "on a non-aggregate type."));
865 /* The C++-version of lookup_transparent_type. */
867 /* FIXME: carlton/2004-01-16: The problem that this is trying to
868 address is that, unfortunately, sometimes NAME is wrong: it may not
869 include the name of namespaces enclosing the type in question.
870 lookup_transparent_type gets called when the type in question
871 is a declaration, and we're trying to find its definition; but, for
872 declarations, our type name deduction mechanism doesn't work.
873 There's nothing we can do to fix this in general, I think, in the
874 absence of debug information about namespaces (I've filed PR
875 gdb/1511 about this); until such debug information becomes more
876 prevalent, one heuristic which sometimes looks is to search for the
877 definition in namespaces containing the current namespace.
879 We should delete this functions once the appropriate debug
880 information becomes more widespread. (GCC 3.4 will be the first
881 released version of GCC with such information.) */
884 cp_lookup_transparent_type (const char *name)
886 /* First, try the honest way of looking up the definition. */
887 struct type *t = basic_lookup_transparent_type (name);
893 /* If that doesn't work and we're within a namespace, look there
895 scope = block_scope (get_selected_block (0));
897 if (scope[0] == '\0')
900 return cp_lookup_transparent_type_loop (name, scope, 0);
903 /* Lookup the type definition associated to NAME in namespaces/classes
904 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
905 must be the index of the start of a component of SCOPE. */
908 cp_lookup_transparent_type_loop (const char *name,
912 int scope_length = length + cp_find_first_component (scope + length);
915 /* If the current scope is followed by "::", look in the next
917 if (scope[scope_length] == ':')
920 = cp_lookup_transparent_type_loop (name, scope,
927 full_name = alloca (scope_length + 2 + strlen (name) + 1);
928 strncpy (full_name, scope, scope_length);
929 strncpy (full_name + scope_length, "::", 2);
930 strcpy (full_name + scope_length + 2, name);
932 return basic_lookup_transparent_type (full_name);
935 /* This used to do something but was removed when it became
939 maintenance_cplus_namespace (char *args, int from_tty)
941 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
944 /* Provide a prototype to silence -Wmissing-prototypes. */
945 extern initialize_file_ftype _initialize_cp_namespace;
948 _initialize_cp_namespace (void)
950 struct cmd_list_element *cmd;
952 cmd = add_cmd ("namespace", class_maintenance,
953 maintenance_cplus_namespace,
954 _("Deprecated placeholder for removed functionality."),
955 &maint_cplus_cmd_list);
956 deprecate_cmd (cmd, NULL);