1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2002-2013 Free Software Foundation, Inc.
4 Contributed by MontaVista Software.
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"
25 #include "gdb_assert.h"
27 #include "dictionary.h"
32 #include "complaints.h"
34 #include "exceptions.h"
35 #include "expression.h"
39 #include "safe-ctype.h"
41 #define d_left(dc) (dc)->u.s_binary.left
42 #define d_right(dc) (dc)->u.s_binary.right
44 /* Functions related to demangled name parsing. */
46 static unsigned int cp_find_first_component_aux (const char *name,
49 static void demangled_name_complaint (const char *name);
51 /* Functions/variables related to overload resolution. */
53 static int sym_return_val_size = -1;
54 static int sym_return_val_index;
55 static struct symbol **sym_return_val;
57 static void overload_list_add_symbol (struct symbol *sym,
58 const char *oload_name);
60 static void make_symbol_overload_list_using (const char *func_name,
61 const char *namespace);
63 static void make_symbol_overload_list_qualified (const char *func_name);
65 /* The list of "maint cplus" commands. */
67 struct cmd_list_element *maint_cplus_cmd_list = NULL;
69 /* The actual commands. */
71 static void maint_cplus_command (char *arg, int from_tty);
72 static void first_component_command (char *arg, int from_tty);
74 /* A list of typedefs which should not be substituted by replace_typedefs. */
75 static const char * const ignore_typedefs[] =
77 "std::istream", "std::iostream", "std::ostream", "std::string"
81 replace_typedefs (struct demangle_parse_info *info,
82 struct demangle_component *ret_comp,
83 canonicalization_ftype *finder,
86 /* A convenience function to copy STRING into OBSTACK, returning a pointer
87 to the newly allocated string and saving the number of bytes saved in LEN.
89 It does not copy the terminating '\0' byte! */
92 copy_string_to_obstack (struct obstack *obstack, const char *string,
95 *len = strlen (string);
96 return obstack_copy (obstack, string, *len);
99 /* A cleanup wrapper for cp_demangled_name_parse_free. */
102 do_demangled_name_parse_free_cleanup (void *data)
104 struct demangle_parse_info *info = (struct demangle_parse_info *) data;
106 cp_demangled_name_parse_free (info);
109 /* Create a cleanup for C++ name parsing. */
112 make_cleanup_cp_demangled_name_parse_free (struct demangle_parse_info *info)
114 return make_cleanup (do_demangled_name_parse_free_cleanup, info);
117 /* Return 1 if STRING is clearly already in canonical form. This
118 function is conservative; things which it does not recognize are
119 assumed to be non-canonical, and the parser will sort them out
120 afterwards. This speeds up the critical path for alphanumeric
124 cp_already_canonical (const char *string)
126 /* Identifier start character [a-zA-Z_]. */
127 if (!ISIDST (string[0]))
130 /* These are the only two identifiers which canonicalize to other
131 than themselves or an error: unsigned -> unsigned int and
133 if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
135 else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
138 /* Identifier character [a-zA-Z0-9_]. */
139 while (ISIDNUM (string[1]))
142 if (string[1] == '\0')
148 /* Inspect the given RET_COMP for its type. If it is a typedef,
149 replace the node with the typedef's tree.
151 Returns 1 if any typedef substitutions were made, 0 otherwise. */
154 inspect_type (struct demangle_parse_info *info,
155 struct demangle_component *ret_comp,
156 canonicalization_ftype *finder,
162 volatile struct gdb_exception except;
164 /* Copy the symbol's name from RET_COMP and look it up
165 in the symbol table. */
166 name = (char *) alloca (ret_comp->u.s_name.len + 1);
167 memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len);
168 name[ret_comp->u.s_name.len] = '\0';
170 /* Ignore any typedefs that should not be substituted. */
171 for (i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i)
173 if (strcmp (name, ignore_typedefs[i]) == 0)
178 TRY_CATCH (except, RETURN_MASK_ALL)
180 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
183 if (except.reason >= 0 && sym != NULL)
185 struct type *otype = SYMBOL_TYPE (sym);
189 const char *new_name = (*finder) (otype, data);
191 if (new_name != NULL)
193 ret_comp->u.s_name.s = new_name;
194 ret_comp->u.s_name.len = strlen (new_name);
201 /* If the type is a typedef or namespace alias, replace it. */
202 if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF
203 || TYPE_CODE (otype) == TYPE_CODE_NAMESPACE)
208 struct demangle_parse_info *i;
211 /* Get the real type of the typedef. */
212 type = check_typedef (otype);
214 /* If the symbol is a namespace and its type name is no different
215 than the name we looked up, this symbol is not a namespace
216 alias and does not need to be substituted. */
217 if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE
218 && strcmp (TYPE_NAME (type), name) == 0)
221 is_anon = (TYPE_TAG_NAME (type) == NULL
222 && (TYPE_CODE (type) == TYPE_CODE_ENUM
223 || TYPE_CODE (type) == TYPE_CODE_STRUCT
224 || TYPE_CODE (type) == TYPE_CODE_UNION));
227 struct type *last = otype;
229 /* Find the last typedef for the type. */
230 while (TYPE_TARGET_TYPE (last) != NULL
231 && (TYPE_CODE (TYPE_TARGET_TYPE (last))
232 == TYPE_CODE_TYPEDEF))
233 last = TYPE_TARGET_TYPE (last);
235 /* If there is only one typedef for this anonymous type,
236 do not substitute it. */
240 /* Use the last typedef seen as the type for this
245 buf = mem_fileopen ();
246 TRY_CATCH (except, RETURN_MASK_ERROR)
248 type_print (type, "", buf, -1);
251 /* If type_print threw an exception, there is little point
252 in continuing, so just bow out gracefully. */
253 if (except.reason < 0)
255 ui_file_delete (buf);
259 name = ui_file_obsavestring (buf, &info->obstack, &len);
260 ui_file_delete (buf);
262 /* Turn the result into a new tree. Note that this
263 tree will contain pointers into NAME, so NAME cannot
264 be free'd until all typedef conversion is done and
265 the final result is converted into a string. */
266 i = cp_demangled_name_to_comp (name, NULL);
269 /* Merge the two trees. */
270 cp_merge_demangle_parse_infos (info, ret_comp, i);
272 /* Replace any newly introduced typedefs -- but not
273 if the type is anonymous (that would lead to infinite
276 replace_typedefs (info, ret_comp, finder, data);
280 /* This shouldn't happen unless the type printer has
281 output something that the name parser cannot grok.
282 Nonetheless, an ounce of prevention...
284 Canonicalize the name again, and store it in the
285 current node (RET_COMP). */
286 char *canon = cp_canonicalize_string_no_typedefs (name);
290 /* Copy the canonicalization into the obstack and
292 name = copy_string_to_obstack (&info->obstack, canon, &len);
296 ret_comp->u.s_name.s = name;
297 ret_comp->u.s_name.len = len;
307 /* Replace any typedefs appearing in the qualified name
308 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
312 replace_typedefs_qualified_name (struct demangle_parse_info *info,
313 struct demangle_component *ret_comp,
314 canonicalization_ftype *finder,
319 struct ui_file *buf = mem_fileopen ();
320 struct demangle_component *comp = ret_comp;
322 /* Walk each node of the qualified name, reconstructing the name of
323 this element. With every node, check for any typedef substitutions.
324 If a substitution has occurred, replace the qualified name node
325 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
327 while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
329 if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
331 struct demangle_component new;
333 ui_file_write (buf, d_left (comp)->u.s_name.s,
334 d_left (comp)->u.s_name.len);
335 name = ui_file_obsavestring (buf, &info->obstack, &len);
336 new.type = DEMANGLE_COMPONENT_NAME;
337 new.u.s_name.s = name;
338 new.u.s_name.len = len;
339 if (inspect_type (info, &new, finder, data))
344 /* A typedef was substituted in NEW. Convert it to a
345 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
348 ui_file_rewind (buf);
349 n = cp_comp_to_string (&new, 100);
352 /* If something went astray, abort typedef substitutions. */
353 ui_file_delete (buf);
357 s = copy_string_to_obstack (&info->obstack, n, &slen);
360 d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
361 d_left (ret_comp)->u.s_name.s = s;
362 d_left (ret_comp)->u.s_name.len = slen;
363 d_right (ret_comp) = d_right (comp);
370 /* The current node is not a name, so simply replace any
371 typedefs in it. Then print it to the stream to continue
372 checking for more typedefs in the tree. */
373 replace_typedefs (info, d_left (comp), finder, data);
374 name = cp_comp_to_string (d_left (comp), 100);
377 /* If something went astray, abort typedef substitutions. */
378 ui_file_delete (buf);
381 fputs_unfiltered (name, buf);
385 ui_file_write (buf, "::", 2);
386 comp = d_right (comp);
389 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
390 name assembled above and append the name given by COMP. Then use this
391 reassembled name to check for a typedef. */
393 if (comp->type == DEMANGLE_COMPONENT_NAME)
395 ui_file_write (buf, comp->u.s_name.s, comp->u.s_name.len);
396 name = ui_file_obsavestring (buf, &info->obstack, &len);
398 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
399 with a DEMANGLE_COMPONENT_NAME node containing the whole
401 ret_comp->type = DEMANGLE_COMPONENT_NAME;
402 ret_comp->u.s_name.s = name;
403 ret_comp->u.s_name.len = len;
404 inspect_type (info, ret_comp, finder, data);
407 replace_typedefs (info, comp, finder, data);
409 ui_file_delete (buf);
413 /* A function to check const and volatile qualifiers for argument types.
415 "Parameter declarations that differ only in the presence
416 or absence of `const' and/or `volatile' are equivalent."
417 C++ Standard N3290, clause 13.1.3 #4. */
420 check_cv_qualifiers (struct demangle_component *ret_comp)
422 while (d_left (ret_comp) != NULL
423 && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST
424 || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE))
426 d_left (ret_comp) = d_left (d_left (ret_comp));
430 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
431 their basic types. */
434 replace_typedefs (struct demangle_parse_info *info,
435 struct demangle_component *ret_comp,
436 canonicalization_ftype *finder,
442 && (ret_comp->type == DEMANGLE_COMPONENT_NAME
443 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
444 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE
445 || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE))
447 char *local_name = cp_comp_to_string (ret_comp, 10);
449 if (local_name != NULL)
452 volatile struct gdb_exception except;
455 TRY_CATCH (except, RETURN_MASK_ALL)
457 sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0);
461 if (except.reason >= 0 && sym != NULL)
463 struct type *otype = SYMBOL_TYPE (sym);
464 const char *new_name = (*finder) (otype, data);
466 if (new_name != NULL)
468 ret_comp->type = DEMANGLE_COMPONENT_NAME;
469 ret_comp->u.s_name.s = new_name;
470 ret_comp->u.s_name.len = strlen (new_name);
477 switch (ret_comp->type)
479 case DEMANGLE_COMPONENT_ARGLIST:
480 check_cv_qualifiers (ret_comp);
483 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
484 case DEMANGLE_COMPONENT_TEMPLATE:
485 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
486 case DEMANGLE_COMPONENT_TYPED_NAME:
487 replace_typedefs (info, d_left (ret_comp), finder, data);
488 replace_typedefs (info, d_right (ret_comp), finder, data);
491 case DEMANGLE_COMPONENT_NAME:
492 inspect_type (info, ret_comp, finder, data);
495 case DEMANGLE_COMPONENT_QUAL_NAME:
496 replace_typedefs_qualified_name (info, ret_comp, finder, data);
499 case DEMANGLE_COMPONENT_LOCAL_NAME:
500 case DEMANGLE_COMPONENT_CTOR:
501 case DEMANGLE_COMPONENT_ARRAY_TYPE:
502 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
503 replace_typedefs (info, d_right (ret_comp), finder, data);
506 case DEMANGLE_COMPONENT_CONST:
507 case DEMANGLE_COMPONENT_RESTRICT:
508 case DEMANGLE_COMPONENT_VOLATILE:
509 case DEMANGLE_COMPONENT_VOLATILE_THIS:
510 case DEMANGLE_COMPONENT_CONST_THIS:
511 case DEMANGLE_COMPONENT_RESTRICT_THIS:
512 case DEMANGLE_COMPONENT_POINTER:
513 case DEMANGLE_COMPONENT_REFERENCE:
514 replace_typedefs (info, d_left (ret_comp), finder, data);
523 /* Parse STRING and convert it to canonical form, resolving any typedefs.
524 If parsing fails, or if STRING is already canonical, return NULL.
525 Otherwise return the canonical form. The return value is allocated via
526 xmalloc. If FINDER is not NULL, then type components are passed to
527 FINDER to be looked up. DATA is passed verbatim to FINDER. */
530 cp_canonicalize_string_full (const char *string,
531 canonicalization_ftype *finder,
535 unsigned int estimated_len;
536 struct demangle_parse_info *info;
539 estimated_len = strlen (string) * 2;
540 info = cp_demangled_name_to_comp (string, NULL);
543 /* Replace all the typedefs in the tree. */
544 replace_typedefs (info, info->tree, finder, data);
546 /* Convert the tree back into a string. */
547 ret = cp_comp_to_string (info->tree, estimated_len);
548 gdb_assert (ret != NULL);
550 /* Free the parse information. */
551 cp_demangled_name_parse_free (info);
553 /* Finally, compare the original string with the computed
554 name, returning NULL if they are the same. */
555 if (strcmp (string, ret) == 0)
565 /* Like cp_canonicalize_string_full, but always passes NULL for
569 cp_canonicalize_string_no_typedefs (const char *string)
571 return cp_canonicalize_string_full (string, NULL, NULL);
574 /* Parse STRING and convert it to canonical form. If parsing fails,
575 or if STRING is already canonical, return NULL. Otherwise return
576 the canonical form. The return value is allocated via xmalloc. */
579 cp_canonicalize_string (const char *string)
581 struct demangle_parse_info *info;
582 unsigned int estimated_len;
585 if (cp_already_canonical (string))
588 info = cp_demangled_name_to_comp (string, NULL);
592 estimated_len = strlen (string) * 2;
593 ret = cp_comp_to_string (info->tree, estimated_len);
594 cp_demangled_name_parse_free (info);
598 warning (_("internal error: string \"%s\" failed to be canonicalized"),
603 if (strcmp (string, ret) == 0)
612 /* Convert a mangled name to a demangle_component tree. *MEMORY is
613 set to the block of used memory that should be freed when finished
614 with the tree. DEMANGLED_P is set to the char * that should be
615 freed when finished with the tree, or NULL if none was needed.
616 OPTIONS will be passed to the demangler. */
618 static struct demangle_parse_info *
619 mangled_name_to_comp (const char *mangled_name, int options,
620 void **memory, char **demangled_p)
622 char *demangled_name;
623 struct demangle_parse_info *info;
625 /* If it looks like a v3 mangled name, then try to go directly
627 if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
629 struct demangle_component *ret;
631 ret = cplus_demangle_v3_components (mangled_name,
635 info = cp_new_demangle_parse_info ();
642 /* If it doesn't, or if that failed, then try to demangle the
644 demangled_name = gdb_demangle (mangled_name, options);
645 if (demangled_name == NULL)
648 /* If we could demangle the name, parse it to build the component
650 info = cp_demangled_name_to_comp (demangled_name, NULL);
654 xfree (demangled_name);
658 *demangled_p = demangled_name;
662 /* Return the name of the class containing method PHYSNAME. */
665 cp_class_name_from_physname (const char *physname)
667 void *storage = NULL;
668 char *demangled_name = NULL, *ret;
669 struct demangle_component *ret_comp, *prev_comp, *cur_comp;
670 struct demangle_parse_info *info;
673 info = mangled_name_to_comp (physname, DMGL_ANSI,
674 &storage, &demangled_name);
679 ret_comp = info->tree;
681 /* First strip off any qualifiers, if we have a function or
684 switch (ret_comp->type)
686 case DEMANGLE_COMPONENT_CONST:
687 case DEMANGLE_COMPONENT_RESTRICT:
688 case DEMANGLE_COMPONENT_VOLATILE:
689 case DEMANGLE_COMPONENT_CONST_THIS:
690 case DEMANGLE_COMPONENT_RESTRICT_THIS:
691 case DEMANGLE_COMPONENT_VOLATILE_THIS:
692 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
693 ret_comp = d_left (ret_comp);
700 /* If what we have now is a function, discard the argument list. */
701 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
702 ret_comp = d_left (ret_comp);
704 /* If what we have now is a template, strip off the template
705 arguments. The left subtree may be a qualified name. */
706 if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
707 ret_comp = d_left (ret_comp);
709 /* What we have now should be a name, possibly qualified.
710 Additional qualifiers could live in the left subtree or the right
711 subtree. Find the last piece. */
716 switch (cur_comp->type)
718 case DEMANGLE_COMPONENT_QUAL_NAME:
719 case DEMANGLE_COMPONENT_LOCAL_NAME:
720 prev_comp = cur_comp;
721 cur_comp = d_right (cur_comp);
723 case DEMANGLE_COMPONENT_TEMPLATE:
724 case DEMANGLE_COMPONENT_NAME:
725 case DEMANGLE_COMPONENT_CTOR:
726 case DEMANGLE_COMPONENT_DTOR:
727 case DEMANGLE_COMPONENT_OPERATOR:
728 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
738 if (cur_comp != NULL && prev_comp != NULL)
740 /* We want to discard the rightmost child of PREV_COMP. */
741 *prev_comp = *d_left (prev_comp);
742 /* The ten is completely arbitrary; we don't have a good
744 ret = cp_comp_to_string (ret_comp, 10);
748 xfree (demangled_name);
749 cp_demangled_name_parse_free (info);
753 /* Return the child of COMP which is the basename of a method,
754 variable, et cetera. All scope qualifiers are discarded, but
755 template arguments will be included. The component tree may be
758 static struct demangle_component *
759 unqualified_name_from_comp (struct demangle_component *comp)
761 struct demangle_component *ret_comp = comp, *last_template;
765 last_template = NULL;
767 switch (ret_comp->type)
769 case DEMANGLE_COMPONENT_QUAL_NAME:
770 case DEMANGLE_COMPONENT_LOCAL_NAME:
771 ret_comp = d_right (ret_comp);
773 case DEMANGLE_COMPONENT_TYPED_NAME:
774 ret_comp = d_left (ret_comp);
776 case DEMANGLE_COMPONENT_TEMPLATE:
777 gdb_assert (last_template == NULL);
778 last_template = ret_comp;
779 ret_comp = d_left (ret_comp);
781 case DEMANGLE_COMPONENT_CONST:
782 case DEMANGLE_COMPONENT_RESTRICT:
783 case DEMANGLE_COMPONENT_VOLATILE:
784 case DEMANGLE_COMPONENT_CONST_THIS:
785 case DEMANGLE_COMPONENT_RESTRICT_THIS:
786 case DEMANGLE_COMPONENT_VOLATILE_THIS:
787 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
788 ret_comp = d_left (ret_comp);
790 case DEMANGLE_COMPONENT_NAME:
791 case DEMANGLE_COMPONENT_CTOR:
792 case DEMANGLE_COMPONENT_DTOR:
793 case DEMANGLE_COMPONENT_OPERATOR:
794 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
804 d_left (last_template) = ret_comp;
805 return last_template;
811 /* Return the name of the method whose linkage name is PHYSNAME. */
814 method_name_from_physname (const char *physname)
816 void *storage = NULL;
817 char *demangled_name = NULL, *ret;
818 struct demangle_component *ret_comp;
819 struct demangle_parse_info *info;
821 info = mangled_name_to_comp (physname, DMGL_ANSI,
822 &storage, &demangled_name);
826 ret_comp = unqualified_name_from_comp (info->tree);
829 if (ret_comp != NULL)
830 /* The ten is completely arbitrary; we don't have a good
832 ret = cp_comp_to_string (ret_comp, 10);
835 xfree (demangled_name);
836 cp_demangled_name_parse_free (info);
840 /* If FULL_NAME is the demangled name of a C++ function (including an
841 arg list, possibly including namespace/class qualifications),
842 return a new string containing only the function name (without the
843 arg list/class qualifications). Otherwise, return NULL. The
844 caller is responsible for freeing the memory in question. */
847 cp_func_name (const char *full_name)
850 struct demangle_component *ret_comp;
851 struct demangle_parse_info *info;
853 info = cp_demangled_name_to_comp (full_name, NULL);
857 ret_comp = unqualified_name_from_comp (info->tree);
860 if (ret_comp != NULL)
861 ret = cp_comp_to_string (ret_comp, 10);
863 cp_demangled_name_parse_free (info);
867 /* DEMANGLED_NAME is the name of a function, including parameters and
868 (optionally) a return type. Return the name of the function without
869 parameters or return type, or NULL if we can not parse the name. */
872 cp_remove_params (const char *demangled_name)
875 struct demangle_component *ret_comp;
876 struct demangle_parse_info *info;
879 if (demangled_name == NULL)
882 info = cp_demangled_name_to_comp (demangled_name, NULL);
886 /* First strip off any qualifiers, if we have a function or method. */
887 ret_comp = info->tree;
889 switch (ret_comp->type)
891 case DEMANGLE_COMPONENT_CONST:
892 case DEMANGLE_COMPONENT_RESTRICT:
893 case DEMANGLE_COMPONENT_VOLATILE:
894 case DEMANGLE_COMPONENT_CONST_THIS:
895 case DEMANGLE_COMPONENT_RESTRICT_THIS:
896 case DEMANGLE_COMPONENT_VOLATILE_THIS:
897 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
898 ret_comp = d_left (ret_comp);
905 /* What we have now should be a function. Return its name. */
906 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
907 ret = cp_comp_to_string (d_left (ret_comp), 10);
909 cp_demangled_name_parse_free (info);
913 /* Here are some random pieces of trivia to keep in mind while trying
914 to take apart demangled names:
916 - Names can contain function arguments or templates, so the process
917 has to be, to some extent recursive: maybe keep track of your
918 depth based on encountering <> and ().
920 - Parentheses don't just have to happen at the end of a name: they
921 can occur even if the name in question isn't a function, because
922 a template argument might be a type that's a function.
924 - Conversely, even if you're trying to deal with a function, its
925 demangled name might not end with ')': it could be a const or
926 volatile class method, in which case it ends with "const" or
929 - Parentheses are also used in anonymous namespaces: a variable
930 'foo' in an anonymous namespace gets demangled as "(anonymous
933 - And operator names can contain parentheses or angle brackets. */
935 /* FIXME: carlton/2003-03-13: We have several functions here with
936 overlapping functionality; can we combine them? Also, do they
937 handle all the above considerations correctly? */
940 /* This returns the length of first component of NAME, which should be
941 the demangled name of a C++ variable/function/method/etc.
942 Specifically, it returns the index of the first colon forming the
943 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
944 it returns the 1, and given 'foo', it returns 0. */
946 /* The character in NAME indexed by the return value is guaranteed to
947 always be either ':' or '\0'. */
949 /* NOTE: carlton/2003-03-13: This function is currently only intended
950 for internal use: it's probably not entirely safe when called on
951 user-generated input, because some of the 'index += 2' lines in
952 cp_find_first_component_aux might go past the end of malformed
956 cp_find_first_component (const char *name)
958 return cp_find_first_component_aux (name, 0);
961 /* Helper function for cp_find_first_component. Like that function,
962 it returns the length of the first component of NAME, but to make
963 the recursion easier, it also stops if it reaches an unexpected ')'
964 or '>' if the value of PERMISSIVE is nonzero. */
966 /* Let's optimize away calls to strlen("operator"). */
968 #define LENGTH_OF_OPERATOR 8
971 cp_find_first_component_aux (const char *name, int permissive)
973 unsigned int index = 0;
974 /* Operator names can show up in unexpected places. Since these can
975 contain parentheses or angle brackets, they can screw up the
976 recursion. But not every string 'operator' is part of an
977 operater name: e.g. you could have a variable 'cooperator'. So
978 this variable tells us whether or not we should treat the string
979 'operator' as starting an operator. */
980 int operator_possible = 1;
987 /* Template; eat it up. The calls to cp_first_component
988 should only return (I hope!) when they reach the '>'
989 terminating the component or a '::' between two
990 components. (Hence the '+ 2'.) */
992 for (index += cp_find_first_component_aux (name + index, 1);
994 index += cp_find_first_component_aux (name + index, 1))
996 if (name[index] != ':')
998 demangled_name_complaint (name);
999 return strlen (name);
1003 operator_possible = 1;
1006 /* Similar comment as to '<'. */
1008 for (index += cp_find_first_component_aux (name + index, 1);
1010 index += cp_find_first_component_aux (name + index, 1))
1012 if (name[index] != ':')
1014 demangled_name_complaint (name);
1015 return strlen (name);
1019 operator_possible = 1;
1027 demangled_name_complaint (name);
1028 return strlen (name);
1034 /* Operator names can screw up the recursion. */
1035 if (operator_possible
1036 && strncmp (name + index, "operator",
1037 LENGTH_OF_OPERATOR) == 0)
1039 index += LENGTH_OF_OPERATOR;
1040 while (ISSPACE(name[index]))
1042 switch (name[index])
1044 /* Skip over one less than the appropriate number of
1045 characters: the for loop will skip over the last
1048 if (name[index + 1] == '<')
1055 if (name[index + 1] == '>')
1068 operator_possible = 0;
1075 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1076 set of relevant characters are here: it's necessary to
1077 include any character that can show up before 'operator'
1078 in a demangled name, and it's safe to include any
1079 character that can't be part of an identifier's name. */
1080 operator_possible = 1;
1083 operator_possible = 0;
1089 /* Complain about a demangled name that we don't know how to parse.
1090 NAME is the demangled name in question. */
1093 demangled_name_complaint (const char *name)
1095 complaint (&symfile_complaints,
1096 "unexpected demangled name '%s'", name);
1099 /* If NAME is the fully-qualified name of a C++
1100 function/variable/method/etc., this returns the length of its
1101 entire prefix: all of the namespaces and classes that make up its
1102 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1103 4, given 'foo', it returns 0. */
1106 cp_entire_prefix_len (const char *name)
1108 unsigned int current_len = cp_find_first_component (name);
1109 unsigned int previous_len = 0;
1111 while (name[current_len] != '\0')
1113 gdb_assert (name[current_len] == ':');
1114 previous_len = current_len;
1115 /* Skip the '::'. */
1117 current_len += cp_find_first_component (name + current_len);
1120 return previous_len;
1123 /* Overload resolution functions. */
1125 /* Test to see if SYM is a symbol that we haven't seen corresponding
1126 to a function named OLOAD_NAME. If so, add it to the current
1130 overload_list_add_symbol (struct symbol *sym,
1131 const char *oload_name)
1137 /* If there is no type information, we can't do anything, so
1139 if (SYMBOL_TYPE (sym) == NULL)
1142 /* skip any symbols that we've already considered. */
1143 for (i = 0; i < sym_return_val_index; ++i)
1144 if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1145 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
1148 /* Get the demangled name without parameters */
1149 sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1153 /* skip symbols that cannot match */
1154 if (strcmp (sym_name, oload_name) != 0)
1162 /* We have a match for an overload instance, so add SYM to the
1163 current list of overload instances */
1164 if (sym_return_val_index + 3 > sym_return_val_size)
1166 newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
1167 sym_return_val = (struct symbol **)
1168 xrealloc ((char *) sym_return_val, newsize);
1170 sym_return_val[sym_return_val_index++] = sym;
1171 sym_return_val[sym_return_val_index] = NULL;
1174 /* Return a null-terminated list of pointers to function symbols that
1175 are named FUNC_NAME and are visible within NAMESPACE. */
1178 make_symbol_overload_list (const char *func_name,
1179 const char *namespace)
1181 struct cleanup *old_cleanups;
1184 sym_return_val_size = 100;
1185 sym_return_val_index = 0;
1186 sym_return_val = xmalloc ((sym_return_val_size + 1) *
1187 sizeof (struct symbol *));
1188 sym_return_val[0] = NULL;
1190 old_cleanups = make_cleanup (xfree, sym_return_val);
1192 make_symbol_overload_list_using (func_name, namespace);
1194 if (namespace[0] == '\0')
1198 char *concatenated_name
1199 = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
1200 strcpy (concatenated_name, namespace);
1201 strcat (concatenated_name, "::");
1202 strcat (concatenated_name, func_name);
1203 name = concatenated_name;
1206 make_symbol_overload_list_qualified (name);
1208 discard_cleanups (old_cleanups);
1210 return sym_return_val;
1213 /* Add all symbols with a name matching NAME in BLOCK to the overload
1217 make_symbol_overload_list_block (const char *name,
1218 const struct block *block)
1220 struct block_iterator iter;
1223 for (sym = block_iter_name_first (block, name, &iter);
1225 sym = block_iter_name_next (name, &iter))
1226 overload_list_add_symbol (sym, name);
1229 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1232 make_symbol_overload_list_namespace (const char *func_name,
1233 const char *namespace)
1236 const struct block *block = NULL;
1238 if (namespace[0] == '\0')
1242 char *concatenated_name
1243 = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
1245 strcpy (concatenated_name, namespace);
1246 strcat (concatenated_name, "::");
1247 strcat (concatenated_name, func_name);
1248 name = concatenated_name;
1251 /* Look in the static block. */
1252 block = block_static_block (get_selected_block (0));
1254 make_symbol_overload_list_block (name, block);
1256 /* Look in the global block. */
1257 block = block_global_block (block);
1259 make_symbol_overload_list_block (name, block);
1263 /* Search the namespace of the given type and namespace of and public
1267 make_symbol_overload_list_adl_namespace (struct type *type,
1268 const char *func_name)
1271 const char *type_name;
1274 while (TYPE_CODE (type) == TYPE_CODE_PTR
1275 || TYPE_CODE (type) == TYPE_CODE_REF
1276 || TYPE_CODE (type) == TYPE_CODE_ARRAY
1277 || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1279 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1280 type = check_typedef(type);
1282 type = TYPE_TARGET_TYPE (type);
1285 type_name = TYPE_NAME (type);
1287 if (type_name == NULL)
1290 prefix_len = cp_entire_prefix_len (type_name);
1292 if (prefix_len != 0)
1294 namespace = alloca (prefix_len + 1);
1295 strncpy (namespace, type_name, prefix_len);
1296 namespace[prefix_len] = '\0';
1298 make_symbol_overload_list_namespace (func_name, namespace);
1301 /* Check public base type */
1302 if (TYPE_CODE (type) == TYPE_CODE_CLASS)
1303 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1305 if (BASETYPE_VIA_PUBLIC (type, i))
1306 make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type,
1312 /* Adds the overload list overload candidates for FUNC_NAME found
1313 through argument dependent lookup. */
1316 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
1317 const char *func_name)
1321 gdb_assert (sym_return_val_size != -1);
1323 for (i = 1; i <= nargs; i++)
1324 make_symbol_overload_list_adl_namespace (arg_types[i - 1],
1327 return sym_return_val;
1330 /* Used for cleanups to reset the "searched" flag in case of an
1334 reset_directive_searched (void *data)
1336 struct using_direct *direct = data;
1337 direct->searched = 0;
1340 /* This applies the using directives to add namespaces to search in,
1341 and then searches for overloads in all of those namespaces. It
1342 adds the symbols found to sym_return_val. Arguments are as in
1343 make_symbol_overload_list. */
1346 make_symbol_overload_list_using (const char *func_name,
1347 const char *namespace)
1349 struct using_direct *current;
1350 const struct block *block;
1352 /* First, go through the using directives. If any of them apply,
1353 look in the appropriate namespaces for new functions to match
1356 for (block = get_selected_block (0);
1358 block = BLOCK_SUPERBLOCK (block))
1359 for (current = block_using (block);
1361 current = current->next)
1363 /* Prevent recursive calls. */
1364 if (current->searched)
1367 /* If this is a namespace alias or imported declaration ignore
1369 if (current->alias != NULL || current->declaration != NULL)
1372 if (strcmp (namespace, current->import_dest) == 0)
1374 /* Mark this import as searched so that the recursive call
1375 does not search it again. */
1376 struct cleanup *old_chain;
1377 current->searched = 1;
1378 old_chain = make_cleanup (reset_directive_searched,
1381 make_symbol_overload_list_using (func_name,
1382 current->import_src);
1384 current->searched = 0;
1385 discard_cleanups (old_chain);
1389 /* Now, add names for this namespace. */
1390 make_symbol_overload_list_namespace (func_name, namespace);
1393 /* This does the bulk of the work of finding overloaded symbols.
1394 FUNC_NAME is the name of the overloaded function we're looking for
1395 (possibly including namespace info). */
1398 make_symbol_overload_list_qualified (const char *func_name)
1401 struct objfile *objfile;
1402 const struct block *b, *surrounding_static_block = 0;
1404 /* Look through the partial symtabs for all symbols which begin by
1405 matching FUNC_NAME. Make sure we read that symbol table in. */
1407 ALL_OBJFILES (objfile)
1410 objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1413 /* Search upwards from currently selected frame (so that we can
1414 complete on local vars. */
1416 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1417 make_symbol_overload_list_block (func_name, b);
1419 surrounding_static_block = block_static_block (get_selected_block (0));
1421 /* Go through the symtabs and check the externs and statics for
1422 symbols which match. */
1424 ALL_PRIMARY_SYMTABS (objfile, s)
1427 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
1428 make_symbol_overload_list_block (func_name, b);
1431 ALL_PRIMARY_SYMTABS (objfile, s)
1434 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
1435 /* Don't do this block twice. */
1436 if (b == surrounding_static_block)
1438 make_symbol_overload_list_block (func_name, b);
1442 /* Lookup the rtti type for a class name. */
1445 cp_lookup_rtti_type (const char *name, struct block *block)
1447 struct symbol * rtti_sym;
1448 struct type * rtti_type;
1450 rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
1452 if (rtti_sym == NULL)
1454 warning (_("RTTI symbol not found for class '%s'"), name);
1458 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1460 warning (_("RTTI symbol for class '%s' is not a type"), name);
1464 rtti_type = SYMBOL_TYPE (rtti_sym);
1466 switch (TYPE_CODE (rtti_type))
1468 case TYPE_CODE_CLASS:
1470 case TYPE_CODE_NAMESPACE:
1471 /* chastain/2003-11-26: the symbol tables often contain fake
1472 symbols for namespaces with the same name as the struct.
1473 This warning is an indication of a bug in the lookup order
1474 or a bug in the way that the symbol tables are populated. */
1475 warning (_("RTTI symbol for class '%s' is a namespace"), name);
1478 warning (_("RTTI symbol for class '%s' has bad type"), name);
1485 /* A wrapper for bfd_demangle. */
1488 gdb_demangle (const char *name, int options)
1490 return bfd_demangle (NULL, name, options);
1493 /* Don't allow just "maintenance cplus". */
1496 maint_cplus_command (char *arg, int from_tty)
1498 printf_unfiltered (_("\"maintenance cplus\" must be followed "
1499 "by the name of a command.\n"));
1500 help_list (maint_cplus_cmd_list,
1501 "maintenance cplus ",
1505 /* This is a front end for cp_find_first_component, for unit testing.
1506 Be careful when using it: see the NOTE above
1507 cp_find_first_component. */
1510 first_component_command (char *arg, int from_tty)
1518 len = cp_find_first_component (arg);
1519 prefix = alloca (len + 1);
1521 memcpy (prefix, arg, len);
1524 printf_unfiltered ("%s\n", prefix);
1527 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
1530 /* Implement "info vtbl". */
1533 info_vtbl_command (char *arg, int from_tty)
1535 struct value *value;
1537 value = parse_and_eval (arg);
1538 cplus_print_vtable (value);
1542 _initialize_cp_support (void)
1544 add_prefix_cmd ("cplus", class_maintenance,
1545 maint_cplus_command,
1546 _("C++ maintenance commands."),
1547 &maint_cplus_cmd_list,
1548 "maintenance cplus ",
1549 0, &maintenancelist);
1550 add_alias_cmd ("cp", "cplus",
1551 class_maintenance, 1,
1554 add_cmd ("first_component",
1556 first_component_command,
1557 _("Print the first class/namespace component of NAME."),
1558 &maint_cplus_cmd_list);
1560 add_info ("vtbl", info_vtbl_command,
1561 _("Show the virtual function table for a C++ object.\n\
1562 Usage: info vtbl EXPRESSION\n\
1563 Evaluate EXPRESSION and display the virtual function table for the\n\
1564 resulting object."));