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
;
210 lang_this
= lookup_language_this (langdef
, block
);
212 if (lang_this
.symbol
== NULL
)
213 return null_block_symbol
;
216 type
= check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this
.symbol
)));
217 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
218 This can happen for lambda functions compiled with clang++,
219 which outputs no name for the container class. */
220 if (TYPE_NAME (type
) == NULL
)
221 return null_block_symbol
;
223 /* Look for symbol NAME in this class. */
224 sym
= cp_lookup_nested_symbol (type
, name
, block
, domain
);
230 /* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
231 BLOCK specifies the context in which to perform the search.
232 NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
233 the length of the entire scope of NAME (up to, but not including, the last
236 Note: At least in the case of Fortran, which also uses this code, there
237 may be no text after the last "::". */
239 static struct block_symbol
240 cp_search_static_and_baseclasses (const char *name
,
241 const struct block
*block
,
242 const domain_enum domain
,
243 unsigned int prefix_len
,
246 struct block_symbol sym
;
247 char *klass
, *nested
;
248 struct cleanup
*cleanup
;
249 struct block_symbol klass_sym
;
250 struct type
*klass_type
;
252 /* Check for malformed input. */
253 if (prefix_len
+ 2 > strlen (name
) || name
[prefix_len
+ 1] != ':')
254 return null_block_symbol
;
256 /* Find the name of the class and the name of the method, variable, etc. */
258 /* The class name is everything up to and including PREFIX_LEN. */
259 klass
= savestring (name
, prefix_len
);
261 /* The rest of the name is everything else past the initial scope
263 nested
= xstrdup (name
+ prefix_len
+ 2);
265 /* Add cleanups to free memory for these strings. */
266 cleanup
= make_cleanup (xfree
, klass
);
267 make_cleanup (xfree
, nested
);
269 /* Lookup a class named KLASS. If none is found, there is nothing
270 more that can be done. KLASS could be a namespace, so always look
271 in VAR_DOMAIN. This works for classes too because of
272 symbol_matches_domain (which should be replaced with something else,
273 but it's what we have today). */
274 klass_sym
= lookup_global_symbol (klass
, block
, VAR_DOMAIN
);
275 if (klass_sym
.symbol
== NULL
)
277 do_cleanups (cleanup
);
278 return null_block_symbol
;
280 klass_type
= SYMBOL_TYPE (klass_sym
.symbol
);
282 /* Look for a symbol named NESTED in this class.
283 The caller is assumed to have already have done a basic lookup of NAME.
284 So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here. */
285 sym
= cp_lookup_nested_symbol_1 (klass_type
, nested
, name
, block
, domain
,
288 do_cleanups (cleanup
);
292 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
293 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
294 through base classes for a matching symbol.
296 Note: Part of the complexity is because NAME may itself specify scope.
297 Part of the complexity is also because this handles the case where
298 there is no scoping in which case we also try looking in the class of
299 "this" if we can compute it. */
301 static struct block_symbol
302 cp_lookup_symbol_in_namespace (const char *the_namespace
, const char *name
,
303 const struct block
*block
,
304 const domain_enum domain
, int search
)
306 char *concatenated_name
= NULL
;
308 unsigned int prefix_len
;
309 struct block_symbol sym
;
311 if (the_namespace
[0] != '\0')
314 = (char *) alloca (strlen (the_namespace
) + 2 + strlen (name
) + 1);
315 strcpy (concatenated_name
, the_namespace
);
316 strcat (concatenated_name
, "::");
317 strcat (concatenated_name
, name
);
318 name
= concatenated_name
;
321 prefix_len
= cp_entire_prefix_len (name
);
323 return cp_lookup_bare_symbol (NULL
, name
, block
, domain
, search
);
325 /* This would be simpler if we just called cp_lookup_nested_symbol
326 at this point. But that would require first looking up the containing
327 class/namespace. Since we're only searching static and global blocks
328 there's often no need to first do that lookup. */
331 = the_namespace
[0] != '\0' && cp_is_in_anonymous (the_namespace
);
332 sym
= cp_basic_lookup_symbol (name
, block
, domain
, is_in_anonymous
);
333 if (sym
.symbol
!= NULL
)
337 sym
= cp_search_static_and_baseclasses (name
, block
, domain
, prefix_len
,
343 /* Used for cleanups to reset the "searched" flag in case of an error. */
346 reset_directive_searched (void *data
)
348 struct using_direct
*direct
= (struct using_direct
*) data
;
349 direct
->searched
= 0;
352 /* Search for NAME by applying all import statements belonging to
353 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
354 search is restricted to using declarations.
362 If SEARCH_PARENTS the search will include imports which are
363 applicable in parents of SCOPE.
373 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
374 namespaces X and Y will be considered. If SEARCH_PARENTS is false
375 only the import of Y is considered.
377 SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
378 pass 0 for it. Internally we pass 1 when recursing. */
380 static struct block_symbol
381 cp_lookup_symbol_via_imports (const char *scope
,
383 const struct block
*block
,
384 const domain_enum domain
,
385 const int search_scope_first
,
386 const int declaration_only
,
387 const int search_parents
)
389 struct using_direct
*current
;
390 struct block_symbol sym
;
393 struct cleanup
*searched_cleanup
;
398 /* First, try to find the symbol in the given namespace if requested. */
399 if (search_scope_first
)
400 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
403 if (sym
.symbol
!= NULL
)
406 /* Go through the using directives. If any of them add new names to
407 the namespace we're searching in, see if we can find a match by
410 for (current
= block_using (block
);
412 current
= current
->next
)
414 const char **excludep
;
416 len
= strlen (current
->import_dest
);
417 directive_match
= (search_parents
418 ? (startswith (scope
, current
->import_dest
)
421 || scope
[len
] == '\0'))
422 : strcmp (scope
, current
->import_dest
) == 0);
424 /* If the import destination is the current scope or one of its
425 ancestors then it is applicable. */
426 if (directive_match
&& !current
->searched
)
428 /* Mark this import as searched so that the recursive call
429 does not search it again. */
430 current
->searched
= 1;
431 searched_cleanup
= make_cleanup (reset_directive_searched
,
434 /* If there is an import of a single declaration, compare the
435 imported declaration (after optional renaming by its alias)
436 with the sought out name. If there is a match pass
437 current->import_src as NAMESPACE to direct the search
438 towards the imported namespace. */
439 if (current
->declaration
440 && strcmp (name
, current
->alias
441 ? current
->alias
: current
->declaration
) == 0)
442 sym
= cp_lookup_symbol_in_namespace (current
->import_src
,
443 current
->declaration
,
446 /* If this is a DECLARATION_ONLY search or a symbol was found
447 or this import statement was an import declaration, the
448 search of this import is complete. */
449 if (declaration_only
|| sym
.symbol
!= NULL
|| current
->declaration
)
451 current
->searched
= 0;
452 discard_cleanups (searched_cleanup
);
454 if (sym
.symbol
!= NULL
)
460 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
461 for (excludep
= current
->excludes
; *excludep
; excludep
++)
462 if (strcmp (name
, *excludep
) == 0)
466 discard_cleanups (searched_cleanup
);
470 if (current
->alias
!= NULL
471 && strcmp (name
, current
->alias
) == 0)
472 /* If the import is creating an alias and the alias matches
473 the sought name. Pass current->import_src as the NAME to
474 direct the search towards the aliased namespace. */
476 sym
= cp_lookup_symbol_in_namespace (scope
,
480 else if (current
->alias
== NULL
)
482 /* If this import statement creates no alias, pass
483 current->inner as NAMESPACE to direct the search
484 towards the imported namespace. */
485 sym
= cp_lookup_symbol_via_imports (current
->import_src
,
489 current
->searched
= 0;
490 discard_cleanups (searched_cleanup
);
492 if (sym
.symbol
!= NULL
)
497 return null_block_symbol
;
500 /* Helper function that searches an array of symbols for one named NAME. */
502 static struct symbol
*
503 search_symbol_list (const char *name
, int num
,
504 struct symbol
**syms
)
508 /* Maybe we should store a dictionary in here instead. */
509 for (i
= 0; i
< num
; ++i
)
511 if (strcmp (name
, SYMBOL_NATURAL_NAME (syms
[i
])) == 0)
517 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
518 searches through the template parameters of the function and the
522 cp_lookup_symbol_imports_or_template (const char *scope
,
524 const struct block
*block
,
525 const domain_enum domain
)
527 struct symbol
*function
= BLOCK_FUNCTION (block
);
528 struct block_symbol result
;
530 if (symbol_lookup_debug
)
532 fprintf_unfiltered (gdb_stdlog
,
533 "cp_lookup_symbol_imports_or_template"
534 " (%s, %s, %s, %s)\n",
535 scope
, name
, host_address_to_string (block
),
536 domain_name (domain
));
539 if (function
!= NULL
&& SYMBOL_LANGUAGE (function
) == language_cplus
)
541 /* Search the function's template parameters. */
542 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function
))
544 struct template_symbol
*templ
545 = (struct template_symbol
*) function
;
546 struct symbol
*sym
= search_symbol_list (name
,
547 templ
->n_template_arguments
,
548 templ
->template_arguments
);
552 if (symbol_lookup_debug
)
554 fprintf_unfiltered (gdb_stdlog
,
555 "cp_lookup_symbol_imports_or_template"
557 host_address_to_string (sym
));
559 return (struct block_symbol
) {sym
, block
};
563 /* Search the template parameters of the function's defining
565 if (SYMBOL_NATURAL_NAME (function
))
567 struct type
*context
;
568 char *name_copy
= xstrdup (SYMBOL_NATURAL_NAME (function
));
569 struct cleanup
*cleanups
= make_cleanup (xfree
, name_copy
);
570 const struct language_defn
*lang
= language_def (language_cplus
);
571 struct gdbarch
*arch
= symbol_arch (function
);
572 const struct block
*parent
= BLOCK_SUPERBLOCK (block
);
577 unsigned int prefix_len
= cp_entire_prefix_len (name_copy
);
583 name_copy
[prefix_len
] = '\0';
584 context
= lookup_typename (lang
, arch
,
593 = search_symbol_list (name
,
594 TYPE_N_TEMPLATE_ARGUMENTS (context
),
595 TYPE_TEMPLATE_ARGUMENTS (context
));
598 do_cleanups (cleanups
);
599 if (symbol_lookup_debug
)
603 "cp_lookup_symbol_imports_or_template (...) = %s\n",
604 host_address_to_string (sym
));
606 return (struct block_symbol
) {sym
, parent
};
610 do_cleanups (cleanups
);
614 result
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 0, 1, 1);
615 if (symbol_lookup_debug
)
617 fprintf_unfiltered (gdb_stdlog
,
618 "cp_lookup_symbol_imports_or_template (...) = %s\n",
619 result
.symbol
!= NULL
620 ? host_address_to_string (result
.symbol
) : "NULL");
625 /* Search for NAME by applying relevant import statements belonging to BLOCK
626 and its parents. SCOPE is the namespace scope of the context in which the
627 search is being evaluated. */
629 static struct block_symbol
630 cp_lookup_symbol_via_all_imports (const char *scope
, const char *name
,
631 const struct block
*block
,
632 const domain_enum domain
)
634 struct block_symbol sym
;
636 while (block
!= NULL
)
638 sym
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 0, 0, 1);
642 block
= BLOCK_SUPERBLOCK (block
);
645 return null_block_symbol
;
648 /* Searches for NAME in the current namespace, and by applying
649 relevant import statements belonging to BLOCK and its parents.
650 SCOPE is the namespace scope of the context in which the search is
654 cp_lookup_symbol_namespace (const char *scope
,
656 const struct block
*block
,
657 const domain_enum domain
)
659 struct block_symbol sym
;
661 if (symbol_lookup_debug
)
663 fprintf_unfiltered (gdb_stdlog
,
664 "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
665 scope
, name
, host_address_to_string (block
),
666 domain_name (domain
));
669 /* First, try to find the symbol in the given namespace. */
670 sym
= cp_lookup_symbol_in_namespace (scope
, name
, block
, domain
, 1);
672 /* Search for name in namespaces imported to this and parent blocks. */
673 if (sym
.symbol
== NULL
)
674 sym
= cp_lookup_symbol_via_all_imports (scope
, name
, block
, domain
);
676 if (symbol_lookup_debug
)
678 fprintf_unfiltered (gdb_stdlog
,
679 "cp_lookup_symbol_namespace (...) = %s\n",
681 ? host_address_to_string (sym
.symbol
) : "NULL");
686 /* Lookup NAME at namespace scope (or, in C terms, in static and
687 global variables). SCOPE is the namespace that the current
688 function is defined within; only consider namespaces whose length
689 is at least SCOPE_LEN. Other arguments are as in
690 cp_lookup_symbol_nonlocal.
692 For example, if we're within a function A::B::f and looking for a
693 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
694 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
695 but with SCOPE_LEN = 1. And then it calls itself with NAME and
696 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
697 "A::B::x"; if it doesn't find it, then the second call looks for
698 "A::x", and if that call fails, then the first call looks for
701 static struct block_symbol
702 lookup_namespace_scope (const struct language_defn
*langdef
,
704 const struct block
*block
,
705 const domain_enum domain
,
711 if (scope
[scope_len
] != '\0')
713 /* Recursively search for names in child namespaces first. */
715 struct block_symbol sym
;
716 int new_scope_len
= scope_len
;
718 /* If the current scope is followed by "::", skip past that. */
719 if (new_scope_len
!= 0)
721 gdb_assert (scope
[new_scope_len
] == ':');
724 new_scope_len
+= cp_find_first_component (scope
+ new_scope_len
);
725 sym
= lookup_namespace_scope (langdef
, name
, block
, domain
,
726 scope
, new_scope_len
);
727 if (sym
.symbol
!= NULL
)
731 /* Okay, we didn't find a match in our children, so look for the
732 name in the current namespace.
734 If we there is no scope and we know we have a bare symbol, then short
735 circuit everything and call cp_lookup_bare_symbol directly.
736 This isn't an optimization, rather it allows us to pass LANGDEF which
737 is needed for primitive type lookup. The test doesn't have to be
738 perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
739 template symbol with "::" in the argument list) then
740 cp_lookup_symbol_in_namespace will catch it. */
742 if (scope_len
== 0 && strchr (name
, ':') == NULL
)
743 return cp_lookup_bare_symbol (langdef
, name
, block
, domain
, 1);
745 the_namespace
= (char *) alloca (scope_len
+ 1);
746 strncpy (the_namespace
, scope
, scope_len
);
747 the_namespace
[scope_len
] = '\0';
748 return cp_lookup_symbol_in_namespace (the_namespace
, name
,
752 /* The C++-specific version of name lookup for static and global
753 names. This makes sure that names get looked for in all namespaces
754 that are in scope. NAME is the natural name of the symbol that
755 we're looking for, BLOCK is the block that we're searching within,
756 DOMAIN says what kind of symbols we're looking for. */
759 cp_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
761 const struct block
*block
,
762 const domain_enum domain
)
764 struct block_symbol sym
;
765 const char *scope
= block_scope (block
);
767 if (symbol_lookup_debug
)
769 fprintf_unfiltered (gdb_stdlog
,
770 "cp_lookup_symbol_non_local"
771 " (%s, %s (scope %s), %s)\n",
772 name
, host_address_to_string (block
), scope
,
773 domain_name (domain
));
776 /* First, try to find the symbol in the given namespace, and all
777 containing namespaces. */
778 sym
= lookup_namespace_scope (langdef
, name
, block
, domain
, scope
, 0);
780 /* Search for name in namespaces imported to this and parent blocks. */
781 if (sym
.symbol
== NULL
)
782 sym
= cp_lookup_symbol_via_all_imports (scope
, name
, block
, domain
);
784 if (symbol_lookup_debug
)
786 fprintf_unfiltered (gdb_stdlog
,
787 "cp_lookup_symbol_nonlocal (...) = %s\n",
789 ? host_address_to_string (sym
.symbol
)
795 /* Search through the base classes of PARENT_TYPE for a base class
796 named NAME and return its type. If not found, return NULL. */
799 cp_find_type_baseclass_by_name (struct type
*parent_type
, const char *name
)
803 parent_type
= check_typedef (parent_type
);
804 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
806 struct type
*type
= check_typedef (TYPE_BASECLASS (parent_type
, i
));
807 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
809 if (base_name
== NULL
)
812 if (streq (base_name
, name
))
815 type
= cp_find_type_baseclass_by_name (type
, name
);
823 /* Search through the base classes of PARENT_TYPE for a symbol named
824 NAME in block BLOCK. */
826 static struct block_symbol
827 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
828 const struct block
*block
, const domain_enum domain
,
832 struct block_symbol sym
;
833 struct cleanup
*cleanup
;
834 char *concatenated_name
;
838 concatenated_name
= NULL
;
839 cleanup
= make_cleanup (free_current_contents
, &concatenated_name
);
841 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
844 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
845 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
847 if (base_name
== NULL
)
850 len
= strlen (base_name
) + 2 + strlen (name
) + 1;
851 concatenated_name
= (char *) xrealloc (concatenated_name
, len
);
852 xsnprintf (concatenated_name
, len
, "%s::%s", base_name
, name
);
854 sym
= cp_lookup_nested_symbol_1 (base_type
, name
, concatenated_name
,
855 block
, domain
, 1, is_in_anonymous
);
856 if (sym
.symbol
!= NULL
)
860 do_cleanups (cleanup
);
864 /* Helper function to look up NESTED_NAME in CONTAINER_TYPE and in DOMAIN
865 and within the context of BLOCK.
866 NESTED_NAME may have scope ("::").
867 CONTAINER_TYPE needn't have been "check_typedef'd" yet.
868 CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
869 passed as an argument so that callers can control how space for it is
871 If BASIC_LOOKUP is non-zero then perform a basic lookup of
872 CONCATENATED_NAME. See cp_basic_lookup_symbol for details.
873 If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
876 static struct block_symbol
877 cp_lookup_nested_symbol_1 (struct type
*container_type
,
878 const char *nested_name
,
879 const char *concatenated_name
,
880 const struct block
*block
,
881 const domain_enum domain
,
882 int basic_lookup
, int is_in_anonymous
)
884 struct block_symbol sym
;
886 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
887 of classes like, say, data or function members. Instead,
888 they're just represented by symbols whose names are
889 qualified by the name of the surrounding class. This is
890 just like members of namespaces; in particular,
891 cp_basic_lookup_symbol works when looking them up. */
895 sym
= cp_basic_lookup_symbol (concatenated_name
, block
, domain
,
897 if (sym
.symbol
!= NULL
)
901 /* Now search all static file-level symbols. We have to do this for things
902 like typedefs in the class. We do not try to guess any imported
903 namespace as even the fully specified namespace search is already not
904 C++ compliant and more assumptions could make it too magic. */
906 /* First search in this symtab, what we want is possibly there. */
907 sym
= lookup_symbol_in_static_block (concatenated_name
, block
, domain
);
908 if (sym
.symbol
!= NULL
)
911 /* Nope. We now have to search all static blocks in all objfiles,
912 even if block != NULL, because there's no guarantees as to which
913 symtab the symbol we want is in. Except for symbols defined in
914 anonymous namespaces should be treated as local to a single file,
915 which we just searched. */
916 if (!is_in_anonymous
)
918 sym
= lookup_static_symbol (concatenated_name
, domain
);
919 if (sym
.symbol
!= NULL
)
923 /* If this is a class with baseclasses, search them next. */
924 container_type
= check_typedef (container_type
);
925 if (TYPE_N_BASECLASSES (container_type
) > 0)
927 sym
= find_symbol_in_baseclass (container_type
, nested_name
, block
,
928 domain
, is_in_anonymous
);
929 if (sym
.symbol
!= NULL
)
933 return null_block_symbol
;
936 /* Look up a symbol named NESTED_NAME that is nested inside the C++
937 class or namespace given by PARENT_TYPE, from within the context
938 given by BLOCK, and in DOMAIN.
939 Return NULL if there is no such nested symbol. */
942 cp_lookup_nested_symbol (struct type
*parent_type
,
943 const char *nested_name
,
944 const struct block
*block
,
945 const domain_enum domain
)
947 /* type_name_no_tag_or_error provides better error reporting using the
949 struct type
*saved_parent_type
= parent_type
;
951 parent_type
= check_typedef (parent_type
);
953 if (symbol_lookup_debug
)
955 const char *type_name
= type_name_no_tag (saved_parent_type
);
957 fprintf_unfiltered (gdb_stdlog
,
958 "cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
959 type_name
!= NULL
? type_name
: "unnamed",
960 nested_name
, host_address_to_string (block
),
961 domain_name (domain
));
964 switch (TYPE_CODE (parent_type
))
966 case TYPE_CODE_STRUCT
:
967 case TYPE_CODE_NAMESPACE
:
968 case TYPE_CODE_UNION
:
970 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
971 specific code to lookup nested symbols in modules, by calling the
972 function pointer la_lookup_symbol_nonlocal, which ends up here. */
973 case TYPE_CODE_MODULE
:
976 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
977 struct block_symbol sym
;
978 char *concatenated_name
;
981 size
= strlen (parent_name
) + 2 + strlen (nested_name
) + 1;
982 concatenated_name
= (char *) alloca (size
);
983 xsnprintf (concatenated_name
, size
, "%s::%s",
984 parent_name
, nested_name
);
985 is_in_anonymous
= cp_is_in_anonymous (concatenated_name
);
987 sym
= cp_lookup_nested_symbol_1 (parent_type
, nested_name
,
988 concatenated_name
, block
, domain
,
991 if (symbol_lookup_debug
)
993 fprintf_unfiltered (gdb_stdlog
,
994 "cp_lookup_nested_symbol (...) = %s\n",
996 ? host_address_to_string (sym
.symbol
)
1002 case TYPE_CODE_FUNC
:
1003 case TYPE_CODE_METHOD
:
1004 if (symbol_lookup_debug
)
1006 fprintf_unfiltered (gdb_stdlog
,
1007 "cp_lookup_nested_symbol (...) = NULL"
1008 " (func/method)\n");
1010 return null_block_symbol
;
1013 internal_error (__FILE__
, __LINE__
,
1014 _("cp_lookup_nested_symbol called "
1015 "on a non-aggregate type."));
1019 /* The C++-version of lookup_transparent_type. */
1021 /* FIXME: carlton/2004-01-16: The problem that this is trying to
1022 address is that, unfortunately, sometimes NAME is wrong: it may not
1023 include the name of namespaces enclosing the type in question.
1024 lookup_transparent_type gets called when the type in question
1025 is a declaration, and we're trying to find its definition; but, for
1026 declarations, our type name deduction mechanism doesn't work.
1027 There's nothing we can do to fix this in general, I think, in the
1028 absence of debug information about namespaces (I've filed PR
1029 gdb/1511 about this); until such debug information becomes more
1030 prevalent, one heuristic which sometimes looks is to search for the
1031 definition in namespaces containing the current namespace.
1033 We should delete this functions once the appropriate debug
1034 information becomes more widespread. (GCC 3.4 will be the first
1035 released version of GCC with such information.) */
1038 cp_lookup_transparent_type (const char *name
)
1040 /* First, try the honest way of looking up the definition. */
1041 struct type
*t
= basic_lookup_transparent_type (name
);
1047 /* If that doesn't work and we're within a namespace, look there
1049 scope
= block_scope (get_selected_block (0));
1051 if (scope
[0] == '\0')
1054 return cp_lookup_transparent_type_loop (name
, scope
, 0);
1057 /* Lookup the type definition associated to NAME in namespaces/classes
1058 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
1059 must be the index of the start of a component of SCOPE. */
1061 static struct type
*
1062 cp_lookup_transparent_type_loop (const char *name
,
1066 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
1069 /* If the current scope is followed by "::", look in the next
1071 if (scope
[scope_length
] == ':')
1074 = cp_lookup_transparent_type_loop (name
, scope
,
1081 full_name
= (char *) alloca (scope_length
+ 2 + strlen (name
) + 1);
1082 strncpy (full_name
, scope
, scope_length
);
1083 strncpy (full_name
+ scope_length
, "::", 2);
1084 strcpy (full_name
+ scope_length
+ 2, name
);
1086 return basic_lookup_transparent_type (full_name
);
1089 /* This used to do something but was removed when it became
1093 maintenance_cplus_namespace (char *args
, int from_tty
)
1095 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1098 /* Provide a prototype to silence -Wmissing-prototypes. */
1099 extern initialize_file_ftype _initialize_cp_namespace
;
1102 _initialize_cp_namespace (void)
1104 struct cmd_list_element
*cmd
;
1106 cmd
= add_cmd ("namespace", class_maintenance
,
1107 maintenance_cplus_namespace
,
1108 _("Deprecated placeholder for removed functionality."),
1109 &maint_cplus_cmd_list
);
1110 deprecate_cmd (cmd
, NULL
);