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"
36 static struct block_symbol
37 cp_lookup_nested_symbol_1 (struct type
*container_type
,
38 const char *nested_name
,
39 const char *concatenated_name
,
40 const struct block
*block
,
41 const domain_enum domain
,
42 int basic_lookup
, int is_in_anonymous
);
44 static struct type
*cp_lookup_transparent_type_loop (const char *name
,
48 /* Check to see if SYMBOL refers to an object contained within an
49 anonymous namespace; if so, add an appropriate using directive. */
52 cp_scan_for_anonymous_namespaces (const struct symbol
*const symbol
,
53 struct objfile
*const objfile
)
55 if (SYMBOL_DEMANGLED_NAME (symbol
) != NULL
)
57 const char *name
= SYMBOL_DEMANGLED_NAME (symbol
);
58 unsigned int previous_component
;
59 unsigned int next_component
;
61 /* Start with a quick-and-dirty check for mention of "(anonymous
64 if (!cp_is_in_anonymous (name
))
67 previous_component
= 0;
68 next_component
= cp_find_first_component (name
+ previous_component
);
70 while (name
[next_component
] == ':')
72 if (((next_component
- previous_component
)
73 == CP_ANONYMOUS_NAMESPACE_LEN
)
74 && strncmp (name
+ previous_component
,
75 CP_ANONYMOUS_NAMESPACE_STR
,
76 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
78 int dest_len
= (previous_component
== 0
79 ? 0 : previous_component
- 2);
80 int src_len
= next_component
;
82 char *dest
= (char *) alloca (dest_len
+ 1);
83 char *src
= (char *) alloca (src_len
+ 1);
85 memcpy (dest
, name
, dest_len
);
86 memcpy (src
, name
, src_len
);
88 dest
[dest_len
] = '\0';
91 /* We've found a component of the name that's an
92 anonymous namespace. So add symbols in it to the
93 namespace given by the previous component if there is
94 one, or to the global namespace if there isn't. */
95 add_using_directive (&local_using_directives
,
96 dest
, src
, NULL
, NULL
, NULL
, 1,
97 &objfile
->objfile_obstack
);
99 /* The "+ 2" is for the "::". */
100 previous_component
= next_component
+ 2;
101 next_component
= (previous_component
102 + cp_find_first_component (name
103 + previous_component
));
108 /* Test whether or not NAMESPACE looks like it mentions an anonymous
109 namespace; return nonzero if so. */
112 cp_is_in_anonymous (const char *symbol_name
)
114 return (strstr (symbol_name
, CP_ANONYMOUS_NAMESPACE_STR
)
118 /* Look up NAME in DOMAIN in BLOCK's static block and in global blocks.
119 If IS_IN_ANONYMOUS is nonzero, the symbol in question is located
120 within an anonymous namespace. */
122 static struct block_symbol
123 cp_basic_lookup_symbol (const char *name
, const struct block
*block
,
124 const domain_enum domain
, int is_in_anonymous
)
126 struct block_symbol sym
;
128 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
129 if (sym
.symbol
!= NULL
)
134 /* Symbols defined in anonymous namespaces have external linkage
135 but should be treated as local to a single file nonetheless.
136 So we only search the current file's global block. */
138 const struct block
*global_block
= block_global_block (block
);
140 if (global_block
!= NULL
)
142 sym
.symbol
= lookup_symbol_in_block (name
, global_block
, domain
);
143 sym
.block
= global_block
;
147 sym
= lookup_global_symbol (name
, block
, domain
);
152 /* Search bare symbol NAME in DOMAIN in BLOCK.
153 NAME is guaranteed to not have any scope (no "::") in its name, though
154 if for example NAME is a template spec then "::" may appear in the
156 If LANGDEF is non-NULL then try to lookup NAME as a primitive type in
157 that language. Normally we wouldn't need LANGDEF but fortran also uses
159 If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
160 if so then also search for NAME in that class. */
162 static struct block_symbol
163 cp_lookup_bare_symbol (const struct language_defn
*langdef
,
164 const char *name
, const struct block
*block
,
165 const domain_enum domain
, int search
)
167 struct block_symbol sym
;
169 /* Note: We can't do a simple assert for ':' not being in NAME because
170 ':' may be in the args of a template spec. This isn't intended to be
171 a complete test, just cheap and documentary. */
172 if (strchr (name
, '<') == NULL
&& strchr (name
, '(') == NULL
)
173 gdb_assert (strstr (name
, "::") == NULL
);
175 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
176 if (sym
.symbol
!= NULL
)
179 /* If we didn't find a definition for a builtin type in the static block,
180 search for it now. This is actually the right thing to do and can be
181 a massive performance win. E.g., when debugging a program with lots of
182 shared libraries we could search all of them only to find out the
183 builtin type isn't defined in any of them. This is common for types
185 if (langdef
!= NULL
&& domain
== VAR_DOMAIN
)
187 struct gdbarch
*gdbarch
;
190 gdbarch
= target_gdbarch ();
192 gdbarch
= block_gdbarch (block
);
194 = language_lookup_primitive_type_as_symbol (langdef
, gdbarch
, name
);
196 if (sym
.symbol
!= NULL
)
200 sym
= lookup_global_symbol (name
, block
, domain
);
201 if (sym
.symbol
!= NULL
)
206 struct block_symbol lang_this
;
209 lang_this
.symbol
= NULL
;
212 lang_this
= lookup_language_this (langdef
, block
);
214 if (lang_this
.symbol
== NULL
)
215 return null_block_symbol
;
218 type
= check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this
.symbol
)));
219 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
220 This can happen for lambda functions compiled with clang++,
221 which outputs no name for the container class. */
222 if (TYPE_NAME (type
) == NULL
)
223 return null_block_symbol
;
225 /* Look for symbol NAME in this class. */
226 sym
= cp_lookup_nested_symbol (type
, name
, block
, domain
);
232 /* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
233 BLOCK specifies the context in which to perform the search.
234 NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
235 the length of the entire scope of NAME (up to, but not including, the last
238 Note: At least in the case of Fortran, which also uses this code, there
239 may be no text after the last "::". */
241 static struct block_symbol
242 cp_search_static_and_baseclasses (const char *name
,
243 const struct block
*block
,
244 const domain_enum domain
,
245 unsigned int prefix_len
,
248 struct block_symbol sym
;
249 char *klass
, *nested
;
250 struct cleanup
*cleanup
;
251 struct block_symbol klass_sym
;
252 struct type
*klass_type
;
254 /* Check for malformed input. */
255 if (prefix_len
+ 2 > strlen (name
) || name
[prefix_len
+ 1] != ':')
256 return null_block_symbol
;
258 /* Find the name of the class and the name of the method, variable, etc. */
260 /* The class name is everything up to and including PREFIX_LEN. */
261 klass
= savestring (name
, prefix_len
);
263 /* The rest of the name is everything else past the initial scope
265 nested
= xstrdup (name
+ prefix_len
+ 2);
267 /* Add cleanups to free memory for these strings. */
268 cleanup
= make_cleanup (xfree
, klass
);
269 make_cleanup (xfree
, nested
);
271 /* Lookup a class named KLASS. If none is found, there is nothing
272 more that can be done. KLASS could be a namespace, so always look
273 in VAR_DOMAIN. This works for classes too because of
274 symbol_matches_domain (which should be replaced with something else,
275 but it's what we have today). */
276 klass_sym
= lookup_global_symbol (klass
, block
, VAR_DOMAIN
);
277 if (klass_sym
.symbol
== NULL
)
279 do_cleanups (cleanup
);
280 return null_block_symbol
;
282 klass_type
= SYMBOL_TYPE (klass_sym
.symbol
);
284 /* Look for a symbol named NESTED in this class.
285 The caller is assumed to have already have done a basic lookup of NAME.
286 So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here. */
287 sym
= cp_lookup_nested_symbol_1 (klass_type
, nested
, name
, block
, domain
,
290 do_cleanups (cleanup
);
294 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
295 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
296 through base classes for a matching symbol.
298 Note: Part of the complexity is because NAME may itself specify scope.
299 Part of the complexity is also because this handles the case where
300 there is no scoping in which case we also try looking in the class of
301 "this" if we can compute it. */
303 static struct block_symbol
304 cp_lookup_symbol_in_namespace (const char *the_namespace
, const char *name
,
305 const struct block
*block
,
306 const domain_enum domain
, int search
)
308 char *concatenated_name
= NULL
;
310 unsigned int prefix_len
;
311 struct block_symbol sym
;
313 if (the_namespace
[0] != '\0')
316 = (char *) alloca (strlen (the_namespace
) + 2 + strlen (name
) + 1);
317 strcpy (concatenated_name
, the_namespace
);
318 strcat (concatenated_name
, "::");
319 strcat (concatenated_name
, name
);
320 name
= concatenated_name
;
323 prefix_len
= cp_entire_prefix_len (name
);
325 return cp_lookup_bare_symbol (NULL
, name
, block
, domain
, search
);
327 /* This would be simpler if we just called cp_lookup_nested_symbol
328 at this point. But that would require first looking up the containing
329 class/namespace. Since we're only searching static and global blocks
330 there's often no need to first do that lookup. */
333 = the_namespace
[0] != '\0' && cp_is_in_anonymous (the_namespace
);
334 sym
= cp_basic_lookup_symbol (name
, block
, domain
, is_in_anonymous
);
335 if (sym
.symbol
!= NULL
)
339 sym
= cp_search_static_and_baseclasses (name
, block
, domain
, prefix_len
,
345 /* Used for cleanups to reset the "searched" flag in case of an error. */
348 reset_directive_searched (void *data
)
350 struct using_direct
*direct
= (struct using_direct
*) data
;
351 direct
->searched
= 0;
354 /* Search for NAME by applying all import statements belonging to
355 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
356 search is restricted to using declarations.
364 If SEARCH_PARENTS the search will include imports which are
365 applicable in parents of SCOPE.
375 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
376 namespaces X and Y will be considered. If SEARCH_PARENTS is false
377 only the import of Y is considered.
379 SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
380 pass 0 for it. Internally we pass 1 when recursing. */
382 static struct block_symbol
383 cp_lookup_symbol_via_imports (const char *scope
,
385 const struct block
*block
,
386 const domain_enum domain
,
387 const int search_scope_first
,
388 const int declaration_only
,
389 const int search_parents
)
391 struct using_direct
*current
;
392 struct block_symbol sym
;
395 struct cleanup
*searched_cleanup
;
400 /* First, try to find the symbol in the given namespace if requested. */
401 if (search_scope_first
)
402 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
405 if (sym
.symbol
!= NULL
)
408 /* Go through the using directives. If any of them add new names to
409 the namespace we're searching in, see if we can find a match by
412 for (current
= block_using (block
);
414 current
= current
->next
)
416 const char **excludep
;
418 len
= strlen (current
->import_dest
);
419 directive_match
= (search_parents
420 ? (startswith (scope
, current
->import_dest
)
423 || scope
[len
] == '\0'))
424 : strcmp (scope
, current
->import_dest
) == 0);
426 /* If the import destination is the current scope or one of its
427 ancestors then it is applicable. */
428 if (directive_match
&& !current
->searched
)
430 /* Mark this import as searched so that the recursive call
431 does not search it again. */
432 current
->searched
= 1;
433 searched_cleanup
= make_cleanup (reset_directive_searched
,
436 /* If there is an import of a single declaration, compare the
437 imported declaration (after optional renaming by its alias)
438 with the sought out name. If there is a match pass
439 current->import_src as NAMESPACE to direct the search
440 towards the imported namespace. */
441 if (current
->declaration
442 && strcmp (name
, current
->alias
443 ? current
->alias
: current
->declaration
) == 0)
444 sym
= cp_lookup_symbol_in_namespace (current
->import_src
,
445 current
->declaration
,
448 /* If this is a DECLARATION_ONLY search or a symbol was found
449 or this import statement was an import declaration, the
450 search of this import is complete. */
451 if (declaration_only
|| sym
.symbol
!= NULL
|| current
->declaration
)
453 current
->searched
= 0;
454 discard_cleanups (searched_cleanup
);
456 if (sym
.symbol
!= NULL
)
462 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
463 for (excludep
= current
->excludes
; *excludep
; excludep
++)
464 if (strcmp (name
, *excludep
) == 0)
468 discard_cleanups (searched_cleanup
);
472 if (current
->alias
!= NULL
473 && strcmp (name
, current
->alias
) == 0)
474 /* If the import is creating an alias and the alias matches
475 the sought name. Pass current->import_src as the NAME to
476 direct the search towards the aliased namespace. */
478 sym
= cp_lookup_symbol_in_namespace (scope
,
482 else if (current
->alias
== NULL
)
484 /* If this import statement creates no alias, pass
485 current->inner as NAMESPACE to direct the search
486 towards the imported namespace. */
487 sym
= cp_lookup_symbol_via_imports (current
->import_src
,
491 current
->searched
= 0;
492 discard_cleanups (searched_cleanup
);
494 if (sym
.symbol
!= NULL
)
499 return null_block_symbol
;
502 /* Helper function that searches an array of symbols for one named NAME. */
504 static struct symbol
*
505 search_symbol_list (const char *name
, int num
,
506 struct symbol
**syms
)
510 /* Maybe we should store a dictionary in here instead. */
511 for (i
= 0; i
< num
; ++i
)
513 if (strcmp (name
, SYMBOL_NATURAL_NAME (syms
[i
])) == 0)
519 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
520 searches through the template parameters of the function and the
524 cp_lookup_symbol_imports_or_template (const char *scope
,
526 const struct block
*block
,
527 const domain_enum domain
)
529 struct symbol
*function
= BLOCK_FUNCTION (block
);
530 struct block_symbol result
;
532 if (symbol_lookup_debug
)
534 fprintf_unfiltered (gdb_stdlog
,
535 "cp_lookup_symbol_imports_or_template"
536 " (%s, %s, %s, %s)\n",
537 scope
, name
, host_address_to_string (block
),
538 domain_name (domain
));
541 if (function
!= NULL
&& SYMBOL_LANGUAGE (function
) == language_cplus
)
543 /* Search the function's template parameters. */
544 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function
))
546 struct template_symbol
*templ
547 = (struct template_symbol
*) function
;
548 struct symbol
*sym
= search_symbol_list (name
,
549 templ
->n_template_arguments
,
550 templ
->template_arguments
);
554 if (symbol_lookup_debug
)
556 fprintf_unfiltered (gdb_stdlog
,
557 "cp_lookup_symbol_imports_or_template"
559 host_address_to_string (sym
));
561 return (struct block_symbol
) {sym
, block
};
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
);
573 struct gdbarch
*arch
= symbol_arch (function
);
574 const struct block
*parent
= BLOCK_SUPERBLOCK (block
);
579 unsigned int prefix_len
= cp_entire_prefix_len (name_copy
);
585 name_copy
[prefix_len
] = '\0';
586 context
= lookup_typename (lang
, arch
,
595 = search_symbol_list (name
,
596 TYPE_N_TEMPLATE_ARGUMENTS (context
),
597 TYPE_TEMPLATE_ARGUMENTS (context
));
600 do_cleanups (cleanups
);
601 if (symbol_lookup_debug
)
605 "cp_lookup_symbol_imports_or_template (...) = %s\n",
606 host_address_to_string (sym
));
608 return (struct block_symbol
) {sym
, parent
};
612 do_cleanups (cleanups
);
616 result
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 0, 1, 1);
617 if (symbol_lookup_debug
)
619 fprintf_unfiltered (gdb_stdlog
,
620 "cp_lookup_symbol_imports_or_template (...) = %s\n",
621 result
.symbol
!= NULL
622 ? host_address_to_string (result
.symbol
) : "NULL");
627 /* Search for NAME by applying relevant import statements belonging to BLOCK
628 and its parents. SCOPE is the namespace scope of the context in which the
629 search is being evaluated. */
631 static struct block_symbol
632 cp_lookup_symbol_via_all_imports (const char *scope
, const char *name
,
633 const struct block
*block
,
634 const domain_enum domain
)
636 struct block_symbol sym
;
638 while (block
!= NULL
)
640 sym
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 0, 0, 1);
644 block
= BLOCK_SUPERBLOCK (block
);
647 return null_block_symbol
;
650 /* Searches for NAME in the current namespace, and by applying
651 relevant import statements belonging to BLOCK and its parents.
652 SCOPE is the namespace scope of the context in which the search is
656 cp_lookup_symbol_namespace (const char *scope
,
658 const struct block
*block
,
659 const domain_enum domain
)
661 struct block_symbol sym
;
663 if (symbol_lookup_debug
)
665 fprintf_unfiltered (gdb_stdlog
,
666 "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
667 scope
, name
, host_address_to_string (block
),
668 domain_name (domain
));
671 /* First, try to find the symbol in the given namespace. */
672 sym
= cp_lookup_symbol_in_namespace (scope
, name
, block
, domain
, 1);
674 /* Search for name in namespaces imported to this and parent blocks. */
675 if (sym
.symbol
== NULL
)
676 sym
= cp_lookup_symbol_via_all_imports (scope
, name
, block
, domain
);
678 if (symbol_lookup_debug
)
680 fprintf_unfiltered (gdb_stdlog
,
681 "cp_lookup_symbol_namespace (...) = %s\n",
683 ? host_address_to_string (sym
.symbol
) : "NULL");
688 /* Lookup NAME at namespace scope (or, in C terms, in static and
689 global variables). SCOPE is the namespace that the current
690 function is defined within; only consider namespaces whose length
691 is at least SCOPE_LEN. Other arguments are as in
692 cp_lookup_symbol_nonlocal.
694 For example, if we're within a function A::B::f and looking for a
695 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
696 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
697 but with SCOPE_LEN = 1. And then it calls itself with NAME and
698 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
699 "A::B::x"; if it doesn't find it, then the second call looks for
700 "A::x", and if that call fails, then the first call looks for
703 static struct block_symbol
704 lookup_namespace_scope (const struct language_defn
*langdef
,
706 const struct block
*block
,
707 const domain_enum domain
,
713 if (scope
[scope_len
] != '\0')
715 /* Recursively search for names in child namespaces first. */
717 struct block_symbol sym
;
718 int new_scope_len
= scope_len
;
720 /* If the current scope is followed by "::", skip past that. */
721 if (new_scope_len
!= 0)
723 gdb_assert (scope
[new_scope_len
] == ':');
726 new_scope_len
+= cp_find_first_component (scope
+ new_scope_len
);
727 sym
= lookup_namespace_scope (langdef
, name
, block
, domain
,
728 scope
, new_scope_len
);
729 if (sym
.symbol
!= NULL
)
733 /* Okay, we didn't find a match in our children, so look for the
734 name in the current namespace.
736 If we there is no scope and we know we have a bare symbol, then short
737 circuit everything and call cp_lookup_bare_symbol directly.
738 This isn't an optimization, rather it allows us to pass LANGDEF which
739 is needed for primitive type lookup. The test doesn't have to be
740 perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
741 template symbol with "::" in the argument list) then
742 cp_lookup_symbol_in_namespace will catch it. */
744 if (scope_len
== 0 && strchr (name
, ':') == NULL
)
745 return cp_lookup_bare_symbol (langdef
, name
, block
, domain
, 1);
747 the_namespace
= (char *) alloca (scope_len
+ 1);
748 strncpy (the_namespace
, scope
, scope_len
);
749 the_namespace
[scope_len
] = '\0';
750 return cp_lookup_symbol_in_namespace (the_namespace
, name
,
754 /* The C++-specific version of name lookup for static and global
755 names. This makes sure that names get looked for in all namespaces
756 that are in scope. NAME is the natural name of the symbol that
757 we're looking for, BLOCK is the block that we're searching within,
758 DOMAIN says what kind of symbols we're looking for. */
761 cp_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
763 const struct block
*block
,
764 const domain_enum domain
)
766 struct block_symbol sym
;
767 const char *scope
= block_scope (block
);
769 if (symbol_lookup_debug
)
771 fprintf_unfiltered (gdb_stdlog
,
772 "cp_lookup_symbol_non_local"
773 " (%s, %s (scope %s), %s)\n",
774 name
, host_address_to_string (block
), scope
,
775 domain_name (domain
));
778 /* First, try to find the symbol in the given namespace, and all
779 containing namespaces. */
780 sym
= lookup_namespace_scope (langdef
, name
, block
, domain
, scope
, 0);
782 /* Search for name in namespaces imported to this and parent blocks. */
783 if (sym
.symbol
== NULL
)
784 sym
= cp_lookup_symbol_via_all_imports (scope
, name
, block
, domain
);
786 if (symbol_lookup_debug
)
788 fprintf_unfiltered (gdb_stdlog
,
789 "cp_lookup_symbol_nonlocal (...) = %s\n",
791 ? host_address_to_string (sym
.symbol
)
797 /* Search through the base classes of PARENT_TYPE for a base class
798 named NAME and return its type. If not found, return NULL. */
801 cp_find_type_baseclass_by_name (struct type
*parent_type
, const char *name
)
805 parent_type
= check_typedef (parent_type
);
806 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
808 struct type
*type
= check_typedef (TYPE_BASECLASS (parent_type
, i
));
809 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
811 if (base_name
== NULL
)
814 if (streq (base_name
, name
))
817 type
= cp_find_type_baseclass_by_name (type
, name
);
825 /* Search through the base classes of PARENT_TYPE for a symbol named
826 NAME in block BLOCK. */
828 static struct block_symbol
829 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
830 const struct block
*block
, const domain_enum domain
,
834 struct block_symbol sym
;
835 struct cleanup
*cleanup
;
836 char *concatenated_name
;
840 concatenated_name
= NULL
;
841 cleanup
= make_cleanup (free_current_contents
, &concatenated_name
);
843 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
846 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
847 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
849 if (base_name
== NULL
)
852 len
= strlen (base_name
) + 2 + strlen (name
) + 1;
853 concatenated_name
= (char *) xrealloc (concatenated_name
, len
);
854 xsnprintf (concatenated_name
, len
, "%s::%s", base_name
, name
);
856 sym
= cp_lookup_nested_symbol_1 (base_type
, name
, concatenated_name
,
857 block
, domain
, 1, is_in_anonymous
);
858 if (sym
.symbol
!= NULL
)
862 do_cleanups (cleanup
);
866 /* Helper function to look up NESTED_NAME in CONTAINER_TYPE and in DOMAIN
867 and within the context of BLOCK.
868 NESTED_NAME may have scope ("::").
869 CONTAINER_TYPE needn't have been "check_typedef'd" yet.
870 CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
871 passed as an argument so that callers can control how space for it is
873 If BASIC_LOOKUP is non-zero then perform a basic lookup of
874 CONCATENATED_NAME. See cp_basic_lookup_symbol for details.
875 If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
878 static struct block_symbol
879 cp_lookup_nested_symbol_1 (struct type
*container_type
,
880 const char *nested_name
,
881 const char *concatenated_name
,
882 const struct block
*block
,
883 const domain_enum domain
,
884 int basic_lookup
, int is_in_anonymous
)
886 struct block_symbol sym
;
888 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
889 of classes like, say, data or function members. Instead,
890 they're just represented by symbols whose names are
891 qualified by the name of the surrounding class. This is
892 just like members of namespaces; in particular,
893 cp_basic_lookup_symbol works when looking them up. */
897 sym
= cp_basic_lookup_symbol (concatenated_name
, block
, domain
,
899 if (sym
.symbol
!= NULL
)
903 /* Now search all static file-level symbols. We have to do this for things
904 like typedefs in the class. We do not try to guess any imported
905 namespace as even the fully specified namespace search is already not
906 C++ compliant and more assumptions could make it too magic. */
908 /* First search in this symtab, what we want is possibly there. */
909 sym
= lookup_symbol_in_static_block (concatenated_name
, block
, domain
);
910 if (sym
.symbol
!= NULL
)
913 /* Nope. We now have to search all static blocks in all objfiles,
914 even if block != NULL, because there's no guarantees as to which
915 symtab the symbol we want is in. Except for symbols defined in
916 anonymous namespaces should be treated as local to a single file,
917 which we just searched. */
918 if (!is_in_anonymous
)
920 sym
= lookup_static_symbol (concatenated_name
, domain
);
921 if (sym
.symbol
!= NULL
)
925 /* If this is a class with baseclasses, search them next. */
926 container_type
= check_typedef (container_type
);
927 if (TYPE_N_BASECLASSES (container_type
) > 0)
929 sym
= find_symbol_in_baseclass (container_type
, nested_name
, block
,
930 domain
, is_in_anonymous
);
931 if (sym
.symbol
!= NULL
)
935 return null_block_symbol
;
938 /* Look up a symbol named NESTED_NAME that is nested inside the C++
939 class or namespace given by PARENT_TYPE, from within the context
940 given by BLOCK, and in DOMAIN.
941 Return NULL if there is no such nested symbol. */
944 cp_lookup_nested_symbol (struct type
*parent_type
,
945 const char *nested_name
,
946 const struct block
*block
,
947 const domain_enum domain
)
949 /* type_name_no_tag_or_error provides better error reporting using the
951 struct type
*saved_parent_type
= parent_type
;
953 parent_type
= check_typedef (parent_type
);
955 if (symbol_lookup_debug
)
957 const char *type_name
= type_name_no_tag (saved_parent_type
);
959 fprintf_unfiltered (gdb_stdlog
,
960 "cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
961 type_name
!= NULL
? type_name
: "unnamed",
962 nested_name
, host_address_to_string (block
),
963 domain_name (domain
));
966 switch (TYPE_CODE (parent_type
))
968 case TYPE_CODE_STRUCT
:
969 case TYPE_CODE_NAMESPACE
:
970 case TYPE_CODE_UNION
:
972 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
973 specific code to lookup nested symbols in modules, by calling the
974 function pointer la_lookup_symbol_nonlocal, which ends up here. */
975 case TYPE_CODE_MODULE
:
978 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
979 struct block_symbol sym
;
980 char *concatenated_name
;
983 size
= strlen (parent_name
) + 2 + strlen (nested_name
) + 1;
984 concatenated_name
= (char *) alloca (size
);
985 xsnprintf (concatenated_name
, size
, "%s::%s",
986 parent_name
, nested_name
);
987 is_in_anonymous
= cp_is_in_anonymous (concatenated_name
);
989 sym
= cp_lookup_nested_symbol_1 (parent_type
, nested_name
,
990 concatenated_name
, block
, domain
,
993 if (symbol_lookup_debug
)
995 fprintf_unfiltered (gdb_stdlog
,
996 "cp_lookup_nested_symbol (...) = %s\n",
998 ? host_address_to_string (sym
.symbol
)
1004 case TYPE_CODE_FUNC
:
1005 case TYPE_CODE_METHOD
:
1006 if (symbol_lookup_debug
)
1008 fprintf_unfiltered (gdb_stdlog
,
1009 "cp_lookup_nested_symbol (...) = NULL"
1010 " (func/method)\n");
1012 return null_block_symbol
;
1015 internal_error (__FILE__
, __LINE__
,
1016 _("cp_lookup_nested_symbol called "
1017 "on a non-aggregate type."));
1021 /* The C++-version of lookup_transparent_type. */
1023 /* FIXME: carlton/2004-01-16: The problem that this is trying to
1024 address is that, unfortunately, sometimes NAME is wrong: it may not
1025 include the name of namespaces enclosing the type in question.
1026 lookup_transparent_type gets called when the type in question
1027 is a declaration, and we're trying to find its definition; but, for
1028 declarations, our type name deduction mechanism doesn't work.
1029 There's nothing we can do to fix this in general, I think, in the
1030 absence of debug information about namespaces (I've filed PR
1031 gdb/1511 about this); until such debug information becomes more
1032 prevalent, one heuristic which sometimes looks is to search for the
1033 definition in namespaces containing the current namespace.
1035 We should delete this functions once the appropriate debug
1036 information becomes more widespread. (GCC 3.4 will be the first
1037 released version of GCC with such information.) */
1040 cp_lookup_transparent_type (const char *name
)
1042 /* First, try the honest way of looking up the definition. */
1043 struct type
*t
= basic_lookup_transparent_type (name
);
1049 /* If that doesn't work and we're within a namespace, look there
1051 scope
= block_scope (get_selected_block (0));
1053 if (scope
[0] == '\0')
1056 return cp_lookup_transparent_type_loop (name
, scope
, 0);
1059 /* Lookup the type definition associated to NAME in namespaces/classes
1060 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
1061 must be the index of the start of a component of SCOPE. */
1063 static struct type
*
1064 cp_lookup_transparent_type_loop (const char *name
,
1068 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
1071 /* If the current scope is followed by "::", look in the next
1073 if (scope
[scope_length
] == ':')
1076 = cp_lookup_transparent_type_loop (name
, scope
,
1083 full_name
= (char *) alloca (scope_length
+ 2 + strlen (name
) + 1);
1084 strncpy (full_name
, scope
, scope_length
);
1085 strncpy (full_name
+ scope_length
, "::", 2);
1086 strcpy (full_name
+ scope_length
+ 2, name
);
1088 return basic_lookup_transparent_type (full_name
);
1091 /* This used to do something but was removed when it became
1095 maintenance_cplus_namespace (char *args
, int from_tty
)
1097 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1100 /* Provide a prototype to silence -Wmissing-prototypes. */
1101 extern initialize_file_ftype _initialize_cp_namespace
;
1104 _initialize_cp_namespace (void)
1106 struct cmd_list_element
*cmd
;
1108 cmd
= add_cmd ("namespace", class_maintenance
,
1109 maintenance_cplus_namespace
,
1110 _("Deprecated placeholder for removed functionality."),
1111 &maint_cplus_cmd_list
);
1112 deprecate_cmd (cmd
, NULL
);