1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2003-2017 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"
37 static struct block_symbol
38 cp_lookup_nested_symbol_1 (struct type
*container_type
,
39 const char *nested_name
,
40 const char *concatenated_name
,
41 const struct block
*block
,
42 const domain_enum domain
,
43 int basic_lookup
, int is_in_anonymous
);
45 static struct type
*cp_lookup_transparent_type_loop (const char *name
,
49 /* Check to see if SYMBOL refers to an object contained within an
50 anonymous namespace; if so, add an appropriate using directive. */
53 cp_scan_for_anonymous_namespaces (const struct symbol
*const symbol
,
54 struct objfile
*const objfile
)
56 if (SYMBOL_DEMANGLED_NAME (symbol
) != NULL
)
58 const char *name
= SYMBOL_DEMANGLED_NAME (symbol
);
59 unsigned int previous_component
;
60 unsigned int next_component
;
62 /* Start with a quick-and-dirty check for mention of "(anonymous
65 if (!cp_is_in_anonymous (name
))
68 previous_component
= 0;
69 next_component
= cp_find_first_component (name
+ previous_component
);
71 while (name
[next_component
] == ':')
73 if (((next_component
- previous_component
)
74 == CP_ANONYMOUS_NAMESPACE_LEN
)
75 && strncmp (name
+ previous_component
,
76 CP_ANONYMOUS_NAMESPACE_STR
,
77 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
79 int dest_len
= (previous_component
== 0
80 ? 0 : previous_component
- 2);
81 int src_len
= next_component
;
83 char *dest
= (char *) alloca (dest_len
+ 1);
84 char *src
= (char *) alloca (src_len
+ 1);
86 memcpy (dest
, name
, dest_len
);
87 memcpy (src
, name
, src_len
);
89 dest
[dest_len
] = '\0';
92 /* We've found a component of the name that's an
93 anonymous namespace. So add symbols in it to the
94 namespace given by the previous component if there is
95 one, or to the global namespace if there isn't. */
96 add_using_directive (&local_using_directives
,
97 dest
, src
, NULL
, NULL
, NULL
, 1,
98 &objfile
->objfile_obstack
);
100 /* The "+ 2" is for the "::". */
101 previous_component
= next_component
+ 2;
102 next_component
= (previous_component
103 + cp_find_first_component (name
104 + previous_component
));
109 /* Test whether or not NAMESPACE looks like it mentions an anonymous
110 namespace; return nonzero if so. */
113 cp_is_in_anonymous (const char *symbol_name
)
115 return (strstr (symbol_name
, CP_ANONYMOUS_NAMESPACE_STR
)
119 /* Look up NAME in DOMAIN in BLOCK's static block and in global blocks.
120 If IS_IN_ANONYMOUS is nonzero, the symbol in question is located
121 within an anonymous namespace. */
123 static struct block_symbol
124 cp_basic_lookup_symbol (const char *name
, const struct block
*block
,
125 const domain_enum domain
, int is_in_anonymous
)
127 struct block_symbol sym
;
129 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
130 if (sym
.symbol
!= NULL
)
135 /* Symbols defined in anonymous namespaces have external linkage
136 but should be treated as local to a single file nonetheless.
137 So we only search the current file's global block. */
139 const struct block
*global_block
= block_global_block (block
);
141 if (global_block
!= NULL
)
143 sym
.symbol
= lookup_symbol_in_block (name
, global_block
, domain
);
144 sym
.block
= global_block
;
148 sym
= lookup_global_symbol (name
, block
, domain
);
153 /* Search bare symbol NAME in DOMAIN in BLOCK.
154 NAME is guaranteed to not have any scope (no "::") in its name, though
155 if for example NAME is a template spec then "::" may appear in the
157 If LANGDEF is non-NULL then try to lookup NAME as a primitive type in
158 that language. Normally we wouldn't need LANGDEF but fortran also uses
160 If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
161 if so then also search for NAME in that class. */
163 static struct block_symbol
164 cp_lookup_bare_symbol (const struct language_defn
*langdef
,
165 const char *name
, const struct block
*block
,
166 const domain_enum domain
, int search
)
168 struct block_symbol sym
;
170 /* Note: We can't do a simple assert for ':' not being in NAME because
171 ':' may be in the args of a template spec. This isn't intended to be
172 a complete test, just cheap and documentary. */
173 if (strchr (name
, '<') == NULL
&& strchr (name
, '(') == NULL
)
174 gdb_assert (strstr (name
, "::") == NULL
);
176 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
177 if (sym
.symbol
!= NULL
)
180 /* If we didn't find a definition for a builtin type in the static block,
181 search for it now. This is actually the right thing to do and can be
182 a massive performance win. E.g., when debugging a program with lots of
183 shared libraries we could search all of them only to find out the
184 builtin type isn't defined in any of them. This is common for types
186 if (langdef
!= NULL
&& domain
== VAR_DOMAIN
)
188 struct gdbarch
*gdbarch
;
191 gdbarch
= target_gdbarch ();
193 gdbarch
= block_gdbarch (block
);
195 = language_lookup_primitive_type_as_symbol (langdef
, gdbarch
, name
);
197 if (sym
.symbol
!= NULL
)
201 sym
= lookup_global_symbol (name
, block
, domain
);
202 if (sym
.symbol
!= NULL
)
207 struct block_symbol lang_this
;
210 lang_this
.symbol
= NULL
;
213 lang_this
= lookup_language_this (langdef
, block
);
215 if (lang_this
.symbol
== NULL
)
216 return null_block_symbol
;
219 type
= check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this
.symbol
)));
220 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
221 This can happen for lambda functions compiled with clang++,
222 which outputs no name for the container class. */
223 if (TYPE_NAME (type
) == NULL
)
224 return null_block_symbol
;
226 /* Look for symbol NAME in this class. */
227 sym
= cp_lookup_nested_symbol (type
, name
, block
, domain
);
233 /* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
234 BLOCK specifies the context in which to perform the search.
235 NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
236 the length of the entire scope of NAME (up to, but not including, the last
239 Note: At least in the case of Fortran, which also uses this code, there
240 may be no text after the last "::". */
242 static struct block_symbol
243 cp_search_static_and_baseclasses (const char *name
,
244 const struct block
*block
,
245 const domain_enum domain
,
246 unsigned int prefix_len
,
249 /* Check for malformed input. */
250 if (prefix_len
+ 2 > strlen (name
) || name
[prefix_len
+ 1] != ':')
251 return null_block_symbol
;
253 /* The class, namespace or function name is everything up to and
254 including PREFIX_LEN. */
255 std::string
scope (name
, prefix_len
);
257 /* The rest of the name is everything else past the initial scope
259 const char *nested
= name
+ prefix_len
+ 2;
261 /* Lookup the scope symbol. If none is found, there is nothing more
262 that can be done. SCOPE could be a namespace, so always look in
263 VAR_DOMAIN. This works for classes too because of
264 symbol_matches_domain (which should be replaced with something
265 else, but it's what we have today). */
266 block_symbol scope_sym
= lookup_symbol_in_static_block (scope
.c_str (),
268 if (scope_sym
.symbol
== NULL
)
269 scope_sym
= lookup_global_symbol (scope
.c_str (), block
, VAR_DOMAIN
);
270 if (scope_sym
.symbol
== NULL
)
271 return null_block_symbol
;
273 struct type
*scope_type
= SYMBOL_TYPE (scope_sym
.symbol
);
275 /* If the scope is a function/method, then look up NESTED as a local
276 static variable. E.g., "print 'function()::static_var'". */
277 if (TYPE_CODE (scope_type
) == TYPE_CODE_FUNC
278 || TYPE_CODE (scope_type
) == TYPE_CODE_METHOD
)
279 return lookup_symbol (nested
, SYMBOL_BLOCK_VALUE (scope_sym
.symbol
),
282 /* Look for a symbol named NESTED in this class/namespace.
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 return cp_lookup_nested_symbol_1 (scope_type
, nested
, name
,
286 block
, domain
, 0, is_in_anonymous
);
289 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
290 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
291 through base classes for a matching symbol.
293 Note: Part of the complexity is because NAME may itself specify scope.
294 Part of the complexity is also because this handles the case where
295 there is no scoping in which case we also try looking in the class of
296 "this" if we can compute it. */
298 static struct block_symbol
299 cp_lookup_symbol_in_namespace (const char *the_namespace
, const char *name
,
300 const struct block
*block
,
301 const domain_enum domain
, int search
)
303 char *concatenated_name
= NULL
;
305 unsigned int prefix_len
;
306 struct block_symbol sym
;
308 if (the_namespace
[0] != '\0')
311 = (char *) alloca (strlen (the_namespace
) + 2 + strlen (name
) + 1);
312 strcpy (concatenated_name
, the_namespace
);
313 strcat (concatenated_name
, "::");
314 strcat (concatenated_name
, name
);
315 name
= concatenated_name
;
318 prefix_len
= cp_entire_prefix_len (name
);
320 return cp_lookup_bare_symbol (NULL
, name
, block
, domain
, search
);
322 /* This would be simpler if we just called cp_lookup_nested_symbol
323 at this point. But that would require first looking up the containing
324 class/namespace. Since we're only searching static and global blocks
325 there's often no need to first do that lookup. */
328 = the_namespace
[0] != '\0' && cp_is_in_anonymous (the_namespace
);
329 sym
= cp_basic_lookup_symbol (name
, block
, domain
, is_in_anonymous
);
330 if (sym
.symbol
!= NULL
)
334 sym
= cp_search_static_and_baseclasses (name
, block
, domain
, prefix_len
,
340 /* Used for cleanups to reset the "searched" flag in case of an error. */
343 reset_directive_searched (void *data
)
345 struct using_direct
*direct
= (struct using_direct
*) data
;
346 direct
->searched
= 0;
349 /* Search for NAME by applying all import statements belonging to
350 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
351 search is restricted to using declarations.
359 If SEARCH_PARENTS the search will include imports which are
360 applicable in parents of SCOPE.
370 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
371 namespaces X and Y will be considered. If SEARCH_PARENTS is false
372 only the import of Y is considered.
374 SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
375 pass 0 for it. Internally we pass 1 when recursing. */
377 static struct block_symbol
378 cp_lookup_symbol_via_imports (const char *scope
,
380 const struct block
*block
,
381 const domain_enum domain
,
382 const int search_scope_first
,
383 const int declaration_only
,
384 const int search_parents
)
386 struct using_direct
*current
;
387 struct block_symbol sym
;
390 struct cleanup
*searched_cleanup
;
395 /* First, try to find the symbol in the given namespace if requested. */
396 if (search_scope_first
)
397 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
400 if (sym
.symbol
!= NULL
)
403 /* Go through the using directives. If any of them add new names to
404 the namespace we're searching in, see if we can find a match by
407 for (current
= block_using (block
);
409 current
= current
->next
)
411 const char **excludep
;
413 len
= strlen (current
->import_dest
);
414 directive_match
= (search_parents
415 ? (startswith (scope
, current
->import_dest
)
418 || scope
[len
] == '\0'))
419 : strcmp (scope
, current
->import_dest
) == 0);
421 /* If the import destination is the current scope or one of its
422 ancestors then it is applicable. */
423 if (directive_match
&& !current
->searched
)
425 /* Mark this import as searched so that the recursive call
426 does not search it again. */
427 current
->searched
= 1;
428 searched_cleanup
= make_cleanup (reset_directive_searched
,
431 /* If there is an import of a single declaration, compare the
432 imported declaration (after optional renaming by its alias)
433 with the sought out name. If there is a match pass
434 current->import_src as NAMESPACE to direct the search
435 towards the imported namespace. */
436 if (current
->declaration
437 && strcmp (name
, current
->alias
438 ? current
->alias
: current
->declaration
) == 0)
439 sym
= cp_lookup_symbol_in_namespace (current
->import_src
,
440 current
->declaration
,
443 /* If this is a DECLARATION_ONLY search or a symbol was found
444 or this import statement was an import declaration, the
445 search of this import is complete. */
446 if (declaration_only
|| sym
.symbol
!= NULL
|| current
->declaration
)
448 current
->searched
= 0;
449 discard_cleanups (searched_cleanup
);
451 if (sym
.symbol
!= NULL
)
457 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
458 for (excludep
= current
->excludes
; *excludep
; excludep
++)
459 if (strcmp (name
, *excludep
) == 0)
463 discard_cleanups (searched_cleanup
);
467 if (current
->alias
!= NULL
468 && strcmp (name
, current
->alias
) == 0)
469 /* If the import is creating an alias and the alias matches
470 the sought name. Pass current->import_src as the NAME to
471 direct the search towards the aliased namespace. */
473 sym
= cp_lookup_symbol_in_namespace (scope
,
477 else if (current
->alias
== NULL
)
479 /* If this import statement creates no alias, pass
480 current->inner as NAMESPACE to direct the search
481 towards the imported namespace. */
482 sym
= cp_lookup_symbol_via_imports (current
->import_src
,
486 current
->searched
= 0;
487 discard_cleanups (searched_cleanup
);
489 if (sym
.symbol
!= NULL
)
494 return null_block_symbol
;
497 /* Helper function that searches an array of symbols for one named NAME. */
499 static struct symbol
*
500 search_symbol_list (const char *name
, int num
,
501 struct symbol
**syms
)
505 /* Maybe we should store a dictionary in here instead. */
506 for (i
= 0; i
< num
; ++i
)
508 if (strcmp (name
, SYMBOL_NATURAL_NAME (syms
[i
])) == 0)
514 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
515 searches through the template parameters of the function and the
519 cp_lookup_symbol_imports_or_template (const char *scope
,
521 const struct block
*block
,
522 const domain_enum domain
)
524 struct symbol
*function
= BLOCK_FUNCTION (block
);
525 struct block_symbol result
;
527 if (symbol_lookup_debug
)
529 fprintf_unfiltered (gdb_stdlog
,
530 "cp_lookup_symbol_imports_or_template"
531 " (%s, %s, %s, %s)\n",
532 scope
, name
, host_address_to_string (block
),
533 domain_name (domain
));
536 if (function
!= NULL
&& SYMBOL_LANGUAGE (function
) == language_cplus
)
538 /* Search the function's template parameters. */
539 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function
))
541 struct template_symbol
*templ
542 = (struct template_symbol
*) function
;
543 struct symbol
*sym
= search_symbol_list (name
,
544 templ
->n_template_arguments
,
545 templ
->template_arguments
);
549 if (symbol_lookup_debug
)
551 fprintf_unfiltered (gdb_stdlog
,
552 "cp_lookup_symbol_imports_or_template"
554 host_address_to_string (sym
));
556 return (struct block_symbol
) {sym
, block
};
560 /* Search the template parameters of the function's defining
562 if (SYMBOL_NATURAL_NAME (function
))
564 struct type
*context
;
565 std::string
name_copy (SYMBOL_NATURAL_NAME (function
));
566 const struct language_defn
*lang
= language_def (language_cplus
);
567 struct gdbarch
*arch
= symbol_arch (function
);
568 const struct block
*parent
= BLOCK_SUPERBLOCK (block
);
573 unsigned int prefix_len
574 = cp_entire_prefix_len (name_copy
.c_str ());
580 name_copy
.erase (prefix_len
);
581 context
= lookup_typename (lang
, arch
,
590 = search_symbol_list (name
,
591 TYPE_N_TEMPLATE_ARGUMENTS (context
),
592 TYPE_TEMPLATE_ARGUMENTS (context
));
595 if (symbol_lookup_debug
)
599 "cp_lookup_symbol_imports_or_template (...) = %s\n",
600 host_address_to_string (sym
));
602 return (struct block_symbol
) {sym
, parent
};
608 result
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 0, 1, 1);
609 if (symbol_lookup_debug
)
611 fprintf_unfiltered (gdb_stdlog
,
612 "cp_lookup_symbol_imports_or_template (...) = %s\n",
613 result
.symbol
!= NULL
614 ? host_address_to_string (result
.symbol
) : "NULL");
619 /* Search for NAME by applying relevant import statements belonging to BLOCK
620 and its parents. SCOPE is the namespace scope of the context in which the
621 search is being evaluated. */
623 static struct block_symbol
624 cp_lookup_symbol_via_all_imports (const char *scope
, const char *name
,
625 const struct block
*block
,
626 const domain_enum domain
)
628 struct block_symbol sym
;
630 while (block
!= NULL
)
632 sym
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 0, 0, 1);
636 block
= BLOCK_SUPERBLOCK (block
);
639 return null_block_symbol
;
642 /* Searches for NAME in the current namespace, and by applying
643 relevant import statements belonging to BLOCK and its parents.
644 SCOPE is the namespace scope of the context in which the search is
648 cp_lookup_symbol_namespace (const char *scope
,
650 const struct block
*block
,
651 const domain_enum domain
)
653 struct block_symbol sym
;
655 if (symbol_lookup_debug
)
657 fprintf_unfiltered (gdb_stdlog
,
658 "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
659 scope
, name
, host_address_to_string (block
),
660 domain_name (domain
));
663 /* First, try to find the symbol in the given namespace. */
664 sym
= cp_lookup_symbol_in_namespace (scope
, name
, block
, domain
, 1);
666 /* Search for name in namespaces imported to this and parent blocks. */
667 if (sym
.symbol
== NULL
)
668 sym
= cp_lookup_symbol_via_all_imports (scope
, name
, block
, domain
);
670 if (symbol_lookup_debug
)
672 fprintf_unfiltered (gdb_stdlog
,
673 "cp_lookup_symbol_namespace (...) = %s\n",
675 ? host_address_to_string (sym
.symbol
) : "NULL");
680 /* Lookup NAME at namespace scope (or, in C terms, in static and
681 global variables). SCOPE is the namespace that the current
682 function is defined within; only consider namespaces whose length
683 is at least SCOPE_LEN. Other arguments are as in
684 cp_lookup_symbol_nonlocal.
686 For example, if we're within a function A::B::f and looking for a
687 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
688 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
689 but with SCOPE_LEN = 1. And then it calls itself with NAME and
690 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
691 "A::B::x"; if it doesn't find it, then the second call looks for
692 "A::x", and if that call fails, then the first call looks for
695 static struct block_symbol
696 lookup_namespace_scope (const struct language_defn
*langdef
,
698 const struct block
*block
,
699 const domain_enum domain
,
705 if (scope
[scope_len
] != '\0')
707 /* Recursively search for names in child namespaces first. */
709 struct block_symbol sym
;
710 int new_scope_len
= scope_len
;
712 /* If the current scope is followed by "::", skip past that. */
713 if (new_scope_len
!= 0)
715 gdb_assert (scope
[new_scope_len
] == ':');
718 new_scope_len
+= cp_find_first_component (scope
+ new_scope_len
);
719 sym
= lookup_namespace_scope (langdef
, name
, block
, domain
,
720 scope
, new_scope_len
);
721 if (sym
.symbol
!= NULL
)
725 /* Okay, we didn't find a match in our children, so look for the
726 name in the current namespace.
728 If we there is no scope and we know we have a bare symbol, then short
729 circuit everything and call cp_lookup_bare_symbol directly.
730 This isn't an optimization, rather it allows us to pass LANGDEF which
731 is needed for primitive type lookup. The test doesn't have to be
732 perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
733 template symbol with "::" in the argument list) then
734 cp_lookup_symbol_in_namespace will catch it. */
736 if (scope_len
== 0 && strchr (name
, ':') == NULL
)
737 return cp_lookup_bare_symbol (langdef
, name
, block
, domain
, 1);
739 the_namespace
= (char *) alloca (scope_len
+ 1);
740 strncpy (the_namespace
, scope
, scope_len
);
741 the_namespace
[scope_len
] = '\0';
742 return cp_lookup_symbol_in_namespace (the_namespace
, name
,
746 /* The C++-specific version of name lookup for static and global
747 names. This makes sure that names get looked for in all namespaces
748 that are in scope. NAME is the natural name of the symbol that
749 we're looking for, BLOCK is the block that we're searching within,
750 DOMAIN says what kind of symbols we're looking for. */
753 cp_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
755 const struct block
*block
,
756 const domain_enum domain
)
758 struct block_symbol sym
;
759 const char *scope
= block_scope (block
);
761 if (symbol_lookup_debug
)
763 fprintf_unfiltered (gdb_stdlog
,
764 "cp_lookup_symbol_non_local"
765 " (%s, %s (scope %s), %s)\n",
766 name
, host_address_to_string (block
), scope
,
767 domain_name (domain
));
770 /* First, try to find the symbol in the given namespace, and all
771 containing namespaces. */
772 sym
= lookup_namespace_scope (langdef
, name
, block
, domain
, scope
, 0);
774 /* Search for name in namespaces imported to this and parent blocks. */
775 if (sym
.symbol
== NULL
)
776 sym
= cp_lookup_symbol_via_all_imports (scope
, name
, block
, domain
);
778 if (symbol_lookup_debug
)
780 fprintf_unfiltered (gdb_stdlog
,
781 "cp_lookup_symbol_nonlocal (...) = %s\n",
783 ? host_address_to_string (sym
.symbol
)
789 /* Search through the base classes of PARENT_TYPE for a base class
790 named NAME and return its type. If not found, return NULL. */
793 cp_find_type_baseclass_by_name (struct type
*parent_type
, const char *name
)
797 parent_type
= check_typedef (parent_type
);
798 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
800 struct type
*type
= check_typedef (TYPE_BASECLASS (parent_type
, i
));
801 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
803 if (base_name
== NULL
)
806 if (streq (base_name
, name
))
809 type
= cp_find_type_baseclass_by_name (type
, name
);
817 /* Search through the base classes of PARENT_TYPE for a symbol named
818 NAME in block BLOCK. */
820 static struct block_symbol
821 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
822 const struct block
*block
, const domain_enum domain
,
826 struct block_symbol sym
;
831 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
833 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
834 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
836 if (base_name
== NULL
)
839 std::string concatenated_name
= std::string (base_name
) + "::" + name
;
841 sym
= cp_lookup_nested_symbol_1 (base_type
, name
,
842 concatenated_name
.c_str (),
843 block
, domain
, 1, is_in_anonymous
);
844 if (sym
.symbol
!= NULL
)
851 /* Helper function to look up NESTED_NAME in CONTAINER_TYPE and in DOMAIN
852 and within the context of BLOCK.
853 NESTED_NAME may have scope ("::").
854 CONTAINER_TYPE needn't have been "check_typedef'd" yet.
855 CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
856 passed as an argument so that callers can control how space for it is
858 If BASIC_LOOKUP is non-zero then perform a basic lookup of
859 CONCATENATED_NAME. See cp_basic_lookup_symbol for details.
860 If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
863 static struct block_symbol
864 cp_lookup_nested_symbol_1 (struct type
*container_type
,
865 const char *nested_name
,
866 const char *concatenated_name
,
867 const struct block
*block
,
868 const domain_enum domain
,
869 int basic_lookup
, int is_in_anonymous
)
871 struct block_symbol sym
;
873 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
874 of classes like, say, data or function members. Instead,
875 they're just represented by symbols whose names are
876 qualified by the name of the surrounding class. This is
877 just like members of namespaces; in particular,
878 cp_basic_lookup_symbol works when looking them up. */
882 sym
= cp_basic_lookup_symbol (concatenated_name
, block
, domain
,
884 if (sym
.symbol
!= NULL
)
888 /* Now search all static file-level symbols. We have to do this for things
889 like typedefs in the class. We do not try to guess any imported
890 namespace as even the fully specified namespace search is already not
891 C++ compliant and more assumptions could make it too magic. */
893 /* First search in this symtab, what we want is possibly there. */
894 sym
= lookup_symbol_in_static_block (concatenated_name
, block
, domain
);
895 if (sym
.symbol
!= NULL
)
898 /* Nope. We now have to search all static blocks in all objfiles,
899 even if block != NULL, because there's no guarantees as to which
900 symtab the symbol we want is in. Except for symbols defined in
901 anonymous namespaces should be treated as local to a single file,
902 which we just searched. */
903 if (!is_in_anonymous
)
905 sym
= lookup_static_symbol (concatenated_name
, domain
);
906 if (sym
.symbol
!= NULL
)
910 /* If this is a class with baseclasses, search them next. */
911 container_type
= check_typedef (container_type
);
912 if (TYPE_N_BASECLASSES (container_type
) > 0)
914 sym
= find_symbol_in_baseclass (container_type
, nested_name
, block
,
915 domain
, is_in_anonymous
);
916 if (sym
.symbol
!= NULL
)
920 return null_block_symbol
;
923 /* Look up a symbol named NESTED_NAME that is nested inside the C++
924 class or namespace given by PARENT_TYPE, from within the context
925 given by BLOCK, and in DOMAIN.
926 Return NULL if there is no such nested symbol. */
929 cp_lookup_nested_symbol (struct type
*parent_type
,
930 const char *nested_name
,
931 const struct block
*block
,
932 const domain_enum domain
)
934 /* type_name_no_tag_or_error provides better error reporting using the
936 struct type
*saved_parent_type
= parent_type
;
938 parent_type
= check_typedef (parent_type
);
940 if (symbol_lookup_debug
)
942 const char *type_name
= type_name_no_tag (saved_parent_type
);
944 fprintf_unfiltered (gdb_stdlog
,
945 "cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
946 type_name
!= NULL
? type_name
: "unnamed",
947 nested_name
, host_address_to_string (block
),
948 domain_name (domain
));
951 switch (TYPE_CODE (parent_type
))
953 case TYPE_CODE_STRUCT
:
954 case TYPE_CODE_NAMESPACE
:
955 case TYPE_CODE_UNION
:
957 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
958 specific code to lookup nested symbols in modules, by calling the
959 function pointer la_lookup_symbol_nonlocal, which ends up here. */
960 case TYPE_CODE_MODULE
:
963 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
964 struct block_symbol sym
;
965 char *concatenated_name
;
968 size
= strlen (parent_name
) + 2 + strlen (nested_name
) + 1;
969 concatenated_name
= (char *) alloca (size
);
970 xsnprintf (concatenated_name
, size
, "%s::%s",
971 parent_name
, nested_name
);
972 is_in_anonymous
= cp_is_in_anonymous (concatenated_name
);
974 sym
= cp_lookup_nested_symbol_1 (parent_type
, nested_name
,
975 concatenated_name
, block
, domain
,
978 if (symbol_lookup_debug
)
980 fprintf_unfiltered (gdb_stdlog
,
981 "cp_lookup_nested_symbol (...) = %s\n",
983 ? host_address_to_string (sym
.symbol
)
990 case TYPE_CODE_METHOD
:
991 if (symbol_lookup_debug
)
993 fprintf_unfiltered (gdb_stdlog
,
994 "cp_lookup_nested_symbol (...) = NULL"
997 return null_block_symbol
;
1000 internal_error (__FILE__
, __LINE__
,
1001 _("cp_lookup_nested_symbol called "
1002 "on a non-aggregate type."));
1006 /* The C++-version of lookup_transparent_type. */
1008 /* FIXME: carlton/2004-01-16: The problem that this is trying to
1009 address is that, unfortunately, sometimes NAME is wrong: it may not
1010 include the name of namespaces enclosing the type in question.
1011 lookup_transparent_type gets called when the type in question
1012 is a declaration, and we're trying to find its definition; but, for
1013 declarations, our type name deduction mechanism doesn't work.
1014 There's nothing we can do to fix this in general, I think, in the
1015 absence of debug information about namespaces (I've filed PR
1016 gdb/1511 about this); until such debug information becomes more
1017 prevalent, one heuristic which sometimes looks is to search for the
1018 definition in namespaces containing the current namespace.
1020 We should delete this functions once the appropriate debug
1021 information becomes more widespread. (GCC 3.4 will be the first
1022 released version of GCC with such information.) */
1025 cp_lookup_transparent_type (const char *name
)
1027 /* First, try the honest way of looking up the definition. */
1028 struct type
*t
= basic_lookup_transparent_type (name
);
1034 /* If that doesn't work and we're within a namespace, look there
1036 scope
= block_scope (get_selected_block (0));
1038 if (scope
[0] == '\0')
1041 return cp_lookup_transparent_type_loop (name
, scope
, 0);
1044 /* Lookup the type definition associated to NAME in namespaces/classes
1045 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
1046 must be the index of the start of a component of SCOPE. */
1048 static struct type
*
1049 cp_lookup_transparent_type_loop (const char *name
,
1053 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
1056 /* If the current scope is followed by "::", look in the next
1058 if (scope
[scope_length
] == ':')
1061 = cp_lookup_transparent_type_loop (name
, scope
,
1068 full_name
= (char *) alloca (scope_length
+ 2 + strlen (name
) + 1);
1069 strncpy (full_name
, scope
, scope_length
);
1070 strncpy (full_name
+ scope_length
, "::", 2);
1071 strcpy (full_name
+ scope_length
+ 2, name
);
1073 return basic_lookup_transparent_type (full_name
);
1076 /* This used to do something but was removed when it became
1080 maintenance_cplus_namespace (char *args
, int from_tty
)
1082 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1085 /* Provide a prototype to silence -Wmissing-prototypes. */
1086 extern initialize_file_ftype _initialize_cp_namespace
;
1089 _initialize_cp_namespace (void)
1091 struct cmd_list_element
*cmd
;
1093 cmd
= add_cmd ("namespace", class_maintenance
,
1094 maintenance_cplus_namespace
,
1095 _("Deprecated placeholder for removed functionality."),
1096 &maint_cplus_cmd_list
);
1097 deprecate_cmd (cmd
, NULL
);