1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2003-2015 Free Software Foundation, Inc.
4 Contributed by David Carlton and by Kealia, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "cp-support.h"
23 #include "gdb_obstack.h"
29 #include "dictionary.h"
35 static struct block_symbol
36 cp_lookup_nested_symbol_1 (struct type
*container_type
,
37 const char *nested_name
,
38 const char *concatenated_name
,
39 const struct block
*block
,
40 const domain_enum domain
,
41 int basic_lookup
, int is_in_anonymous
);
43 static struct type
*cp_lookup_transparent_type_loop (const char *name
,
47 /* Check to see if SYMBOL refers to an object contained within an
48 anonymous namespace; if so, add an appropriate using directive. */
51 cp_scan_for_anonymous_namespaces (const struct symbol
*const symbol
,
52 struct objfile
*const objfile
)
54 if (SYMBOL_DEMANGLED_NAME (symbol
) != NULL
)
56 const char *name
= SYMBOL_DEMANGLED_NAME (symbol
);
57 unsigned int previous_component
;
58 unsigned int next_component
;
60 /* Start with a quick-and-dirty check for mention of "(anonymous
63 if (!cp_is_in_anonymous (name
))
66 previous_component
= 0;
67 next_component
= cp_find_first_component (name
+ previous_component
);
69 while (name
[next_component
] == ':')
71 if (((next_component
- previous_component
)
72 == CP_ANONYMOUS_NAMESPACE_LEN
)
73 && strncmp (name
+ previous_component
,
74 CP_ANONYMOUS_NAMESPACE_STR
,
75 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
77 int dest_len
= (previous_component
== 0
78 ? 0 : previous_component
- 2);
79 int src_len
= next_component
;
81 char *dest
= alloca (dest_len
+ 1);
82 char *src
= alloca (src_len
+ 1);
84 memcpy (dest
, name
, dest_len
);
85 memcpy (src
, name
, src_len
);
87 dest
[dest_len
] = '\0';
90 /* We've found a component of the name that's an
91 anonymous namespace. So add symbols in it to the
92 namespace given by the previous component if there is
93 one, or to the global namespace if there isn't. */
94 cp_add_using_directive (dest
, src
, NULL
, NULL
, NULL
, 1,
95 &objfile
->objfile_obstack
);
97 /* The "+ 2" is for the "::". */
98 previous_component
= next_component
+ 2;
99 next_component
= (previous_component
100 + cp_find_first_component (name
101 + previous_component
));
106 /* Add a using directive to using_directives. If the using directive
107 in question has already been added, don't add it twice.
109 Create a new struct using_direct which imports the namespace SRC
110 into the scope DEST. ALIAS is the name of the imported namespace
111 in the current scope. If ALIAS is NULL then the namespace is known
112 by its original name. DECLARATION is the name if the imported
113 varable if this is a declaration import (Eg. using A::x), otherwise
114 it is NULL. EXCLUDES is a list of names not to import from an
115 imported module or NULL. If COPY_NAMES is non-zero, then the
116 arguments are copied into newly allocated memory so they can be
117 temporaries. For EXCLUDES the VEC pointers are copied but the
118 pointed to characters are not copied. */
121 cp_add_using_directive (const char *dest
,
124 const char *declaration
,
125 VEC (const_char_ptr
) *excludes
,
127 struct obstack
*obstack
)
129 struct using_direct
*current
;
130 struct using_direct
*newobj
;
132 /* Has it already been added? */
134 for (current
= using_directives
; current
!= NULL
; current
= current
->next
)
139 if (strcmp (current
->import_src
, src
) != 0)
141 if (strcmp (current
->import_dest
, dest
) != 0)
143 if ((alias
== NULL
&& current
->alias
!= NULL
)
144 || (alias
!= NULL
&& current
->alias
== NULL
)
145 || (alias
!= NULL
&& current
->alias
!= NULL
146 && strcmp (alias
, current
->alias
) != 0))
148 if ((declaration
== NULL
&& current
->declaration
!= NULL
)
149 || (declaration
!= NULL
&& current
->declaration
== NULL
)
150 || (declaration
!= NULL
&& current
->declaration
!= NULL
151 && strcmp (declaration
, current
->declaration
) != 0))
154 /* Compare the contents of EXCLUDES. */
155 for (ix
= 0; VEC_iterate (const_char_ptr
, excludes
, ix
, param
); ix
++)
156 if (current
->excludes
[ix
] == NULL
157 || strcmp (param
, current
->excludes
[ix
]) != 0)
159 if (ix
< VEC_length (const_char_ptr
, excludes
)
160 || current
->excludes
[ix
] != NULL
)
163 /* Parameters exactly match CURRENT. */
167 newobj
= obstack_alloc (obstack
, (sizeof (*newobj
)
168 + (VEC_length (const_char_ptr
, excludes
)
169 * sizeof (*newobj
->excludes
))));
170 memset (newobj
, 0, sizeof (*newobj
));
174 newobj
->import_src
= obstack_copy0 (obstack
, src
, strlen (src
));
175 newobj
->import_dest
= obstack_copy0 (obstack
, dest
, strlen (dest
));
179 newobj
->import_src
= src
;
180 newobj
->import_dest
= dest
;
183 if (alias
!= NULL
&& copy_names
)
184 newobj
->alias
= obstack_copy0 (obstack
, alias
, strlen (alias
));
186 newobj
->alias
= alias
;
188 if (declaration
!= NULL
&& copy_names
)
189 newobj
->declaration
= obstack_copy0 (obstack
,
190 declaration
, strlen (declaration
));
192 newobj
->declaration
= declaration
;
194 memcpy (newobj
->excludes
, VEC_address (const_char_ptr
, excludes
),
195 VEC_length (const_char_ptr
, excludes
) * sizeof (*newobj
->excludes
));
196 newobj
->excludes
[VEC_length (const_char_ptr
, excludes
)] = NULL
;
198 newobj
->next
= using_directives
;
199 using_directives
= newobj
;
202 /* Test whether or not NAMESPACE looks like it mentions an anonymous
203 namespace; return nonzero if so. */
206 cp_is_in_anonymous (const char *symbol_name
)
208 return (strstr (symbol_name
, CP_ANONYMOUS_NAMESPACE_STR
)
212 /* Look up NAME in DOMAIN in BLOCK's static block and in global blocks.
213 If IS_IN_ANONYMOUS is nonzero, the symbol in question is located
214 within an anonymous namespace. */
216 static struct block_symbol
217 cp_basic_lookup_symbol (const char *name
, const struct block
*block
,
218 const domain_enum domain
, int is_in_anonymous
)
220 struct block_symbol sym
;
222 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
223 if (sym
.symbol
!= NULL
)
228 /* Symbols defined in anonymous namespaces have external linkage
229 but should be treated as local to a single file nonetheless.
230 So we only search the current file's global block. */
232 const struct block
*global_block
= block_global_block (block
);
234 if (global_block
!= NULL
)
236 sym
.symbol
= lookup_symbol_in_block (name
, global_block
, domain
);
237 sym
.block
= global_block
;
241 sym
= lookup_global_symbol (name
, block
, domain
);
246 /* Search bare symbol NAME in DOMAIN in BLOCK.
247 NAME is guaranteed to not have any scope (no "::") in its name, though
248 if for example NAME is a template spec then "::" may appear in the
250 If LANGDEF is non-NULL then try to lookup NAME as a primitive type in
251 that language. Normally we wouldn't need LANGDEF but fortran also uses
253 If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
254 if so then also search for NAME in that class. */
256 static struct block_symbol
257 cp_lookup_bare_symbol (const struct language_defn
*langdef
,
258 const char *name
, const struct block
*block
,
259 const domain_enum domain
, int search
)
261 struct block_symbol sym
;
263 /* Note: We can't do a simple assert for ':' not being in NAME because
264 ':' may be in the args of a template spec. This isn't intended to be
265 a complete test, just cheap and documentary. */
266 if (strchr (name
, '<') == NULL
&& strchr (name
, '(') == NULL
)
267 gdb_assert (strchr (name
, ':') == NULL
);
269 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
270 if (sym
.symbol
!= NULL
)
273 /* If we didn't find a definition for a builtin type in the static block,
274 search for it now. This is actually the right thing to do and can be
275 a massive performance win. E.g., when debugging a program with lots of
276 shared libraries we could search all of them only to find out the
277 builtin type isn't defined in any of them. This is common for types
279 if (langdef
!= NULL
&& domain
== VAR_DOMAIN
)
281 struct gdbarch
*gdbarch
;
284 gdbarch
= target_gdbarch ();
286 gdbarch
= block_gdbarch (block
);
288 = language_lookup_primitive_type_as_symbol (langdef
, gdbarch
, name
);
290 if (sym
.symbol
!= NULL
)
294 sym
= lookup_global_symbol (name
, block
, domain
);
295 if (sym
.symbol
!= NULL
)
300 struct block_symbol lang_this
;
303 lang_this
= lookup_language_this (language_def (language_cplus
), block
);
304 if (lang_this
.symbol
== NULL
)
305 return (struct block_symbol
) {NULL
, NULL
};
307 type
= check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this
.symbol
)));
308 /* If TYPE_NAME is NULL, abandon trying to find this symbol.
309 This can happen for lambda functions compiled with clang++,
310 which outputs no name for the container class. */
311 if (TYPE_NAME (type
) == NULL
)
312 return (struct block_symbol
) {NULL
, NULL
};
314 /* Look for symbol NAME in this class. */
315 sym
= cp_lookup_nested_symbol (type
, name
, block
, domain
);
321 /* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
322 BLOCK specifies the context in which to perform the search.
323 NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
324 the length of the entire scope of NAME (up to, but not including, the last
327 Note: At least in the case of Fortran, which also uses this code, there
328 may be no text after the last "::". */
330 static struct block_symbol
331 cp_search_static_and_baseclasses (const char *name
,
332 const struct block
*block
,
333 const domain_enum domain
,
334 unsigned int prefix_len
,
337 struct block_symbol sym
;
338 char *klass
, *nested
;
339 struct cleanup
*cleanup
;
340 struct block_symbol klass_sym
;
341 struct type
*klass_type
;
343 /* The test here uses <= instead of < because Fortran also uses this,
344 and the module.exp testcase will pass "modmany::" for NAME here. */
345 gdb_assert (prefix_len
+ 2 <= strlen (name
));
346 gdb_assert (name
[prefix_len
+ 1] == ':');
348 /* Find the name of the class and the name of the method, variable, etc. */
350 /* The class name is everything up to and including PREFIX_LEN. */
351 klass
= savestring (name
, prefix_len
);
353 /* The rest of the name is everything else past the initial scope
355 nested
= xstrdup (name
+ prefix_len
+ 2);
357 /* Add cleanups to free memory for these strings. */
358 cleanup
= make_cleanup (xfree
, klass
);
359 make_cleanup (xfree
, nested
);
361 /* Lookup a class named KLASS. If none is found, there is nothing
362 more that can be done. KLASS could be a namespace, so always look
363 in VAR_DOMAIN. This works for classes too because of
364 symbol_matches_domain (which should be replaced with something else,
365 but it's what we have today). */
366 klass_sym
= lookup_global_symbol (klass
, block
, VAR_DOMAIN
);
367 if (klass_sym
.symbol
== NULL
)
369 do_cleanups (cleanup
);
370 return (struct block_symbol
) {NULL
, NULL
};
372 klass_type
= SYMBOL_TYPE (klass_sym
.symbol
);
374 /* Look for a symbol named NESTED in this class.
375 The caller is assumed to have already have done a basic lookup of NAME.
376 So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here. */
377 sym
= cp_lookup_nested_symbol_1 (klass_type
, nested
, name
, block
, domain
,
380 do_cleanups (cleanup
);
384 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
385 as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
386 through base classes for a matching symbol.
388 Note: Part of the complexity is because NAME may itself specify scope.
389 Part of the complexity is also because this handles the case where
390 there is no scoping in which case we also try looking in the class of
391 "this" if we can compute it. */
393 static struct block_symbol
394 cp_lookup_symbol_in_namespace (const char *the_namespace
, const char *name
,
395 const struct block
*block
,
396 const domain_enum domain
, int search
)
398 char *concatenated_name
= NULL
;
400 unsigned int prefix_len
;
401 struct block_symbol sym
;
403 if (the_namespace
[0] != '\0')
405 concatenated_name
= alloca (strlen (the_namespace
) + 2
406 + strlen (name
) + 1);
407 strcpy (concatenated_name
, the_namespace
);
408 strcat (concatenated_name
, "::");
409 strcat (concatenated_name
, name
);
410 name
= concatenated_name
;
413 prefix_len
= cp_entire_prefix_len (name
);
415 return cp_lookup_bare_symbol (NULL
, name
, block
, domain
, search
);
417 /* This would be simpler if we just called cp_lookup_nested_symbol
418 at this point. But that would require first looking up the containing
419 class/namespace. Since we're only searching static and global blocks
420 there's often no need to first do that lookup. */
423 = the_namespace
[0] != '\0' && cp_is_in_anonymous (the_namespace
);
424 sym
= cp_basic_lookup_symbol (name
, block
, domain
, is_in_anonymous
);
425 if (sym
.symbol
!= NULL
)
429 sym
= cp_search_static_and_baseclasses (name
, block
, domain
, prefix_len
,
435 /* Used for cleanups to reset the "searched" flag in case of an error. */
438 reset_directive_searched (void *data
)
440 struct using_direct
*direct
= data
;
441 direct
->searched
= 0;
444 /* Search for NAME by applying all import statements belonging to
445 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
446 search is restricted to using declarations.
454 If SEARCH_PARENTS the search will include imports which are
455 applicable in parents of SCOPE.
465 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
466 namespaces X and Y will be considered. If SEARCH_PARENTS is false
467 only the import of Y is considered.
469 SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
470 pass 0 for it. Internally we pass 1 when recursing. */
472 static struct block_symbol
473 cp_lookup_symbol_via_imports (const char *scope
,
475 const struct block
*block
,
476 const domain_enum domain
,
477 const int search_scope_first
,
478 const int declaration_only
,
479 const int search_parents
)
481 struct using_direct
*current
;
482 struct block_symbol sym
;
485 struct cleanup
*searched_cleanup
;
490 /* First, try to find the symbol in the given namespace if requested. */
491 if (search_scope_first
)
492 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
495 if (sym
.symbol
!= NULL
)
498 /* Go through the using directives. If any of them add new names to
499 the namespace we're searching in, see if we can find a match by
502 for (current
= block_using (block
);
504 current
= current
->next
)
506 const char **excludep
;
508 len
= strlen (current
->import_dest
);
509 directive_match
= (search_parents
510 ? (startswith (scope
, current
->import_dest
)
513 || scope
[len
] == '\0'))
514 : strcmp (scope
, current
->import_dest
) == 0);
516 /* If the import destination is the current scope or one of its
517 ancestors then it is applicable. */
518 if (directive_match
&& !current
->searched
)
520 /* Mark this import as searched so that the recursive call
521 does not search it again. */
522 current
->searched
= 1;
523 searched_cleanup
= make_cleanup (reset_directive_searched
,
526 /* If there is an import of a single declaration, compare the
527 imported declaration (after optional renaming by its alias)
528 with the sought out name. If there is a match pass
529 current->import_src as NAMESPACE to direct the search
530 towards the imported namespace. */
531 if (current
->declaration
532 && strcmp (name
, current
->alias
533 ? current
->alias
: current
->declaration
) == 0)
534 sym
= cp_lookup_symbol_in_namespace (current
->import_src
,
535 current
->declaration
,
538 /* If this is a DECLARATION_ONLY search or a symbol was found
539 or this import statement was an import declaration, the
540 search of this import is complete. */
541 if (declaration_only
|| sym
.symbol
!= NULL
|| current
->declaration
)
543 current
->searched
= 0;
544 discard_cleanups (searched_cleanup
);
546 if (sym
.symbol
!= NULL
)
552 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
553 for (excludep
= current
->excludes
; *excludep
; excludep
++)
554 if (strcmp (name
, *excludep
) == 0)
558 discard_cleanups (searched_cleanup
);
562 if (current
->alias
!= NULL
563 && strcmp (name
, current
->alias
) == 0)
564 /* If the import is creating an alias and the alias matches
565 the sought name. Pass current->import_src as the NAME to
566 direct the search towards the aliased namespace. */
568 sym
= cp_lookup_symbol_in_namespace (scope
,
572 else if (current
->alias
== NULL
)
574 /* If this import statement creates no alias, pass
575 current->inner as NAMESPACE to direct the search
576 towards the imported namespace. */
577 sym
= cp_lookup_symbol_via_imports (current
->import_src
,
581 current
->searched
= 0;
582 discard_cleanups (searched_cleanup
);
584 if (sym
.symbol
!= NULL
)
589 return (struct block_symbol
) {NULL
, NULL
};
592 /* Helper function that searches an array of symbols for one named NAME. */
594 static struct symbol
*
595 search_symbol_list (const char *name
, int num
,
596 struct symbol
**syms
)
600 /* Maybe we should store a dictionary in here instead. */
601 for (i
= 0; i
< num
; ++i
)
603 if (strcmp (name
, SYMBOL_NATURAL_NAME (syms
[i
])) == 0)
609 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
610 searches through the template parameters of the function and the
614 cp_lookup_symbol_imports_or_template (const char *scope
,
616 const struct block
*block
,
617 const domain_enum domain
)
619 struct symbol
*function
= BLOCK_FUNCTION (block
);
620 struct block_symbol result
;
622 if (symbol_lookup_debug
)
624 fprintf_unfiltered (gdb_stdlog
,
625 "cp_lookup_symbol_imports_or_template"
626 " (%s, %s, %s, %s)\n",
627 scope
, name
, host_address_to_string (block
),
628 domain_name (domain
));
631 if (function
!= NULL
&& SYMBOL_LANGUAGE (function
) == language_cplus
)
633 /* Search the function's template parameters. */
634 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function
))
636 struct template_symbol
*templ
637 = (struct template_symbol
*) function
;
638 struct symbol
*sym
= search_symbol_list (name
,
639 templ
->n_template_arguments
,
640 templ
->template_arguments
);
644 if (symbol_lookup_debug
)
646 fprintf_unfiltered (gdb_stdlog
,
647 "cp_lookup_symbol_imports_or_template"
649 host_address_to_string (sym
));
651 return (struct block_symbol
) {sym
, block
};
655 /* Search the template parameters of the function's defining
657 if (SYMBOL_NATURAL_NAME (function
))
659 struct type
*context
;
660 char *name_copy
= xstrdup (SYMBOL_NATURAL_NAME (function
));
661 struct cleanup
*cleanups
= make_cleanup (xfree
, name_copy
);
662 const struct language_defn
*lang
= language_def (language_cplus
);
663 struct gdbarch
*arch
= symbol_arch (function
);
664 const struct block
*parent
= BLOCK_SUPERBLOCK (block
);
669 unsigned int prefix_len
= cp_entire_prefix_len (name_copy
);
675 name_copy
[prefix_len
] = '\0';
676 context
= lookup_typename (lang
, arch
,
685 = search_symbol_list (name
,
686 TYPE_N_TEMPLATE_ARGUMENTS (context
),
687 TYPE_TEMPLATE_ARGUMENTS (context
));
690 do_cleanups (cleanups
);
691 if (symbol_lookup_debug
)
695 "cp_lookup_symbol_imports_or_template (...) = %s\n",
696 host_address_to_string (sym
));
698 return (struct block_symbol
) {sym
, parent
};
702 do_cleanups (cleanups
);
706 result
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 0, 1, 1);
707 if (symbol_lookup_debug
)
709 fprintf_unfiltered (gdb_stdlog
,
710 "cp_lookup_symbol_imports_or_template (...) = %s\n",
711 result
.symbol
!= NULL
712 ? host_address_to_string (result
.symbol
) : "NULL");
717 /* Search for NAME by applying relevant import statements belonging to BLOCK
718 and its parents. SCOPE is the namespace scope of the context in which the
719 search is being evaluated. */
721 static struct block_symbol
722 cp_lookup_symbol_via_all_imports (const char *scope
, const char *name
,
723 const struct block
*block
,
724 const domain_enum domain
)
726 struct block_symbol sym
;
728 while (block
!= NULL
)
730 sym
= cp_lookup_symbol_via_imports (scope
, name
, block
, domain
, 0, 0, 1);
734 block
= BLOCK_SUPERBLOCK (block
);
737 return (struct block_symbol
) {NULL
, NULL
};
740 /* Searches for NAME in the current namespace, and by applying
741 relevant import statements belonging to BLOCK and its parents.
742 SCOPE is the namespace scope of the context in which the search is
746 cp_lookup_symbol_namespace (const char *scope
,
748 const struct block
*block
,
749 const domain_enum domain
)
751 struct block_symbol sym
;
753 if (symbol_lookup_debug
)
755 fprintf_unfiltered (gdb_stdlog
,
756 "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
757 scope
, name
, host_address_to_string (block
),
758 domain_name (domain
));
761 /* First, try to find the symbol in the given namespace. */
762 sym
= cp_lookup_symbol_in_namespace (scope
, name
, block
, domain
, 1);
764 /* Search for name in namespaces imported to this and parent blocks. */
765 if (sym
.symbol
== NULL
)
766 sym
= cp_lookup_symbol_via_all_imports (scope
, name
, block
, domain
);
768 if (symbol_lookup_debug
)
770 fprintf_unfiltered (gdb_stdlog
,
771 "cp_lookup_symbol_namespace (...) = %s\n",
773 ? host_address_to_string (sym
.symbol
) : "NULL");
778 /* Lookup NAME at namespace scope (or, in C terms, in static and
779 global variables). SCOPE is the namespace that the current
780 function is defined within; only consider namespaces whose length
781 is at least SCOPE_LEN. Other arguments are as in
782 cp_lookup_symbol_nonlocal.
784 For example, if we're within a function A::B::f and looking for a
785 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
786 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
787 but with SCOPE_LEN = 1. And then it calls itself with NAME and
788 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
789 "A::B::x"; if it doesn't find it, then the second call looks for
790 "A::x", and if that call fails, then the first call looks for
793 static struct block_symbol
794 lookup_namespace_scope (const struct language_defn
*langdef
,
796 const struct block
*block
,
797 const domain_enum domain
,
803 if (scope
[scope_len
] != '\0')
805 /* Recursively search for names in child namespaces first. */
807 struct block_symbol sym
;
808 int new_scope_len
= scope_len
;
810 /* If the current scope is followed by "::", skip past that. */
811 if (new_scope_len
!= 0)
813 gdb_assert (scope
[new_scope_len
] == ':');
816 new_scope_len
+= cp_find_first_component (scope
+ new_scope_len
);
817 sym
= lookup_namespace_scope (langdef
, name
, block
, domain
,
818 scope
, new_scope_len
);
819 if (sym
.symbol
!= NULL
)
823 /* Okay, we didn't find a match in our children, so look for the
824 name in the current namespace.
826 If we there is no scope and we know we have a bare symbol, then short
827 circuit everything and call cp_lookup_bare_symbol directly.
828 This isn't an optimization, rather it allows us to pass LANGDEF which
829 is needed for primitive type lookup. The test doesn't have to be
830 perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
831 template symbol with "::" in the argument list) then
832 cp_lookup_symbol_in_namespace will catch it. */
834 if (scope_len
== 0 && strchr (name
, ':') == NULL
)
835 return cp_lookup_bare_symbol (langdef
, name
, block
, domain
, 1);
837 the_namespace
= alloca (scope_len
+ 1);
838 strncpy (the_namespace
, scope
, scope_len
);
839 the_namespace
[scope_len
] = '\0';
840 return cp_lookup_symbol_in_namespace (the_namespace
, name
,
844 /* The C++-specific version of name lookup for static and global
845 names. This makes sure that names get looked for in all namespaces
846 that are in scope. NAME is the natural name of the symbol that
847 we're looking for, BLOCK is the block that we're searching within,
848 DOMAIN says what kind of symbols we're looking for. */
851 cp_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
853 const struct block
*block
,
854 const domain_enum domain
)
856 struct block_symbol sym
;
857 const char *scope
= block_scope (block
);
859 if (symbol_lookup_debug
)
861 fprintf_unfiltered (gdb_stdlog
,
862 "cp_lookup_symbol_non_local"
863 " (%s, %s (scope %s), %s)\n",
864 name
, host_address_to_string (block
), scope
,
865 domain_name (domain
));
868 /* First, try to find the symbol in the given namespace, and all
869 containing namespaces. */
870 sym
= lookup_namespace_scope (langdef
, name
, block
, domain
, scope
, 0);
872 /* Search for name in namespaces imported to this and parent blocks. */
873 if (sym
.symbol
== NULL
)
874 sym
= cp_lookup_symbol_via_all_imports (scope
, name
, block
, domain
);
876 if (symbol_lookup_debug
)
878 fprintf_unfiltered (gdb_stdlog
,
879 "cp_lookup_symbol_nonlocal (...) = %s\n",
881 ? host_address_to_string (sym
.symbol
)
887 /* Search through the base classes of PARENT_TYPE for a base class
888 named NAME and return its type. If not found, return NULL. */
891 cp_find_type_baseclass_by_name (struct type
*parent_type
, const char *name
)
895 parent_type
= check_typedef (parent_type
);
896 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
898 struct type
*type
= check_typedef (TYPE_BASECLASS (parent_type
, i
));
899 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
901 if (base_name
== NULL
)
904 if (streq (base_name
, name
))
907 type
= cp_find_type_baseclass_by_name (type
, name
);
915 /* Search through the base classes of PARENT_TYPE for a symbol named
916 NAME in block BLOCK. */
918 static struct block_symbol
919 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
920 const struct block
*block
, const domain_enum domain
,
924 struct block_symbol sym
;
925 struct cleanup
*cleanup
;
926 char *concatenated_name
;
930 concatenated_name
= NULL
;
931 cleanup
= make_cleanup (free_current_contents
, &concatenated_name
);
933 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
936 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
937 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
939 if (base_name
== NULL
)
942 len
= strlen (base_name
) + 2 + strlen (name
) + 1;
943 concatenated_name
= xrealloc (concatenated_name
, len
);
944 xsnprintf (concatenated_name
, len
, "%s::%s", base_name
, name
);
946 sym
= cp_lookup_nested_symbol_1 (base_type
, name
, concatenated_name
,
947 block
, domain
, 1, is_in_anonymous
);
948 if (sym
.symbol
!= NULL
)
952 do_cleanups (cleanup
);
956 /* Helper function to look up NESTED_NAME in CONTAINER_TYPE and in DOMAIN
957 and within the context of BLOCK.
958 NESTED_NAME may have scope ("::").
959 CONTAINER_TYPE needn't have been "check_typedef'd" yet.
960 CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
961 passed as an argument so that callers can control how space for it is
963 If BASIC_LOOKUP is non-zero then perform a basic lookup of
964 CONCATENATED_NAME. See cp_basic_lookup_symbol for details.
965 If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
968 static struct block_symbol
969 cp_lookup_nested_symbol_1 (struct type
*container_type
,
970 const char *nested_name
,
971 const char *concatenated_name
,
972 const struct block
*block
,
973 const domain_enum domain
,
974 int basic_lookup
, int is_in_anonymous
)
976 struct block_symbol sym
;
978 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
979 of classes like, say, data or function members. Instead,
980 they're just represented by symbols whose names are
981 qualified by the name of the surrounding class. This is
982 just like members of namespaces; in particular,
983 cp_basic_lookup_symbol works when looking them up. */
987 sym
= cp_basic_lookup_symbol (concatenated_name
, block
, domain
,
989 if (sym
.symbol
!= NULL
)
993 /* Now search all static file-level symbols. We have to do this for things
994 like typedefs in the class. We do not try to guess any imported
995 namespace as even the fully specified namespace search is already not
996 C++ compliant and more assumptions could make it too magic. */
998 /* First search in this symtab, what we want is possibly there. */
999 sym
= lookup_symbol_in_static_block (concatenated_name
, block
, domain
);
1000 if (sym
.symbol
!= NULL
)
1003 /* Nope. We now have to search all static blocks in all objfiles,
1004 even if block != NULL, because there's no guarantees as to which
1005 symtab the symbol we want is in. Except for symbols defined in
1006 anonymous namespaces should be treated as local to a single file,
1007 which we just searched. */
1008 if (!is_in_anonymous
)
1010 sym
= lookup_static_symbol (concatenated_name
, domain
);
1011 if (sym
.symbol
!= NULL
)
1015 /* If this is a class with baseclasses, search them next. */
1016 container_type
= check_typedef (container_type
);
1017 if (TYPE_N_BASECLASSES (container_type
) > 0)
1019 sym
= find_symbol_in_baseclass (container_type
, nested_name
, block
,
1020 domain
, is_in_anonymous
);
1021 if (sym
.symbol
!= NULL
)
1025 return (struct block_symbol
) {NULL
, NULL
};
1028 /* Look up a symbol named NESTED_NAME that is nested inside the C++
1029 class or namespace given by PARENT_TYPE, from within the context
1030 given by BLOCK, and in DOMAIN.
1031 Return NULL if there is no such nested symbol. */
1034 cp_lookup_nested_symbol (struct type
*parent_type
,
1035 const char *nested_name
,
1036 const struct block
*block
,
1037 const domain_enum domain
)
1039 /* type_name_no_tag_or_error provides better error reporting using the
1041 struct type
*saved_parent_type
= parent_type
;
1043 parent_type
= check_typedef (parent_type
);
1045 if (symbol_lookup_debug
)
1047 const char *type_name
= type_name_no_tag (saved_parent_type
);
1049 fprintf_unfiltered (gdb_stdlog
,
1050 "cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
1051 type_name
!= NULL
? type_name
: "unnamed",
1052 nested_name
, host_address_to_string (block
),
1053 domain_name (domain
));
1056 switch (TYPE_CODE (parent_type
))
1058 case TYPE_CODE_STRUCT
:
1059 case TYPE_CODE_NAMESPACE
:
1060 case TYPE_CODE_UNION
:
1061 case TYPE_CODE_ENUM
:
1062 /* NOTE: Handle modules here as well, because Fortran is re-using the C++
1063 specific code to lookup nested symbols in modules, by calling the
1064 function pointer la_lookup_symbol_nonlocal, which ends up here. */
1065 case TYPE_CODE_MODULE
:
1068 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
1069 struct block_symbol sym
;
1070 char *concatenated_name
;
1071 int is_in_anonymous
;
1073 size
= strlen (parent_name
) + 2 + strlen (nested_name
) + 1;
1074 concatenated_name
= alloca (size
);
1075 xsnprintf (concatenated_name
, size
, "%s::%s",
1076 parent_name
, nested_name
);
1077 is_in_anonymous
= cp_is_in_anonymous (concatenated_name
);
1079 sym
= cp_lookup_nested_symbol_1 (parent_type
, nested_name
,
1080 concatenated_name
, block
, domain
,
1081 1, is_in_anonymous
);
1083 if (symbol_lookup_debug
)
1085 fprintf_unfiltered (gdb_stdlog
,
1086 "cp_lookup_nested_symbol (...) = %s\n",
1088 ? host_address_to_string (sym
.symbol
)
1094 case TYPE_CODE_FUNC
:
1095 case TYPE_CODE_METHOD
:
1096 if (symbol_lookup_debug
)
1098 fprintf_unfiltered (gdb_stdlog
,
1099 "cp_lookup_nested_symbol (...) = NULL"
1100 " (func/method)\n");
1102 return (struct block_symbol
) {NULL
, NULL
};
1105 internal_error (__FILE__
, __LINE__
,
1106 _("cp_lookup_nested_symbol called "
1107 "on a non-aggregate type."));
1111 /* The C++-version of lookup_transparent_type. */
1113 /* FIXME: carlton/2004-01-16: The problem that this is trying to
1114 address is that, unfortunately, sometimes NAME is wrong: it may not
1115 include the name of namespaces enclosing the type in question.
1116 lookup_transparent_type gets called when the type in question
1117 is a declaration, and we're trying to find its definition; but, for
1118 declarations, our type name deduction mechanism doesn't work.
1119 There's nothing we can do to fix this in general, I think, in the
1120 absence of debug information about namespaces (I've filed PR
1121 gdb/1511 about this); until such debug information becomes more
1122 prevalent, one heuristic which sometimes looks is to search for the
1123 definition in namespaces containing the current namespace.
1125 We should delete this functions once the appropriate debug
1126 information becomes more widespread. (GCC 3.4 will be the first
1127 released version of GCC with such information.) */
1130 cp_lookup_transparent_type (const char *name
)
1132 /* First, try the honest way of looking up the definition. */
1133 struct type
*t
= basic_lookup_transparent_type (name
);
1139 /* If that doesn't work and we're within a namespace, look there
1141 scope
= block_scope (get_selected_block (0));
1143 if (scope
[0] == '\0')
1146 return cp_lookup_transparent_type_loop (name
, scope
, 0);
1149 /* Lookup the type definition associated to NAME in namespaces/classes
1150 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
1151 must be the index of the start of a component of SCOPE. */
1153 static struct type
*
1154 cp_lookup_transparent_type_loop (const char *name
,
1158 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
1161 /* If the current scope is followed by "::", look in the next
1163 if (scope
[scope_length
] == ':')
1166 = cp_lookup_transparent_type_loop (name
, scope
,
1173 full_name
= alloca (scope_length
+ 2 + strlen (name
) + 1);
1174 strncpy (full_name
, scope
, scope_length
);
1175 strncpy (full_name
+ scope_length
, "::", 2);
1176 strcpy (full_name
+ scope_length
+ 2, name
);
1178 return basic_lookup_transparent_type (full_name
);
1181 /* This used to do something but was removed when it became
1185 maintenance_cplus_namespace (char *args
, int from_tty
)
1187 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1190 /* Provide a prototype to silence -Wmissing-prototypes. */
1191 extern initialize_file_ftype _initialize_cp_namespace
;
1194 _initialize_cp_namespace (void)
1196 struct cmd_list_element
*cmd
;
1198 cmd
= add_cmd ("namespace", class_maintenance
,
1199 maintenance_cplus_namespace
,
1200 _("Deprecated placeholder for removed functionality."),
1201 &maint_cplus_cmd_list
);
1202 deprecate_cmd (cmd
, NULL
);