1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2002-2019 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 "dictionary.h"
30 #include "complaints.h"
32 #include "expression.h"
35 #include "namespace.h"
37 #include "gdb_setjmp.h"
38 #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 related to overload resolution. */
53 static void overload_list_add_symbol (struct symbol *sym,
54 const char *oload_name,
55 std::vector<symbol *> *overload_list);
57 static void add_symbol_overload_list_using
58 (const char *func_name, const char *the_namespace,
59 std::vector<symbol *> *overload_list);
61 static void add_symbol_overload_list_qualified
62 (const char *func_name,
63 std::vector<symbol *> *overload_list);
65 /* The list of "maint cplus" commands. */
67 struct cmd_list_element *maint_cplus_cmd_list = NULL;
69 /* A list of typedefs which should not be substituted by replace_typedefs. */
70 static const char * const ignore_typedefs[] =
72 "std::istream", "std::iostream", "std::ostream", "std::string"
76 replace_typedefs (struct demangle_parse_info *info,
77 struct demangle_component *ret_comp,
78 canonicalization_ftype *finder,
81 /* A convenience function to copy STRING into OBSTACK, returning a pointer
82 to the newly allocated string and saving the number of bytes saved in LEN.
84 It does not copy the terminating '\0' byte! */
87 copy_string_to_obstack (struct obstack *obstack, const char *string,
90 *len = strlen (string);
91 return (char *) obstack_copy (obstack, string, *len);
94 /* Return 1 if STRING is clearly already in canonical form. This
95 function is conservative; things which it does not recognize are
96 assumed to be non-canonical, and the parser will sort them out
97 afterwards. This speeds up the critical path for alphanumeric
101 cp_already_canonical (const char *string)
103 /* Identifier start character [a-zA-Z_]. */
104 if (!ISIDST (string[0]))
107 /* These are the only two identifiers which canonicalize to other
108 than themselves or an error: unsigned -> unsigned int and
110 if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
112 else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
115 /* Identifier character [a-zA-Z0-9_]. */
116 while (ISIDNUM (string[1]))
119 if (string[1] == '\0')
125 /* Inspect the given RET_COMP for its type. If it is a typedef,
126 replace the node with the typedef's tree.
128 Returns 1 if any typedef substitutions were made, 0 otherwise. */
131 inspect_type (struct demangle_parse_info *info,
132 struct demangle_component *ret_comp,
133 canonicalization_ftype *finder,
139 /* Copy the symbol's name from RET_COMP and look it up
140 in the symbol table. */
141 name = (char *) alloca (ret_comp->u.s_name.len + 1);
142 memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len);
143 name[ret_comp->u.s_name.len] = '\0';
145 /* Ignore any typedefs that should not be substituted. */
146 for (int i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i)
148 if (strcmp (name, ignore_typedefs[i]) == 0)
156 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
158 CATCH (except, RETURN_MASK_ALL)
166 struct type *otype = SYMBOL_TYPE (sym);
170 const char *new_name = (*finder) (otype, data);
172 if (new_name != NULL)
174 ret_comp->u.s_name.s = new_name;
175 ret_comp->u.s_name.len = strlen (new_name);
182 /* If the type is a typedef or namespace alias, replace it. */
183 if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF
184 || TYPE_CODE (otype) == TYPE_CODE_NAMESPACE)
189 std::unique_ptr<demangle_parse_info> i;
191 /* Get the real type of the typedef. */
192 type = check_typedef (otype);
194 /* If the symbol is a namespace and its type name is no different
195 than the name we looked up, this symbol is not a namespace
196 alias and does not need to be substituted. */
197 if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE
198 && strcmp (TYPE_NAME (type), name) == 0)
201 is_anon = (TYPE_NAME (type) == NULL
202 && (TYPE_CODE (type) == TYPE_CODE_ENUM
203 || TYPE_CODE (type) == TYPE_CODE_STRUCT
204 || TYPE_CODE (type) == TYPE_CODE_UNION));
207 struct type *last = otype;
209 /* Find the last typedef for the type. */
210 while (TYPE_TARGET_TYPE (last) != NULL
211 && (TYPE_CODE (TYPE_TARGET_TYPE (last))
212 == TYPE_CODE_TYPEDEF))
213 last = TYPE_TARGET_TYPE (last);
215 /* If there is only one typedef for this anonymous type,
216 do not substitute it. */
220 /* Use the last typedef seen as the type for this
228 type_print (type, "", &buf, -1);
230 /* If type_print threw an exception, there is little point
231 in continuing, so just bow out gracefully. */
232 CATCH (except, RETURN_MASK_ERROR)
239 name = (char *) obstack_copy0 (&info->obstack, buf.c_str (), len);
241 /* Turn the result into a new tree. Note that this
242 tree will contain pointers into NAME, so NAME cannot
243 be free'd until all typedef conversion is done and
244 the final result is converted into a string. */
245 i = cp_demangled_name_to_comp (name, NULL);
248 /* Merge the two trees. */
249 cp_merge_demangle_parse_infos (info, ret_comp, i.get ());
251 /* Replace any newly introduced typedefs -- but not
252 if the type is anonymous (that would lead to infinite
255 replace_typedefs (info, ret_comp, finder, data);
259 /* This shouldn't happen unless the type printer has
260 output something that the name parser cannot grok.
261 Nonetheless, an ounce of prevention...
263 Canonicalize the name again, and store it in the
264 current node (RET_COMP). */
265 std::string canon = cp_canonicalize_string_no_typedefs (name);
269 /* Copy the canonicalization into the obstack. */
270 name = copy_string_to_obstack (&info->obstack, canon.c_str (), &len);
273 ret_comp->u.s_name.s = name;
274 ret_comp->u.s_name.len = len;
284 /* Replace any typedefs appearing in the qualified name
285 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
289 replace_typedefs_qualified_name (struct demangle_parse_info *info,
290 struct demangle_component *ret_comp,
291 canonicalization_ftype *finder,
295 struct demangle_component *comp = ret_comp;
297 /* Walk each node of the qualified name, reconstructing the name of
298 this element. With every node, check for any typedef substitutions.
299 If a substitution has occurred, replace the qualified name node
300 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
302 while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
304 if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
306 struct demangle_component newobj;
308 buf.write (d_left (comp)->u.s_name.s, d_left (comp)->u.s_name.len);
309 newobj.type = DEMANGLE_COMPONENT_NAME;
311 = (char *) obstack_copy0 (&info->obstack,
312 buf.c_str (), buf.size ());
313 newobj.u.s_name.len = buf.size ();
314 if (inspect_type (info, &newobj, finder, data))
319 /* A typedef was substituted in NEW. Convert it to a
320 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
324 gdb::unique_xmalloc_ptr<char> n
325 = cp_comp_to_string (&newobj, 100);
328 /* If something went astray, abort typedef substitutions. */
332 s = copy_string_to_obstack (&info->obstack, n.get (), &slen);
334 d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
335 d_left (ret_comp)->u.s_name.s = s;
336 d_left (ret_comp)->u.s_name.len = slen;
337 d_right (ret_comp) = d_right (comp);
344 /* The current node is not a name, so simply replace any
345 typedefs in it. Then print it to the stream to continue
346 checking for more typedefs in the tree. */
347 replace_typedefs (info, d_left (comp), finder, data);
348 gdb::unique_xmalloc_ptr<char> name
349 = cp_comp_to_string (d_left (comp), 100);
352 /* If something went astray, abort typedef substitutions. */
355 buf.puts (name.get ());
359 comp = d_right (comp);
362 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
363 name assembled above and append the name given by COMP. Then use this
364 reassembled name to check for a typedef. */
366 if (comp->type == DEMANGLE_COMPONENT_NAME)
368 buf.write (comp->u.s_name.s, comp->u.s_name.len);
370 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
371 with a DEMANGLE_COMPONENT_NAME node containing the whole
373 ret_comp->type = DEMANGLE_COMPONENT_NAME;
375 = (char *) obstack_copy0 (&info->obstack,
376 buf.c_str (), buf.size ());
377 ret_comp->u.s_name.len = buf.size ();
378 inspect_type (info, ret_comp, finder, data);
381 replace_typedefs (info, comp, finder, data);
385 /* A function to check const and volatile qualifiers for argument types.
387 "Parameter declarations that differ only in the presence
388 or absence of `const' and/or `volatile' are equivalent."
389 C++ Standard N3290, clause 13.1.3 #4. */
392 check_cv_qualifiers (struct demangle_component *ret_comp)
394 while (d_left (ret_comp) != NULL
395 && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST
396 || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE))
398 d_left (ret_comp) = d_left (d_left (ret_comp));
402 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
403 their basic types. */
406 replace_typedefs (struct demangle_parse_info *info,
407 struct demangle_component *ret_comp,
408 canonicalization_ftype *finder,
414 && (ret_comp->type == DEMANGLE_COMPONENT_NAME
415 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
416 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE
417 || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE))
419 gdb::unique_xmalloc_ptr<char> local_name
420 = cp_comp_to_string (ret_comp, 10);
422 if (local_name != NULL)
424 struct symbol *sym = NULL;
429 sym = lookup_symbol (local_name.get (), 0,
430 VAR_DOMAIN, 0).symbol;
432 CATCH (except, RETURN_MASK_ALL)
439 struct type *otype = SYMBOL_TYPE (sym);
440 const char *new_name = (*finder) (otype, data);
442 if (new_name != NULL)
444 ret_comp->type = DEMANGLE_COMPONENT_NAME;
445 ret_comp->u.s_name.s = new_name;
446 ret_comp->u.s_name.len = strlen (new_name);
453 switch (ret_comp->type)
455 case DEMANGLE_COMPONENT_ARGLIST:
456 check_cv_qualifiers (ret_comp);
459 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
460 case DEMANGLE_COMPONENT_TEMPLATE:
461 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
462 case DEMANGLE_COMPONENT_TYPED_NAME:
463 replace_typedefs (info, d_left (ret_comp), finder, data);
464 replace_typedefs (info, d_right (ret_comp), finder, data);
467 case DEMANGLE_COMPONENT_NAME:
468 inspect_type (info, ret_comp, finder, data);
471 case DEMANGLE_COMPONENT_QUAL_NAME:
472 replace_typedefs_qualified_name (info, ret_comp, finder, data);
475 case DEMANGLE_COMPONENT_LOCAL_NAME:
476 case DEMANGLE_COMPONENT_CTOR:
477 case DEMANGLE_COMPONENT_ARRAY_TYPE:
478 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
479 replace_typedefs (info, d_right (ret_comp), finder, data);
482 case DEMANGLE_COMPONENT_CONST:
483 case DEMANGLE_COMPONENT_RESTRICT:
484 case DEMANGLE_COMPONENT_VOLATILE:
485 case DEMANGLE_COMPONENT_VOLATILE_THIS:
486 case DEMANGLE_COMPONENT_CONST_THIS:
487 case DEMANGLE_COMPONENT_RESTRICT_THIS:
488 case DEMANGLE_COMPONENT_POINTER:
489 case DEMANGLE_COMPONENT_REFERENCE:
490 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
491 replace_typedefs (info, d_left (ret_comp), finder, data);
500 /* Parse STRING and convert it to canonical form, resolving any
501 typedefs. If parsing fails, or if STRING is already canonical,
502 return the empty string. Otherwise return the canonical form. If
503 FINDER is not NULL, then type components are passed to FINDER to be
504 looked up. DATA is passed verbatim to FINDER. */
507 cp_canonicalize_string_full (const char *string,
508 canonicalization_ftype *finder,
512 unsigned int estimated_len;
513 std::unique_ptr<demangle_parse_info> info;
515 estimated_len = strlen (string) * 2;
516 info = cp_demangled_name_to_comp (string, NULL);
519 /* Replace all the typedefs in the tree. */
520 replace_typedefs (info.get (), info->tree, finder, data);
522 /* Convert the tree back into a string. */
523 gdb::unique_xmalloc_ptr<char> us = cp_comp_to_string (info->tree,
528 /* Finally, compare the original string with the computed
529 name, returning NULL if they are the same. */
531 return std::string ();
537 /* Like cp_canonicalize_string_full, but always passes NULL for
541 cp_canonicalize_string_no_typedefs (const char *string)
543 return cp_canonicalize_string_full (string, NULL, NULL);
546 /* Parse STRING and convert it to canonical form. If parsing fails,
547 or if STRING is already canonical, return the empty string.
548 Otherwise return the canonical form. */
551 cp_canonicalize_string (const char *string)
553 std::unique_ptr<demangle_parse_info> info;
554 unsigned int estimated_len;
556 if (cp_already_canonical (string))
557 return std::string ();
559 info = cp_demangled_name_to_comp (string, NULL);
561 return std::string ();
563 estimated_len = strlen (string) * 2;
564 gdb::unique_xmalloc_ptr<char> us (cp_comp_to_string (info->tree,
569 warning (_("internal error: string \"%s\" failed to be canonicalized"),
571 return std::string ();
574 std::string ret (us.get ());
577 return std::string ();
582 /* Convert a mangled name to a demangle_component tree. *MEMORY is
583 set to the block of used memory that should be freed when finished
584 with the tree. DEMANGLED_P is set to the char * that should be
585 freed when finished with the tree, or NULL if none was needed.
586 OPTIONS will be passed to the demangler. */
588 static std::unique_ptr<demangle_parse_info>
589 mangled_name_to_comp (const char *mangled_name, int options,
590 void **memory, char **demangled_p)
592 char *demangled_name;
594 /* If it looks like a v3 mangled name, then try to go directly
596 if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
598 struct demangle_component *ret;
600 ret = cplus_demangle_v3_components (mangled_name,
604 std::unique_ptr<demangle_parse_info> info (new demangle_parse_info);
611 /* If it doesn't, or if that failed, then try to demangle the
613 demangled_name = gdb_demangle (mangled_name, options);
614 if (demangled_name == NULL)
617 /* If we could demangle the name, parse it to build the component
619 std::unique_ptr<demangle_parse_info> info
620 = cp_demangled_name_to_comp (demangled_name, NULL);
624 xfree (demangled_name);
628 *demangled_p = demangled_name;
632 /* Return the name of the class containing method PHYSNAME. */
635 cp_class_name_from_physname (const char *physname)
637 void *storage = NULL;
638 char *demangled_name = NULL;
639 gdb::unique_xmalloc_ptr<char> ret;
640 struct demangle_component *ret_comp, *prev_comp, *cur_comp;
641 std::unique_ptr<demangle_parse_info> info;
644 info = mangled_name_to_comp (physname, DMGL_ANSI,
645 &storage, &demangled_name);
650 ret_comp = info->tree;
652 /* First strip off any qualifiers, if we have a function or
655 switch (ret_comp->type)
657 case DEMANGLE_COMPONENT_CONST:
658 case DEMANGLE_COMPONENT_RESTRICT:
659 case DEMANGLE_COMPONENT_VOLATILE:
660 case DEMANGLE_COMPONENT_CONST_THIS:
661 case DEMANGLE_COMPONENT_RESTRICT_THIS:
662 case DEMANGLE_COMPONENT_VOLATILE_THIS:
663 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
664 ret_comp = d_left (ret_comp);
671 /* If what we have now is a function, discard the argument list. */
672 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
673 ret_comp = d_left (ret_comp);
675 /* If what we have now is a template, strip off the template
676 arguments. The left subtree may be a qualified name. */
677 if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
678 ret_comp = d_left (ret_comp);
680 /* What we have now should be a name, possibly qualified.
681 Additional qualifiers could live in the left subtree or the right
682 subtree. Find the last piece. */
687 switch (cur_comp->type)
689 case DEMANGLE_COMPONENT_QUAL_NAME:
690 case DEMANGLE_COMPONENT_LOCAL_NAME:
691 prev_comp = cur_comp;
692 cur_comp = d_right (cur_comp);
694 case DEMANGLE_COMPONENT_TEMPLATE:
695 case DEMANGLE_COMPONENT_NAME:
696 case DEMANGLE_COMPONENT_CTOR:
697 case DEMANGLE_COMPONENT_DTOR:
698 case DEMANGLE_COMPONENT_OPERATOR:
699 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
708 if (cur_comp != NULL && prev_comp != NULL)
710 /* We want to discard the rightmost child of PREV_COMP. */
711 *prev_comp = *d_left (prev_comp);
712 /* The ten is completely arbitrary; we don't have a good
714 ret = cp_comp_to_string (ret_comp, 10);
718 xfree (demangled_name);
719 return ret.release ();
722 /* Return the child of COMP which is the basename of a method,
723 variable, et cetera. All scope qualifiers are discarded, but
724 template arguments will be included. The component tree may be
727 static struct demangle_component *
728 unqualified_name_from_comp (struct demangle_component *comp)
730 struct demangle_component *ret_comp = comp, *last_template;
734 last_template = NULL;
736 switch (ret_comp->type)
738 case DEMANGLE_COMPONENT_QUAL_NAME:
739 case DEMANGLE_COMPONENT_LOCAL_NAME:
740 ret_comp = d_right (ret_comp);
742 case DEMANGLE_COMPONENT_TYPED_NAME:
743 ret_comp = d_left (ret_comp);
745 case DEMANGLE_COMPONENT_TEMPLATE:
746 gdb_assert (last_template == NULL);
747 last_template = ret_comp;
748 ret_comp = d_left (ret_comp);
750 case DEMANGLE_COMPONENT_CONST:
751 case DEMANGLE_COMPONENT_RESTRICT:
752 case DEMANGLE_COMPONENT_VOLATILE:
753 case DEMANGLE_COMPONENT_CONST_THIS:
754 case DEMANGLE_COMPONENT_RESTRICT_THIS:
755 case DEMANGLE_COMPONENT_VOLATILE_THIS:
756 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
757 ret_comp = d_left (ret_comp);
759 case DEMANGLE_COMPONENT_NAME:
760 case DEMANGLE_COMPONENT_CTOR:
761 case DEMANGLE_COMPONENT_DTOR:
762 case DEMANGLE_COMPONENT_OPERATOR:
763 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
773 d_left (last_template) = ret_comp;
774 return last_template;
780 /* Return the name of the method whose linkage name is PHYSNAME. */
783 method_name_from_physname (const char *physname)
785 void *storage = NULL;
786 char *demangled_name = NULL;
787 gdb::unique_xmalloc_ptr<char> ret;
788 struct demangle_component *ret_comp;
789 std::unique_ptr<demangle_parse_info> info;
791 info = mangled_name_to_comp (physname, DMGL_ANSI,
792 &storage, &demangled_name);
796 ret_comp = unqualified_name_from_comp (info->tree);
798 if (ret_comp != NULL)
799 /* The ten is completely arbitrary; we don't have a good
801 ret = cp_comp_to_string (ret_comp, 10);
804 xfree (demangled_name);
805 return ret.release ();
808 /* If FULL_NAME is the demangled name of a C++ function (including an
809 arg list, possibly including namespace/class qualifications),
810 return a new string containing only the function name (without the
811 arg list/class qualifications). Otherwise, return NULL. The
812 caller is responsible for freeing the memory in question. */
815 cp_func_name (const char *full_name)
817 gdb::unique_xmalloc_ptr<char> ret;
818 struct demangle_component *ret_comp;
819 std::unique_ptr<demangle_parse_info> info;
821 info = cp_demangled_name_to_comp (full_name, NULL);
825 ret_comp = unqualified_name_from_comp (info->tree);
827 if (ret_comp != NULL)
828 ret = cp_comp_to_string (ret_comp, 10);
830 return ret.release ();
833 /* Helper for cp_remove_params. DEMANGLED_NAME is the name of a
834 function, including parameters and (optionally) a return type.
835 Return the name of the function without parameters or return type,
836 or NULL if we can not parse the name. If REQUIRE_PARAMS is false,
837 then tolerate a non-existing or unbalanced parameter list. */
839 static gdb::unique_xmalloc_ptr<char>
840 cp_remove_params_1 (const char *demangled_name, bool require_params)
843 struct demangle_component *ret_comp;
844 std::unique_ptr<demangle_parse_info> info;
845 gdb::unique_xmalloc_ptr<char> ret;
847 if (demangled_name == NULL)
850 info = cp_demangled_name_to_comp (demangled_name, NULL);
854 /* First strip off any qualifiers, if we have a function or method. */
855 ret_comp = info->tree;
857 switch (ret_comp->type)
859 case DEMANGLE_COMPONENT_CONST:
860 case DEMANGLE_COMPONENT_RESTRICT:
861 case DEMANGLE_COMPONENT_VOLATILE:
862 case DEMANGLE_COMPONENT_CONST_THIS:
863 case DEMANGLE_COMPONENT_RESTRICT_THIS:
864 case DEMANGLE_COMPONENT_VOLATILE_THIS:
865 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
866 ret_comp = d_left (ret_comp);
873 /* What we have now should be a function. Return its name. */
874 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
875 ret = cp_comp_to_string (d_left (ret_comp), 10);
876 else if (!require_params
877 && (ret_comp->type == DEMANGLE_COMPONENT_NAME
878 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
879 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE))
880 ret = cp_comp_to_string (ret_comp, 10);
885 /* DEMANGLED_NAME is the name of a function, including parameters and
886 (optionally) a return type. Return the name of the function
887 without parameters or return type, or NULL if we can not parse the
890 gdb::unique_xmalloc_ptr<char>
891 cp_remove_params (const char *demangled_name)
893 return cp_remove_params_1 (demangled_name, true);
896 /* See cp-support.h. */
898 gdb::unique_xmalloc_ptr<char>
899 cp_remove_params_if_any (const char *demangled_name, bool completion_mode)
901 /* Trying to remove parameters from the empty string fails. If
902 we're completing / matching everything, avoid returning NULL
903 which would make callers interpret the result as an error. */
904 if (demangled_name[0] == '\0' && completion_mode)
905 return gdb::unique_xmalloc_ptr<char> (xstrdup (""));
907 gdb::unique_xmalloc_ptr<char> without_params
908 = cp_remove_params_1 (demangled_name, false);
910 if (without_params == NULL && completion_mode)
912 std::string copy = demangled_name;
914 while (!copy.empty ())
917 without_params = cp_remove_params_1 (copy.c_str (), false);
918 if (without_params != NULL)
923 return without_params;
926 /* Here are some random pieces of trivia to keep in mind while trying
927 to take apart demangled names:
929 - Names can contain function arguments or templates, so the process
930 has to be, to some extent recursive: maybe keep track of your
931 depth based on encountering <> and ().
933 - Parentheses don't just have to happen at the end of a name: they
934 can occur even if the name in question isn't a function, because
935 a template argument might be a type that's a function.
937 - Conversely, even if you're trying to deal with a function, its
938 demangled name might not end with ')': it could be a const or
939 volatile class method, in which case it ends with "const" or
942 - Parentheses are also used in anonymous namespaces: a variable
943 'foo' in an anonymous namespace gets demangled as "(anonymous
946 - And operator names can contain parentheses or angle brackets. */
948 /* FIXME: carlton/2003-03-13: We have several functions here with
949 overlapping functionality; can we combine them? Also, do they
950 handle all the above considerations correctly? */
953 /* This returns the length of first component of NAME, which should be
954 the demangled name of a C++ variable/function/method/etc.
955 Specifically, it returns the index of the first colon forming the
956 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
957 it returns the 1, and given 'foo', it returns 0. */
959 /* The character in NAME indexed by the return value is guaranteed to
960 always be either ':' or '\0'. */
962 /* NOTE: carlton/2003-03-13: This function is currently only intended
963 for internal use: it's probably not entirely safe when called on
964 user-generated input, because some of the 'index += 2' lines in
965 cp_find_first_component_aux might go past the end of malformed
969 cp_find_first_component (const char *name)
971 return cp_find_first_component_aux (name, 0);
974 /* Helper function for cp_find_first_component. Like that function,
975 it returns the length of the first component of NAME, but to make
976 the recursion easier, it also stops if it reaches an unexpected ')'
977 or '>' if the value of PERMISSIVE is nonzero. */
980 cp_find_first_component_aux (const char *name, int permissive)
982 unsigned int index = 0;
983 /* Operator names can show up in unexpected places. Since these can
984 contain parentheses or angle brackets, they can screw up the
985 recursion. But not every string 'operator' is part of an
986 operater name: e.g. you could have a variable 'cooperator'. So
987 this variable tells us whether or not we should treat the string
988 'operator' as starting an operator. */
989 int operator_possible = 1;
996 /* Template; eat it up. The calls to cp_first_component
997 should only return (I hope!) when they reach the '>'
998 terminating the component or a '::' between two
999 components. (Hence the '+ 2'.) */
1001 for (index += cp_find_first_component_aux (name + index, 1);
1003 index += cp_find_first_component_aux (name + index, 1))
1005 if (name[index] != ':')
1007 demangled_name_complaint (name);
1008 return strlen (name);
1012 operator_possible = 1;
1015 /* Similar comment as to '<'. */
1017 for (index += cp_find_first_component_aux (name + index, 1);
1019 index += cp_find_first_component_aux (name + index, 1))
1021 if (name[index] != ':')
1023 demangled_name_complaint (name);
1024 return strlen (name);
1028 operator_possible = 1;
1036 demangled_name_complaint (name);
1037 return strlen (name);
1042 /* ':' marks a component iff the next character is also a ':'.
1043 Otherwise it is probably malformed input. */
1044 if (name[index + 1] == ':')
1048 /* Operator names can screw up the recursion. */
1049 if (operator_possible
1050 && startswith (name + index, CP_OPERATOR_STR))
1052 index += CP_OPERATOR_LEN;
1053 while (ISSPACE(name[index]))
1055 switch (name[index])
1059 /* Skip over one less than the appropriate number of
1060 characters: the for loop will skip over the last
1063 if (name[index + 1] == '<')
1070 if (name[index + 1] == '>')
1083 operator_possible = 0;
1090 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1091 set of relevant characters are here: it's necessary to
1092 include any character that can show up before 'operator'
1093 in a demangled name, and it's safe to include any
1094 character that can't be part of an identifier's name. */
1095 operator_possible = 1;
1098 operator_possible = 0;
1104 /* Complain about a demangled name that we don't know how to parse.
1105 NAME is the demangled name in question. */
1108 demangled_name_complaint (const char *name)
1110 complaint ("unexpected demangled name '%s'", name);
1113 /* If NAME is the fully-qualified name of a C++
1114 function/variable/method/etc., this returns the length of its
1115 entire prefix: all of the namespaces and classes that make up its
1116 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1117 4, given 'foo', it returns 0. */
1120 cp_entire_prefix_len (const char *name)
1122 unsigned int current_len = cp_find_first_component (name);
1123 unsigned int previous_len = 0;
1125 while (name[current_len] != '\0')
1127 gdb_assert (name[current_len] == ':');
1128 previous_len = current_len;
1129 /* Skip the '::'. */
1131 current_len += cp_find_first_component (name + current_len);
1134 return previous_len;
1137 /* Overload resolution functions. */
1139 /* Test to see if SYM is a symbol that we haven't seen corresponding
1140 to a function named OLOAD_NAME. If so, add it to
1144 overload_list_add_symbol (struct symbol *sym,
1145 const char *oload_name,
1146 std::vector<symbol *> *overload_list)
1148 /* If there is no type information, we can't do anything, so
1150 if (SYMBOL_TYPE (sym) == NULL)
1153 /* skip any symbols that we've already considered. */
1154 for (symbol *listed_sym : *overload_list)
1155 if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1156 SYMBOL_LINKAGE_NAME (listed_sym)) == 0)
1159 /* Get the demangled name without parameters */
1160 gdb::unique_xmalloc_ptr<char> sym_name
1161 = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1165 /* skip symbols that cannot match */
1166 if (strcmp (sym_name.get (), oload_name) != 0)
1169 overload_list->push_back (sym);
1172 /* Return a null-terminated list of pointers to function symbols that
1173 are named FUNC_NAME and are visible within NAMESPACE. */
1175 struct std::vector<symbol *>
1176 make_symbol_overload_list (const char *func_name,
1177 const char *the_namespace)
1180 std::vector<symbol *> overload_list;
1182 overload_list.reserve (100);
1184 add_symbol_overload_list_using (func_name, the_namespace, &overload_list);
1186 if (the_namespace[0] == '\0')
1190 char *concatenated_name
1191 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1192 strcpy (concatenated_name, the_namespace);
1193 strcat (concatenated_name, "::");
1194 strcat (concatenated_name, func_name);
1195 name = concatenated_name;
1198 add_symbol_overload_list_qualified (name, &overload_list);
1199 return overload_list;
1202 /* Add all symbols with a name matching NAME in BLOCK to the overload
1206 add_symbol_overload_list_block (const char *name,
1207 const struct block *block,
1208 std::vector<symbol *> *overload_list)
1210 struct block_iterator iter;
1213 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
1215 ALL_BLOCK_SYMBOLS_WITH_NAME (block, lookup_name, iter, sym)
1216 overload_list_add_symbol (sym, name, overload_list);
1219 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1222 add_symbol_overload_list_namespace (const char *func_name,
1223 const char *the_namespace,
1224 std::vector<symbol *> *overload_list)
1227 const struct block *block = NULL;
1229 if (the_namespace[0] == '\0')
1233 char *concatenated_name
1234 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1236 strcpy (concatenated_name, the_namespace);
1237 strcat (concatenated_name, "::");
1238 strcat (concatenated_name, func_name);
1239 name = concatenated_name;
1242 /* Look in the static block. */
1243 block = block_static_block (get_selected_block (0));
1245 add_symbol_overload_list_block (name, block, overload_list);
1247 /* Look in the global block. */
1248 block = block_global_block (block);
1250 add_symbol_overload_list_block (name, block, overload_list);
1254 /* Search the namespace of the given type and namespace of and public
1258 add_symbol_overload_list_adl_namespace (struct type *type,
1259 const char *func_name,
1260 std::vector<symbol *> *overload_list)
1262 char *the_namespace;
1263 const char *type_name;
1266 while (TYPE_CODE (type) == TYPE_CODE_PTR
1267 || TYPE_IS_REFERENCE (type)
1268 || TYPE_CODE (type) == TYPE_CODE_ARRAY
1269 || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1271 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1272 type = check_typedef(type);
1274 type = TYPE_TARGET_TYPE (type);
1277 type_name = TYPE_NAME (type);
1279 if (type_name == NULL)
1282 prefix_len = cp_entire_prefix_len (type_name);
1284 if (prefix_len != 0)
1286 the_namespace = (char *) alloca (prefix_len + 1);
1287 strncpy (the_namespace, type_name, prefix_len);
1288 the_namespace[prefix_len] = '\0';
1290 add_symbol_overload_list_namespace (func_name, the_namespace,
1294 /* Check public base type */
1295 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1296 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1298 if (BASETYPE_VIA_PUBLIC (type, i))
1299 add_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type, i),
1305 /* Adds to OVERLOAD_LIST the overload list overload candidates for
1306 FUNC_NAME found through argument dependent lookup. */
1309 add_symbol_overload_list_adl (gdb::array_view<type *> arg_types,
1310 const char *func_name,
1311 std::vector<symbol *> *overload_list)
1313 for (type *arg_type : arg_types)
1314 add_symbol_overload_list_adl_namespace (arg_type, func_name,
1318 /* This applies the using directives to add namespaces to search in,
1319 and then searches for overloads in all of those namespaces. It
1320 adds the symbols found to sym_return_val. Arguments are as in
1321 make_symbol_overload_list. */
1324 add_symbol_overload_list_using (const char *func_name,
1325 const char *the_namespace,
1326 std::vector<symbol *> *overload_list)
1328 struct using_direct *current;
1329 const struct block *block;
1331 /* First, go through the using directives. If any of them apply,
1332 look in the appropriate namespaces for new functions to match
1335 for (block = get_selected_block (0);
1337 block = BLOCK_SUPERBLOCK (block))
1338 for (current = block_using (block);
1340 current = current->next)
1342 /* Prevent recursive calls. */
1343 if (current->searched)
1346 /* If this is a namespace alias or imported declaration ignore
1348 if (current->alias != NULL || current->declaration != NULL)
1351 if (strcmp (the_namespace, current->import_dest) == 0)
1353 /* Mark this import as searched so that the recursive call
1354 does not search it again. */
1355 scoped_restore reset_directive_searched
1356 = make_scoped_restore (¤t->searched, 1);
1358 add_symbol_overload_list_using (func_name,
1359 current->import_src,
1364 /* Now, add names for this namespace. */
1365 add_symbol_overload_list_namespace (func_name, the_namespace,
1369 /* This does the bulk of the work of finding overloaded symbols.
1370 FUNC_NAME is the name of the overloaded function we're looking for
1371 (possibly including namespace info). */
1374 add_symbol_overload_list_qualified (const char *func_name,
1375 std::vector<symbol *> *overload_list)
1377 struct compunit_symtab *cust;
1378 struct objfile *objfile;
1379 const struct block *b, *surrounding_static_block = 0;
1381 /* Look through the partial symtabs for all symbols which begin by
1382 matching FUNC_NAME. Make sure we read that symbol table in. */
1384 ALL_OBJFILES (objfile)
1387 objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1390 /* Search upwards from currently selected frame (so that we can
1391 complete on local vars. */
1393 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1394 add_symbol_overload_list_block (func_name, b, overload_list);
1396 surrounding_static_block = block_static_block (get_selected_block (0));
1398 /* Go through the symtabs and check the externs and statics for
1399 symbols which match. */
1401 ALL_COMPUNITS (objfile, cust)
1404 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), GLOBAL_BLOCK);
1405 add_symbol_overload_list_block (func_name, b, overload_list);
1408 ALL_COMPUNITS (objfile, cust)
1411 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
1412 /* Don't do this block twice. */
1413 if (b == surrounding_static_block)
1415 add_symbol_overload_list_block (func_name, b, overload_list);
1419 /* Lookup the rtti type for a class name. */
1422 cp_lookup_rtti_type (const char *name, struct block *block)
1424 struct symbol * rtti_sym;
1425 struct type * rtti_type;
1427 /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
1428 Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
1429 rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
1431 if (rtti_sym == NULL)
1433 warning (_("RTTI symbol not found for class '%s'"), name);
1437 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1439 warning (_("RTTI symbol for class '%s' is not a type"), name);
1443 rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym));
1445 switch (TYPE_CODE (rtti_type))
1447 case TYPE_CODE_STRUCT:
1449 case TYPE_CODE_NAMESPACE:
1450 /* chastain/2003-11-26: the symbol tables often contain fake
1451 symbols for namespaces with the same name as the struct.
1452 This warning is an indication of a bug in the lookup order
1453 or a bug in the way that the symbol tables are populated. */
1454 warning (_("RTTI symbol for class '%s' is a namespace"), name);
1457 warning (_("RTTI symbol for class '%s' has bad type"), name);
1464 #ifdef HAVE_WORKING_FORK
1466 /* If nonzero, attempt to catch crashes in the demangler and print
1467 useful debugging information. */
1469 static int catch_demangler_crashes = 1;
1471 /* Stack context and environment for demangler crash recovery. */
1473 static SIGJMP_BUF gdb_demangle_jmp_buf;
1475 /* If nonzero, attempt to dump core from the signal handler. */
1477 static int gdb_demangle_attempt_core_dump = 1;
1479 /* Signal handler for gdb_demangle. */
1482 gdb_demangle_signal_handler (int signo)
1484 if (gdb_demangle_attempt_core_dump)
1489 gdb_demangle_attempt_core_dump = 0;
1492 SIGLONGJMP (gdb_demangle_jmp_buf, signo);
1497 /* A wrapper for bfd_demangle. */
1500 gdb_demangle (const char *name, int options)
1502 char *result = NULL;
1503 int crash_signal = 0;
1505 #ifdef HAVE_WORKING_FORK
1506 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1507 struct sigaction sa, old_sa;
1511 static int core_dump_allowed = -1;
1513 if (core_dump_allowed == -1)
1515 core_dump_allowed = can_dump_core (LIMIT_CUR);
1517 if (!core_dump_allowed)
1518 gdb_demangle_attempt_core_dump = 0;
1521 if (catch_demangler_crashes)
1523 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1524 sa.sa_handler = gdb_demangle_signal_handler;
1525 sigemptyset (&sa.sa_mask);
1526 #ifdef HAVE_SIGALTSTACK
1527 sa.sa_flags = SA_ONSTACK;
1531 sigaction (SIGSEGV, &sa, &old_sa);
1533 ofunc = signal (SIGSEGV, gdb_demangle_signal_handler);
1536 crash_signal = SIGSETJMP (gdb_demangle_jmp_buf);
1540 if (crash_signal == 0)
1541 result = bfd_demangle (NULL, name, options);
1543 #ifdef HAVE_WORKING_FORK
1544 if (catch_demangler_crashes)
1546 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1547 sigaction (SIGSEGV, &old_sa, NULL);
1549 signal (SIGSEGV, ofunc);
1552 if (crash_signal != 0)
1554 static int error_reported = 0;
1556 if (!error_reported)
1558 std::string short_msg
1559 = string_printf (_("unable to demangle '%s' "
1560 "(demangler failed with signal %d)"),
1561 name, crash_signal);
1563 std::string long_msg
1564 = string_printf ("%s:%d: %s: %s", __FILE__, __LINE__,
1565 "demangler-warning", short_msg.c_str ());
1567 target_terminal::scoped_restore_terminal_state term_state;
1568 target_terminal::ours_for_output ();
1571 if (core_dump_allowed)
1572 fprintf_unfiltered (gdb_stderr,
1573 _("%s\nAttempting to dump core.\n"),
1576 warn_cant_dump_core (long_msg.c_str ());
1578 demangler_warning (__FILE__, __LINE__, "%s", short_msg.c_str ());
1591 /* See cp-support.h. */
1594 gdb_sniff_from_mangled_name (const char *mangled, char **demangled)
1596 *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
1597 return *demangled != NULL;
1600 /* See cp-support.h. */
1603 cp_search_name_hash (const char *search_name)
1605 /* cp_entire_prefix_len assumes a fully-qualified name with no
1607 if (startswith (search_name, "::"))
1610 unsigned int prefix_len = cp_entire_prefix_len (search_name);
1611 if (prefix_len != 0)
1612 search_name += prefix_len + 2;
1614 unsigned int hash = 0;
1615 for (const char *string = search_name; *string != '\0'; ++string)
1617 string = skip_spaces (string);
1622 /* Ignore ABI tags such as "[abi:cxx11]. */
1624 && startswith (string + 1, "abi:")
1625 && string[5] != ':')
1628 hash = SYMBOL_HASH_NEXT (hash, *string);
1633 /* Helper for cp_symbol_name_matches (i.e., symbol_name_matcher_ftype
1634 implementation for symbol_name_match_type::WILD matching). Split
1635 to a separate function for unit-testing convenience.
1637 If SYMBOL_SEARCH_NAME has more scopes than LOOKUP_NAME, we try to
1638 match ignoring the extra leading scopes of SYMBOL_SEARCH_NAME.
1639 This allows conveniently setting breakpoints on functions/methods
1640 inside any namespace/class without specifying the fully-qualified
1645 [symbol search name] [lookup name]
1646 foo::bar::func foo::bar::func
1647 foo::bar::func bar::func
1652 [symbol search name] [lookup name]
1653 foo::zbar::func bar::func
1654 foo::bar::func foo::func
1656 See more examples in the test_cp_symbol_name_matches selftest
1659 See symbol_name_matcher_ftype for description of SYMBOL_SEARCH_NAME
1662 LOOKUP_NAME/LOOKUP_NAME_LEN is the name we're looking up.
1664 See strncmp_iw_with_mode for description of MODE.
1668 cp_symbol_name_matches_1 (const char *symbol_search_name,
1669 const char *lookup_name,
1670 size_t lookup_name_len,
1671 strncmp_iw_mode mode,
1672 completion_match_result *comp_match_res)
1674 const char *sname = symbol_search_name;
1675 completion_match_for_lcd *match_for_lcd
1676 = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
1680 if (strncmp_iw_with_mode (sname, lookup_name, lookup_name_len,
1681 mode, language_cplus, match_for_lcd) == 0)
1683 if (comp_match_res != NULL)
1685 /* Note here we set different MATCH and MATCH_FOR_LCD
1686 strings. This is because with
1688 (gdb) b push_bac[TAB]
1690 we want the completion matches to list
1692 std::vector<int>::push_back(...)
1693 std::vector<char>::push_back(...)
1695 etc., which are SYMBOL_SEARCH_NAMEs, while we want
1696 the input line to auto-complete to
1698 (gdb) push_back(...)
1700 which is SNAME, not to
1704 which would be the regular common prefix between all
1705 the matches otherwise. */
1706 comp_match_res->set_match (symbol_search_name, sname);
1711 unsigned int len = cp_find_first_component (sname);
1713 if (sname[len] == '\0')
1716 gdb_assert (sname[len] == ':');
1717 /* Skip the '::'. */
1722 /* C++ symbol_name_matcher_ftype implementation. */
1725 cp_fq_symbol_name_matches (const char *symbol_search_name,
1726 const lookup_name_info &lookup_name,
1727 completion_match_result *comp_match_res)
1729 /* Get the demangled name. */
1730 const std::string &name = lookup_name.cplus ().lookup_name ();
1731 completion_match_for_lcd *match_for_lcd
1732 = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
1733 strncmp_iw_mode mode = (lookup_name.completion_mode ()
1734 ? strncmp_iw_mode::NORMAL
1735 : strncmp_iw_mode::MATCH_PARAMS);
1737 if (strncmp_iw_with_mode (symbol_search_name,
1738 name.c_str (), name.size (),
1739 mode, language_cplus, match_for_lcd) == 0)
1741 if (comp_match_res != NULL)
1742 comp_match_res->set_match (symbol_search_name);
1749 /* C++ symbol_name_matcher_ftype implementation for wild matches.
1750 Defers work to cp_symbol_name_matches_1. */
1753 cp_symbol_name_matches (const char *symbol_search_name,
1754 const lookup_name_info &lookup_name,
1755 completion_match_result *comp_match_res)
1757 /* Get the demangled name. */
1758 const std::string &name = lookup_name.cplus ().lookup_name ();
1760 strncmp_iw_mode mode = (lookup_name.completion_mode ()
1761 ? strncmp_iw_mode::NORMAL
1762 : strncmp_iw_mode::MATCH_PARAMS);
1764 return cp_symbol_name_matches_1 (symbol_search_name,
1765 name.c_str (), name.size (),
1766 mode, comp_match_res);
1769 /* See cp-support.h. */
1771 symbol_name_matcher_ftype *
1772 cp_get_symbol_name_matcher (const lookup_name_info &lookup_name)
1774 switch (lookup_name.match_type ())
1776 case symbol_name_match_type::FULL:
1777 case symbol_name_match_type::EXPRESSION:
1778 case symbol_name_match_type::SEARCH_NAME:
1779 return cp_fq_symbol_name_matches;
1780 case symbol_name_match_type::WILD:
1781 return cp_symbol_name_matches;
1784 gdb_assert_not_reached ("");
1789 namespace selftests {
1792 test_cp_symbol_name_matches ()
1794 #define CHECK_MATCH(SYMBOL, INPUT) \
1795 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, \
1796 INPUT, sizeof (INPUT) - 1, \
1797 strncmp_iw_mode::MATCH_PARAMS, \
1800 #define CHECK_NOT_MATCH(SYMBOL, INPUT) \
1801 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, \
1802 INPUT, sizeof (INPUT) - 1, \
1803 strncmp_iw_mode::MATCH_PARAMS, \
1806 /* Like CHECK_MATCH, and also check that INPUT (and all substrings
1807 that start at index 0) completes to SYMBOL. */
1808 #define CHECK_MATCH_C(SYMBOL, INPUT) \
1811 CHECK_MATCH (SYMBOL, INPUT); \
1812 for (size_t i = 0; i < sizeof (INPUT) - 1; i++) \
1813 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, INPUT, i, \
1814 strncmp_iw_mode::NORMAL, \
1818 /* Like CHECK_NOT_MATCH, and also check that INPUT does NOT complete
1820 #define CHECK_NOT_MATCH_C(SYMBOL, INPUT) \
1823 CHECK_NOT_MATCH (SYMBOL, INPUT); \
1824 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, INPUT, \
1825 sizeof (INPUT) - 1, \
1826 strncmp_iw_mode::NORMAL, \
1830 /* Lookup name without parens matches all overloads. */
1831 CHECK_MATCH_C ("function()", "function");
1832 CHECK_MATCH_C ("function(int)", "function");
1834 /* Check whitespace around parameters is ignored. */
1835 CHECK_MATCH_C ("function()", "function ()");
1836 CHECK_MATCH_C ("function ( )", "function()");
1837 CHECK_MATCH_C ("function ()", "function( )");
1838 CHECK_MATCH_C ("func(int)", "func( int )");
1839 CHECK_MATCH_C ("func(int)", "func ( int ) ");
1840 CHECK_MATCH_C ("func ( int )", "func( int )");
1841 CHECK_MATCH_C ("func ( int )", "func ( int ) ");
1843 /* Check symbol name prefixes aren't incorrectly matched. */
1844 CHECK_NOT_MATCH ("func", "function");
1845 CHECK_NOT_MATCH ("function", "func");
1846 CHECK_NOT_MATCH ("function()", "func");
1848 /* Check that if the lookup name includes parameters, only the right
1849 overload matches. */
1850 CHECK_MATCH_C ("function(int)", "function(int)");
1851 CHECK_NOT_MATCH_C ("function(int)", "function()");
1853 /* Check that whitespace within symbol names is not ignored. */
1854 CHECK_NOT_MATCH_C ("function", "func tion");
1855 CHECK_NOT_MATCH_C ("func__tion", "func_ _tion");
1856 CHECK_NOT_MATCH_C ("func11tion", "func1 1tion");
1858 /* Check the converse, which can happen with template function,
1859 where the return type is part of the demangled name. */
1860 CHECK_NOT_MATCH_C ("func tion", "function");
1861 CHECK_NOT_MATCH_C ("func1 1tion", "func11tion");
1862 CHECK_NOT_MATCH_C ("func_ _tion", "func__tion");
1864 /* Within parameters too. */
1865 CHECK_NOT_MATCH_C ("func(param)", "func(par am)");
1867 /* Check handling of whitespace around C++ operators. */
1868 CHECK_NOT_MATCH_C ("operator<<", "opera tor<<");
1869 CHECK_NOT_MATCH_C ("operator<<", "operator< <");
1870 CHECK_NOT_MATCH_C ("operator<<", "operator < <");
1871 CHECK_NOT_MATCH_C ("operator==", "operator= =");
1872 CHECK_NOT_MATCH_C ("operator==", "operator = =");
1873 CHECK_MATCH_C ("operator<<", "operator <<");
1874 CHECK_MATCH_C ("operator<<()", "operator <<");
1875 CHECK_NOT_MATCH_C ("operator<<()", "operator<<(int)");
1876 CHECK_NOT_MATCH_C ("operator<<(int)", "operator<<()");
1877 CHECK_MATCH_C ("operator==", "operator ==");
1878 CHECK_MATCH_C ("operator==()", "operator ==");
1879 CHECK_MATCH_C ("operator <<", "operator<<");
1880 CHECK_MATCH_C ("operator ==", "operator==");
1881 CHECK_MATCH_C ("operator bool", "operator bool");
1882 CHECK_MATCH_C ("operator bool ()", "operator bool");
1883 CHECK_MATCH_C ("operatorX<<", "operatorX < <");
1884 CHECK_MATCH_C ("Xoperator<<", "Xoperator < <");
1886 CHECK_MATCH_C ("operator()(int)", "operator()(int)");
1887 CHECK_MATCH_C ("operator()(int)", "operator ( ) ( int )");
1888 CHECK_MATCH_C ("operator()<long>(int)", "operator ( ) < long > ( int )");
1889 /* The first "()" is not the parameter list. */
1890 CHECK_NOT_MATCH ("operator()(int)", "operator");
1892 /* Misc user-defined operator tests. */
1894 CHECK_NOT_MATCH_C ("operator/=()", "operator ^=");
1895 /* Same length at end of input. */
1896 CHECK_NOT_MATCH_C ("operator>>", "operator[]");
1897 /* Same length but not at end of input. */
1898 CHECK_NOT_MATCH_C ("operator>>()", "operator[]()");
1900 CHECK_MATCH_C ("base::operator char*()", "base::operator char*()");
1901 CHECK_MATCH_C ("base::operator char*()", "base::operator char * ()");
1902 CHECK_MATCH_C ("base::operator char**()", "base::operator char * * ()");
1903 CHECK_MATCH ("base::operator char**()", "base::operator char * *");
1904 CHECK_MATCH_C ("base::operator*()", "base::operator*()");
1905 CHECK_NOT_MATCH_C ("base::operator char*()", "base::operatorc");
1906 CHECK_NOT_MATCH ("base::operator char*()", "base::operator char");
1907 CHECK_NOT_MATCH ("base::operator char*()", "base::operat");
1909 /* Check handling of whitespace around C++ scope operators. */
1910 CHECK_NOT_MATCH_C ("foo::bar", "foo: :bar");
1911 CHECK_MATCH_C ("foo::bar", "foo :: bar");
1912 CHECK_MATCH_C ("foo :: bar", "foo::bar");
1914 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi()");
1915 CHECK_MATCH_C ("abc::def::ghi ( )", "abc::def::ghi()");
1916 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi ( )");
1917 CHECK_MATCH_C ("function()", "function()");
1918 CHECK_MATCH_C ("bar::function()", "bar::function()");
1920 /* Wild matching tests follow. */
1922 /* Tests matching symbols in some scope. */
1923 CHECK_MATCH_C ("foo::function()", "function");
1924 CHECK_MATCH_C ("foo::function(int)", "function");
1925 CHECK_MATCH_C ("foo::bar::function()", "function");
1926 CHECK_MATCH_C ("bar::function()", "bar::function");
1927 CHECK_MATCH_C ("foo::bar::function()", "bar::function");
1928 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function");
1930 /* Same, with parameters in the lookup name. */
1931 CHECK_MATCH_C ("foo::function()", "function()");
1932 CHECK_MATCH_C ("foo::bar::function()", "function()");
1933 CHECK_MATCH_C ("foo::function(int)", "function(int)");
1934 CHECK_MATCH_C ("foo::function()", "foo::function()");
1935 CHECK_MATCH_C ("foo::bar::function()", "bar::function()");
1936 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function(int)");
1937 CHECK_MATCH_C ("bar::function()", "bar::function()");
1939 CHECK_NOT_MATCH_C ("foo::bar::function(int)", "bar::function()");
1941 CHECK_MATCH_C ("(anonymous namespace)::bar::function(int)",
1942 "bar::function(int)");
1943 CHECK_MATCH_C ("foo::(anonymous namespace)::bar::function(int)",
1946 /* Lookup scope wider than symbol scope, should not match. */
1947 CHECK_NOT_MATCH_C ("function()", "bar::function");
1948 CHECK_NOT_MATCH_C ("function()", "bar::function()");
1950 /* Explicit global scope doesn't match. */
1951 CHECK_NOT_MATCH_C ("foo::function()", "::function");
1952 CHECK_NOT_MATCH_C ("foo::function()", "::function()");
1953 CHECK_NOT_MATCH_C ("foo::function(int)", "::function()");
1954 CHECK_NOT_MATCH_C ("foo::function(int)", "::function(int)");
1956 /* Test ABI tag matching/ignoring. */
1958 /* If the symbol name has an ABI tag, but the lookup name doesn't,
1959 then the ABI tag in the symbol name is ignored. */
1960 CHECK_MATCH_C ("function[abi:foo]()", "function");
1961 CHECK_MATCH_C ("function[abi:foo](int)", "function");
1962 CHECK_MATCH_C ("function[abi:foo]()", "function ()");
1963 CHECK_NOT_MATCH_C ("function[abi:foo]()", "function (int)");
1965 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo]");
1966 CHECK_MATCH_C ("function[abi:foo](int)", "function[abi:foo]");
1967 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo] ()");
1968 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function");
1969 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function");
1970 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo]");
1971 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function[abi:foo]");
1972 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] ()");
1973 CHECK_NOT_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] (int)");
1975 CHECK_MATCH_C ("function [abi:foo][abi:bar] ( )", "function [abi:foo]");
1977 /* If the symbol name does not have an ABI tag, while the lookup
1978 name has one, then there's no match. */
1979 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]()");
1980 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]");
1983 /* If non-NULL, return STR wrapped in quotes. Otherwise, return a
1984 "<null>" string (with no quotes). */
1987 quote (const char *str)
1990 return std::string (1, '\"') + str + '\"';
1995 /* Check that removing parameter info out of NAME produces EXPECTED.
1996 COMPLETION_MODE indicates whether we're testing normal and
1997 completion mode. FILE and LINE are used to provide better test
1998 location information in case ithe check fails. */
2001 check_remove_params (const char *file, int line,
2002 const char *name, const char *expected,
2003 bool completion_mode)
2005 gdb::unique_xmalloc_ptr<char> result
2006 = cp_remove_params_if_any (name, completion_mode);
2008 if ((expected == NULL) != (result == NULL)
2009 || (expected != NULL
2010 && strcmp (result.get (), expected) != 0))
2012 error (_("%s:%d: make-paramless self-test failed: (completion=%d) "
2013 "\"%s\" -> %s, expected %s"),
2014 file, line, completion_mode, name,
2015 quote (result.get ()).c_str (), quote (expected).c_str ());
2019 /* Entry point for cp_remove_params unit tests. */
2022 test_cp_remove_params ()
2024 /* Check that removing parameter info out of NAME produces EXPECTED.
2025 Checks both normal and completion modes. */
2026 #define CHECK(NAME, EXPECTED) \
2029 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, false); \
2030 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2034 /* Similar, but used when NAME is incomplete -- i.e., is has
2035 unbalanced parentheses. In this case, looking for the exact name
2036 should fail / return empty. */
2037 #define CHECK_INCOMPL(NAME, EXPECTED) \
2040 check_remove_params (__FILE__, __LINE__, NAME, NULL, false); \
2041 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2045 CHECK ("function()", "function");
2046 CHECK_INCOMPL ("function(", "function");
2047 CHECK ("function() const", "function");
2049 CHECK ("(anonymous namespace)::A::B::C",
2050 "(anonymous namespace)::A::B::C");
2052 CHECK ("A::(anonymous namespace)",
2053 "A::(anonymous namespace)");
2055 CHECK_INCOMPL ("A::(anonymou", "A");
2057 CHECK ("A::foo<int>()",
2060 CHECK_INCOMPL ("A::foo<int>(",
2063 CHECK ("A::foo<(anonymous namespace)::B>::func(int)",
2064 "A::foo<(anonymous namespace)::B>::func");
2066 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::func(in",
2067 "A::foo<(anonymous namespace)::B>::func");
2069 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::",
2070 "A::foo<(anonymous namespace)::B>");
2072 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>:",
2073 "A::foo<(anonymous namespace)::B>");
2075 CHECK ("A::foo<(anonymous namespace)::B>",
2076 "A::foo<(anonymous namespace)::B>");
2078 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B",
2081 /* Shouldn't this parse? Looks like a bug in
2082 cp_demangled_name_to_comp. See PR c++/22411. */
2084 CHECK ("A::foo<void(int)>::func(int)",
2085 "A::foo<void(int)>::func");
2087 CHECK_INCOMPL ("A::foo<void(int)>::func(int)",
2091 CHECK_INCOMPL ("A::foo<void(int",
2095 #undef CHECK_INCOMPL
2098 } // namespace selftests
2100 #endif /* GDB_SELF_CHECK */
2102 /* Don't allow just "maintenance cplus". */
2105 maint_cplus_command (const char *arg, int from_tty)
2107 printf_unfiltered (_("\"maintenance cplus\" must be followed "
2108 "by the name of a command.\n"));
2109 help_list (maint_cplus_cmd_list,
2110 "maintenance cplus ",
2111 all_commands, gdb_stdout);
2114 /* This is a front end for cp_find_first_component, for unit testing.
2115 Be careful when using it: see the NOTE above
2116 cp_find_first_component. */
2119 first_component_command (const char *arg, int from_tty)
2127 len = cp_find_first_component (arg);
2128 prefix = (char *) alloca (len + 1);
2130 memcpy (prefix, arg, len);
2133 printf_unfiltered ("%s\n", prefix);
2136 /* Implement "info vtbl". */
2139 info_vtbl_command (const char *arg, int from_tty)
2141 struct value *value;
2143 value = parse_and_eval (arg);
2144 cplus_print_vtable (value);
2148 _initialize_cp_support (void)
2150 add_prefix_cmd ("cplus", class_maintenance,
2151 maint_cplus_command,
2152 _("C++ maintenance commands."),
2153 &maint_cplus_cmd_list,
2154 "maintenance cplus ",
2155 0, &maintenancelist);
2156 add_alias_cmd ("cp", "cplus",
2157 class_maintenance, 1,
2160 add_cmd ("first_component",
2162 first_component_command,
2163 _("Print the first class/namespace component of NAME."),
2164 &maint_cplus_cmd_list);
2166 add_info ("vtbl", info_vtbl_command,
2167 _("Show the virtual function table for a C++ object.\n\
2168 Usage: info vtbl EXPRESSION\n\
2169 Evaluate EXPRESSION and display the virtual function table for the\n\
2170 resulting object."));
2172 #ifdef HAVE_WORKING_FORK
2173 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance,
2174 &catch_demangler_crashes, _("\
2175 Set whether to attempt to catch demangler crashes."), _("\
2176 Show whether to attempt to catch demangler crashes."), _("\
2177 If enabled GDB will attempt to catch demangler crashes and\n\
2178 display the offending symbol."),
2181 &maintenance_set_cmdlist,
2182 &maintenance_show_cmdlist);
2186 selftests::register_test ("cp_symbol_name_matches",
2187 selftests::test_cp_symbol_name_matches);
2188 selftests::register_test ("cp_remove_params",
2189 selftests::test_cp_remove_params);