1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2002-2021 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 (otype
->code () == TYPE_CODE_TYPEDEF
187 || otype
->code () == 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 () != nullptr
211 && strcmp (type
->name (), name
) == 0)
214 is_anon
= (type
->name () == NULL
215 && (type
->code () == TYPE_CODE_ENUM
216 || type
->code () == TYPE_CODE_STRUCT
217 || type
->code () == 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_TARGET_TYPE (last
)->code ()
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 /* Helper for replace_typedefs_qualified_name to handle
298 DEMANGLE_COMPONENT_TEMPLATE. TMPL is the template node. BUF is
299 the buffer that holds the qualified name being built by
300 replace_typedefs_qualified_name. REPL is the node that will be
301 rewritten as a DEMANGLE_COMPONENT_NAME node holding the 'template
302 plus template arguments' name with typedefs replaced. */
305 replace_typedefs_template (struct demangle_parse_info
*info
,
307 struct demangle_component
*tmpl
,
308 struct demangle_component
*repl
,
309 canonicalization_ftype
*finder
,
312 demangle_component
*tmpl_arglist
= d_right (tmpl
);
314 /* Replace typedefs in the template argument list. */
315 replace_typedefs (info
, tmpl_arglist
, finder
, data
);
317 /* Convert 'template + replaced template argument list' to a string
318 and replace the REPL node. */
319 gdb::unique_xmalloc_ptr
<char> tmpl_str
= cp_comp_to_string (tmpl
, 100);
320 if (tmpl_str
== nullptr)
322 /* If something went astray, abort typedef substitutions. */
325 buf
.puts (tmpl_str
.get ());
327 repl
->type
= DEMANGLE_COMPONENT_NAME
;
328 repl
->u
.s_name
.s
= obstack_strdup (&info
->obstack
, buf
.string ());
329 repl
->u
.s_name
.len
= buf
.size ();
333 /* Replace any typedefs appearing in the qualified name
334 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
338 replace_typedefs_qualified_name (struct demangle_parse_info
*info
,
339 struct demangle_component
*ret_comp
,
340 canonicalization_ftype
*finder
,
344 struct demangle_component
*comp
= ret_comp
;
346 /* Walk each node of the qualified name, reconstructing the name of
347 this element. With every node, check for any typedef substitutions.
348 If a substitution has occurred, replace the qualified name node
349 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
351 while (comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
)
353 if (d_left (comp
)->type
== DEMANGLE_COMPONENT_TEMPLATE
)
355 /* Convert 'template + replaced template argument list' to a
356 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
358 if (!replace_typedefs_template (info
, buf
,
359 d_left (comp
), d_left (ret_comp
),
364 d_right (ret_comp
) = d_right (comp
);
367 /* Fallback to DEMANGLE_COMPONENT_NAME processing. We want
368 to call inspect_type for this template, in case we have a
369 template alias, like:
370 template<typename T> using alias = base<int, t>;
371 in which case we want inspect_type to do a replacement like:
372 alias<int> -> base<int, int>
376 if (d_left (comp
)->type
== DEMANGLE_COMPONENT_NAME
)
378 struct demangle_component newobj
;
380 buf
.write (d_left (comp
)->u
.s_name
.s
, d_left (comp
)->u
.s_name
.len
);
381 newobj
.type
= DEMANGLE_COMPONENT_NAME
;
382 newobj
.u
.s_name
.s
= obstack_strdup (&info
->obstack
, buf
.string ());
383 newobj
.u
.s_name
.len
= buf
.size ();
384 if (inspect_type (info
, &newobj
, finder
, data
))
389 /* A typedef was substituted in NEW. Convert it to a
390 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
394 gdb::unique_xmalloc_ptr
<char> n
395 = cp_comp_to_string (&newobj
, 100);
398 /* If something went astray, abort typedef substitutions. */
402 s
= copy_string_to_obstack (&info
->obstack
, n
.get (), &slen
);
404 d_left (ret_comp
)->type
= DEMANGLE_COMPONENT_NAME
;
405 d_left (ret_comp
)->u
.s_name
.s
= s
;
406 d_left (ret_comp
)->u
.s_name
.len
= slen
;
407 d_right (ret_comp
) = d_right (comp
);
414 /* The current node is not a name, so simply replace any
415 typedefs in it. Then print it to the stream to continue
416 checking for more typedefs in the tree. */
417 replace_typedefs (info
, d_left (comp
), finder
, data
);
418 gdb::unique_xmalloc_ptr
<char> name
419 = cp_comp_to_string (d_left (comp
), 100);
422 /* If something went astray, abort typedef substitutions. */
425 buf
.puts (name
.get ());
429 comp
= d_right (comp
);
432 /* If the next component is DEMANGLE_COMPONENT_TEMPLATE or
433 DEMANGLE_COMPONENT_NAME, save the qualified name assembled above
434 and append the name given by COMP. Then use this reassembled
435 name to check for a typedef. */
437 if (comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
439 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node with a
440 DEMANGLE_COMPONENT_NAME node containing the whole name. */
441 if (!replace_typedefs_template (info
, buf
, comp
, ret_comp
, finder
, data
))
443 inspect_type (info
, ret_comp
, finder
, data
);
445 else if (comp
->type
== DEMANGLE_COMPONENT_NAME
)
447 buf
.write (comp
->u
.s_name
.s
, comp
->u
.s_name
.len
);
449 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
450 with a DEMANGLE_COMPONENT_NAME node containing the whole
452 ret_comp
->type
= DEMANGLE_COMPONENT_NAME
;
453 ret_comp
->u
.s_name
.s
= obstack_strdup (&info
->obstack
, buf
.string ());
454 ret_comp
->u
.s_name
.len
= buf
.size ();
455 inspect_type (info
, ret_comp
, finder
, data
);
458 replace_typedefs (info
, comp
, finder
, data
);
462 /* A function to check const and volatile qualifiers for argument types.
464 "Parameter declarations that differ only in the presence
465 or absence of `const' and/or `volatile' are equivalent."
466 C++ Standard N3290, clause 13.1.3 #4. */
469 check_cv_qualifiers (struct demangle_component
*ret_comp
)
471 while (d_left (ret_comp
) != NULL
472 && (d_left (ret_comp
)->type
== DEMANGLE_COMPONENT_CONST
473 || d_left (ret_comp
)->type
== DEMANGLE_COMPONENT_VOLATILE
))
475 d_left (ret_comp
) = d_left (d_left (ret_comp
));
479 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
480 their basic types. */
483 replace_typedefs (struct demangle_parse_info
*info
,
484 struct demangle_component
*ret_comp
,
485 canonicalization_ftype
*finder
,
491 && (ret_comp
->type
== DEMANGLE_COMPONENT_NAME
492 || ret_comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
493 || ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
494 || ret_comp
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
))
496 gdb::unique_xmalloc_ptr
<char> local_name
497 = cp_comp_to_string (ret_comp
, 10);
499 if (local_name
!= NULL
)
501 struct symbol
*sym
= NULL
;
506 sym
= lookup_symbol (local_name
.get (), 0,
507 VAR_DOMAIN
, 0).symbol
;
509 catch (const gdb_exception
&except
)
515 struct type
*otype
= SYMBOL_TYPE (sym
);
516 const char *new_name
= (*finder
) (otype
, data
);
518 if (new_name
!= NULL
)
520 ret_comp
->type
= DEMANGLE_COMPONENT_NAME
;
521 ret_comp
->u
.s_name
.s
= new_name
;
522 ret_comp
->u
.s_name
.len
= strlen (new_name
);
529 switch (ret_comp
->type
)
531 case DEMANGLE_COMPONENT_ARGLIST
:
532 check_cv_qualifiers (ret_comp
);
535 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
536 case DEMANGLE_COMPONENT_TEMPLATE
:
537 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
538 case DEMANGLE_COMPONENT_TYPED_NAME
:
539 replace_typedefs (info
, d_left (ret_comp
), finder
, data
);
540 replace_typedefs (info
, d_right (ret_comp
), finder
, data
);
543 case DEMANGLE_COMPONENT_NAME
:
544 inspect_type (info
, ret_comp
, finder
, data
);
547 case DEMANGLE_COMPONENT_QUAL_NAME
:
548 replace_typedefs_qualified_name (info
, ret_comp
, finder
, data
);
551 case DEMANGLE_COMPONENT_LOCAL_NAME
:
552 case DEMANGLE_COMPONENT_CTOR
:
553 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
554 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
555 replace_typedefs (info
, d_right (ret_comp
), finder
, data
);
558 case DEMANGLE_COMPONENT_CONST
:
559 case DEMANGLE_COMPONENT_RESTRICT
:
560 case DEMANGLE_COMPONENT_VOLATILE
:
561 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
562 case DEMANGLE_COMPONENT_CONST_THIS
:
563 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
564 case DEMANGLE_COMPONENT_POINTER
:
565 case DEMANGLE_COMPONENT_REFERENCE
:
566 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
567 replace_typedefs (info
, d_left (ret_comp
), finder
, data
);
576 /* Parse STRING and convert it to canonical form, resolving any
577 typedefs. If parsing fails, or if STRING is already canonical,
578 return nullptr. Otherwise return the canonical form. If
579 FINDER is not NULL, then type components are passed to FINDER to be
580 looked up. DATA is passed verbatim to FINDER. */
582 gdb::unique_xmalloc_ptr
<char>
583 cp_canonicalize_string_full (const char *string
,
584 canonicalization_ftype
*finder
,
587 unsigned int estimated_len
;
588 std::unique_ptr
<demangle_parse_info
> info
;
590 estimated_len
= strlen (string
) * 2;
591 info
= cp_demangled_name_to_comp (string
, NULL
);
594 /* Replace all the typedefs in the tree. */
595 replace_typedefs (info
.get (), info
->tree
, finder
, data
);
597 /* Convert the tree back into a string. */
598 gdb::unique_xmalloc_ptr
<char> us
= cp_comp_to_string (info
->tree
,
602 /* Finally, compare the original string with the computed
603 name, returning NULL if they are the same. */
604 if (strcmp (us
.get (), string
) == 0)
613 /* Like cp_canonicalize_string_full, but always passes NULL for
616 gdb::unique_xmalloc_ptr
<char>
617 cp_canonicalize_string_no_typedefs (const char *string
)
619 return cp_canonicalize_string_full (string
, NULL
, NULL
);
622 /* Parse STRING and convert it to canonical form. If parsing fails,
623 or if STRING is already canonical, return nullptr.
624 Otherwise return the canonical form. */
626 gdb::unique_xmalloc_ptr
<char>
627 cp_canonicalize_string (const char *string
)
629 std::unique_ptr
<demangle_parse_info
> info
;
630 unsigned int estimated_len
;
632 if (cp_already_canonical (string
))
635 info
= cp_demangled_name_to_comp (string
, NULL
);
639 estimated_len
= strlen (string
) * 2;
640 gdb::unique_xmalloc_ptr
<char> us (cp_comp_to_string (info
->tree
,
645 warning (_("internal error: string \"%s\" failed to be canonicalized"),
650 if (strcmp (us
.get (), string
) == 0)
656 /* Convert a mangled name to a demangle_component tree. *MEMORY is
657 set to the block of used memory that should be freed when finished
658 with the tree. DEMANGLED_P is set to the char * that should be
659 freed when finished with the tree, or NULL if none was needed.
660 OPTIONS will be passed to the demangler. */
662 static std::unique_ptr
<demangle_parse_info
>
663 mangled_name_to_comp (const char *mangled_name
, int options
,
664 void **memory
, char **demangled_p
)
666 char *demangled_name
;
668 /* If it looks like a v3 mangled name, then try to go directly
670 if (mangled_name
[0] == '_' && mangled_name
[1] == 'Z')
672 struct demangle_component
*ret
;
674 ret
= cplus_demangle_v3_components (mangled_name
,
678 std::unique_ptr
<demangle_parse_info
> info (new demangle_parse_info
);
685 /* If it doesn't, or if that failed, then try to demangle the
687 demangled_name
= gdb_demangle (mangled_name
, options
);
688 if (demangled_name
== NULL
)
691 /* If we could demangle the name, parse it to build the component
693 std::unique_ptr
<demangle_parse_info
> info
694 = cp_demangled_name_to_comp (demangled_name
, NULL
);
698 xfree (demangled_name
);
702 *demangled_p
= demangled_name
;
706 /* Return the name of the class containing method PHYSNAME. */
709 cp_class_name_from_physname (const char *physname
)
711 void *storage
= NULL
;
712 char *demangled_name
= NULL
;
713 gdb::unique_xmalloc_ptr
<char> ret
;
714 struct demangle_component
*ret_comp
, *prev_comp
, *cur_comp
;
715 std::unique_ptr
<demangle_parse_info
> info
;
718 info
= mangled_name_to_comp (physname
, DMGL_ANSI
,
719 &storage
, &demangled_name
);
724 ret_comp
= info
->tree
;
726 /* First strip off any qualifiers, if we have a function or
729 switch (ret_comp
->type
)
731 case DEMANGLE_COMPONENT_CONST
:
732 case DEMANGLE_COMPONENT_RESTRICT
:
733 case DEMANGLE_COMPONENT_VOLATILE
:
734 case DEMANGLE_COMPONENT_CONST_THIS
:
735 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
736 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
737 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
738 ret_comp
= d_left (ret_comp
);
745 /* If what we have now is a function, discard the argument list. */
746 if (ret_comp
->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
747 ret_comp
= d_left (ret_comp
);
749 /* If what we have now is a template, strip off the template
750 arguments. The left subtree may be a qualified name. */
751 if (ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
752 ret_comp
= d_left (ret_comp
);
754 /* What we have now should be a name, possibly qualified.
755 Additional qualifiers could live in the left subtree or the right
756 subtree. Find the last piece. */
761 switch (cur_comp
->type
)
763 case DEMANGLE_COMPONENT_QUAL_NAME
:
764 case DEMANGLE_COMPONENT_LOCAL_NAME
:
765 prev_comp
= cur_comp
;
766 cur_comp
= d_right (cur_comp
);
768 case DEMANGLE_COMPONENT_TEMPLATE
:
769 case DEMANGLE_COMPONENT_NAME
:
770 case DEMANGLE_COMPONENT_CTOR
:
771 case DEMANGLE_COMPONENT_DTOR
:
772 case DEMANGLE_COMPONENT_OPERATOR
:
773 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
782 if (cur_comp
!= NULL
&& prev_comp
!= NULL
)
784 /* We want to discard the rightmost child of PREV_COMP. */
785 *prev_comp
= *d_left (prev_comp
);
786 /* The ten is completely arbitrary; we don't have a good
788 ret
= cp_comp_to_string (ret_comp
, 10);
792 xfree (demangled_name
);
793 return ret
.release ();
796 /* Return the child of COMP which is the basename of a method,
797 variable, et cetera. All scope qualifiers are discarded, but
798 template arguments will be included. The component tree may be
801 static struct demangle_component
*
802 unqualified_name_from_comp (struct demangle_component
*comp
)
804 struct demangle_component
*ret_comp
= comp
, *last_template
;
808 last_template
= NULL
;
810 switch (ret_comp
->type
)
812 case DEMANGLE_COMPONENT_QUAL_NAME
:
813 case DEMANGLE_COMPONENT_LOCAL_NAME
:
814 ret_comp
= d_right (ret_comp
);
816 case DEMANGLE_COMPONENT_TYPED_NAME
:
817 ret_comp
= d_left (ret_comp
);
819 case DEMANGLE_COMPONENT_TEMPLATE
:
820 gdb_assert (last_template
== NULL
);
821 last_template
= ret_comp
;
822 ret_comp
= d_left (ret_comp
);
824 case DEMANGLE_COMPONENT_CONST
:
825 case DEMANGLE_COMPONENT_RESTRICT
:
826 case DEMANGLE_COMPONENT_VOLATILE
:
827 case DEMANGLE_COMPONENT_CONST_THIS
:
828 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
829 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
830 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
831 ret_comp
= d_left (ret_comp
);
833 case DEMANGLE_COMPONENT_NAME
:
834 case DEMANGLE_COMPONENT_CTOR
:
835 case DEMANGLE_COMPONENT_DTOR
:
836 case DEMANGLE_COMPONENT_OPERATOR
:
837 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
847 d_left (last_template
) = ret_comp
;
848 return last_template
;
854 /* Return the name of the method whose linkage name is PHYSNAME. */
857 method_name_from_physname (const char *physname
)
859 void *storage
= NULL
;
860 char *demangled_name
= NULL
;
861 gdb::unique_xmalloc_ptr
<char> ret
;
862 struct demangle_component
*ret_comp
;
863 std::unique_ptr
<demangle_parse_info
> info
;
865 info
= mangled_name_to_comp (physname
, DMGL_ANSI
,
866 &storage
, &demangled_name
);
870 ret_comp
= unqualified_name_from_comp (info
->tree
);
872 if (ret_comp
!= NULL
)
873 /* The ten is completely arbitrary; we don't have a good
875 ret
= cp_comp_to_string (ret_comp
, 10);
878 xfree (demangled_name
);
879 return ret
.release ();
882 /* If FULL_NAME is the demangled name of a C++ function (including an
883 arg list, possibly including namespace/class qualifications),
884 return a new string containing only the function name (without the
885 arg list/class qualifications). Otherwise, return NULL. */
887 gdb::unique_xmalloc_ptr
<char>
888 cp_func_name (const char *full_name
)
890 gdb::unique_xmalloc_ptr
<char> ret
;
891 struct demangle_component
*ret_comp
;
892 std::unique_ptr
<demangle_parse_info
> info
;
894 info
= cp_demangled_name_to_comp (full_name
, NULL
);
898 ret_comp
= unqualified_name_from_comp (info
->tree
);
900 if (ret_comp
!= NULL
)
901 ret
= cp_comp_to_string (ret_comp
, 10);
906 /* Helper for cp_remove_params. DEMANGLED_NAME is the name of a
907 function, including parameters and (optionally) a return type.
908 Return the name of the function without parameters or return type,
909 or NULL if we can not parse the name. If REQUIRE_PARAMS is false,
910 then tolerate a non-existing or unbalanced parameter list. */
912 static gdb::unique_xmalloc_ptr
<char>
913 cp_remove_params_1 (const char *demangled_name
, bool require_params
)
916 struct demangle_component
*ret_comp
;
917 std::unique_ptr
<demangle_parse_info
> info
;
918 gdb::unique_xmalloc_ptr
<char> ret
;
920 if (demangled_name
== NULL
)
923 info
= cp_demangled_name_to_comp (demangled_name
, NULL
);
927 /* First strip off any qualifiers, if we have a function or method. */
928 ret_comp
= info
->tree
;
930 switch (ret_comp
->type
)
932 case DEMANGLE_COMPONENT_CONST
:
933 case DEMANGLE_COMPONENT_RESTRICT
:
934 case DEMANGLE_COMPONENT_VOLATILE
:
935 case DEMANGLE_COMPONENT_CONST_THIS
:
936 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
937 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
938 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
939 ret_comp
= d_left (ret_comp
);
946 /* What we have now should be a function. Return its name. */
947 if (ret_comp
->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
948 ret
= cp_comp_to_string (d_left (ret_comp
), 10);
949 else if (!require_params
950 && (ret_comp
->type
== DEMANGLE_COMPONENT_NAME
951 || ret_comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
952 || ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
))
953 ret
= cp_comp_to_string (ret_comp
, 10);
958 /* DEMANGLED_NAME is the name of a function, including parameters and
959 (optionally) a return type. Return the name of the function
960 without parameters or return type, or NULL if we can not parse the
963 gdb::unique_xmalloc_ptr
<char>
964 cp_remove_params (const char *demangled_name
)
966 return cp_remove_params_1 (demangled_name
, true);
969 /* See cp-support.h. */
971 gdb::unique_xmalloc_ptr
<char>
972 cp_remove_params_if_any (const char *demangled_name
, bool completion_mode
)
974 /* Trying to remove parameters from the empty string fails. If
975 we're completing / matching everything, avoid returning NULL
976 which would make callers interpret the result as an error. */
977 if (demangled_name
[0] == '\0' && completion_mode
)
978 return make_unique_xstrdup ("");
980 gdb::unique_xmalloc_ptr
<char> without_params
981 = cp_remove_params_1 (demangled_name
, false);
983 if (without_params
== NULL
&& completion_mode
)
985 std::string copy
= demangled_name
;
987 while (!copy
.empty ())
990 without_params
= cp_remove_params_1 (copy
.c_str (), false);
991 if (without_params
!= NULL
)
996 return without_params
;
999 /* Here are some random pieces of trivia to keep in mind while trying
1000 to take apart demangled names:
1002 - Names can contain function arguments or templates, so the process
1003 has to be, to some extent recursive: maybe keep track of your
1004 depth based on encountering <> and ().
1006 - Parentheses don't just have to happen at the end of a name: they
1007 can occur even if the name in question isn't a function, because
1008 a template argument might be a type that's a function.
1010 - Conversely, even if you're trying to deal with a function, its
1011 demangled name might not end with ')': it could be a const or
1012 volatile class method, in which case it ends with "const" or
1015 - Parentheses are also used in anonymous namespaces: a variable
1016 'foo' in an anonymous namespace gets demangled as "(anonymous
1019 - And operator names can contain parentheses or angle brackets. */
1021 /* FIXME: carlton/2003-03-13: We have several functions here with
1022 overlapping functionality; can we combine them? Also, do they
1023 handle all the above considerations correctly? */
1026 /* This returns the length of first component of NAME, which should be
1027 the demangled name of a C++ variable/function/method/etc.
1028 Specifically, it returns the index of the first colon forming the
1029 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
1030 it returns the 1, and given 'foo', it returns 0. */
1032 /* The character in NAME indexed by the return value is guaranteed to
1033 always be either ':' or '\0'. */
1035 /* NOTE: carlton/2003-03-13: This function is currently only intended
1036 for internal use: it's probably not entirely safe when called on
1037 user-generated input, because some of the 'index += 2' lines in
1038 cp_find_first_component_aux might go past the end of malformed
1042 cp_find_first_component (const char *name
)
1044 return cp_find_first_component_aux (name
, 0);
1047 /* Helper function for cp_find_first_component. Like that function,
1048 it returns the length of the first component of NAME, but to make
1049 the recursion easier, it also stops if it reaches an unexpected ')'
1050 or '>' if the value of PERMISSIVE is nonzero. */
1053 cp_find_first_component_aux (const char *name
, int permissive
)
1055 unsigned int index
= 0;
1056 /* Operator names can show up in unexpected places. Since these can
1057 contain parentheses or angle brackets, they can screw up the
1058 recursion. But not every string 'operator' is part of an
1059 operator name: e.g. you could have a variable 'cooperator'. So
1060 this variable tells us whether or not we should treat the string
1061 'operator' as starting an operator. */
1062 int operator_possible
= 1;
1066 switch (name
[index
])
1069 /* Template; eat it up. The calls to cp_first_component
1070 should only return (I hope!) when they reach the '>'
1071 terminating the component or a '::' between two
1072 components. (Hence the '+ 2'.) */
1074 for (index
+= cp_find_first_component_aux (name
+ index
, 1);
1076 index
+= cp_find_first_component_aux (name
+ index
, 1))
1078 if (name
[index
] != ':')
1080 demangled_name_complaint (name
);
1081 return strlen (name
);
1085 operator_possible
= 1;
1088 /* Similar comment as to '<'. */
1090 for (index
+= cp_find_first_component_aux (name
+ index
, 1);
1092 index
+= cp_find_first_component_aux (name
+ index
, 1))
1094 if (name
[index
] != ':')
1096 demangled_name_complaint (name
);
1097 return strlen (name
);
1101 operator_possible
= 1;
1109 demangled_name_complaint (name
);
1110 return strlen (name
);
1115 /* ':' marks a component iff the next character is also a ':'.
1116 Otherwise it is probably malformed input. */
1117 if (name
[index
+ 1] == ':')
1121 /* Operator names can screw up the recursion. */
1122 if (operator_possible
1123 && startswith (name
+ index
, CP_OPERATOR_STR
))
1125 index
+= CP_OPERATOR_LEN
;
1126 while (ISSPACE(name
[index
]))
1128 switch (name
[index
])
1132 /* Skip over one less than the appropriate number of
1133 characters: the for loop will skip over the last
1136 if (name
[index
+ 1] == '<')
1143 if (name
[index
+ 1] == '>')
1156 operator_possible
= 0;
1163 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1164 set of relevant characters are here: it's necessary to
1165 include any character that can show up before 'operator'
1166 in a demangled name, and it's safe to include any
1167 character that can't be part of an identifier's name. */
1168 operator_possible
= 1;
1171 operator_possible
= 0;
1177 /* Complain about a demangled name that we don't know how to parse.
1178 NAME is the demangled name in question. */
1181 demangled_name_complaint (const char *name
)
1183 complaint ("unexpected demangled name '%s'", name
);
1186 /* If NAME is the fully-qualified name of a C++
1187 function/variable/method/etc., this returns the length of its
1188 entire prefix: all of the namespaces and classes that make up its
1189 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1190 4, given 'foo', it returns 0. */
1193 cp_entire_prefix_len (const char *name
)
1195 unsigned int current_len
= cp_find_first_component (name
);
1196 unsigned int previous_len
= 0;
1198 while (name
[current_len
] != '\0')
1200 gdb_assert (name
[current_len
] == ':');
1201 previous_len
= current_len
;
1202 /* Skip the '::'. */
1204 current_len
+= cp_find_first_component (name
+ current_len
);
1207 return previous_len
;
1210 /* Overload resolution functions. */
1212 /* Test to see if SYM is a symbol that we haven't seen corresponding
1213 to a function named OLOAD_NAME. If so, add it to
1217 overload_list_add_symbol (struct symbol
*sym
,
1218 const char *oload_name
,
1219 std::vector
<symbol
*> *overload_list
)
1221 /* If there is no type information, we can't do anything, so
1223 if (SYMBOL_TYPE (sym
) == NULL
)
1226 /* skip any symbols that we've already considered. */
1227 for (symbol
*listed_sym
: *overload_list
)
1228 if (strcmp (sym
->linkage_name (), listed_sym
->linkage_name ()) == 0)
1231 /* Get the demangled name without parameters */
1232 gdb::unique_xmalloc_ptr
<char> sym_name
1233 = cp_remove_params (sym
->natural_name ());
1237 /* skip symbols that cannot match */
1238 if (strcmp (sym_name
.get (), oload_name
) != 0)
1241 overload_list
->push_back (sym
);
1244 /* Return a null-terminated list of pointers to function symbols that
1245 are named FUNC_NAME and are visible within NAMESPACE. */
1247 struct std::vector
<symbol
*>
1248 make_symbol_overload_list (const char *func_name
,
1249 const char *the_namespace
)
1252 std::vector
<symbol
*> overload_list
;
1254 overload_list
.reserve (100);
1256 add_symbol_overload_list_using (func_name
, the_namespace
, &overload_list
);
1258 if (the_namespace
[0] == '\0')
1262 char *concatenated_name
1263 = (char *) alloca (strlen (the_namespace
) + 2 + strlen (func_name
) + 1);
1264 strcpy (concatenated_name
, the_namespace
);
1265 strcat (concatenated_name
, "::");
1266 strcat (concatenated_name
, func_name
);
1267 name
= concatenated_name
;
1270 add_symbol_overload_list_qualified (name
, &overload_list
);
1271 return overload_list
;
1274 /* Add all symbols with a name matching NAME in BLOCK to the overload
1278 add_symbol_overload_list_block (const char *name
,
1279 const struct block
*block
,
1280 std::vector
<symbol
*> *overload_list
)
1282 struct block_iterator iter
;
1285 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
1287 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, lookup_name
, iter
, sym
)
1288 overload_list_add_symbol (sym
, name
, overload_list
);
1291 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1294 add_symbol_overload_list_namespace (const char *func_name
,
1295 const char *the_namespace
,
1296 std::vector
<symbol
*> *overload_list
)
1299 const struct block
*block
= NULL
;
1301 if (the_namespace
[0] == '\0')
1305 char *concatenated_name
1306 = (char *) alloca (strlen (the_namespace
) + 2 + strlen (func_name
) + 1);
1308 strcpy (concatenated_name
, the_namespace
);
1309 strcat (concatenated_name
, "::");
1310 strcat (concatenated_name
, func_name
);
1311 name
= concatenated_name
;
1314 /* Look in the static block. */
1315 block
= block_static_block (get_selected_block (0));
1317 add_symbol_overload_list_block (name
, block
, overload_list
);
1319 /* Look in the global block. */
1320 block
= block_global_block (block
);
1322 add_symbol_overload_list_block (name
, block
, overload_list
);
1326 /* Search the namespace of the given type and namespace of and public
1330 add_symbol_overload_list_adl_namespace (struct type
*type
,
1331 const char *func_name
,
1332 std::vector
<symbol
*> *overload_list
)
1334 char *the_namespace
;
1335 const char *type_name
;
1338 while (type
->code () == TYPE_CODE_PTR
1339 || TYPE_IS_REFERENCE (type
)
1340 || type
->code () == TYPE_CODE_ARRAY
1341 || type
->code () == TYPE_CODE_TYPEDEF
)
1343 if (type
->code () == TYPE_CODE_TYPEDEF
)
1344 type
= check_typedef (type
);
1346 type
= TYPE_TARGET_TYPE (type
);
1349 type_name
= type
->name ();
1351 if (type_name
== NULL
)
1354 prefix_len
= cp_entire_prefix_len (type_name
);
1356 if (prefix_len
!= 0)
1358 the_namespace
= (char *) alloca (prefix_len
+ 1);
1359 strncpy (the_namespace
, type_name
, prefix_len
);
1360 the_namespace
[prefix_len
] = '\0';
1362 add_symbol_overload_list_namespace (func_name
, the_namespace
,
1366 /* Check public base type */
1367 if (type
->code () == TYPE_CODE_STRUCT
)
1368 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1370 if (BASETYPE_VIA_PUBLIC (type
, i
))
1371 add_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type
, i
),
1377 /* Adds to OVERLOAD_LIST the overload list overload candidates for
1378 FUNC_NAME found through argument dependent lookup. */
1381 add_symbol_overload_list_adl (gdb::array_view
<type
*> arg_types
,
1382 const char *func_name
,
1383 std::vector
<symbol
*> *overload_list
)
1385 for (type
*arg_type
: arg_types
)
1386 add_symbol_overload_list_adl_namespace (arg_type
, func_name
,
1390 /* This applies the using directives to add namespaces to search in,
1391 and then searches for overloads in all of those namespaces. It
1392 adds the symbols found to sym_return_val. Arguments are as in
1393 make_symbol_overload_list. */
1396 add_symbol_overload_list_using (const char *func_name
,
1397 const char *the_namespace
,
1398 std::vector
<symbol
*> *overload_list
)
1400 struct using_direct
*current
;
1401 const struct block
*block
;
1403 /* First, go through the using directives. If any of them apply,
1404 look in the appropriate namespaces for new functions to match
1407 for (block
= get_selected_block (0);
1409 block
= BLOCK_SUPERBLOCK (block
))
1410 for (current
= block_using (block
);
1412 current
= current
->next
)
1414 /* Prevent recursive calls. */
1415 if (current
->searched
)
1418 /* If this is a namespace alias or imported declaration ignore
1420 if (current
->alias
!= NULL
|| current
->declaration
!= NULL
)
1423 if (strcmp (the_namespace
, current
->import_dest
) == 0)
1425 /* Mark this import as searched so that the recursive call
1426 does not search it again. */
1427 scoped_restore reset_directive_searched
1428 = make_scoped_restore (¤t
->searched
, 1);
1430 add_symbol_overload_list_using (func_name
,
1431 current
->import_src
,
1436 /* Now, add names for this namespace. */
1437 add_symbol_overload_list_namespace (func_name
, the_namespace
,
1441 /* This does the bulk of the work of finding overloaded symbols.
1442 FUNC_NAME is the name of the overloaded function we're looking for
1443 (possibly including namespace info). */
1446 add_symbol_overload_list_qualified (const char *func_name
,
1447 std::vector
<symbol
*> *overload_list
)
1449 const struct block
*b
, *surrounding_static_block
= 0;
1451 /* Look through the partial symtabs for all symbols which begin by
1452 matching FUNC_NAME. Make sure we read that symbol table in. */
1454 for (objfile
*objf
: current_program_space
->objfiles ())
1455 objf
->expand_symtabs_for_function (func_name
);
1457 /* Search upwards from currently selected frame (so that we can
1458 complete on local vars. */
1460 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
1461 add_symbol_overload_list_block (func_name
, b
, overload_list
);
1463 surrounding_static_block
= block_static_block (get_selected_block (0));
1465 /* Go through the symtabs and check the externs and statics for
1466 symbols which match. */
1468 for (objfile
*objfile
: current_program_space
->objfiles ())
1470 for (compunit_symtab
*cust
: objfile
->compunits ())
1473 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), GLOBAL_BLOCK
);
1474 add_symbol_overload_list_block (func_name
, b
, overload_list
);
1478 for (objfile
*objfile
: current_program_space
->objfiles ())
1480 for (compunit_symtab
*cust
: objfile
->compunits ())
1483 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), STATIC_BLOCK
);
1484 /* Don't do this block twice. */
1485 if (b
== surrounding_static_block
)
1487 add_symbol_overload_list_block (func_name
, b
, overload_list
);
1492 /* Lookup the rtti type for a class name. */
1495 cp_lookup_rtti_type (const char *name
, const struct block
*block
)
1497 struct symbol
* rtti_sym
;
1498 struct type
* rtti_type
;
1500 /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
1501 Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
1502 rtti_sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, NULL
).symbol
;
1504 if (rtti_sym
== NULL
)
1506 warning (_("RTTI symbol not found for class '%s'"), name
);
1510 if (SYMBOL_CLASS (rtti_sym
) != LOC_TYPEDEF
)
1512 warning (_("RTTI symbol for class '%s' is not a type"), name
);
1516 rtti_type
= check_typedef (SYMBOL_TYPE (rtti_sym
));
1518 switch (rtti_type
->code ())
1520 case TYPE_CODE_STRUCT
:
1522 case TYPE_CODE_NAMESPACE
:
1523 /* chastain/2003-11-26: the symbol tables often contain fake
1524 symbols for namespaces with the same name as the struct.
1525 This warning is an indication of a bug in the lookup order
1526 or a bug in the way that the symbol tables are populated. */
1527 warning (_("RTTI symbol for class '%s' is a namespace"), name
);
1530 warning (_("RTTI symbol for class '%s' has bad type"), name
);
1537 #ifdef HAVE_WORKING_FORK
1539 /* If true, attempt to catch crashes in the demangler and print
1540 useful debugging information. */
1542 static bool catch_demangler_crashes
= true;
1544 /* Stack context and environment for demangler crash recovery. */
1546 static thread_local SIGJMP_BUF
*gdb_demangle_jmp_buf
;
1548 /* If true, attempt to dump core from the signal handler. */
1550 static std::atomic
<bool> gdb_demangle_attempt_core_dump
;
1552 /* Signal handler for gdb_demangle. */
1555 gdb_demangle_signal_handler (int signo
)
1557 if (gdb_demangle_attempt_core_dump
)
1562 gdb_demangle_attempt_core_dump
= false;
1565 SIGLONGJMP (*gdb_demangle_jmp_buf
, signo
);
1568 /* A helper for gdb_demangle that reports a demangling failure. */
1571 report_failed_demangle (const char *name
, bool core_dump_allowed
,
1574 static bool error_reported
= false;
1576 if (!error_reported
)
1578 std::string short_msg
1579 = string_printf (_("unable to demangle '%s' "
1580 "(demangler failed with signal %d)"),
1581 name
, crash_signal
);
1583 std::string long_msg
1584 = string_printf ("%s:%d: %s: %s", __FILE__
, __LINE__
,
1585 "demangler-warning", short_msg
.c_str ());
1587 target_terminal::scoped_restore_terminal_state term_state
;
1588 target_terminal::ours_for_output ();
1591 if (core_dump_allowed
)
1592 fprintf_unfiltered (gdb_stderr
,
1593 _("%s\nAttempting to dump core.\n"),
1596 warn_cant_dump_core (long_msg
.c_str ());
1598 demangler_warning (__FILE__
, __LINE__
, "%s", short_msg
.c_str ());
1600 error_reported
= true;
1606 /* A wrapper for bfd_demangle. */
1609 gdb_demangle (const char *name
, int options
)
1611 char *result
= NULL
;
1612 int crash_signal
= 0;
1614 #ifdef HAVE_WORKING_FORK
1615 scoped_segv_handler_restore restore_segv
1616 (catch_demangler_crashes
1617 ? gdb_demangle_signal_handler
1620 bool core_dump_allowed
= gdb_demangle_attempt_core_dump
;
1622 scoped_restore restore_jmp_buf
1623 = make_scoped_restore (&gdb_demangle_jmp_buf
, &jmp_buf);
1624 if (catch_demangler_crashes
)
1626 /* The signal handler may keep the signal blocked when we longjmp out
1627 of it. If we have sigprocmask, we can use it to unblock the signal
1628 afterwards and we can avoid the performance overhead of saving the
1629 signal mask just in case the signal gets triggered. Otherwise, just
1630 tell sigsetjmp to save the mask. */
1631 #ifdef HAVE_SIGPROCMASK
1632 crash_signal
= SIGSETJMP (*gdb_demangle_jmp_buf
, 0);
1634 crash_signal
= SIGSETJMP (*gdb_demangle_jmp_buf
, 1);
1639 if (crash_signal
== 0)
1640 result
= bfd_demangle (NULL
, name
, options
);
1642 #ifdef HAVE_WORKING_FORK
1643 if (catch_demangler_crashes
)
1645 if (crash_signal
!= 0)
1647 #ifdef HAVE_SIGPROCMASK
1648 /* If we got the signal, SIGSEGV may still be blocked; restore it. */
1649 sigset_t segv_sig_set
;
1650 sigemptyset (&segv_sig_set
);
1651 sigaddset (&segv_sig_set
, SIGSEGV
);
1652 gdb_sigmask (SIG_UNBLOCK
, &segv_sig_set
, NULL
);
1655 /* If there was a failure, we can't report it here, because
1656 we might be in a background thread. Instead, arrange for
1657 the reporting to happen on the main thread. */
1658 std::string copy
= name
;
1659 run_on_main_thread ([=] ()
1661 report_failed_demangle (copy
.c_str (), core_dump_allowed
,
1673 /* See cp-support.h. */
1676 cp_search_name_hash (const char *search_name
)
1678 /* cp_entire_prefix_len assumes a fully-qualified name with no
1680 if (startswith (search_name
, "::"))
1683 unsigned int prefix_len
= cp_entire_prefix_len (search_name
);
1684 if (prefix_len
!= 0)
1685 search_name
+= prefix_len
+ 2;
1687 unsigned int hash
= 0;
1688 for (const char *string
= search_name
; *string
!= '\0'; ++string
)
1690 string
= skip_spaces (string
);
1695 /* Ignore ABI tags such as "[abi:cxx11]. */
1697 && startswith (string
+ 1, "abi:")
1698 && string
[5] != ':')
1701 hash
= SYMBOL_HASH_NEXT (hash
, *string
);
1706 /* Helper for cp_symbol_name_matches (i.e., symbol_name_matcher_ftype
1707 implementation for symbol_name_match_type::WILD matching). Split
1708 to a separate function for unit-testing convenience.
1710 If SYMBOL_SEARCH_NAME has more scopes than LOOKUP_NAME, we try to
1711 match ignoring the extra leading scopes of SYMBOL_SEARCH_NAME.
1712 This allows conveniently setting breakpoints on functions/methods
1713 inside any namespace/class without specifying the fully-qualified
1718 [symbol search name] [lookup name]
1719 foo::bar::func foo::bar::func
1720 foo::bar::func bar::func
1725 [symbol search name] [lookup name]
1726 foo::zbar::func bar::func
1727 foo::bar::func foo::func
1729 See more examples in the test_cp_symbol_name_matches selftest
1732 See symbol_name_matcher_ftype for description of SYMBOL_SEARCH_NAME
1735 LOOKUP_NAME/LOOKUP_NAME_LEN is the name we're looking up.
1737 See strncmp_iw_with_mode for description of MODE.
1741 cp_symbol_name_matches_1 (const char *symbol_search_name
,
1742 const char *lookup_name
,
1743 size_t lookup_name_len
,
1744 strncmp_iw_mode mode
,
1745 completion_match_result
*comp_match_res
)
1747 const char *sname
= symbol_search_name
;
1748 completion_match_for_lcd
*match_for_lcd
1749 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
1753 if (strncmp_iw_with_mode (sname
, lookup_name
, lookup_name_len
,
1754 mode
, language_cplus
, match_for_lcd
) == 0)
1756 if (comp_match_res
!= NULL
)
1758 /* Note here we set different MATCH and MATCH_FOR_LCD
1759 strings. This is because with
1761 (gdb) b push_bac[TAB]
1763 we want the completion matches to list
1765 std::vector<int>::push_back(...)
1766 std::vector<char>::push_back(...)
1768 etc., which are SYMBOL_SEARCH_NAMEs, while we want
1769 the input line to auto-complete to
1771 (gdb) push_back(...)
1773 which is SNAME, not to
1777 which would be the regular common prefix between all
1778 the matches otherwise. */
1779 comp_match_res
->set_match (symbol_search_name
, sname
);
1784 unsigned int len
= cp_find_first_component (sname
);
1786 if (sname
[len
] == '\0')
1789 gdb_assert (sname
[len
] == ':');
1790 /* Skip the '::'. */
1795 /* C++ symbol_name_matcher_ftype implementation. */
1798 cp_fq_symbol_name_matches (const char *symbol_search_name
,
1799 const lookup_name_info
&lookup_name
,
1800 completion_match_result
*comp_match_res
)
1802 /* Get the demangled name. */
1803 const std::string
&name
= lookup_name
.cplus ().lookup_name ();
1804 completion_match_for_lcd
*match_for_lcd
1805 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
1806 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
1807 ? strncmp_iw_mode::NORMAL
1808 : strncmp_iw_mode::MATCH_PARAMS
);
1810 if (strncmp_iw_with_mode (symbol_search_name
,
1811 name
.c_str (), name
.size (),
1812 mode
, language_cplus
, match_for_lcd
) == 0)
1814 if (comp_match_res
!= NULL
)
1815 comp_match_res
->set_match (symbol_search_name
);
1822 /* C++ symbol_name_matcher_ftype implementation for wild matches.
1823 Defers work to cp_symbol_name_matches_1. */
1826 cp_symbol_name_matches (const char *symbol_search_name
,
1827 const lookup_name_info
&lookup_name
,
1828 completion_match_result
*comp_match_res
)
1830 /* Get the demangled name. */
1831 const std::string
&name
= lookup_name
.cplus ().lookup_name ();
1833 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
1834 ? strncmp_iw_mode::NORMAL
1835 : strncmp_iw_mode::MATCH_PARAMS
);
1837 return cp_symbol_name_matches_1 (symbol_search_name
,
1838 name
.c_str (), name
.size (),
1839 mode
, comp_match_res
);
1842 /* See cp-support.h. */
1844 symbol_name_matcher_ftype
*
1845 cp_get_symbol_name_matcher (const lookup_name_info
&lookup_name
)
1847 switch (lookup_name
.match_type ())
1849 case symbol_name_match_type::FULL
:
1850 case symbol_name_match_type::EXPRESSION
:
1851 case symbol_name_match_type::SEARCH_NAME
:
1852 return cp_fq_symbol_name_matches
;
1853 case symbol_name_match_type::WILD
:
1854 return cp_symbol_name_matches
;
1857 gdb_assert_not_reached ("");
1862 namespace selftests
{
1865 test_cp_symbol_name_matches ()
1867 #define CHECK_MATCH(SYMBOL, INPUT) \
1868 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, \
1869 INPUT, sizeof (INPUT) - 1, \
1870 strncmp_iw_mode::MATCH_PARAMS, \
1873 #define CHECK_NOT_MATCH(SYMBOL, INPUT) \
1874 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, \
1875 INPUT, sizeof (INPUT) - 1, \
1876 strncmp_iw_mode::MATCH_PARAMS, \
1879 /* Like CHECK_MATCH, and also check that INPUT (and all substrings
1880 that start at index 0) completes to SYMBOL. */
1881 #define CHECK_MATCH_C(SYMBOL, INPUT) \
1884 CHECK_MATCH (SYMBOL, INPUT); \
1885 for (size_t i = 0; i < sizeof (INPUT) - 1; i++) \
1886 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, INPUT, i, \
1887 strncmp_iw_mode::NORMAL, \
1891 /* Like CHECK_NOT_MATCH, and also check that INPUT does NOT complete
1893 #define CHECK_NOT_MATCH_C(SYMBOL, INPUT) \
1896 CHECK_NOT_MATCH (SYMBOL, INPUT); \
1897 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, INPUT, \
1898 sizeof (INPUT) - 1, \
1899 strncmp_iw_mode::NORMAL, \
1903 /* Lookup name without parens matches all overloads. */
1904 CHECK_MATCH_C ("function()", "function");
1905 CHECK_MATCH_C ("function(int)", "function");
1907 /* Check whitespace around parameters is ignored. */
1908 CHECK_MATCH_C ("function()", "function ()");
1909 CHECK_MATCH_C ("function ( )", "function()");
1910 CHECK_MATCH_C ("function ()", "function( )");
1911 CHECK_MATCH_C ("func(int)", "func( int )");
1912 CHECK_MATCH_C ("func(int)", "func ( int ) ");
1913 CHECK_MATCH_C ("func ( int )", "func( int )");
1914 CHECK_MATCH_C ("func ( int )", "func ( int ) ");
1916 /* Check symbol name prefixes aren't incorrectly matched. */
1917 CHECK_NOT_MATCH ("func", "function");
1918 CHECK_NOT_MATCH ("function", "func");
1919 CHECK_NOT_MATCH ("function()", "func");
1921 /* Check that if the lookup name includes parameters, only the right
1922 overload matches. */
1923 CHECK_MATCH_C ("function(int)", "function(int)");
1924 CHECK_NOT_MATCH_C ("function(int)", "function()");
1926 /* Check that whitespace within symbol names is not ignored. */
1927 CHECK_NOT_MATCH_C ("function", "func tion");
1928 CHECK_NOT_MATCH_C ("func__tion", "func_ _tion");
1929 CHECK_NOT_MATCH_C ("func11tion", "func1 1tion");
1931 /* Check the converse, which can happen with template function,
1932 where the return type is part of the demangled name. */
1933 CHECK_NOT_MATCH_C ("func tion", "function");
1934 CHECK_NOT_MATCH_C ("func1 1tion", "func11tion");
1935 CHECK_NOT_MATCH_C ("func_ _tion", "func__tion");
1937 /* Within parameters too. */
1938 CHECK_NOT_MATCH_C ("func(param)", "func(par am)");
1940 /* Check handling of whitespace around C++ operators. */
1941 CHECK_NOT_MATCH_C ("operator<<", "opera tor<<");
1942 CHECK_NOT_MATCH_C ("operator<<", "operator< <");
1943 CHECK_NOT_MATCH_C ("operator<<", "operator < <");
1944 CHECK_NOT_MATCH_C ("operator==", "operator= =");
1945 CHECK_NOT_MATCH_C ("operator==", "operator = =");
1946 CHECK_MATCH_C ("operator<<", "operator <<");
1947 CHECK_MATCH_C ("operator<<()", "operator <<");
1948 CHECK_NOT_MATCH_C ("operator<<()", "operator<<(int)");
1949 CHECK_NOT_MATCH_C ("operator<<(int)", "operator<<()");
1950 CHECK_MATCH_C ("operator==", "operator ==");
1951 CHECK_MATCH_C ("operator==()", "operator ==");
1952 CHECK_MATCH_C ("operator <<", "operator<<");
1953 CHECK_MATCH_C ("operator ==", "operator==");
1954 CHECK_MATCH_C ("operator bool", "operator bool");
1955 CHECK_MATCH_C ("operator bool ()", "operator bool");
1956 CHECK_MATCH_C ("operatorX<<", "operatorX < <");
1957 CHECK_MATCH_C ("Xoperator<<", "Xoperator < <");
1959 CHECK_MATCH_C ("operator()(int)", "operator()(int)");
1960 CHECK_MATCH_C ("operator()(int)", "operator ( ) ( int )");
1961 CHECK_MATCH_C ("operator()<long>(int)", "operator ( ) < long > ( int )");
1962 /* The first "()" is not the parameter list. */
1963 CHECK_NOT_MATCH ("operator()(int)", "operator");
1965 /* Misc user-defined operator tests. */
1967 CHECK_NOT_MATCH_C ("operator/=()", "operator ^=");
1968 /* Same length at end of input. */
1969 CHECK_NOT_MATCH_C ("operator>>", "operator[]");
1970 /* Same length but not at end of input. */
1971 CHECK_NOT_MATCH_C ("operator>>()", "operator[]()");
1973 CHECK_MATCH_C ("base::operator char*()", "base::operator char*()");
1974 CHECK_MATCH_C ("base::operator char*()", "base::operator char * ()");
1975 CHECK_MATCH_C ("base::operator char**()", "base::operator char * * ()");
1976 CHECK_MATCH ("base::operator char**()", "base::operator char * *");
1977 CHECK_MATCH_C ("base::operator*()", "base::operator*()");
1978 CHECK_NOT_MATCH_C ("base::operator char*()", "base::operatorc");
1979 CHECK_NOT_MATCH ("base::operator char*()", "base::operator char");
1980 CHECK_NOT_MATCH ("base::operator char*()", "base::operat");
1982 /* Check handling of whitespace around C++ scope operators. */
1983 CHECK_NOT_MATCH_C ("foo::bar", "foo: :bar");
1984 CHECK_MATCH_C ("foo::bar", "foo :: bar");
1985 CHECK_MATCH_C ("foo :: bar", "foo::bar");
1987 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi()");
1988 CHECK_MATCH_C ("abc::def::ghi ( )", "abc::def::ghi()");
1989 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi ( )");
1990 CHECK_MATCH_C ("function()", "function()");
1991 CHECK_MATCH_C ("bar::function()", "bar::function()");
1993 /* Wild matching tests follow. */
1995 /* Tests matching symbols in some scope. */
1996 CHECK_MATCH_C ("foo::function()", "function");
1997 CHECK_MATCH_C ("foo::function(int)", "function");
1998 CHECK_MATCH_C ("foo::bar::function()", "function");
1999 CHECK_MATCH_C ("bar::function()", "bar::function");
2000 CHECK_MATCH_C ("foo::bar::function()", "bar::function");
2001 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function");
2003 /* Same, with parameters in the lookup name. */
2004 CHECK_MATCH_C ("foo::function()", "function()");
2005 CHECK_MATCH_C ("foo::bar::function()", "function()");
2006 CHECK_MATCH_C ("foo::function(int)", "function(int)");
2007 CHECK_MATCH_C ("foo::function()", "foo::function()");
2008 CHECK_MATCH_C ("foo::bar::function()", "bar::function()");
2009 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function(int)");
2010 CHECK_MATCH_C ("bar::function()", "bar::function()");
2012 CHECK_NOT_MATCH_C ("foo::bar::function(int)", "bar::function()");
2014 CHECK_MATCH_C ("(anonymous namespace)::bar::function(int)",
2015 "bar::function(int)");
2016 CHECK_MATCH_C ("foo::(anonymous namespace)::bar::function(int)",
2019 /* Lookup scope wider than symbol scope, should not match. */
2020 CHECK_NOT_MATCH_C ("function()", "bar::function");
2021 CHECK_NOT_MATCH_C ("function()", "bar::function()");
2023 /* Explicit global scope doesn't match. */
2024 CHECK_NOT_MATCH_C ("foo::function()", "::function");
2025 CHECK_NOT_MATCH_C ("foo::function()", "::function()");
2026 CHECK_NOT_MATCH_C ("foo::function(int)", "::function()");
2027 CHECK_NOT_MATCH_C ("foo::function(int)", "::function(int)");
2029 /* Test ABI tag matching/ignoring. */
2031 /* If the symbol name has an ABI tag, but the lookup name doesn't,
2032 then the ABI tag in the symbol name is ignored. */
2033 CHECK_MATCH_C ("function[abi:foo]()", "function");
2034 CHECK_MATCH_C ("function[abi:foo](int)", "function");
2035 CHECK_MATCH_C ("function[abi:foo]()", "function ()");
2036 CHECK_NOT_MATCH_C ("function[abi:foo]()", "function (int)");
2038 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo]");
2039 CHECK_MATCH_C ("function[abi:foo](int)", "function[abi:foo]");
2040 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo] ()");
2041 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function");
2042 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function");
2043 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo]");
2044 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function[abi:foo]");
2045 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] ()");
2046 CHECK_NOT_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] (int)");
2048 CHECK_MATCH_C ("function [abi:foo][abi:bar] ( )", "function [abi:foo]");
2050 /* If the symbol name does not have an ABI tag, while the lookup
2051 name has one, then there's no match. */
2052 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]()");
2053 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]");
2056 /* If non-NULL, return STR wrapped in quotes. Otherwise, return a
2057 "<null>" string (with no quotes). */
2060 quote (const char *str
)
2063 return std::string (1, '"') + str
+ '"';
2068 /* Check that removing parameter info out of NAME produces EXPECTED.
2069 COMPLETION_MODE indicates whether we're testing normal and
2070 completion mode. FILE and LINE are used to provide better test
2071 location information in case ithe check fails. */
2074 check_remove_params (const char *file
, int line
,
2075 const char *name
, const char *expected
,
2076 bool completion_mode
)
2078 gdb::unique_xmalloc_ptr
<char> result
2079 = cp_remove_params_if_any (name
, completion_mode
);
2081 if ((expected
== NULL
) != (result
== NULL
)
2082 || (expected
!= NULL
2083 && strcmp (result
.get (), expected
) != 0))
2085 error (_("%s:%d: make-paramless self-test failed: (completion=%d) "
2086 "\"%s\" -> %s, expected %s"),
2087 file
, line
, completion_mode
, name
,
2088 quote (result
.get ()).c_str (), quote (expected
).c_str ());
2092 /* Entry point for cp_remove_params unit tests. */
2095 test_cp_remove_params ()
2097 /* Check that removing parameter info out of NAME produces EXPECTED.
2098 Checks both normal and completion modes. */
2099 #define CHECK(NAME, EXPECTED) \
2102 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, false); \
2103 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2107 /* Similar, but used when NAME is incomplete -- i.e., is has
2108 unbalanced parentheses. In this case, looking for the exact name
2109 should fail / return empty. */
2110 #define CHECK_INCOMPL(NAME, EXPECTED) \
2113 check_remove_params (__FILE__, __LINE__, NAME, NULL, false); \
2114 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2118 CHECK ("function()", "function");
2119 CHECK_INCOMPL ("function(", "function");
2120 CHECK ("function() const", "function");
2122 CHECK ("(anonymous namespace)::A::B::C",
2123 "(anonymous namespace)::A::B::C");
2125 CHECK ("A::(anonymous namespace)",
2126 "A::(anonymous namespace)");
2128 CHECK_INCOMPL ("A::(anonymou", "A");
2130 CHECK ("A::foo<int>()",
2133 CHECK_INCOMPL ("A::foo<int>(",
2136 CHECK ("A::foo<(anonymous namespace)::B>::func(int)",
2137 "A::foo<(anonymous namespace)::B>::func");
2139 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::func(in",
2140 "A::foo<(anonymous namespace)::B>::func");
2142 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::",
2143 "A::foo<(anonymous namespace)::B>");
2145 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>:",
2146 "A::foo<(anonymous namespace)::B>");
2148 CHECK ("A::foo<(anonymous namespace)::B>",
2149 "A::foo<(anonymous namespace)::B>");
2151 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B",
2154 /* Shouldn't this parse? Looks like a bug in
2155 cp_demangled_name_to_comp. See PR c++/22411. */
2157 CHECK ("A::foo<void(int)>::func(int)",
2158 "A::foo<void(int)>::func");
2160 CHECK_INCOMPL ("A::foo<void(int)>::func(int)",
2164 CHECK_INCOMPL ("A::foo<void(int",
2168 #undef CHECK_INCOMPL
2171 } // namespace selftests
2173 #endif /* GDB_SELF_CHECK */
2175 /* This is a front end for cp_find_first_component, for unit testing.
2176 Be careful when using it: see the NOTE above
2177 cp_find_first_component. */
2180 first_component_command (const char *arg
, int from_tty
)
2188 len
= cp_find_first_component (arg
);
2189 prefix
= (char *) alloca (len
+ 1);
2191 memcpy (prefix
, arg
, len
);
2194 printf_unfiltered ("%s\n", prefix
);
2197 /* Implement "info vtbl". */
2200 info_vtbl_command (const char *arg
, int from_tty
)
2202 struct value
*value
;
2204 value
= parse_and_eval (arg
);
2205 cplus_print_vtable (value
);
2208 void _initialize_cp_support ();
2210 _initialize_cp_support ()
2212 add_basic_prefix_cmd ("cplus", class_maintenance
,
2213 _("C++ maintenance commands."),
2214 &maint_cplus_cmd_list
,
2215 "maintenance cplus ",
2216 0, &maintenancelist
);
2217 add_alias_cmd ("cp", "cplus",
2218 class_maintenance
, 1,
2221 add_cmd ("first_component",
2223 first_component_command
,
2224 _("Print the first class/namespace component of NAME."),
2225 &maint_cplus_cmd_list
);
2227 add_info ("vtbl", info_vtbl_command
,
2228 _("Show the virtual function table for a C++ object.\n\
2229 Usage: info vtbl EXPRESSION\n\
2230 Evaluate EXPRESSION and display the virtual function table for the\n\
2231 resulting object."));
2233 #ifdef HAVE_WORKING_FORK
2234 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance
,
2235 &catch_demangler_crashes
, _("\
2236 Set whether to attempt to catch demangler crashes."), _("\
2237 Show whether to attempt to catch demangler crashes."), _("\
2238 If enabled GDB will attempt to catch demangler crashes and\n\
2239 display the offending symbol."),
2242 &maintenance_set_cmdlist
,
2243 &maintenance_show_cmdlist
);
2245 gdb_demangle_attempt_core_dump
= can_dump_core (LIMIT_CUR
);
2249 selftests::register_test ("cp_symbol_name_matches",
2250 selftests::test_cp_symbol_name_matches
);
2251 selftests::register_test ("cp_remove_params",
2252 selftests::test_cp_remove_params
);