1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2003-2013 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"
26 #include "gdb_assert.h"
30 #include "dictionary.h"
36 static struct symbol *lookup_namespace_scope (const char *name,
37 const struct block *block,
38 const domain_enum domain,
42 static struct symbol *lookup_symbol_file (const char *name,
43 const struct block *block,
44 const domain_enum domain,
45 int anonymous_namespace,
48 static struct type *cp_lookup_transparent_type_loop (const char *name,
52 /* Check to see if SYMBOL refers to an object contained within an
53 anonymous namespace; if so, add an appropriate using directive. */
56 cp_scan_for_anonymous_namespaces (const struct symbol *const symbol,
57 struct objfile *const objfile)
59 if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
61 const char *name = SYMBOL_DEMANGLED_NAME (symbol);
62 unsigned int previous_component;
63 unsigned int next_component;
65 /* Start with a quick-and-dirty check for mention of "(anonymous
68 if (!cp_is_anonymous (name))
71 previous_component = 0;
72 next_component = cp_find_first_component (name + previous_component);
74 while (name[next_component] == ':')
76 if (((next_component - previous_component)
77 == CP_ANONYMOUS_NAMESPACE_LEN)
78 && strncmp (name + previous_component,
79 CP_ANONYMOUS_NAMESPACE_STR,
80 CP_ANONYMOUS_NAMESPACE_LEN) == 0)
82 int dest_len = (previous_component == 0
83 ? 0 : previous_component - 2);
84 int src_len = next_component;
86 char *dest = alloca (dest_len + 1);
87 char *src = alloca (src_len + 1);
89 memcpy (dest, name, dest_len);
90 memcpy (src, name, src_len);
92 dest[dest_len] = '\0';
95 /* We've found a component of the name that's an
96 anonymous namespace. So add symbols in it to the
97 namespace given by the previous component if there is
98 one, or to the global namespace if there isn't. */
99 cp_add_using_directive (dest, src, NULL, NULL, NULL, 1,
100 &objfile->objfile_obstack);
102 /* The "+ 2" is for the "::". */
103 previous_component = next_component + 2;
104 next_component = (previous_component
105 + cp_find_first_component (name
106 + previous_component));
112 /* Add a using directive to using_directives. If the using directive
113 in question has already been added, don't add it twice.
115 Create a new struct using_direct which imports the namespace SRC
116 into the scope DEST. ALIAS is the name of the imported namespace
117 in the current scope. If ALIAS is NULL then the namespace is known
118 by its original name. DECLARATION is the name if the imported
119 varable if this is a declaration import (Eg. using A::x), otherwise
120 it is NULL. EXCLUDES is a list of names not to import from an
121 imported module or NULL. If COPY_NAMES is non-zero, then the
122 arguments are copied into newly allocated memory so they can be
123 temporaries. For EXCLUDES the VEC pointers are copied but the
124 pointed to characters are not copied. */
127 cp_add_using_directive (const char *dest,
130 const char *declaration,
131 VEC (const_char_ptr) *excludes,
133 struct obstack *obstack)
135 struct using_direct *current;
136 struct using_direct *new;
138 /* Has it already been added? */
140 for (current = using_directives; current != NULL; current = current->next)
145 if (strcmp (current->import_src, src) != 0)
147 if (strcmp (current->import_dest, dest) != 0)
149 if ((alias == NULL && current->alias != NULL)
150 || (alias != NULL && current->alias == NULL)
151 || (alias != NULL && current->alias != NULL
152 && strcmp (alias, current->alias) != 0))
154 if ((declaration == NULL && current->declaration != NULL)
155 || (declaration != NULL && current->declaration == NULL)
156 || (declaration != NULL && current->declaration != NULL
157 && strcmp (declaration, current->declaration) != 0))
160 /* Compare the contents of EXCLUDES. */
161 for (ix = 0; VEC_iterate (const_char_ptr, excludes, ix, param); ix++)
162 if (current->excludes[ix] == NULL
163 || strcmp (param, current->excludes[ix]) != 0)
165 if (ix < VEC_length (const_char_ptr, excludes)
166 || current->excludes[ix] != NULL)
169 /* Parameters exactly match CURRENT. */
173 new = obstack_alloc (obstack, (sizeof (*new)
174 + (VEC_length (const_char_ptr, excludes)
175 * sizeof (*new->excludes))));
176 memset (new, 0, sizeof (*new));
180 new->import_src = obstack_copy0 (obstack, src, strlen (src));
181 new->import_dest = obstack_copy0 (obstack, dest, strlen (dest));
185 new->import_src = src;
186 new->import_dest = dest;
189 if (alias != NULL && copy_names)
190 new->alias = obstack_copy0 (obstack, alias, strlen (alias));
194 if (declaration != NULL && copy_names)
195 new->declaration = obstack_copy0 (obstack,
196 declaration, strlen (declaration));
198 new->declaration = declaration;
200 memcpy (new->excludes, VEC_address (const_char_ptr, excludes),
201 VEC_length (const_char_ptr, excludes) * sizeof (*new->excludes));
202 new->excludes[VEC_length (const_char_ptr, excludes)] = NULL;
204 new->next = using_directives;
205 using_directives = new;
208 /* Test whether or not NAMESPACE looks like it mentions an anonymous
209 namespace; return nonzero if so. */
212 cp_is_anonymous (const char *namespace)
214 return (strstr (namespace, CP_ANONYMOUS_NAMESPACE_STR)
218 /* The C++-specific version of name lookup for static and global
219 names. This makes sure that names get looked for in all namespaces
220 that are in scope. NAME is the natural name of the symbol that
221 we're looking for, BLOCK is the block that we're searching within,
222 DOMAIN says what kind of symbols we're looking for, and if SYMTAB
223 is non-NULL, we should store the symtab where we found the symbol
227 cp_lookup_symbol_nonlocal (const char *name,
228 const struct block *block,
229 const domain_enum domain)
232 const char *scope = block_scope (block);
234 sym = lookup_namespace_scope (name, block,
239 return cp_lookup_symbol_namespace (scope, name,
243 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
244 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
245 through base classes for a matching symbol. */
247 static struct symbol *
248 cp_lookup_symbol_in_namespace (const char *namespace,
250 const struct block *block,
251 const domain_enum domain, int search)
253 if (namespace[0] == '\0')
255 return lookup_symbol_file (name, block, domain, 0, search);
259 char *concatenated_name = alloca (strlen (namespace) + 2
260 + strlen (name) + 1);
262 strcpy (concatenated_name, namespace);
263 strcat (concatenated_name, "::");
264 strcat (concatenated_name, name);
265 return lookup_symbol_file (concatenated_name, block, domain,
266 cp_is_anonymous (namespace), search);
270 /* Used for cleanups to reset the "searched" flag incase
274 reset_directive_searched (void *data)
276 struct using_direct *direct = data;
277 direct->searched = 0;
280 /* Search for NAME by applying all import statements belonging to
281 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
282 search is restricted to using declarations.
290 If SEARCH_PARENTS the search will include imports which are
291 applicable in parents of SCOPE.
301 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
302 namespaces X and Y will be considered. If SEARCH_PARENTS is false
303 only the import of Y is considered. */
306 cp_lookup_symbol_imports (const char *scope,
308 const struct block *block,
309 const domain_enum domain,
310 const int declaration_only,
311 const int search_parents)
313 struct using_direct *current;
314 struct symbol *sym = NULL;
317 struct cleanup *searched_cleanup;
319 /* First, try to find the symbol in the given namespace. */
320 if (!declaration_only)
321 sym = cp_lookup_symbol_in_namespace (scope, name,
327 /* Go through the using directives. If any of them add new names to
328 the namespace we're searching in, see if we can find a match by
331 for (current = block_using (block);
333 current = current->next)
335 const char **excludep;
337 len = strlen (current->import_dest);
338 directive_match = (search_parents
339 ? (strncmp (scope, current->import_dest,
340 strlen (current->import_dest)) == 0
343 || scope[len] == '\0'))
344 : strcmp (scope, current->import_dest) == 0);
346 /* If the import destination is the current scope or one of its
347 ancestors then it is applicable. */
348 if (directive_match && !current->searched)
350 /* Mark this import as searched so that the recursive call
351 does not search it again. */
352 current->searched = 1;
353 searched_cleanup = make_cleanup (reset_directive_searched,
356 /* If there is an import of a single declaration, compare the
357 imported declaration (after optional renaming by its alias)
358 with the sought out name. If there is a match pass
359 current->import_src as NAMESPACE to direct the search
360 towards the imported namespace. */
361 if (current->declaration
362 && strcmp (name, current->alias
363 ? current->alias : current->declaration) == 0)
364 sym = cp_lookup_symbol_in_namespace (current->import_src,
365 current->declaration,
368 /* If this is a DECLARATION_ONLY search or a symbol was found
369 or this import statement was an import declaration, the
370 search of this import is complete. */
371 if (declaration_only || sym != NULL || current->declaration)
373 current->searched = 0;
374 discard_cleanups (searched_cleanup);
382 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
383 for (excludep = current->excludes; *excludep; excludep++)
384 if (strcmp (name, *excludep) == 0)
388 discard_cleanups (searched_cleanup);
392 if (current->alias != NULL
393 && strcmp (name, current->alias) == 0)
394 /* If the import is creating an alias and the alias matches
395 the sought name. Pass current->import_src as the NAME to
396 direct the search towards the aliased namespace. */
398 sym = cp_lookup_symbol_in_namespace (scope,
402 else if (current->alias == NULL)
404 /* If this import statement creates no alias, pass
405 current->inner as NAMESPACE to direct the search
406 towards the imported namespace. */
407 sym = cp_lookup_symbol_imports (current->import_src,
411 current->searched = 0;
412 discard_cleanups (searched_cleanup);
422 /* Helper function that searches an array of symbols for one named
425 static struct symbol *
426 search_symbol_list (const char *name, int num,
427 struct symbol **syms)
431 /* Maybe we should store a dictionary in here instead. */
432 for (i = 0; i < num; ++i)
434 if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
440 /* Like cp_lookup_symbol_imports, but if BLOCK is a function, it
441 searches through the template parameters of the function and the
445 cp_lookup_symbol_imports_or_template (const char *scope,
447 const struct block *block,
448 const domain_enum domain)
450 struct symbol *function = BLOCK_FUNCTION (block);
452 if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
454 /* Search the function's template parameters. */
455 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
457 struct template_symbol *templ
458 = (struct template_symbol *) function;
459 struct symbol *result;
461 result = search_symbol_list (name,
462 templ->n_template_arguments,
463 templ->template_arguments);
468 /* Search the template parameters of the function's defining
470 if (SYMBOL_NATURAL_NAME (function))
472 struct type *context;
473 char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
474 struct cleanup *cleanups = make_cleanup (xfree, name_copy);
475 const struct language_defn *lang = language_def (language_cplus);
476 struct gdbarch *arch = SYMBOL_SYMTAB (function)->objfile->gdbarch;
477 const struct block *parent = BLOCK_SUPERBLOCK (block);
481 struct symbol *result;
482 unsigned int prefix_len = cp_entire_prefix_len (name_copy);
488 name_copy[prefix_len] = '\0';
489 context = lookup_typename (lang, arch,
498 = search_symbol_list (name,
499 TYPE_N_TEMPLATE_ARGUMENTS (context),
500 TYPE_TEMPLATE_ARGUMENTS (context));
505 do_cleanups (cleanups);
509 return cp_lookup_symbol_imports (scope, name, block, domain, 1, 1);
512 /* Searches for NAME in the current namespace, and by applying
513 relevant import statements belonging to BLOCK and its parents.
514 SCOPE is the namespace scope of the context in which the search is
518 cp_lookup_symbol_namespace (const char *scope,
520 const struct block *block,
521 const domain_enum domain)
525 /* First, try to find the symbol in the given namespace. */
526 sym = cp_lookup_symbol_in_namespace (scope, name,
531 /* Search for name in namespaces imported to this and parent
533 while (block != NULL)
535 sym = cp_lookup_symbol_imports (scope, name, block,
541 block = BLOCK_SUPERBLOCK (block);
547 /* Lookup NAME at namespace scope (or, in C terms, in static and
548 global variables). SCOPE is the namespace that the current
549 function is defined within; only consider namespaces whose length
550 is at least SCOPE_LEN. Other arguments are as in
551 cp_lookup_symbol_nonlocal.
553 For example, if we're within a function A::B::f and looking for a
554 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
555 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
556 but with SCOPE_LEN = 1. And then it calls itself with NAME and
557 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
558 "A::B::x"; if it doesn't find it, then the second call looks for
559 "A::x", and if that call fails, then the first call looks for
562 static struct symbol *
563 lookup_namespace_scope (const char *name,
564 const struct block *block,
565 const domain_enum domain,
571 if (scope[scope_len] != '\0')
573 /* Recursively search for names in child namespaces first. */
576 int new_scope_len = scope_len;
578 /* If the current scope is followed by "::", skip past that. */
579 if (new_scope_len != 0)
581 gdb_assert (scope[new_scope_len] == ':');
584 new_scope_len += cp_find_first_component (scope + new_scope_len);
585 sym = lookup_namespace_scope (name, block, domain,
586 scope, new_scope_len);
591 /* Okay, we didn't find a match in our children, so look for the
592 name in the current namespace. */
594 namespace = alloca (scope_len + 1);
595 strncpy (namespace, scope, scope_len);
596 namespace[scope_len] = '\0';
597 return cp_lookup_symbol_in_namespace (namespace, name,
601 /* Look up NAME in BLOCK's static block and in global blocks. If
602 ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
603 within an anonymous namespace. If SEARCH is non-zero, search through
604 base classes for a matching symbol. Other arguments are as in
605 cp_lookup_symbol_nonlocal. */
607 static struct symbol *
608 lookup_symbol_file (const char *name,
609 const struct block *block,
610 const domain_enum domain,
611 int anonymous_namespace, int search)
613 struct symbol *sym = NULL;
615 sym = lookup_symbol_static (name, block, domain);
619 if (anonymous_namespace)
621 /* Symbols defined in anonymous namespaces have external linkage
622 but should be treated as local to a single file nonetheless.
623 So we only search the current file's global block. */
625 const struct block *global_block = block_global_block (block);
627 if (global_block != NULL)
628 sym = lookup_symbol_aux_block (name, global_block, domain);
632 sym = lookup_symbol_global (name, block, domain);
640 char *klass, *nested;
641 unsigned int prefix_len;
642 struct cleanup *cleanup;
643 struct symbol *klass_sym;
645 /* A simple lookup failed. Check if the symbol was defined in
648 cleanup = make_cleanup (null_cleanup, NULL);
650 /* Find the name of the class and the name of the method,
652 prefix_len = cp_entire_prefix_len (name);
654 /* If no prefix was found, search "this". */
660 this = lookup_language_this (language_def (language_cplus), block);
663 do_cleanups (cleanup);
667 type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
668 klass = xstrdup (TYPE_NAME (type));
669 nested = xstrdup (name);
673 /* The class name is everything up to and including PREFIX_LEN. */
674 klass = savestring (name, prefix_len);
676 /* The rest of the name is everything else past the initial scope
678 nested = xstrdup (name + prefix_len + 2);
681 /* Add cleanups to free memory for these strings. */
682 make_cleanup (xfree, klass);
683 make_cleanup (xfree, nested);
685 /* Lookup a class named KLASS. If none is found, there is nothing
686 more that can be done. */
687 klass_sym = lookup_symbol_global (klass, block, domain);
688 if (klass_sym == NULL)
690 do_cleanups (cleanup);
694 /* Look for a symbol named NESTED in this class. */
695 sym = cp_lookup_nested_symbol (SYMBOL_TYPE (klass_sym), nested, block);
696 do_cleanups (cleanup);
702 /* Search through the base classes of PARENT_TYPE for a symbol named
703 NAME in block BLOCK. */
705 static struct symbol *
706 find_symbol_in_baseclass (struct type *parent_type, const char *name,
707 const struct block *block)
711 struct cleanup *cleanup;
712 char *concatenated_name;
715 concatenated_name = NULL;
716 cleanup = make_cleanup (free_current_contents, &concatenated_name);
717 for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
720 const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
722 if (base_name == NULL)
725 /* Search this particular base class. */
726 sym = cp_lookup_symbol_namespace (base_name, name, block, VAR_DOMAIN);
730 len = strlen (base_name) + 2 + strlen (name) + 1;
731 concatenated_name = xrealloc (concatenated_name, len);
732 xsnprintf (concatenated_name, len, "%s::%s", base_name, name);
733 sym = lookup_symbol_static (concatenated_name, block, VAR_DOMAIN);
735 /* If there is currently no BLOCK, e.g., the inferior hasn't yet
736 been started, then try searching all STATIC_BLOCK symbols in
740 sym = lookup_static_symbol_aux (concatenated_name, VAR_DOMAIN);
745 /* If this class has base classes, search them next. */
746 if (TYPE_N_BASECLASSES (TYPE_BASECLASS (parent_type, i)) > 0)
748 sym = find_symbol_in_baseclass (TYPE_BASECLASS (parent_type, i),
755 do_cleanups (cleanup);
759 /* Look up a symbol named NESTED_NAME that is nested inside the C++
760 class or namespace given by PARENT_TYPE, from within the context
761 given by BLOCK. Return NULL if there is no such nested type. */
764 cp_lookup_nested_symbol (struct type *parent_type,
765 const char *nested_name,
766 const struct block *block)
768 /* type_name_no_tag_required provides better error reporting using the
770 struct type *saved_parent_type = parent_type;
772 CHECK_TYPEDEF (parent_type);
774 switch (TYPE_CODE (parent_type))
776 case TYPE_CODE_STRUCT:
777 case TYPE_CODE_NAMESPACE:
778 case TYPE_CODE_UNION:
780 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
781 of classes like, say, data or function members. Instead,
782 they're just represented by symbols whose names are
783 qualified by the name of the surrounding class. This is
784 just like members of namespaces; in particular,
785 lookup_symbol_namespace works when looking them up. */
788 const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
790 = cp_lookup_symbol_in_namespace (parent_name, nested_name,
791 block, VAR_DOMAIN, 0);
792 char *concatenated_name;
797 /* Now search all static file-level symbols. Not strictly
798 correct, but more useful than an error. We do not try to
799 guess any imported namespace as even the fully specified
800 namespace search is already not C++ compliant and more
801 assumptions could make it too magic. */
803 size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
804 concatenated_name = alloca (size);
805 xsnprintf (concatenated_name, size, "%s::%s",
806 parent_name, nested_name);
807 sym = lookup_static_symbol_aux (concatenated_name, VAR_DOMAIN);
811 /* If no matching symbols were found, try searching any
813 return find_symbol_in_baseclass (parent_type, nested_name, block);
816 internal_error (__FILE__, __LINE__,
817 _("cp_lookup_nested_symbol called "
818 "on a non-aggregate type."));
822 /* The C++-version of lookup_transparent_type. */
824 /* FIXME: carlton/2004-01-16: The problem that this is trying to
825 address is that, unfortunately, sometimes NAME is wrong: it may not
826 include the name of namespaces enclosing the type in question.
827 lookup_transparent_type gets called when the type in question
828 is a declaration, and we're trying to find its definition; but, for
829 declarations, our type name deduction mechanism doesn't work.
830 There's nothing we can do to fix this in general, I think, in the
831 absence of debug information about namespaces (I've filed PR
832 gdb/1511 about this); until such debug information becomes more
833 prevalent, one heuristic which sometimes looks is to search for the
834 definition in namespaces containing the current namespace.
836 We should delete this functions once the appropriate debug
837 information becomes more widespread. (GCC 3.4 will be the first
838 released version of GCC with such information.) */
841 cp_lookup_transparent_type (const char *name)
843 /* First, try the honest way of looking up the definition. */
844 struct type *t = basic_lookup_transparent_type (name);
850 /* If that doesn't work and we're within a namespace, look there
852 scope = block_scope (get_selected_block (0));
854 if (scope[0] == '\0')
857 return cp_lookup_transparent_type_loop (name, scope, 0);
860 /* Lookup the type definition associated to NAME in namespaces/classes
861 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
862 must be the index of the start of a component of SCOPE. */
865 cp_lookup_transparent_type_loop (const char *name,
869 int scope_length = length + cp_find_first_component (scope + length);
872 /* If the current scope is followed by "::", look in the next
874 if (scope[scope_length] == ':')
877 = cp_lookup_transparent_type_loop (name, scope,
884 full_name = alloca (scope_length + 2 + strlen (name) + 1);
885 strncpy (full_name, scope, scope_length);
886 strncpy (full_name + scope_length, "::", 2);
887 strcpy (full_name + scope_length + 2, name);
889 return basic_lookup_transparent_type (full_name);
892 /* This used to do something but was removed when it became
896 maintenance_cplus_namespace (char *args, int from_tty)
898 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
901 /* Provide a prototype to silence -Wmissing-prototypes. */
902 extern initialize_file_ftype _initialize_cp_namespace;
905 _initialize_cp_namespace (void)
907 struct cmd_list_element *cmd;
909 cmd = add_cmd ("namespace", class_maintenance,
910 maintenance_cplus_namespace,
911 _("Deprecated placeholder for removed functionality."),
912 &maint_cplus_cmd_list);
913 deprecate_cmd (cmd, NULL);