1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 Contributed by David Carlton and by Kealia, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "cp-support.h"
24 #include "gdb_obstack.h"
27 #include "gdb_assert.h"
31 #include "dictionary.h"
37 static struct symbol
*lookup_namespace_scope (const char *name
,
38 const struct block
*block
,
39 const domain_enum domain
,
43 static struct symbol
*lookup_symbol_file (const char *name
,
44 const struct block
*block
,
45 const domain_enum domain
,
46 int anonymous_namespace
);
48 static struct type
*cp_lookup_transparent_type_loop (const char *name
,
52 /* Check to see if SYMBOL refers to an object contained within an
53 anonymous namespace; if so, add an appropriate using directive. */
56 cp_scan_for_anonymous_namespaces (const struct symbol
*symbol
)
58 if (SYMBOL_DEMANGLED_NAME (symbol
) != NULL
)
60 const char *name
= SYMBOL_DEMANGLED_NAME (symbol
);
61 unsigned int previous_component
;
62 unsigned int next_component
;
64 /* Start with a quick-and-dirty check for mention of "(anonymous
67 if (!cp_is_anonymous (name
))
70 previous_component
= 0;
71 next_component
= cp_find_first_component (name
+ previous_component
);
73 while (name
[next_component
] == ':')
75 if (((next_component
- previous_component
)
76 == CP_ANONYMOUS_NAMESPACE_LEN
)
77 && strncmp (name
+ previous_component
,
78 CP_ANONYMOUS_NAMESPACE_STR
,
79 CP_ANONYMOUS_NAMESPACE_LEN
) == 0)
81 int dest_len
= (previous_component
== 0
82 ? 0 : previous_component
- 2);
83 int src_len
= next_component
;
85 char *dest
= alloca (dest_len
+ 1);
86 char *src
= alloca (src_len
+ 1);
88 memcpy (dest
, name
, dest_len
);
89 memcpy (src
, name
, src_len
);
91 dest
[dest_len
] = '\0';
94 /* We've found a component of the name that's an
95 anonymous namespace. So add symbols in it to the
96 namespace given by the previous component if there is
97 one, or to the global namespace if there isn't. */
98 cp_add_using_directive (dest
, src
, NULL
, NULL
,
99 &SYMBOL_SYMTAB (symbol
)->objfile
->objfile_obstack
);
101 /* The "+ 2" is for the "::". */
102 previous_component
= next_component
+ 2;
103 next_component
= (previous_component
104 + cp_find_first_component (name
105 + previous_component
));
111 /* Add a using directive to using_directives. If the using directive
112 in question has already been added, don't add it twice.
114 Create a new struct using_direct which imports the namespace SRC
115 into the scope DEST. ALIAS is the name of the imported namespace
116 in the current scope. If ALIAS is NULL then the namespace is known
117 by its original name. DECLARATION is the name if the imported
118 varable if this is a declaration import (Eg. using A::x), otherwise
119 it is NULL. The arguments are copied into newly allocated memory
120 so they can be temporaries. */
123 cp_add_using_directive (const char *dest
,
126 const char *declaration
,
127 struct obstack
*obstack
)
129 struct using_direct
*current
;
130 struct using_direct
*new;
132 /* Has it already been added? */
134 for (current
= using_directives
; current
!= NULL
; current
= current
->next
)
136 if (strcmp (current
->import_src
, src
) == 0
137 && strcmp (current
->import_dest
, dest
) == 0
138 && ((alias
== NULL
&& current
->alias
== NULL
)
139 || (alias
!= NULL
&& current
->alias
!= NULL
140 && strcmp (alias
, current
->alias
) == 0))
141 && ((declaration
== NULL
&& current
->declaration
== NULL
)
142 || (declaration
!= NULL
&& current
->declaration
!= NULL
143 && strcmp (declaration
, current
->declaration
) == 0)))
147 new = OBSTACK_ZALLOC (obstack
, struct using_direct
);
149 new->import_src
= obsavestring (src
, strlen (src
), obstack
);
150 new->import_dest
= obsavestring (dest
, strlen (dest
), obstack
);
153 new->alias
= obsavestring (alias
, strlen (alias
), obstack
);
155 if (declaration
!= NULL
)
156 new->declaration
= obsavestring (declaration
, strlen (declaration
),
159 new->next
= using_directives
;
160 using_directives
= new;
163 /* Record the namespace that the function defined by SYMBOL was
164 defined in, if necessary. BLOCK is the associated block; use
165 OBSTACK for allocation. */
168 cp_set_block_scope (const struct symbol
*symbol
,
170 struct obstack
*obstack
,
171 const char *processing_current_prefix
,
172 int processing_has_namespace_info
)
174 if (processing_has_namespace_info
)
177 (block
, obsavestring (processing_current_prefix
,
178 strlen (processing_current_prefix
),
182 else if (SYMBOL_DEMANGLED_NAME (symbol
) != NULL
)
184 /* Try to figure out the appropriate namespace from the
187 /* FIXME: carlton/2003-04-15: If the function in question is
188 a method of a class, the name will actually include the
189 name of the class as well. This should be harmless, but
190 is a little unfortunate. */
192 const char *name
= SYMBOL_DEMANGLED_NAME (symbol
);
193 unsigned int prefix_len
= cp_entire_prefix_len (name
);
195 block_set_scope (block
,
196 obsavestring (name
, prefix_len
, obstack
),
201 /* Test whether or not NAMESPACE looks like it mentions an anonymous
202 namespace; return nonzero if so. */
205 cp_is_anonymous (const char *namespace)
207 return (strstr (namespace, CP_ANONYMOUS_NAMESPACE_STR
)
211 /* The C++-specific version of name lookup for static and global
212 names. This makes sure that names get looked for in all namespaces
213 that are in scope. NAME is the natural name of the symbol that
214 we're looking for, BLOCK is the block that we're searching within,
215 DOMAIN says what kind of symbols we're looking for, and if SYMTAB
216 is non-NULL, we should store the symtab where we found the symbol
220 cp_lookup_symbol_nonlocal (const char *name
,
221 const struct block
*block
,
222 const domain_enum domain
)
225 const char *scope
= block_scope (block
);
227 sym
= lookup_namespace_scope (name
, block
,
232 return cp_lookup_symbol_namespace (scope
, name
,
236 /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
237 as in cp_lookup_symbol_nonlocal. */
239 static struct symbol
*
240 cp_lookup_symbol_in_namespace (const char *namespace,
242 const struct block
*block
,
243 const domain_enum domain
)
245 if (namespace[0] == '\0')
247 return lookup_symbol_file (name
, block
, domain
, 0);
251 char *concatenated_name
= alloca (strlen (namespace) + 2
252 + strlen (name
) + 1);
254 strcpy (concatenated_name
, namespace);
255 strcat (concatenated_name
, "::");
256 strcat (concatenated_name
, name
);
257 return lookup_symbol_file (concatenated_name
, block
, domain
,
258 cp_is_anonymous (namespace));
262 /* Used for cleanups to reset the "searched" flag incase
266 reset_directive_searched (void *data
)
268 struct using_direct
*direct
= data
;
269 direct
->searched
= 0;
272 /* Search for NAME by applying all import statements belonging to
273 BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
274 search is restricted to using declarations.
282 If SEARCH_PARENTS the search will include imports which are
283 applicable in parents of SCOPE.
293 If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
294 namespaces X and Y will be considered. If SEARCH_PARENTS is false
295 only the import of Y is considered. */
298 cp_lookup_symbol_imports (const char *scope
,
300 const struct block
*block
,
301 const domain_enum domain
,
302 const int declaration_only
,
303 const int search_parents
)
305 struct using_direct
*current
;
306 struct symbol
*sym
= NULL
;
309 struct cleanup
*searched_cleanup
;
311 /* First, try to find the symbol in the given namespace. */
312 if (!declaration_only
)
313 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
319 /* Go through the using directives. If any of them add new names to
320 the namespace we're searching in, see if we can find a match by
323 for (current
= block_using (block
);
325 current
= current
->next
)
327 len
= strlen (current
->import_dest
);
328 directive_match
= (search_parents
329 ? (strncmp (scope
, current
->import_dest
,
330 strlen (current
->import_dest
)) == 0
333 || scope
[len
] == '\0'))
334 : strcmp (scope
, current
->import_dest
) == 0);
336 /* If the import destination is the current scope or one of its
337 ancestors then it is applicable. */
338 if (directive_match
&& !current
->searched
)
340 /* Mark this import as searched so that the recursive call
341 does not search it again. */
342 current
->searched
= 1;
343 searched_cleanup
= make_cleanup (reset_directive_searched
,
346 /* If there is an import of a single declaration, compare the
347 imported declaration (after optional renaming by its alias)
348 with the sought out name. If there is a match pass
349 current->import_src as NAMESPACE to direct the search
350 towards the imported namespace. */
351 if (current
->declaration
352 && strcmp (name
, current
->alias
353 ? current
->alias
: current
->declaration
) == 0)
354 sym
= cp_lookup_symbol_in_namespace (current
->import_src
,
355 current
->declaration
,
358 /* If this is a DECLARATION_ONLY search or a symbol was found
359 or this import statement was an import declaration, the
360 search of this import is complete. */
361 if (declaration_only
|| sym
!= NULL
|| current
->declaration
)
363 current
->searched
= 0;
364 discard_cleanups (searched_cleanup
);
372 if (current
->alias
!= NULL
373 && strcmp (name
, current
->alias
) == 0)
374 /* If the import is creating an alias and the alias matches
375 the sought name. Pass current->import_src as the NAME to
376 direct the search towards the aliased namespace. */
378 sym
= cp_lookup_symbol_in_namespace (scope
,
382 else if (current
->alias
== NULL
)
384 /* If this import statement creates no alias, pass
385 current->inner as NAMESPACE to direct the search
386 towards the imported namespace. */
387 sym
= cp_lookup_symbol_imports (current
->import_src
,
391 current
->searched
= 0;
392 discard_cleanups (searched_cleanup
);
402 /* Helper function that searches an array of symbols for one named
405 static struct symbol
*
406 search_symbol_list (const char *name
, int num
,
407 struct symbol
**syms
)
411 /* Maybe we should store a dictionary in here instead. */
412 for (i
= 0; i
< num
; ++i
)
414 if (strcmp (name
, SYMBOL_NATURAL_NAME (syms
[i
])) == 0)
420 /* Like cp_lookup_symbol_imports, but if BLOCK is a function, it
421 searches through the template parameters of the function and the
425 cp_lookup_symbol_imports_or_template (const char *scope
,
427 const struct block
*block
,
428 const domain_enum domain
)
430 struct symbol
*function
= BLOCK_FUNCTION (block
);
432 if (function
!= NULL
&& SYMBOL_LANGUAGE (function
) == language_cplus
)
435 struct cplus_specific
*cps
436 = function
->ginfo
.language_specific
.cplus_specific
;
438 /* Search the function's template parameters. */
439 if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function
))
441 struct template_symbol
*templ
442 = (struct template_symbol
*) function
;
443 struct symbol
*result
;
445 result
= search_symbol_list (name
,
446 templ
->n_template_arguments
,
447 templ
->template_arguments
);
452 /* Search the template parameters of the function's defining
454 if (SYMBOL_NATURAL_NAME (function
))
456 struct type
*context
;
457 char *name_copy
= xstrdup (SYMBOL_NATURAL_NAME (function
));
458 struct cleanup
*cleanups
= make_cleanup (xfree
, name_copy
);
459 const struct language_defn
*lang
= language_def (language_cplus
);
460 struct gdbarch
*arch
= SYMBOL_SYMTAB (function
)->objfile
->gdbarch
;
461 const struct block
*parent
= BLOCK_SUPERBLOCK (block
);
465 struct symbol
*result
;
466 unsigned int prefix_len
= cp_entire_prefix_len (name_copy
);
472 name_copy
[prefix_len
] = '\0';
473 context
= lookup_typename (lang
, arch
,
482 = search_symbol_list (name
,
483 TYPE_N_TEMPLATE_ARGUMENTS (context
),
484 TYPE_TEMPLATE_ARGUMENTS (context
));
489 do_cleanups (cleanups
);
493 return cp_lookup_symbol_imports (scope
, name
, block
, domain
, 1, 1);
496 /* Searches for NAME in the current namespace, and by applying
497 relevant import statements belonging to BLOCK and its parents.
498 SCOPE is the namespace scope of the context in which the search is
502 cp_lookup_symbol_namespace (const char *scope
,
504 const struct block
*block
,
505 const domain_enum domain
)
509 /* First, try to find the symbol in the given namespace. */
510 sym
= cp_lookup_symbol_in_namespace (scope
, name
,
515 /* Search for name in namespaces imported to this and parent
517 while (block
!= NULL
)
519 sym
= cp_lookup_symbol_imports (scope
, name
, block
,
525 block
= BLOCK_SUPERBLOCK (block
);
531 /* Lookup NAME at namespace scope (or, in C terms, in static and
532 global variables). SCOPE is the namespace that the current
533 function is defined within; only consider namespaces whose length
534 is at least SCOPE_LEN. Other arguments are as in
535 cp_lookup_symbol_nonlocal.
537 For example, if we're within a function A::B::f and looking for a
538 symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
539 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
540 but with SCOPE_LEN = 1. And then it calls itself with NAME and
541 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
542 "A::B::x"; if it doesn't find it, then the second call looks for
543 "A::x", and if that call fails, then the first call looks for
546 static struct symbol
*
547 lookup_namespace_scope (const char *name
,
548 const struct block
*block
,
549 const domain_enum domain
,
555 if (scope
[scope_len
] != '\0')
557 /* Recursively search for names in child namespaces first. */
560 int new_scope_len
= scope_len
;
562 /* If the current scope is followed by "::", skip past that. */
563 if (new_scope_len
!= 0)
565 gdb_assert (scope
[new_scope_len
] == ':');
568 new_scope_len
+= cp_find_first_component (scope
+ new_scope_len
);
569 sym
= lookup_namespace_scope (name
, block
, domain
,
570 scope
, new_scope_len
);
575 /* Okay, we didn't find a match in our children, so look for the
576 name in the current namespace. */
578 namespace = alloca (scope_len
+ 1);
579 strncpy (namespace, scope
, scope_len
);
580 namespace[scope_len
] = '\0';
581 return cp_lookup_symbol_in_namespace (namespace, name
,
585 /* Look up NAME in BLOCK's static block and in global blocks. If
586 ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
587 within an anonymous namespace. Other arguments are as in
588 cp_lookup_symbol_nonlocal. */
590 static struct symbol
*
591 lookup_symbol_file (const char *name
,
592 const struct block
*block
,
593 const domain_enum domain
,
594 int anonymous_namespace
)
596 struct symbol
*sym
= NULL
;
598 sym
= lookup_symbol_static (name
, block
, domain
);
602 if (anonymous_namespace
)
604 /* Symbols defined in anonymous namespaces have external linkage
605 but should be treated as local to a single file nonetheless.
606 So we only search the current file's global block. */
608 const struct block
*global_block
= block_global_block (block
);
610 if (global_block
!= NULL
)
611 sym
= lookup_symbol_aux_block (name
, global_block
, domain
);
615 sym
= lookup_symbol_global (name
, block
, domain
);
621 /* Look up a type named NESTED_NAME that is nested inside the C++
622 class or namespace given by PARENT_TYPE, from within the context
623 given by BLOCK. Return NULL if there is no such nested type. */
626 cp_lookup_nested_type (struct type
*parent_type
,
627 const char *nested_name
,
628 const struct block
*block
)
630 /* type_name_no_tag_required provides better error reporting using the
632 struct type
*saved_parent_type
= parent_type
;
634 CHECK_TYPEDEF (parent_type
);
636 switch (TYPE_CODE (parent_type
))
638 case TYPE_CODE_STRUCT
:
639 case TYPE_CODE_NAMESPACE
:
640 case TYPE_CODE_UNION
:
642 /* NOTE: carlton/2003-11-10: We don't treat C++ class members
643 of classes like, say, data or function members. Instead,
644 they're just represented by symbols whose names are
645 qualified by the name of the surrounding class. This is
646 just like members of namespaces; in particular,
647 lookup_symbol_namespace works when looking them up. */
649 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
651 = cp_lookup_symbol_in_namespace (parent_name
, nested_name
,
653 char *concatenated_name
;
655 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
656 return SYMBOL_TYPE (sym
);
658 /* Now search all static file-level symbols. Not strictly
659 correct, but more useful than an error. We do not try to
660 guess any imported namespace as even the fully specified
661 namespace seach is is already not C++ compliant and more
662 assumptions could make it too magic. */
664 concatenated_name
= alloca (strlen (parent_name
) + 2
665 + strlen (nested_name
) + 1);
666 sprintf (concatenated_name
, "%s::%s",
667 parent_name
, nested_name
);
668 sym
= lookup_static_symbol_aux (concatenated_name
,
670 if (sym
!= NULL
&& SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
671 return SYMBOL_TYPE (sym
);
676 internal_error (__FILE__
, __LINE__
,
677 _("cp_lookup_nested_type called "
678 "on a non-aggregate type."));
682 /* The C++-version of lookup_transparent_type. */
684 /* FIXME: carlton/2004-01-16: The problem that this is trying to
685 address is that, unfortunately, sometimes NAME is wrong: it may not
686 include the name of namespaces enclosing the type in question.
687 lookup_transparent_type gets called when the type in question
688 is a declaration, and we're trying to find its definition; but, for
689 declarations, our type name deduction mechanism doesn't work.
690 There's nothing we can do to fix this in general, I think, in the
691 absence of debug information about namespaces (I've filed PR
692 gdb/1511 about this); until such debug information becomes more
693 prevalent, one heuristic which sometimes looks is to search for the
694 definition in namespaces containing the current namespace.
696 We should delete this functions once the appropriate debug
697 information becomes more widespread. (GCC 3.4 will be the first
698 released version of GCC with such information.) */
701 cp_lookup_transparent_type (const char *name
)
703 /* First, try the honest way of looking up the definition. */
704 struct type
*t
= basic_lookup_transparent_type (name
);
710 /* If that doesn't work and we're within a namespace, look there
712 scope
= block_scope (get_selected_block (0));
714 if (scope
[0] == '\0')
717 return cp_lookup_transparent_type_loop (name
, scope
, 0);
720 /* Lookup the type definition associated to NAME in namespaces/classes
721 containing SCOPE whose name is strictly longer than LENGTH. LENGTH
722 must be the index of the start of a component of SCOPE. */
725 cp_lookup_transparent_type_loop (const char *name
,
729 int scope_length
= length
+ cp_find_first_component (scope
+ length
);
732 /* If the current scope is followed by "::", look in the next
734 if (scope
[scope_length
] == ':')
737 = cp_lookup_transparent_type_loop (name
, scope
,
744 full_name
= alloca (scope_length
+ 2 + strlen (name
) + 1);
745 strncpy (full_name
, scope
, scope_length
);
746 strncpy (full_name
+ scope_length
, "::", 2);
747 strcpy (full_name
+ scope_length
+ 2, name
);
749 return basic_lookup_transparent_type (full_name
);
752 /* This used to do something but was removed when it became
756 maintenance_cplus_namespace (char *args
, int from_tty
)
758 printf_unfiltered (_("The `maint namespace' command was removed.\n"));
761 /* Provide a prototype to silence -Wmissing-prototypes. */
762 extern initialize_file_ftype _initialize_cp_namespace
;
765 _initialize_cp_namespace (void)
767 struct cmd_list_element
*cmd
;
769 cmd
= add_cmd ("namespace", class_maintenance
,
770 maintenance_cplus_namespace
,
771 _("Deprecated placeholder for removed functionality."),
772 &maint_cplus_cmd_list
);
773 deprecate_cmd (cmd
, NULL
);