1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2002-2020 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 "gdbsupport/gdb_setjmp.h"
38 #include "safe-ctype.h"
39 #include "gdbsupport/selftest.h"
40 #include "gdbsupport/gdb-sigmask.h"
42 #include "event-top.h"
43 #include "run-on-main-thread.h"
45 #define d_left(dc) (dc)->u.s_binary.left
46 #define d_right(dc) (dc)->u.s_binary.right
48 /* Functions related to demangled name parsing. */
50 static unsigned int cp_find_first_component_aux (const char *name
,
53 static void demangled_name_complaint (const char *name
);
55 /* Functions related to overload resolution. */
57 static void overload_list_add_symbol (struct symbol
*sym
,
58 const char *oload_name
,
59 std::vector
<symbol
*> *overload_list
);
61 static void add_symbol_overload_list_using
62 (const char *func_name
, const char *the_namespace
,
63 std::vector
<symbol
*> *overload_list
);
65 static void add_symbol_overload_list_qualified
66 (const char *func_name
,
67 std::vector
<symbol
*> *overload_list
);
69 /* The list of "maint cplus" commands. */
71 struct cmd_list_element
*maint_cplus_cmd_list
= NULL
;
73 /* A list of typedefs which should not be substituted by replace_typedefs. */
74 static const char * const ignore_typedefs
[] =
76 "std::istream", "std::iostream", "std::ostream", "std::string"
80 replace_typedefs (struct demangle_parse_info
*info
,
81 struct demangle_component
*ret_comp
,
82 canonicalization_ftype
*finder
,
85 /* A convenience function to copy STRING into OBSTACK, returning a pointer
86 to the newly allocated string and saving the number of bytes saved in LEN.
88 It does not copy the terminating '\0' byte! */
91 copy_string_to_obstack (struct obstack
*obstack
, const char *string
,
94 *len
= strlen (string
);
95 return (char *) obstack_copy (obstack
, string
, *len
);
98 /* Return 1 if STRING is clearly already in canonical form. This
99 function is conservative; things which it does not recognize are
100 assumed to be non-canonical, and the parser will sort them out
101 afterwards. This speeds up the critical path for alphanumeric
105 cp_already_canonical (const char *string
)
107 /* Identifier start character [a-zA-Z_]. */
108 if (!ISIDST (string
[0]))
111 /* These are the only two identifiers which canonicalize to other
112 than themselves or an error: unsigned -> unsigned int and
114 if (string
[0] == 'u' && strcmp (&string
[1], "nsigned") == 0)
116 else if (string
[0] == 's' && strcmp (&string
[1], "igned") == 0)
119 /* Identifier character [a-zA-Z0-9_]. */
120 while (ISIDNUM (string
[1]))
123 if (string
[1] == '\0')
129 /* Inspect the given RET_COMP for its type. If it is a typedef,
130 replace the node with the typedef's tree.
132 Returns 1 if any typedef substitutions were made, 0 otherwise. */
135 inspect_type (struct demangle_parse_info
*info
,
136 struct demangle_component
*ret_comp
,
137 canonicalization_ftype
*finder
,
143 /* Copy the symbol's name from RET_COMP and look it up
144 in the symbol table. */
145 name
= (char *) alloca (ret_comp
->u
.s_name
.len
+ 1);
146 memcpy (name
, ret_comp
->u
.s_name
.s
, ret_comp
->u
.s_name
.len
);
147 name
[ret_comp
->u
.s_name
.len
] = '\0';
149 /* Ignore any typedefs that should not be substituted. */
150 for (int i
= 0; i
< ARRAY_SIZE (ignore_typedefs
); ++i
)
152 if (strcmp (name
, ignore_typedefs
[i
]) == 0)
160 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0).symbol
;
162 catch (const gdb_exception
&except
)
169 struct type
*otype
= SYMBOL_TYPE (sym
);
173 const char *new_name
= (*finder
) (otype
, data
);
175 if (new_name
!= NULL
)
177 ret_comp
->u
.s_name
.s
= new_name
;
178 ret_comp
->u
.s_name
.len
= strlen (new_name
);
185 /* If the type is a typedef or namespace alias, replace it. */
186 if (TYPE_CODE (otype
) == TYPE_CODE_TYPEDEF
187 || TYPE_CODE (otype
) == TYPE_CODE_NAMESPACE
)
192 std::unique_ptr
<demangle_parse_info
> i
;
194 /* Get the real type of the typedef. */
195 type
= check_typedef (otype
);
197 /* If the symbol name is the same as the original type name,
198 don't substitute. That would cause infinite recursion in
199 symbol lookups, as the typedef symbol is often the first
200 found symbol in the symbol table.
202 However, this can happen in a number of situations, such as:
204 If the symbol is a namespace and its type name is no different
205 than the name we looked up, this symbol is not a namespace
206 alias and does not need to be substituted.
208 If the symbol is typedef and its type name is the same
209 as the symbol's name, e.g., "typedef struct foo foo;". */
210 if (TYPE_NAME (type
) != nullptr
211 && strcmp (TYPE_NAME (type
), name
) == 0)
214 is_anon
= (TYPE_NAME (type
) == NULL
215 && (TYPE_CODE (type
) == TYPE_CODE_ENUM
216 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
217 || TYPE_CODE (type
) == TYPE_CODE_UNION
));
220 struct type
*last
= otype
;
222 /* Find the last typedef for the type. */
223 while (TYPE_TARGET_TYPE (last
) != NULL
224 && (TYPE_CODE (TYPE_TARGET_TYPE (last
))
225 == TYPE_CODE_TYPEDEF
))
226 last
= TYPE_TARGET_TYPE (last
);
228 /* If there is only one typedef for this anonymous type,
229 do not substitute it. */
233 /* Use the last typedef seen as the type for this
241 type_print (type
, "", &buf
, -1);
243 /* If type_print threw an exception, there is little point
244 in continuing, so just bow out gracefully. */
245 catch (const gdb_exception_error
&except
)
251 name
= obstack_strdup (&info
->obstack
, buf
.string ());
253 /* Turn the result into a new tree. Note that this
254 tree will contain pointers into NAME, so NAME cannot
255 be free'd until all typedef conversion is done and
256 the final result is converted into a string. */
257 i
= cp_demangled_name_to_comp (name
, NULL
);
260 /* Merge the two trees. */
261 cp_merge_demangle_parse_infos (info
, ret_comp
, i
.get ());
263 /* Replace any newly introduced typedefs -- but not
264 if the type is anonymous (that would lead to infinite
267 replace_typedefs (info
, ret_comp
, finder
, data
);
271 /* This shouldn't happen unless the type printer has
272 output something that the name parser cannot grok.
273 Nonetheless, an ounce of prevention...
275 Canonicalize the name again, and store it in the
276 current node (RET_COMP). */
277 gdb::unique_xmalloc_ptr
<char> canon
278 = cp_canonicalize_string_no_typedefs (name
);
280 if (canon
!= nullptr)
282 /* Copy the canonicalization into the obstack. */
283 name
= copy_string_to_obstack (&info
->obstack
, canon
.get (), &len
);
286 ret_comp
->u
.s_name
.s
= name
;
287 ret_comp
->u
.s_name
.len
= len
;
297 /* Replace any typedefs appearing in the qualified name
298 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
302 replace_typedefs_qualified_name (struct demangle_parse_info
*info
,
303 struct demangle_component
*ret_comp
,
304 canonicalization_ftype
*finder
,
308 struct demangle_component
*comp
= ret_comp
;
310 /* Walk each node of the qualified name, reconstructing the name of
311 this element. With every node, check for any typedef substitutions.
312 If a substitution has occurred, replace the qualified name node
313 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
315 while (comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
)
317 if (d_left (comp
)->type
== DEMANGLE_COMPONENT_NAME
)
319 struct demangle_component newobj
;
321 buf
.write (d_left (comp
)->u
.s_name
.s
, d_left (comp
)->u
.s_name
.len
);
322 newobj
.type
= DEMANGLE_COMPONENT_NAME
;
323 newobj
.u
.s_name
.s
= obstack_strdup (&info
->obstack
, buf
.string ());
324 newobj
.u
.s_name
.len
= buf
.size ();
325 if (inspect_type (info
, &newobj
, finder
, data
))
330 /* A typedef was substituted in NEW. Convert it to a
331 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
335 gdb::unique_xmalloc_ptr
<char> n
336 = cp_comp_to_string (&newobj
, 100);
339 /* If something went astray, abort typedef substitutions. */
343 s
= copy_string_to_obstack (&info
->obstack
, n
.get (), &slen
);
345 d_left (ret_comp
)->type
= DEMANGLE_COMPONENT_NAME
;
346 d_left (ret_comp
)->u
.s_name
.s
= s
;
347 d_left (ret_comp
)->u
.s_name
.len
= slen
;
348 d_right (ret_comp
) = d_right (comp
);
355 /* The current node is not a name, so simply replace any
356 typedefs in it. Then print it to the stream to continue
357 checking for more typedefs in the tree. */
358 replace_typedefs (info
, d_left (comp
), finder
, data
);
359 gdb::unique_xmalloc_ptr
<char> name
360 = cp_comp_to_string (d_left (comp
), 100);
363 /* If something went astray, abort typedef substitutions. */
366 buf
.puts (name
.get ());
370 comp
= d_right (comp
);
373 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
374 name assembled above and append the name given by COMP. Then use this
375 reassembled name to check for a typedef. */
377 if (comp
->type
== DEMANGLE_COMPONENT_NAME
)
379 buf
.write (comp
->u
.s_name
.s
, comp
->u
.s_name
.len
);
381 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
382 with a DEMANGLE_COMPONENT_NAME node containing the whole
384 ret_comp
->type
= DEMANGLE_COMPONENT_NAME
;
385 ret_comp
->u
.s_name
.s
= obstack_strdup (&info
->obstack
, buf
.string ());
386 ret_comp
->u
.s_name
.len
= buf
.size ();
387 inspect_type (info
, ret_comp
, finder
, data
);
390 replace_typedefs (info
, comp
, finder
, data
);
394 /* A function to check const and volatile qualifiers for argument types.
396 "Parameter declarations that differ only in the presence
397 or absence of `const' and/or `volatile' are equivalent."
398 C++ Standard N3290, clause 13.1.3 #4. */
401 check_cv_qualifiers (struct demangle_component
*ret_comp
)
403 while (d_left (ret_comp
) != NULL
404 && (d_left (ret_comp
)->type
== DEMANGLE_COMPONENT_CONST
405 || d_left (ret_comp
)->type
== DEMANGLE_COMPONENT_VOLATILE
))
407 d_left (ret_comp
) = d_left (d_left (ret_comp
));
411 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
412 their basic types. */
415 replace_typedefs (struct demangle_parse_info
*info
,
416 struct demangle_component
*ret_comp
,
417 canonicalization_ftype
*finder
,
423 && (ret_comp
->type
== DEMANGLE_COMPONENT_NAME
424 || ret_comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
425 || ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
426 || ret_comp
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
))
428 gdb::unique_xmalloc_ptr
<char> local_name
429 = cp_comp_to_string (ret_comp
, 10);
431 if (local_name
!= NULL
)
433 struct symbol
*sym
= NULL
;
438 sym
= lookup_symbol (local_name
.get (), 0,
439 VAR_DOMAIN
, 0).symbol
;
441 catch (const gdb_exception
&except
)
447 struct type
*otype
= SYMBOL_TYPE (sym
);
448 const char *new_name
= (*finder
) (otype
, data
);
450 if (new_name
!= NULL
)
452 ret_comp
->type
= DEMANGLE_COMPONENT_NAME
;
453 ret_comp
->u
.s_name
.s
= new_name
;
454 ret_comp
->u
.s_name
.len
= strlen (new_name
);
461 switch (ret_comp
->type
)
463 case DEMANGLE_COMPONENT_ARGLIST
:
464 check_cv_qualifiers (ret_comp
);
467 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
468 case DEMANGLE_COMPONENT_TEMPLATE
:
469 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
470 case DEMANGLE_COMPONENT_TYPED_NAME
:
471 replace_typedefs (info
, d_left (ret_comp
), finder
, data
);
472 replace_typedefs (info
, d_right (ret_comp
), finder
, data
);
475 case DEMANGLE_COMPONENT_NAME
:
476 inspect_type (info
, ret_comp
, finder
, data
);
479 case DEMANGLE_COMPONENT_QUAL_NAME
:
480 replace_typedefs_qualified_name (info
, ret_comp
, finder
, data
);
483 case DEMANGLE_COMPONENT_LOCAL_NAME
:
484 case DEMANGLE_COMPONENT_CTOR
:
485 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
486 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
487 replace_typedefs (info
, d_right (ret_comp
), finder
, data
);
490 case DEMANGLE_COMPONENT_CONST
:
491 case DEMANGLE_COMPONENT_RESTRICT
:
492 case DEMANGLE_COMPONENT_VOLATILE
:
493 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
494 case DEMANGLE_COMPONENT_CONST_THIS
:
495 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
496 case DEMANGLE_COMPONENT_POINTER
:
497 case DEMANGLE_COMPONENT_REFERENCE
:
498 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
499 replace_typedefs (info
, d_left (ret_comp
), finder
, data
);
508 /* Parse STRING and convert it to canonical form, resolving any
509 typedefs. If parsing fails, or if STRING is already canonical,
510 return nullptr. Otherwise return the canonical form. If
511 FINDER is not NULL, then type components are passed to FINDER to be
512 looked up. DATA is passed verbatim to FINDER. */
514 gdb::unique_xmalloc_ptr
<char>
515 cp_canonicalize_string_full (const char *string
,
516 canonicalization_ftype
*finder
,
519 unsigned int estimated_len
;
520 std::unique_ptr
<demangle_parse_info
> info
;
522 estimated_len
= strlen (string
) * 2;
523 info
= cp_demangled_name_to_comp (string
, NULL
);
526 /* Replace all the typedefs in the tree. */
527 replace_typedefs (info
.get (), info
->tree
, finder
, data
);
529 /* Convert the tree back into a string. */
530 gdb::unique_xmalloc_ptr
<char> us
= cp_comp_to_string (info
->tree
,
534 /* Finally, compare the original string with the computed
535 name, returning NULL if they are the same. */
536 if (strcmp (us
.get (), string
) == 0)
545 /* Like cp_canonicalize_string_full, but always passes NULL for
548 gdb::unique_xmalloc_ptr
<char>
549 cp_canonicalize_string_no_typedefs (const char *string
)
551 return cp_canonicalize_string_full (string
, NULL
, NULL
);
554 /* Parse STRING and convert it to canonical form. If parsing fails,
555 or if STRING is already canonical, return nullptr.
556 Otherwise return the canonical form. */
558 gdb::unique_xmalloc_ptr
<char>
559 cp_canonicalize_string (const char *string
)
561 std::unique_ptr
<demangle_parse_info
> info
;
562 unsigned int estimated_len
;
564 if (cp_already_canonical (string
))
567 info
= cp_demangled_name_to_comp (string
, NULL
);
571 estimated_len
= strlen (string
) * 2;
572 gdb::unique_xmalloc_ptr
<char> us (cp_comp_to_string (info
->tree
,
577 warning (_("internal error: string \"%s\" failed to be canonicalized"),
582 if (strcmp (us
.get (), string
) == 0)
588 /* Convert a mangled name to a demangle_component tree. *MEMORY is
589 set to the block of used memory that should be freed when finished
590 with the tree. DEMANGLED_P is set to the char * that should be
591 freed when finished with the tree, or NULL if none was needed.
592 OPTIONS will be passed to the demangler. */
594 static std::unique_ptr
<demangle_parse_info
>
595 mangled_name_to_comp (const char *mangled_name
, int options
,
596 void **memory
, char **demangled_p
)
598 char *demangled_name
;
600 /* If it looks like a v3 mangled name, then try to go directly
602 if (mangled_name
[0] == '_' && mangled_name
[1] == 'Z')
604 struct demangle_component
*ret
;
606 ret
= cplus_demangle_v3_components (mangled_name
,
610 std::unique_ptr
<demangle_parse_info
> info (new demangle_parse_info
);
617 /* If it doesn't, or if that failed, then try to demangle the
619 demangled_name
= gdb_demangle (mangled_name
, options
);
620 if (demangled_name
== NULL
)
623 /* If we could demangle the name, parse it to build the component
625 std::unique_ptr
<demangle_parse_info
> info
626 = cp_demangled_name_to_comp (demangled_name
, NULL
);
630 xfree (demangled_name
);
634 *demangled_p
= demangled_name
;
638 /* Return the name of the class containing method PHYSNAME. */
641 cp_class_name_from_physname (const char *physname
)
643 void *storage
= NULL
;
644 char *demangled_name
= NULL
;
645 gdb::unique_xmalloc_ptr
<char> ret
;
646 struct demangle_component
*ret_comp
, *prev_comp
, *cur_comp
;
647 std::unique_ptr
<demangle_parse_info
> info
;
650 info
= mangled_name_to_comp (physname
, DMGL_ANSI
,
651 &storage
, &demangled_name
);
656 ret_comp
= info
->tree
;
658 /* First strip off any qualifiers, if we have a function or
661 switch (ret_comp
->type
)
663 case DEMANGLE_COMPONENT_CONST
:
664 case DEMANGLE_COMPONENT_RESTRICT
:
665 case DEMANGLE_COMPONENT_VOLATILE
:
666 case DEMANGLE_COMPONENT_CONST_THIS
:
667 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
668 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
669 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
670 ret_comp
= d_left (ret_comp
);
677 /* If what we have now is a function, discard the argument list. */
678 if (ret_comp
->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
679 ret_comp
= d_left (ret_comp
);
681 /* If what we have now is a template, strip off the template
682 arguments. The left subtree may be a qualified name. */
683 if (ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
684 ret_comp
= d_left (ret_comp
);
686 /* What we have now should be a name, possibly qualified.
687 Additional qualifiers could live in the left subtree or the right
688 subtree. Find the last piece. */
693 switch (cur_comp
->type
)
695 case DEMANGLE_COMPONENT_QUAL_NAME
:
696 case DEMANGLE_COMPONENT_LOCAL_NAME
:
697 prev_comp
= cur_comp
;
698 cur_comp
= d_right (cur_comp
);
700 case DEMANGLE_COMPONENT_TEMPLATE
:
701 case DEMANGLE_COMPONENT_NAME
:
702 case DEMANGLE_COMPONENT_CTOR
:
703 case DEMANGLE_COMPONENT_DTOR
:
704 case DEMANGLE_COMPONENT_OPERATOR
:
705 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
714 if (cur_comp
!= NULL
&& prev_comp
!= NULL
)
716 /* We want to discard the rightmost child of PREV_COMP. */
717 *prev_comp
= *d_left (prev_comp
);
718 /* The ten is completely arbitrary; we don't have a good
720 ret
= cp_comp_to_string (ret_comp
, 10);
724 xfree (demangled_name
);
725 return ret
.release ();
728 /* Return the child of COMP which is the basename of a method,
729 variable, et cetera. All scope qualifiers are discarded, but
730 template arguments will be included. The component tree may be
733 static struct demangle_component
*
734 unqualified_name_from_comp (struct demangle_component
*comp
)
736 struct demangle_component
*ret_comp
= comp
, *last_template
;
740 last_template
= NULL
;
742 switch (ret_comp
->type
)
744 case DEMANGLE_COMPONENT_QUAL_NAME
:
745 case DEMANGLE_COMPONENT_LOCAL_NAME
:
746 ret_comp
= d_right (ret_comp
);
748 case DEMANGLE_COMPONENT_TYPED_NAME
:
749 ret_comp
= d_left (ret_comp
);
751 case DEMANGLE_COMPONENT_TEMPLATE
:
752 gdb_assert (last_template
== NULL
);
753 last_template
= ret_comp
;
754 ret_comp
= d_left (ret_comp
);
756 case DEMANGLE_COMPONENT_CONST
:
757 case DEMANGLE_COMPONENT_RESTRICT
:
758 case DEMANGLE_COMPONENT_VOLATILE
:
759 case DEMANGLE_COMPONENT_CONST_THIS
:
760 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
761 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
762 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
763 ret_comp
= d_left (ret_comp
);
765 case DEMANGLE_COMPONENT_NAME
:
766 case DEMANGLE_COMPONENT_CTOR
:
767 case DEMANGLE_COMPONENT_DTOR
:
768 case DEMANGLE_COMPONENT_OPERATOR
:
769 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
779 d_left (last_template
) = ret_comp
;
780 return last_template
;
786 /* Return the name of the method whose linkage name is PHYSNAME. */
789 method_name_from_physname (const char *physname
)
791 void *storage
= NULL
;
792 char *demangled_name
= NULL
;
793 gdb::unique_xmalloc_ptr
<char> ret
;
794 struct demangle_component
*ret_comp
;
795 std::unique_ptr
<demangle_parse_info
> info
;
797 info
= mangled_name_to_comp (physname
, DMGL_ANSI
,
798 &storage
, &demangled_name
);
802 ret_comp
= unqualified_name_from_comp (info
->tree
);
804 if (ret_comp
!= NULL
)
805 /* The ten is completely arbitrary; we don't have a good
807 ret
= cp_comp_to_string (ret_comp
, 10);
810 xfree (demangled_name
);
811 return ret
.release ();
814 /* If FULL_NAME is the demangled name of a C++ function (including an
815 arg list, possibly including namespace/class qualifications),
816 return a new string containing only the function name (without the
817 arg list/class qualifications). Otherwise, return NULL. */
819 gdb::unique_xmalloc_ptr
<char>
820 cp_func_name (const char *full_name
)
822 gdb::unique_xmalloc_ptr
<char> ret
;
823 struct demangle_component
*ret_comp
;
824 std::unique_ptr
<demangle_parse_info
> info
;
826 info
= cp_demangled_name_to_comp (full_name
, NULL
);
830 ret_comp
= unqualified_name_from_comp (info
->tree
);
832 if (ret_comp
!= NULL
)
833 ret
= cp_comp_to_string (ret_comp
, 10);
838 /* Helper for cp_remove_params. DEMANGLED_NAME is the name of a
839 function, including parameters and (optionally) a return type.
840 Return the name of the function without parameters or return type,
841 or NULL if we can not parse the name. If REQUIRE_PARAMS is false,
842 then tolerate a non-existing or unbalanced parameter list. */
844 static gdb::unique_xmalloc_ptr
<char>
845 cp_remove_params_1 (const char *demangled_name
, bool require_params
)
848 struct demangle_component
*ret_comp
;
849 std::unique_ptr
<demangle_parse_info
> info
;
850 gdb::unique_xmalloc_ptr
<char> ret
;
852 if (demangled_name
== NULL
)
855 info
= cp_demangled_name_to_comp (demangled_name
, NULL
);
859 /* First strip off any qualifiers, if we have a function or method. */
860 ret_comp
= info
->tree
;
862 switch (ret_comp
->type
)
864 case DEMANGLE_COMPONENT_CONST
:
865 case DEMANGLE_COMPONENT_RESTRICT
:
866 case DEMANGLE_COMPONENT_VOLATILE
:
867 case DEMANGLE_COMPONENT_CONST_THIS
:
868 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
869 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
870 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
871 ret_comp
= d_left (ret_comp
);
878 /* What we have now should be a function. Return its name. */
879 if (ret_comp
->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
880 ret
= cp_comp_to_string (d_left (ret_comp
), 10);
881 else if (!require_params
882 && (ret_comp
->type
== DEMANGLE_COMPONENT_NAME
883 || ret_comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
884 || ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
))
885 ret
= cp_comp_to_string (ret_comp
, 10);
890 /* DEMANGLED_NAME is the name of a function, including parameters and
891 (optionally) a return type. Return the name of the function
892 without parameters or return type, or NULL if we can not parse the
895 gdb::unique_xmalloc_ptr
<char>
896 cp_remove_params (const char *demangled_name
)
898 return cp_remove_params_1 (demangled_name
, true);
901 /* See cp-support.h. */
903 gdb::unique_xmalloc_ptr
<char>
904 cp_remove_params_if_any (const char *demangled_name
, bool completion_mode
)
906 /* Trying to remove parameters from the empty string fails. If
907 we're completing / matching everything, avoid returning NULL
908 which would make callers interpret the result as an error. */
909 if (demangled_name
[0] == '\0' && completion_mode
)
910 return make_unique_xstrdup ("");
912 gdb::unique_xmalloc_ptr
<char> without_params
913 = cp_remove_params_1 (demangled_name
, false);
915 if (without_params
== NULL
&& completion_mode
)
917 std::string copy
= demangled_name
;
919 while (!copy
.empty ())
922 without_params
= cp_remove_params_1 (copy
.c_str (), false);
923 if (without_params
!= NULL
)
928 return without_params
;
931 /* Here are some random pieces of trivia to keep in mind while trying
932 to take apart demangled names:
934 - Names can contain function arguments or templates, so the process
935 has to be, to some extent recursive: maybe keep track of your
936 depth based on encountering <> and ().
938 - Parentheses don't just have to happen at the end of a name: they
939 can occur even if the name in question isn't a function, because
940 a template argument might be a type that's a function.
942 - Conversely, even if you're trying to deal with a function, its
943 demangled name might not end with ')': it could be a const or
944 volatile class method, in which case it ends with "const" or
947 - Parentheses are also used in anonymous namespaces: a variable
948 'foo' in an anonymous namespace gets demangled as "(anonymous
951 - And operator names can contain parentheses or angle brackets. */
953 /* FIXME: carlton/2003-03-13: We have several functions here with
954 overlapping functionality; can we combine them? Also, do they
955 handle all the above considerations correctly? */
958 /* This returns the length of first component of NAME, which should be
959 the demangled name of a C++ variable/function/method/etc.
960 Specifically, it returns the index of the first colon forming the
961 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
962 it returns the 1, and given 'foo', it returns 0. */
964 /* The character in NAME indexed by the return value is guaranteed to
965 always be either ':' or '\0'. */
967 /* NOTE: carlton/2003-03-13: This function is currently only intended
968 for internal use: it's probably not entirely safe when called on
969 user-generated input, because some of the 'index += 2' lines in
970 cp_find_first_component_aux might go past the end of malformed
974 cp_find_first_component (const char *name
)
976 return cp_find_first_component_aux (name
, 0);
979 /* Helper function for cp_find_first_component. Like that function,
980 it returns the length of the first component of NAME, but to make
981 the recursion easier, it also stops if it reaches an unexpected ')'
982 or '>' if the value of PERMISSIVE is nonzero. */
985 cp_find_first_component_aux (const char *name
, int permissive
)
987 unsigned int index
= 0;
988 /* Operator names can show up in unexpected places. Since these can
989 contain parentheses or angle brackets, they can screw up the
990 recursion. But not every string 'operator' is part of an
991 operator name: e.g. you could have a variable 'cooperator'. So
992 this variable tells us whether or not we should treat the string
993 'operator' as starting an operator. */
994 int operator_possible
= 1;
1001 /* Template; eat it up. The calls to cp_first_component
1002 should only return (I hope!) when they reach the '>'
1003 terminating the component or a '::' between two
1004 components. (Hence the '+ 2'.) */
1006 for (index
+= cp_find_first_component_aux (name
+ index
, 1);
1008 index
+= cp_find_first_component_aux (name
+ index
, 1))
1010 if (name
[index
] != ':')
1012 demangled_name_complaint (name
);
1013 return strlen (name
);
1017 operator_possible
= 1;
1020 /* Similar comment as to '<'. */
1022 for (index
+= cp_find_first_component_aux (name
+ index
, 1);
1024 index
+= cp_find_first_component_aux (name
+ index
, 1))
1026 if (name
[index
] != ':')
1028 demangled_name_complaint (name
);
1029 return strlen (name
);
1033 operator_possible
= 1;
1041 demangled_name_complaint (name
);
1042 return strlen (name
);
1047 /* ':' marks a component iff the next character is also a ':'.
1048 Otherwise it is probably malformed input. */
1049 if (name
[index
+ 1] == ':')
1053 /* Operator names can screw up the recursion. */
1054 if (operator_possible
1055 && startswith (name
+ index
, CP_OPERATOR_STR
))
1057 index
+= CP_OPERATOR_LEN
;
1058 while (ISSPACE(name
[index
]))
1060 switch (name
[index
])
1064 /* Skip over one less than the appropriate number of
1065 characters: the for loop will skip over the last
1068 if (name
[index
+ 1] == '<')
1075 if (name
[index
+ 1] == '>')
1088 operator_possible
= 0;
1095 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1096 set of relevant characters are here: it's necessary to
1097 include any character that can show up before 'operator'
1098 in a demangled name, and it's safe to include any
1099 character that can't be part of an identifier's name. */
1100 operator_possible
= 1;
1103 operator_possible
= 0;
1109 /* Complain about a demangled name that we don't know how to parse.
1110 NAME is the demangled name in question. */
1113 demangled_name_complaint (const char *name
)
1115 complaint ("unexpected demangled name '%s'", name
);
1118 /* If NAME is the fully-qualified name of a C++
1119 function/variable/method/etc., this returns the length of its
1120 entire prefix: all of the namespaces and classes that make up its
1121 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1122 4, given 'foo', it returns 0. */
1125 cp_entire_prefix_len (const char *name
)
1127 unsigned int current_len
= cp_find_first_component (name
);
1128 unsigned int previous_len
= 0;
1130 while (name
[current_len
] != '\0')
1132 gdb_assert (name
[current_len
] == ':');
1133 previous_len
= current_len
;
1134 /* Skip the '::'. */
1136 current_len
+= cp_find_first_component (name
+ current_len
);
1139 return previous_len
;
1142 /* Overload resolution functions. */
1144 /* Test to see if SYM is a symbol that we haven't seen corresponding
1145 to a function named OLOAD_NAME. If so, add it to
1149 overload_list_add_symbol (struct symbol
*sym
,
1150 const char *oload_name
,
1151 std::vector
<symbol
*> *overload_list
)
1153 /* If there is no type information, we can't do anything, so
1155 if (SYMBOL_TYPE (sym
) == NULL
)
1158 /* skip any symbols that we've already considered. */
1159 for (symbol
*listed_sym
: *overload_list
)
1160 if (strcmp (sym
->linkage_name (), listed_sym
->linkage_name ()) == 0)
1163 /* Get the demangled name without parameters */
1164 gdb::unique_xmalloc_ptr
<char> sym_name
1165 = cp_remove_params (sym
->natural_name ());
1169 /* skip symbols that cannot match */
1170 if (strcmp (sym_name
.get (), oload_name
) != 0)
1173 overload_list
->push_back (sym
);
1176 /* Return a null-terminated list of pointers to function symbols that
1177 are named FUNC_NAME and are visible within NAMESPACE. */
1179 struct std::vector
<symbol
*>
1180 make_symbol_overload_list (const char *func_name
,
1181 const char *the_namespace
)
1184 std::vector
<symbol
*> overload_list
;
1186 overload_list
.reserve (100);
1188 add_symbol_overload_list_using (func_name
, the_namespace
, &overload_list
);
1190 if (the_namespace
[0] == '\0')
1194 char *concatenated_name
1195 = (char *) alloca (strlen (the_namespace
) + 2 + strlen (func_name
) + 1);
1196 strcpy (concatenated_name
, the_namespace
);
1197 strcat (concatenated_name
, "::");
1198 strcat (concatenated_name
, func_name
);
1199 name
= concatenated_name
;
1202 add_symbol_overload_list_qualified (name
, &overload_list
);
1203 return overload_list
;
1206 /* Add all symbols with a name matching NAME in BLOCK to the overload
1210 add_symbol_overload_list_block (const char *name
,
1211 const struct block
*block
,
1212 std::vector
<symbol
*> *overload_list
)
1214 struct block_iterator iter
;
1217 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
1219 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, lookup_name
, iter
, sym
)
1220 overload_list_add_symbol (sym
, name
, overload_list
);
1223 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1226 add_symbol_overload_list_namespace (const char *func_name
,
1227 const char *the_namespace
,
1228 std::vector
<symbol
*> *overload_list
)
1231 const struct block
*block
= NULL
;
1233 if (the_namespace
[0] == '\0')
1237 char *concatenated_name
1238 = (char *) alloca (strlen (the_namespace
) + 2 + strlen (func_name
) + 1);
1240 strcpy (concatenated_name
, the_namespace
);
1241 strcat (concatenated_name
, "::");
1242 strcat (concatenated_name
, func_name
);
1243 name
= concatenated_name
;
1246 /* Look in the static block. */
1247 block
= block_static_block (get_selected_block (0));
1249 add_symbol_overload_list_block (name
, block
, overload_list
);
1251 /* Look in the global block. */
1252 block
= block_global_block (block
);
1254 add_symbol_overload_list_block (name
, block
, overload_list
);
1258 /* Search the namespace of the given type and namespace of and public
1262 add_symbol_overload_list_adl_namespace (struct type
*type
,
1263 const char *func_name
,
1264 std::vector
<symbol
*> *overload_list
)
1266 char *the_namespace
;
1267 const char *type_name
;
1270 while (TYPE_CODE (type
) == TYPE_CODE_PTR
1271 || TYPE_IS_REFERENCE (type
)
1272 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1273 || TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1275 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1276 type
= check_typedef(type
);
1278 type
= TYPE_TARGET_TYPE (type
);
1281 type_name
= TYPE_NAME (type
);
1283 if (type_name
== NULL
)
1286 prefix_len
= cp_entire_prefix_len (type_name
);
1288 if (prefix_len
!= 0)
1290 the_namespace
= (char *) alloca (prefix_len
+ 1);
1291 strncpy (the_namespace
, type_name
, prefix_len
);
1292 the_namespace
[prefix_len
] = '\0';
1294 add_symbol_overload_list_namespace (func_name
, the_namespace
,
1298 /* Check public base type */
1299 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1300 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1302 if (BASETYPE_VIA_PUBLIC (type
, i
))
1303 add_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type
, i
),
1309 /* Adds to OVERLOAD_LIST the overload list overload candidates for
1310 FUNC_NAME found through argument dependent lookup. */
1313 add_symbol_overload_list_adl (gdb::array_view
<type
*> arg_types
,
1314 const char *func_name
,
1315 std::vector
<symbol
*> *overload_list
)
1317 for (type
*arg_type
: arg_types
)
1318 add_symbol_overload_list_adl_namespace (arg_type
, func_name
,
1322 /* This applies the using directives to add namespaces to search in,
1323 and then searches for overloads in all of those namespaces. It
1324 adds the symbols found to sym_return_val. Arguments are as in
1325 make_symbol_overload_list. */
1328 add_symbol_overload_list_using (const char *func_name
,
1329 const char *the_namespace
,
1330 std::vector
<symbol
*> *overload_list
)
1332 struct using_direct
*current
;
1333 const struct block
*block
;
1335 /* First, go through the using directives. If any of them apply,
1336 look in the appropriate namespaces for new functions to match
1339 for (block
= get_selected_block (0);
1341 block
= BLOCK_SUPERBLOCK (block
))
1342 for (current
= block_using (block
);
1344 current
= current
->next
)
1346 /* Prevent recursive calls. */
1347 if (current
->searched
)
1350 /* If this is a namespace alias or imported declaration ignore
1352 if (current
->alias
!= NULL
|| current
->declaration
!= NULL
)
1355 if (strcmp (the_namespace
, current
->import_dest
) == 0)
1357 /* Mark this import as searched so that the recursive call
1358 does not search it again. */
1359 scoped_restore reset_directive_searched
1360 = make_scoped_restore (¤t
->searched
, 1);
1362 add_symbol_overload_list_using (func_name
,
1363 current
->import_src
,
1368 /* Now, add names for this namespace. */
1369 add_symbol_overload_list_namespace (func_name
, the_namespace
,
1373 /* This does the bulk of the work of finding overloaded symbols.
1374 FUNC_NAME is the name of the overloaded function we're looking for
1375 (possibly including namespace info). */
1378 add_symbol_overload_list_qualified (const char *func_name
,
1379 std::vector
<symbol
*> *overload_list
)
1381 const struct block
*b
, *surrounding_static_block
= 0;
1383 /* Look through the partial symtabs for all symbols which begin by
1384 matching FUNC_NAME. Make sure we read that symbol table in. */
1386 for (objfile
*objf
: current_program_space
->objfiles ())
1389 objf
->sf
->qf
->expand_symtabs_for_function (objf
, func_name
);
1392 /* Search upwards from currently selected frame (so that we can
1393 complete on local vars. */
1395 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
1396 add_symbol_overload_list_block (func_name
, b
, overload_list
);
1398 surrounding_static_block
= block_static_block (get_selected_block (0));
1400 /* Go through the symtabs and check the externs and statics for
1401 symbols which match. */
1403 for (objfile
*objfile
: current_program_space
->objfiles ())
1405 for (compunit_symtab
*cust
: objfile
->compunits ())
1408 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), GLOBAL_BLOCK
);
1409 add_symbol_overload_list_block (func_name
, b
, overload_list
);
1413 for (objfile
*objfile
: current_program_space
->objfiles ())
1415 for (compunit_symtab
*cust
: objfile
->compunits ())
1418 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), STATIC_BLOCK
);
1419 /* Don't do this block twice. */
1420 if (b
== surrounding_static_block
)
1422 add_symbol_overload_list_block (func_name
, b
, overload_list
);
1427 /* Lookup the rtti type for a class name. */
1430 cp_lookup_rtti_type (const char *name
, const struct block
*block
)
1432 struct symbol
* rtti_sym
;
1433 struct type
* rtti_type
;
1435 /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
1436 Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
1437 rtti_sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, NULL
).symbol
;
1439 if (rtti_sym
== NULL
)
1441 warning (_("RTTI symbol not found for class '%s'"), name
);
1445 if (SYMBOL_CLASS (rtti_sym
) != LOC_TYPEDEF
)
1447 warning (_("RTTI symbol for class '%s' is not a type"), name
);
1451 rtti_type
= check_typedef (SYMBOL_TYPE (rtti_sym
));
1453 switch (TYPE_CODE (rtti_type
))
1455 case TYPE_CODE_STRUCT
:
1457 case TYPE_CODE_NAMESPACE
:
1458 /* chastain/2003-11-26: the symbol tables often contain fake
1459 symbols for namespaces with the same name as the struct.
1460 This warning is an indication of a bug in the lookup order
1461 or a bug in the way that the symbol tables are populated. */
1462 warning (_("RTTI symbol for class '%s' is a namespace"), name
);
1465 warning (_("RTTI symbol for class '%s' has bad type"), name
);
1472 #ifdef HAVE_WORKING_FORK
1474 /* If true, attempt to catch crashes in the demangler and print
1475 useful debugging information. */
1477 static bool catch_demangler_crashes
= true;
1479 /* Stack context and environment for demangler crash recovery. */
1481 static thread_local SIGJMP_BUF
*gdb_demangle_jmp_buf
;
1483 /* If true, attempt to dump core from the signal handler. */
1485 static std::atomic
<bool> gdb_demangle_attempt_core_dump
;
1487 /* Signal handler for gdb_demangle. */
1490 gdb_demangle_signal_handler (int signo
)
1492 if (gdb_demangle_attempt_core_dump
)
1497 gdb_demangle_attempt_core_dump
= false;
1500 SIGLONGJMP (*gdb_demangle_jmp_buf
, signo
);
1503 /* A helper for gdb_demangle that reports a demangling failure. */
1506 report_failed_demangle (const char *name
, bool core_dump_allowed
,
1509 static bool error_reported
= false;
1511 if (!error_reported
)
1513 std::string short_msg
1514 = string_printf (_("unable to demangle '%s' "
1515 "(demangler failed with signal %d)"),
1516 name
, crash_signal
);
1518 std::string long_msg
1519 = string_printf ("%s:%d: %s: %s", __FILE__
, __LINE__
,
1520 "demangler-warning", short_msg
.c_str ());
1522 target_terminal::scoped_restore_terminal_state term_state
;
1523 target_terminal::ours_for_output ();
1526 if (core_dump_allowed
)
1527 fprintf_unfiltered (gdb_stderr
,
1528 _("%s\nAttempting to dump core.\n"),
1531 warn_cant_dump_core (long_msg
.c_str ());
1533 demangler_warning (__FILE__
, __LINE__
, "%s", short_msg
.c_str ());
1535 error_reported
= true;
1541 /* A wrapper for bfd_demangle. */
1544 gdb_demangle (const char *name
, int options
)
1546 char *result
= NULL
;
1547 int crash_signal
= 0;
1549 #ifdef HAVE_WORKING_FORK
1550 scoped_restore restore_segv
1551 = make_scoped_restore (&thread_local_segv_handler
,
1552 catch_demangler_crashes
1553 ? gdb_demangle_signal_handler
1556 bool core_dump_allowed
= gdb_demangle_attempt_core_dump
;
1558 scoped_restore restore_jmp_buf
1559 = make_scoped_restore (&gdb_demangle_jmp_buf
, &jmp_buf);
1560 if (catch_demangler_crashes
)
1562 /* The signal handler may keep the signal blocked when we longjmp out
1563 of it. If we have sigprocmask, we can use it to unblock the signal
1564 afterwards and we can avoid the performance overhead of saving the
1565 signal mask just in case the signal gets triggered. Otherwise, just
1566 tell sigsetjmp to save the mask. */
1567 #ifdef HAVE_SIGPROCMASK
1568 crash_signal
= SIGSETJMP (*gdb_demangle_jmp_buf
, 0);
1570 crash_signal
= SIGSETJMP (*gdb_demangle_jmp_buf
, 1);
1575 if (crash_signal
== 0)
1576 result
= bfd_demangle (NULL
, name
, options
);
1578 #ifdef HAVE_WORKING_FORK
1579 if (catch_demangler_crashes
)
1581 if (crash_signal
!= 0)
1583 #ifdef HAVE_SIGPROCMASK
1584 /* If we got the signal, SIGSEGV may still be blocked; restore it. */
1585 sigset_t segv_sig_set
;
1586 sigemptyset (&segv_sig_set
);
1587 sigaddset (&segv_sig_set
, SIGSEGV
);
1588 gdb_sigmask (SIG_UNBLOCK
, &segv_sig_set
, NULL
);
1591 /* If there was a failure, we can't report it here, because
1592 we might be in a background thread. Instead, arrange for
1593 the reporting to happen on the main thread. */
1594 std::string copy
= name
;
1595 run_on_main_thread ([=] ()
1597 report_failed_demangle (copy
.c_str (), core_dump_allowed
,
1609 /* See cp-support.h. */
1612 gdb_sniff_from_mangled_name (const char *mangled
, char **demangled
)
1614 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
1615 return *demangled
!= NULL
;
1618 /* See cp-support.h. */
1621 cp_search_name_hash (const char *search_name
)
1623 /* cp_entire_prefix_len assumes a fully-qualified name with no
1625 if (startswith (search_name
, "::"))
1628 unsigned int prefix_len
= cp_entire_prefix_len (search_name
);
1629 if (prefix_len
!= 0)
1630 search_name
+= prefix_len
+ 2;
1632 unsigned int hash
= 0;
1633 for (const char *string
= search_name
; *string
!= '\0'; ++string
)
1635 string
= skip_spaces (string
);
1640 /* Ignore ABI tags such as "[abi:cxx11]. */
1642 && startswith (string
+ 1, "abi:")
1643 && string
[5] != ':')
1646 hash
= SYMBOL_HASH_NEXT (hash
, *string
);
1651 /* Helper for cp_symbol_name_matches (i.e., symbol_name_matcher_ftype
1652 implementation for symbol_name_match_type::WILD matching). Split
1653 to a separate function for unit-testing convenience.
1655 If SYMBOL_SEARCH_NAME has more scopes than LOOKUP_NAME, we try to
1656 match ignoring the extra leading scopes of SYMBOL_SEARCH_NAME.
1657 This allows conveniently setting breakpoints on functions/methods
1658 inside any namespace/class without specifying the fully-qualified
1663 [symbol search name] [lookup name]
1664 foo::bar::func foo::bar::func
1665 foo::bar::func bar::func
1670 [symbol search name] [lookup name]
1671 foo::zbar::func bar::func
1672 foo::bar::func foo::func
1674 See more examples in the test_cp_symbol_name_matches selftest
1677 See symbol_name_matcher_ftype for description of SYMBOL_SEARCH_NAME
1680 LOOKUP_NAME/LOOKUP_NAME_LEN is the name we're looking up.
1682 See strncmp_iw_with_mode for description of MODE.
1686 cp_symbol_name_matches_1 (const char *symbol_search_name
,
1687 const char *lookup_name
,
1688 size_t lookup_name_len
,
1689 strncmp_iw_mode mode
,
1690 completion_match_result
*comp_match_res
)
1692 const char *sname
= symbol_search_name
;
1693 completion_match_for_lcd
*match_for_lcd
1694 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
1698 if (strncmp_iw_with_mode (sname
, lookup_name
, lookup_name_len
,
1699 mode
, language_cplus
, match_for_lcd
) == 0)
1701 if (comp_match_res
!= NULL
)
1703 /* Note here we set different MATCH and MATCH_FOR_LCD
1704 strings. This is because with
1706 (gdb) b push_bac[TAB]
1708 we want the completion matches to list
1710 std::vector<int>::push_back(...)
1711 std::vector<char>::push_back(...)
1713 etc., which are SYMBOL_SEARCH_NAMEs, while we want
1714 the input line to auto-complete to
1716 (gdb) push_back(...)
1718 which is SNAME, not to
1722 which would be the regular common prefix between all
1723 the matches otherwise. */
1724 comp_match_res
->set_match (symbol_search_name
, sname
);
1729 unsigned int len
= cp_find_first_component (sname
);
1731 if (sname
[len
] == '\0')
1734 gdb_assert (sname
[len
] == ':');
1735 /* Skip the '::'. */
1740 /* C++ symbol_name_matcher_ftype implementation. */
1743 cp_fq_symbol_name_matches (const char *symbol_search_name
,
1744 const lookup_name_info
&lookup_name
,
1745 completion_match_result
*comp_match_res
)
1747 /* Get the demangled name. */
1748 const std::string
&name
= lookup_name
.cplus ().lookup_name ();
1749 completion_match_for_lcd
*match_for_lcd
1750 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
1751 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
1752 ? strncmp_iw_mode::NORMAL
1753 : strncmp_iw_mode::MATCH_PARAMS
);
1755 if (strncmp_iw_with_mode (symbol_search_name
,
1756 name
.c_str (), name
.size (),
1757 mode
, language_cplus
, match_for_lcd
) == 0)
1759 if (comp_match_res
!= NULL
)
1760 comp_match_res
->set_match (symbol_search_name
);
1767 /* C++ symbol_name_matcher_ftype implementation for wild matches.
1768 Defers work to cp_symbol_name_matches_1. */
1771 cp_symbol_name_matches (const char *symbol_search_name
,
1772 const lookup_name_info
&lookup_name
,
1773 completion_match_result
*comp_match_res
)
1775 /* Get the demangled name. */
1776 const std::string
&name
= lookup_name
.cplus ().lookup_name ();
1778 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
1779 ? strncmp_iw_mode::NORMAL
1780 : strncmp_iw_mode::MATCH_PARAMS
);
1782 return cp_symbol_name_matches_1 (symbol_search_name
,
1783 name
.c_str (), name
.size (),
1784 mode
, comp_match_res
);
1787 /* See cp-support.h. */
1789 symbol_name_matcher_ftype
*
1790 cp_get_symbol_name_matcher (const lookup_name_info
&lookup_name
)
1792 switch (lookup_name
.match_type ())
1794 case symbol_name_match_type::FULL
:
1795 case symbol_name_match_type::EXPRESSION
:
1796 case symbol_name_match_type::SEARCH_NAME
:
1797 return cp_fq_symbol_name_matches
;
1798 case symbol_name_match_type::WILD
:
1799 return cp_symbol_name_matches
;
1802 gdb_assert_not_reached ("");
1807 namespace selftests
{
1810 test_cp_symbol_name_matches ()
1812 #define CHECK_MATCH(SYMBOL, INPUT) \
1813 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, \
1814 INPUT, sizeof (INPUT) - 1, \
1815 strncmp_iw_mode::MATCH_PARAMS, \
1818 #define CHECK_NOT_MATCH(SYMBOL, INPUT) \
1819 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, \
1820 INPUT, sizeof (INPUT) - 1, \
1821 strncmp_iw_mode::MATCH_PARAMS, \
1824 /* Like CHECK_MATCH, and also check that INPUT (and all substrings
1825 that start at index 0) completes to SYMBOL. */
1826 #define CHECK_MATCH_C(SYMBOL, INPUT) \
1829 CHECK_MATCH (SYMBOL, INPUT); \
1830 for (size_t i = 0; i < sizeof (INPUT) - 1; i++) \
1831 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, INPUT, i, \
1832 strncmp_iw_mode::NORMAL, \
1836 /* Like CHECK_NOT_MATCH, and also check that INPUT does NOT complete
1838 #define CHECK_NOT_MATCH_C(SYMBOL, INPUT) \
1841 CHECK_NOT_MATCH (SYMBOL, INPUT); \
1842 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, INPUT, \
1843 sizeof (INPUT) - 1, \
1844 strncmp_iw_mode::NORMAL, \
1848 /* Lookup name without parens matches all overloads. */
1849 CHECK_MATCH_C ("function()", "function");
1850 CHECK_MATCH_C ("function(int)", "function");
1852 /* Check whitespace around parameters is ignored. */
1853 CHECK_MATCH_C ("function()", "function ()");
1854 CHECK_MATCH_C ("function ( )", "function()");
1855 CHECK_MATCH_C ("function ()", "function( )");
1856 CHECK_MATCH_C ("func(int)", "func( int )");
1857 CHECK_MATCH_C ("func(int)", "func ( int ) ");
1858 CHECK_MATCH_C ("func ( int )", "func( int )");
1859 CHECK_MATCH_C ("func ( int )", "func ( int ) ");
1861 /* Check symbol name prefixes aren't incorrectly matched. */
1862 CHECK_NOT_MATCH ("func", "function");
1863 CHECK_NOT_MATCH ("function", "func");
1864 CHECK_NOT_MATCH ("function()", "func");
1866 /* Check that if the lookup name includes parameters, only the right
1867 overload matches. */
1868 CHECK_MATCH_C ("function(int)", "function(int)");
1869 CHECK_NOT_MATCH_C ("function(int)", "function()");
1871 /* Check that whitespace within symbol names is not ignored. */
1872 CHECK_NOT_MATCH_C ("function", "func tion");
1873 CHECK_NOT_MATCH_C ("func__tion", "func_ _tion");
1874 CHECK_NOT_MATCH_C ("func11tion", "func1 1tion");
1876 /* Check the converse, which can happen with template function,
1877 where the return type is part of the demangled name. */
1878 CHECK_NOT_MATCH_C ("func tion", "function");
1879 CHECK_NOT_MATCH_C ("func1 1tion", "func11tion");
1880 CHECK_NOT_MATCH_C ("func_ _tion", "func__tion");
1882 /* Within parameters too. */
1883 CHECK_NOT_MATCH_C ("func(param)", "func(par am)");
1885 /* Check handling of whitespace around C++ operators. */
1886 CHECK_NOT_MATCH_C ("operator<<", "opera tor<<");
1887 CHECK_NOT_MATCH_C ("operator<<", "operator< <");
1888 CHECK_NOT_MATCH_C ("operator<<", "operator < <");
1889 CHECK_NOT_MATCH_C ("operator==", "operator= =");
1890 CHECK_NOT_MATCH_C ("operator==", "operator = =");
1891 CHECK_MATCH_C ("operator<<", "operator <<");
1892 CHECK_MATCH_C ("operator<<()", "operator <<");
1893 CHECK_NOT_MATCH_C ("operator<<()", "operator<<(int)");
1894 CHECK_NOT_MATCH_C ("operator<<(int)", "operator<<()");
1895 CHECK_MATCH_C ("operator==", "operator ==");
1896 CHECK_MATCH_C ("operator==()", "operator ==");
1897 CHECK_MATCH_C ("operator <<", "operator<<");
1898 CHECK_MATCH_C ("operator ==", "operator==");
1899 CHECK_MATCH_C ("operator bool", "operator bool");
1900 CHECK_MATCH_C ("operator bool ()", "operator bool");
1901 CHECK_MATCH_C ("operatorX<<", "operatorX < <");
1902 CHECK_MATCH_C ("Xoperator<<", "Xoperator < <");
1904 CHECK_MATCH_C ("operator()(int)", "operator()(int)");
1905 CHECK_MATCH_C ("operator()(int)", "operator ( ) ( int )");
1906 CHECK_MATCH_C ("operator()<long>(int)", "operator ( ) < long > ( int )");
1907 /* The first "()" is not the parameter list. */
1908 CHECK_NOT_MATCH ("operator()(int)", "operator");
1910 /* Misc user-defined operator tests. */
1912 CHECK_NOT_MATCH_C ("operator/=()", "operator ^=");
1913 /* Same length at end of input. */
1914 CHECK_NOT_MATCH_C ("operator>>", "operator[]");
1915 /* Same length but not at end of input. */
1916 CHECK_NOT_MATCH_C ("operator>>()", "operator[]()");
1918 CHECK_MATCH_C ("base::operator char*()", "base::operator char*()");
1919 CHECK_MATCH_C ("base::operator char*()", "base::operator char * ()");
1920 CHECK_MATCH_C ("base::operator char**()", "base::operator char * * ()");
1921 CHECK_MATCH ("base::operator char**()", "base::operator char * *");
1922 CHECK_MATCH_C ("base::operator*()", "base::operator*()");
1923 CHECK_NOT_MATCH_C ("base::operator char*()", "base::operatorc");
1924 CHECK_NOT_MATCH ("base::operator char*()", "base::operator char");
1925 CHECK_NOT_MATCH ("base::operator char*()", "base::operat");
1927 /* Check handling of whitespace around C++ scope operators. */
1928 CHECK_NOT_MATCH_C ("foo::bar", "foo: :bar");
1929 CHECK_MATCH_C ("foo::bar", "foo :: bar");
1930 CHECK_MATCH_C ("foo :: bar", "foo::bar");
1932 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi()");
1933 CHECK_MATCH_C ("abc::def::ghi ( )", "abc::def::ghi()");
1934 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi ( )");
1935 CHECK_MATCH_C ("function()", "function()");
1936 CHECK_MATCH_C ("bar::function()", "bar::function()");
1938 /* Wild matching tests follow. */
1940 /* Tests matching symbols in some scope. */
1941 CHECK_MATCH_C ("foo::function()", "function");
1942 CHECK_MATCH_C ("foo::function(int)", "function");
1943 CHECK_MATCH_C ("foo::bar::function()", "function");
1944 CHECK_MATCH_C ("bar::function()", "bar::function");
1945 CHECK_MATCH_C ("foo::bar::function()", "bar::function");
1946 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function");
1948 /* Same, with parameters in the lookup name. */
1949 CHECK_MATCH_C ("foo::function()", "function()");
1950 CHECK_MATCH_C ("foo::bar::function()", "function()");
1951 CHECK_MATCH_C ("foo::function(int)", "function(int)");
1952 CHECK_MATCH_C ("foo::function()", "foo::function()");
1953 CHECK_MATCH_C ("foo::bar::function()", "bar::function()");
1954 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function(int)");
1955 CHECK_MATCH_C ("bar::function()", "bar::function()");
1957 CHECK_NOT_MATCH_C ("foo::bar::function(int)", "bar::function()");
1959 CHECK_MATCH_C ("(anonymous namespace)::bar::function(int)",
1960 "bar::function(int)");
1961 CHECK_MATCH_C ("foo::(anonymous namespace)::bar::function(int)",
1964 /* Lookup scope wider than symbol scope, should not match. */
1965 CHECK_NOT_MATCH_C ("function()", "bar::function");
1966 CHECK_NOT_MATCH_C ("function()", "bar::function()");
1968 /* Explicit global scope doesn't match. */
1969 CHECK_NOT_MATCH_C ("foo::function()", "::function");
1970 CHECK_NOT_MATCH_C ("foo::function()", "::function()");
1971 CHECK_NOT_MATCH_C ("foo::function(int)", "::function()");
1972 CHECK_NOT_MATCH_C ("foo::function(int)", "::function(int)");
1974 /* Test ABI tag matching/ignoring. */
1976 /* If the symbol name has an ABI tag, but the lookup name doesn't,
1977 then the ABI tag in the symbol name is ignored. */
1978 CHECK_MATCH_C ("function[abi:foo]()", "function");
1979 CHECK_MATCH_C ("function[abi:foo](int)", "function");
1980 CHECK_MATCH_C ("function[abi:foo]()", "function ()");
1981 CHECK_NOT_MATCH_C ("function[abi:foo]()", "function (int)");
1983 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo]");
1984 CHECK_MATCH_C ("function[abi:foo](int)", "function[abi:foo]");
1985 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo] ()");
1986 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function");
1987 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function");
1988 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo]");
1989 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function[abi:foo]");
1990 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] ()");
1991 CHECK_NOT_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] (int)");
1993 CHECK_MATCH_C ("function [abi:foo][abi:bar] ( )", "function [abi:foo]");
1995 /* If the symbol name does not have an ABI tag, while the lookup
1996 name has one, then there's no match. */
1997 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]()");
1998 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]");
2001 /* If non-NULL, return STR wrapped in quotes. Otherwise, return a
2002 "<null>" string (with no quotes). */
2005 quote (const char *str
)
2008 return std::string (1, '"') + str
+ '"';
2013 /* Check that removing parameter info out of NAME produces EXPECTED.
2014 COMPLETION_MODE indicates whether we're testing normal and
2015 completion mode. FILE and LINE are used to provide better test
2016 location information in case ithe check fails. */
2019 check_remove_params (const char *file
, int line
,
2020 const char *name
, const char *expected
,
2021 bool completion_mode
)
2023 gdb::unique_xmalloc_ptr
<char> result
2024 = cp_remove_params_if_any (name
, completion_mode
);
2026 if ((expected
== NULL
) != (result
== NULL
)
2027 || (expected
!= NULL
2028 && strcmp (result
.get (), expected
) != 0))
2030 error (_("%s:%d: make-paramless self-test failed: (completion=%d) "
2031 "\"%s\" -> %s, expected %s"),
2032 file
, line
, completion_mode
, name
,
2033 quote (result
.get ()).c_str (), quote (expected
).c_str ());
2037 /* Entry point for cp_remove_params unit tests. */
2040 test_cp_remove_params ()
2042 /* Check that removing parameter info out of NAME produces EXPECTED.
2043 Checks both normal and completion modes. */
2044 #define CHECK(NAME, EXPECTED) \
2047 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, false); \
2048 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2052 /* Similar, but used when NAME is incomplete -- i.e., is has
2053 unbalanced parentheses. In this case, looking for the exact name
2054 should fail / return empty. */
2055 #define CHECK_INCOMPL(NAME, EXPECTED) \
2058 check_remove_params (__FILE__, __LINE__, NAME, NULL, false); \
2059 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2063 CHECK ("function()", "function");
2064 CHECK_INCOMPL ("function(", "function");
2065 CHECK ("function() const", "function");
2067 CHECK ("(anonymous namespace)::A::B::C",
2068 "(anonymous namespace)::A::B::C");
2070 CHECK ("A::(anonymous namespace)",
2071 "A::(anonymous namespace)");
2073 CHECK_INCOMPL ("A::(anonymou", "A");
2075 CHECK ("A::foo<int>()",
2078 CHECK_INCOMPL ("A::foo<int>(",
2081 CHECK ("A::foo<(anonymous namespace)::B>::func(int)",
2082 "A::foo<(anonymous namespace)::B>::func");
2084 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::func(in",
2085 "A::foo<(anonymous namespace)::B>::func");
2087 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::",
2088 "A::foo<(anonymous namespace)::B>");
2090 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>:",
2091 "A::foo<(anonymous namespace)::B>");
2093 CHECK ("A::foo<(anonymous namespace)::B>",
2094 "A::foo<(anonymous namespace)::B>");
2096 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B",
2099 /* Shouldn't this parse? Looks like a bug in
2100 cp_demangled_name_to_comp. See PR c++/22411. */
2102 CHECK ("A::foo<void(int)>::func(int)",
2103 "A::foo<void(int)>::func");
2105 CHECK_INCOMPL ("A::foo<void(int)>::func(int)",
2109 CHECK_INCOMPL ("A::foo<void(int",
2113 #undef CHECK_INCOMPL
2116 } // namespace selftests
2118 #endif /* GDB_SELF_CHECK */
2120 /* This is a front end for cp_find_first_component, for unit testing.
2121 Be careful when using it: see the NOTE above
2122 cp_find_first_component. */
2125 first_component_command (const char *arg
, int from_tty
)
2133 len
= cp_find_first_component (arg
);
2134 prefix
= (char *) alloca (len
+ 1);
2136 memcpy (prefix
, arg
, len
);
2139 printf_unfiltered ("%s\n", prefix
);
2142 /* Implement "info vtbl". */
2145 info_vtbl_command (const char *arg
, int from_tty
)
2147 struct value
*value
;
2149 value
= parse_and_eval (arg
);
2150 cplus_print_vtable (value
);
2153 void _initialize_cp_support ();
2155 _initialize_cp_support ()
2157 add_basic_prefix_cmd ("cplus", class_maintenance
,
2158 _("C++ maintenance commands."),
2159 &maint_cplus_cmd_list
,
2160 "maintenance cplus ",
2161 0, &maintenancelist
);
2162 add_alias_cmd ("cp", "cplus",
2163 class_maintenance
, 1,
2166 add_cmd ("first_component",
2168 first_component_command
,
2169 _("Print the first class/namespace component of NAME."),
2170 &maint_cplus_cmd_list
);
2172 add_info ("vtbl", info_vtbl_command
,
2173 _("Show the virtual function table for a C++ object.\n\
2174 Usage: info vtbl EXPRESSION\n\
2175 Evaluate EXPRESSION and display the virtual function table for the\n\
2176 resulting object."));
2178 #ifdef HAVE_WORKING_FORK
2179 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance
,
2180 &catch_demangler_crashes
, _("\
2181 Set whether to attempt to catch demangler crashes."), _("\
2182 Show whether to attempt to catch demangler crashes."), _("\
2183 If enabled GDB will attempt to catch demangler crashes and\n\
2184 display the offending symbol."),
2187 &maintenance_set_cmdlist
,
2188 &maintenance_show_cmdlist
);
2190 gdb_demangle_attempt_core_dump
= can_dump_core (LIMIT_CUR
);
2194 selftests::register_test ("cp_symbol_name_matches",
2195 selftests::test_cp_symbol_name_matches
);
2196 selftests::register_test ("cp_remove_params",
2197 selftests::test_cp_remove_params
);