1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2002-2019 Free Software Foundation, Inc.
4 Contributed by MontaVista Software.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "cp-support.h"
25 #include "dictionary.h"
30 #include "complaints.h"
32 #include "expression.h"
35 #include "namespace.h"
37 #include "gdbsupport/gdb_setjmp.h"
38 #include "safe-ctype.h"
39 #include "gdbsupport/selftest.h"
40 #include "gdbsupport/gdb-sigmask.h"
42 #define d_left(dc) (dc)->u.s_binary.left
43 #define d_right(dc) (dc)->u.s_binary.right
45 /* Functions related to demangled name parsing. */
47 static unsigned int cp_find_first_component_aux (const char *name
,
50 static void demangled_name_complaint (const char *name
);
52 /* Functions related to overload resolution. */
54 static void overload_list_add_symbol (struct symbol
*sym
,
55 const char *oload_name
,
56 std::vector
<symbol
*> *overload_list
);
58 static void add_symbol_overload_list_using
59 (const char *func_name
, const char *the_namespace
,
60 std::vector
<symbol
*> *overload_list
);
62 static void add_symbol_overload_list_qualified
63 (const char *func_name
,
64 std::vector
<symbol
*> *overload_list
);
66 /* The list of "maint cplus" commands. */
68 struct cmd_list_element
*maint_cplus_cmd_list
= NULL
;
70 /* A list of typedefs which should not be substituted by replace_typedefs. */
71 static const char * const ignore_typedefs
[] =
73 "std::istream", "std::iostream", "std::ostream", "std::string"
77 replace_typedefs (struct demangle_parse_info
*info
,
78 struct demangle_component
*ret_comp
,
79 canonicalization_ftype
*finder
,
82 /* A convenience function to copy STRING into OBSTACK, returning a pointer
83 to the newly allocated string and saving the number of bytes saved in LEN.
85 It does not copy the terminating '\0' byte! */
88 copy_string_to_obstack (struct obstack
*obstack
, const char *string
,
91 *len
= strlen (string
);
92 return (char *) obstack_copy (obstack
, string
, *len
);
95 /* Return 1 if STRING is clearly already in canonical form. This
96 function is conservative; things which it does not recognize are
97 assumed to be non-canonical, and the parser will sort them out
98 afterwards. This speeds up the critical path for alphanumeric
102 cp_already_canonical (const char *string
)
104 /* Identifier start character [a-zA-Z_]. */
105 if (!ISIDST (string
[0]))
108 /* These are the only two identifiers which canonicalize to other
109 than themselves or an error: unsigned -> unsigned int and
111 if (string
[0] == 'u' && strcmp (&string
[1], "nsigned") == 0)
113 else if (string
[0] == 's' && strcmp (&string
[1], "igned") == 0)
116 /* Identifier character [a-zA-Z0-9_]. */
117 while (ISIDNUM (string
[1]))
120 if (string
[1] == '\0')
126 /* Inspect the given RET_COMP for its type. If it is a typedef,
127 replace the node with the typedef's tree.
129 Returns 1 if any typedef substitutions were made, 0 otherwise. */
132 inspect_type (struct demangle_parse_info
*info
,
133 struct demangle_component
*ret_comp
,
134 canonicalization_ftype
*finder
,
140 /* Copy the symbol's name from RET_COMP and look it up
141 in the symbol table. */
142 name
= (char *) alloca (ret_comp
->u
.s_name
.len
+ 1);
143 memcpy (name
, ret_comp
->u
.s_name
.s
, ret_comp
->u
.s_name
.len
);
144 name
[ret_comp
->u
.s_name
.len
] = '\0';
146 /* Ignore any typedefs that should not be substituted. */
147 for (int i
= 0; i
< ARRAY_SIZE (ignore_typedefs
); ++i
)
149 if (strcmp (name
, ignore_typedefs
[i
]) == 0)
157 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0).symbol
;
159 catch (const gdb_exception
&except
)
166 struct type
*otype
= SYMBOL_TYPE (sym
);
170 const char *new_name
= (*finder
) (otype
, data
);
172 if (new_name
!= NULL
)
174 ret_comp
->u
.s_name
.s
= new_name
;
175 ret_comp
->u
.s_name
.len
= strlen (new_name
);
182 /* If the type is a typedef or namespace alias, replace it. */
183 if (TYPE_CODE (otype
) == TYPE_CODE_TYPEDEF
184 || TYPE_CODE (otype
) == TYPE_CODE_NAMESPACE
)
189 std::unique_ptr
<demangle_parse_info
> i
;
191 /* Get the real type of the typedef. */
192 type
= check_typedef (otype
);
194 /* If the symbol name is the same as the original type name,
195 don't substitute. That would cause infinite recursion in
196 symbol lookups, as the typedef symbol is often the first
197 found symbol in the symbol table.
199 However, this can happen in a number of situations, such as:
201 If the symbol is a namespace and its type name is no different
202 than the name we looked up, this symbol is not a namespace
203 alias and does not need to be substituted.
205 If the symbol is typedef and its type name is the same
206 as the symbol's name, e.g., "typedef struct foo foo;". */
207 if (TYPE_NAME (type
) != nullptr
208 && strcmp (TYPE_NAME (type
), name
) == 0)
211 is_anon
= (TYPE_NAME (type
) == NULL
212 && (TYPE_CODE (type
) == TYPE_CODE_ENUM
213 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
214 || TYPE_CODE (type
) == TYPE_CODE_UNION
));
217 struct type
*last
= otype
;
219 /* Find the last typedef for the type. */
220 while (TYPE_TARGET_TYPE (last
) != NULL
221 && (TYPE_CODE (TYPE_TARGET_TYPE (last
))
222 == TYPE_CODE_TYPEDEF
))
223 last
= TYPE_TARGET_TYPE (last
);
225 /* If there is only one typedef for this anonymous type,
226 do not substitute it. */
230 /* Use the last typedef seen as the type for this
238 type_print (type
, "", &buf
, -1);
240 /* If type_print threw an exception, there is little point
241 in continuing, so just bow out gracefully. */
242 catch (const gdb_exception_error
&except
)
248 name
= obstack_strdup (&info
->obstack
, buf
.string ());
250 /* Turn the result into a new tree. Note that this
251 tree will contain pointers into NAME, so NAME cannot
252 be free'd until all typedef conversion is done and
253 the final result is converted into a string. */
254 i
= cp_demangled_name_to_comp (name
, NULL
);
257 /* Merge the two trees. */
258 cp_merge_demangle_parse_infos (info
, ret_comp
, i
.get ());
260 /* Replace any newly introduced typedefs -- but not
261 if the type is anonymous (that would lead to infinite
264 replace_typedefs (info
, ret_comp
, finder
, data
);
268 /* This shouldn't happen unless the type printer has
269 output something that the name parser cannot grok.
270 Nonetheless, an ounce of prevention...
272 Canonicalize the name again, and store it in the
273 current node (RET_COMP). */
274 std::string canon
= cp_canonicalize_string_no_typedefs (name
);
278 /* Copy the canonicalization into the obstack. */
279 name
= copy_string_to_obstack (&info
->obstack
, canon
.c_str (), &len
);
282 ret_comp
->u
.s_name
.s
= name
;
283 ret_comp
->u
.s_name
.len
= len
;
293 /* Replace any typedefs appearing in the qualified name
294 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
298 replace_typedefs_qualified_name (struct demangle_parse_info
*info
,
299 struct demangle_component
*ret_comp
,
300 canonicalization_ftype
*finder
,
304 struct demangle_component
*comp
= ret_comp
;
306 /* Walk each node of the qualified name, reconstructing the name of
307 this element. With every node, check for any typedef substitutions.
308 If a substitution has occurred, replace the qualified name node
309 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
311 while (comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
)
313 if (d_left (comp
)->type
== DEMANGLE_COMPONENT_NAME
)
315 struct demangle_component newobj
;
317 buf
.write (d_left (comp
)->u
.s_name
.s
, d_left (comp
)->u
.s_name
.len
);
318 newobj
.type
= DEMANGLE_COMPONENT_NAME
;
319 newobj
.u
.s_name
.s
= obstack_strdup (&info
->obstack
, buf
.string ());
320 newobj
.u
.s_name
.len
= buf
.size ();
321 if (inspect_type (info
, &newobj
, finder
, data
))
326 /* A typedef was substituted in NEW. Convert it to a
327 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
331 gdb::unique_xmalloc_ptr
<char> n
332 = cp_comp_to_string (&newobj
, 100);
335 /* If something went astray, abort typedef substitutions. */
339 s
= copy_string_to_obstack (&info
->obstack
, n
.get (), &slen
);
341 d_left (ret_comp
)->type
= DEMANGLE_COMPONENT_NAME
;
342 d_left (ret_comp
)->u
.s_name
.s
= s
;
343 d_left (ret_comp
)->u
.s_name
.len
= slen
;
344 d_right (ret_comp
) = d_right (comp
);
351 /* The current node is not a name, so simply replace any
352 typedefs in it. Then print it to the stream to continue
353 checking for more typedefs in the tree. */
354 replace_typedefs (info
, d_left (comp
), finder
, data
);
355 gdb::unique_xmalloc_ptr
<char> name
356 = cp_comp_to_string (d_left (comp
), 100);
359 /* If something went astray, abort typedef substitutions. */
362 buf
.puts (name
.get ());
366 comp
= d_right (comp
);
369 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
370 name assembled above and append the name given by COMP. Then use this
371 reassembled name to check for a typedef. */
373 if (comp
->type
== DEMANGLE_COMPONENT_NAME
)
375 buf
.write (comp
->u
.s_name
.s
, comp
->u
.s_name
.len
);
377 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
378 with a DEMANGLE_COMPONENT_NAME node containing the whole
380 ret_comp
->type
= DEMANGLE_COMPONENT_NAME
;
381 ret_comp
->u
.s_name
.s
= obstack_strdup (&info
->obstack
, buf
.string ());
382 ret_comp
->u
.s_name
.len
= buf
.size ();
383 inspect_type (info
, ret_comp
, finder
, data
);
386 replace_typedefs (info
, comp
, finder
, data
);
390 /* A function to check const and volatile qualifiers for argument types.
392 "Parameter declarations that differ only in the presence
393 or absence of `const' and/or `volatile' are equivalent."
394 C++ Standard N3290, clause 13.1.3 #4. */
397 check_cv_qualifiers (struct demangle_component
*ret_comp
)
399 while (d_left (ret_comp
) != NULL
400 && (d_left (ret_comp
)->type
== DEMANGLE_COMPONENT_CONST
401 || d_left (ret_comp
)->type
== DEMANGLE_COMPONENT_VOLATILE
))
403 d_left (ret_comp
) = d_left (d_left (ret_comp
));
407 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
408 their basic types. */
411 replace_typedefs (struct demangle_parse_info
*info
,
412 struct demangle_component
*ret_comp
,
413 canonicalization_ftype
*finder
,
419 && (ret_comp
->type
== DEMANGLE_COMPONENT_NAME
420 || ret_comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
421 || ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
422 || ret_comp
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
))
424 gdb::unique_xmalloc_ptr
<char> local_name
425 = cp_comp_to_string (ret_comp
, 10);
427 if (local_name
!= NULL
)
429 struct symbol
*sym
= NULL
;
434 sym
= lookup_symbol (local_name
.get (), 0,
435 VAR_DOMAIN
, 0).symbol
;
437 catch (const gdb_exception
&except
)
443 struct type
*otype
= SYMBOL_TYPE (sym
);
444 const char *new_name
= (*finder
) (otype
, data
);
446 if (new_name
!= NULL
)
448 ret_comp
->type
= DEMANGLE_COMPONENT_NAME
;
449 ret_comp
->u
.s_name
.s
= new_name
;
450 ret_comp
->u
.s_name
.len
= strlen (new_name
);
457 switch (ret_comp
->type
)
459 case DEMANGLE_COMPONENT_ARGLIST
:
460 check_cv_qualifiers (ret_comp
);
463 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
464 case DEMANGLE_COMPONENT_TEMPLATE
:
465 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
466 case DEMANGLE_COMPONENT_TYPED_NAME
:
467 replace_typedefs (info
, d_left (ret_comp
), finder
, data
);
468 replace_typedefs (info
, d_right (ret_comp
), finder
, data
);
471 case DEMANGLE_COMPONENT_NAME
:
472 inspect_type (info
, ret_comp
, finder
, data
);
475 case DEMANGLE_COMPONENT_QUAL_NAME
:
476 replace_typedefs_qualified_name (info
, ret_comp
, finder
, data
);
479 case DEMANGLE_COMPONENT_LOCAL_NAME
:
480 case DEMANGLE_COMPONENT_CTOR
:
481 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
482 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
483 replace_typedefs (info
, d_right (ret_comp
), finder
, data
);
486 case DEMANGLE_COMPONENT_CONST
:
487 case DEMANGLE_COMPONENT_RESTRICT
:
488 case DEMANGLE_COMPONENT_VOLATILE
:
489 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
490 case DEMANGLE_COMPONENT_CONST_THIS
:
491 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
492 case DEMANGLE_COMPONENT_POINTER
:
493 case DEMANGLE_COMPONENT_REFERENCE
:
494 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
495 replace_typedefs (info
, d_left (ret_comp
), finder
, data
);
504 /* Parse STRING and convert it to canonical form, resolving any
505 typedefs. If parsing fails, or if STRING is already canonical,
506 return the empty string. Otherwise return the canonical form. If
507 FINDER is not NULL, then type components are passed to FINDER to be
508 looked up. DATA is passed verbatim to FINDER. */
511 cp_canonicalize_string_full (const char *string
,
512 canonicalization_ftype
*finder
,
516 unsigned int estimated_len
;
517 std::unique_ptr
<demangle_parse_info
> info
;
519 estimated_len
= strlen (string
) * 2;
520 info
= cp_demangled_name_to_comp (string
, NULL
);
523 /* Replace all the typedefs in the tree. */
524 replace_typedefs (info
.get (), info
->tree
, finder
, data
);
526 /* Convert the tree back into a string. */
527 gdb::unique_xmalloc_ptr
<char> us
= cp_comp_to_string (info
->tree
,
532 /* Finally, compare the original string with the computed
533 name, returning NULL if they are the same. */
535 return std::string ();
541 /* Like cp_canonicalize_string_full, but always passes NULL for
545 cp_canonicalize_string_no_typedefs (const char *string
)
547 return cp_canonicalize_string_full (string
, NULL
, NULL
);
550 /* Parse STRING and convert it to canonical form. If parsing fails,
551 or if STRING is already canonical, return the empty string.
552 Otherwise return the canonical form. */
555 cp_canonicalize_string (const char *string
)
557 std::unique_ptr
<demangle_parse_info
> info
;
558 unsigned int estimated_len
;
560 if (cp_already_canonical (string
))
561 return std::string ();
563 info
= cp_demangled_name_to_comp (string
, NULL
);
565 return std::string ();
567 estimated_len
= strlen (string
) * 2;
568 gdb::unique_xmalloc_ptr
<char> us (cp_comp_to_string (info
->tree
,
573 warning (_("internal error: string \"%s\" failed to be canonicalized"),
575 return std::string ();
578 std::string
ret (us
.get ());
581 return std::string ();
586 /* Convert a mangled name to a demangle_component tree. *MEMORY is
587 set to the block of used memory that should be freed when finished
588 with the tree. DEMANGLED_P is set to the char * that should be
589 freed when finished with the tree, or NULL if none was needed.
590 OPTIONS will be passed to the demangler. */
592 static std::unique_ptr
<demangle_parse_info
>
593 mangled_name_to_comp (const char *mangled_name
, int options
,
594 void **memory
, char **demangled_p
)
596 char *demangled_name
;
598 /* If it looks like a v3 mangled name, then try to go directly
600 if (mangled_name
[0] == '_' && mangled_name
[1] == 'Z')
602 struct demangle_component
*ret
;
604 ret
= cplus_demangle_v3_components (mangled_name
,
608 std::unique_ptr
<demangle_parse_info
> info (new demangle_parse_info
);
615 /* If it doesn't, or if that failed, then try to demangle the
617 demangled_name
= gdb_demangle (mangled_name
, options
);
618 if (demangled_name
== NULL
)
621 /* If we could demangle the name, parse it to build the component
623 std::unique_ptr
<demangle_parse_info
> info
624 = cp_demangled_name_to_comp (demangled_name
, NULL
);
628 xfree (demangled_name
);
632 *demangled_p
= demangled_name
;
636 /* Return the name of the class containing method PHYSNAME. */
639 cp_class_name_from_physname (const char *physname
)
641 void *storage
= NULL
;
642 char *demangled_name
= NULL
;
643 gdb::unique_xmalloc_ptr
<char> ret
;
644 struct demangle_component
*ret_comp
, *prev_comp
, *cur_comp
;
645 std::unique_ptr
<demangle_parse_info
> info
;
648 info
= mangled_name_to_comp (physname
, DMGL_ANSI
,
649 &storage
, &demangled_name
);
654 ret_comp
= info
->tree
;
656 /* First strip off any qualifiers, if we have a function or
659 switch (ret_comp
->type
)
661 case DEMANGLE_COMPONENT_CONST
:
662 case DEMANGLE_COMPONENT_RESTRICT
:
663 case DEMANGLE_COMPONENT_VOLATILE
:
664 case DEMANGLE_COMPONENT_CONST_THIS
:
665 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
666 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
667 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
668 ret_comp
= d_left (ret_comp
);
675 /* If what we have now is a function, discard the argument list. */
676 if (ret_comp
->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
677 ret_comp
= d_left (ret_comp
);
679 /* If what we have now is a template, strip off the template
680 arguments. The left subtree may be a qualified name. */
681 if (ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
682 ret_comp
= d_left (ret_comp
);
684 /* What we have now should be a name, possibly qualified.
685 Additional qualifiers could live in the left subtree or the right
686 subtree. Find the last piece. */
691 switch (cur_comp
->type
)
693 case DEMANGLE_COMPONENT_QUAL_NAME
:
694 case DEMANGLE_COMPONENT_LOCAL_NAME
:
695 prev_comp
= cur_comp
;
696 cur_comp
= d_right (cur_comp
);
698 case DEMANGLE_COMPONENT_TEMPLATE
:
699 case DEMANGLE_COMPONENT_NAME
:
700 case DEMANGLE_COMPONENT_CTOR
:
701 case DEMANGLE_COMPONENT_DTOR
:
702 case DEMANGLE_COMPONENT_OPERATOR
:
703 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
712 if (cur_comp
!= NULL
&& prev_comp
!= NULL
)
714 /* We want to discard the rightmost child of PREV_COMP. */
715 *prev_comp
= *d_left (prev_comp
);
716 /* The ten is completely arbitrary; we don't have a good
718 ret
= cp_comp_to_string (ret_comp
, 10);
722 xfree (demangled_name
);
723 return ret
.release ();
726 /* Return the child of COMP which is the basename of a method,
727 variable, et cetera. All scope qualifiers are discarded, but
728 template arguments will be included. The component tree may be
731 static struct demangle_component
*
732 unqualified_name_from_comp (struct demangle_component
*comp
)
734 struct demangle_component
*ret_comp
= comp
, *last_template
;
738 last_template
= NULL
;
740 switch (ret_comp
->type
)
742 case DEMANGLE_COMPONENT_QUAL_NAME
:
743 case DEMANGLE_COMPONENT_LOCAL_NAME
:
744 ret_comp
= d_right (ret_comp
);
746 case DEMANGLE_COMPONENT_TYPED_NAME
:
747 ret_comp
= d_left (ret_comp
);
749 case DEMANGLE_COMPONENT_TEMPLATE
:
750 gdb_assert (last_template
== NULL
);
751 last_template
= ret_comp
;
752 ret_comp
= d_left (ret_comp
);
754 case DEMANGLE_COMPONENT_CONST
:
755 case DEMANGLE_COMPONENT_RESTRICT
:
756 case DEMANGLE_COMPONENT_VOLATILE
:
757 case DEMANGLE_COMPONENT_CONST_THIS
:
758 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
759 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
760 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
761 ret_comp
= d_left (ret_comp
);
763 case DEMANGLE_COMPONENT_NAME
:
764 case DEMANGLE_COMPONENT_CTOR
:
765 case DEMANGLE_COMPONENT_DTOR
:
766 case DEMANGLE_COMPONENT_OPERATOR
:
767 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
777 d_left (last_template
) = ret_comp
;
778 return last_template
;
784 /* Return the name of the method whose linkage name is PHYSNAME. */
787 method_name_from_physname (const char *physname
)
789 void *storage
= NULL
;
790 char *demangled_name
= NULL
;
791 gdb::unique_xmalloc_ptr
<char> ret
;
792 struct demangle_component
*ret_comp
;
793 std::unique_ptr
<demangle_parse_info
> info
;
795 info
= mangled_name_to_comp (physname
, DMGL_ANSI
,
796 &storage
, &demangled_name
);
800 ret_comp
= unqualified_name_from_comp (info
->tree
);
802 if (ret_comp
!= NULL
)
803 /* The ten is completely arbitrary; we don't have a good
805 ret
= cp_comp_to_string (ret_comp
, 10);
808 xfree (demangled_name
);
809 return ret
.release ();
812 /* If FULL_NAME is the demangled name of a C++ function (including an
813 arg list, possibly including namespace/class qualifications),
814 return a new string containing only the function name (without the
815 arg list/class qualifications). Otherwise, return NULL. */
817 gdb::unique_xmalloc_ptr
<char>
818 cp_func_name (const char *full_name
)
820 gdb::unique_xmalloc_ptr
<char> ret
;
821 struct demangle_component
*ret_comp
;
822 std::unique_ptr
<demangle_parse_info
> info
;
824 info
= cp_demangled_name_to_comp (full_name
, NULL
);
828 ret_comp
= unqualified_name_from_comp (info
->tree
);
830 if (ret_comp
!= NULL
)
831 ret
= cp_comp_to_string (ret_comp
, 10);
836 /* Helper for cp_remove_params. DEMANGLED_NAME is the name of a
837 function, including parameters and (optionally) a return type.
838 Return the name of the function without parameters or return type,
839 or NULL if we can not parse the name. If REQUIRE_PARAMS is false,
840 then tolerate a non-existing or unbalanced parameter list. */
842 static gdb::unique_xmalloc_ptr
<char>
843 cp_remove_params_1 (const char *demangled_name
, bool require_params
)
846 struct demangle_component
*ret_comp
;
847 std::unique_ptr
<demangle_parse_info
> info
;
848 gdb::unique_xmalloc_ptr
<char> ret
;
850 if (demangled_name
== NULL
)
853 info
= cp_demangled_name_to_comp (demangled_name
, NULL
);
857 /* First strip off any qualifiers, if we have a function or method. */
858 ret_comp
= info
->tree
;
860 switch (ret_comp
->type
)
862 case DEMANGLE_COMPONENT_CONST
:
863 case DEMANGLE_COMPONENT_RESTRICT
:
864 case DEMANGLE_COMPONENT_VOLATILE
:
865 case DEMANGLE_COMPONENT_CONST_THIS
:
866 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
867 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
868 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
869 ret_comp
= d_left (ret_comp
);
876 /* What we have now should be a function. Return its name. */
877 if (ret_comp
->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
878 ret
= cp_comp_to_string (d_left (ret_comp
), 10);
879 else if (!require_params
880 && (ret_comp
->type
== DEMANGLE_COMPONENT_NAME
881 || ret_comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
882 || ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
))
883 ret
= cp_comp_to_string (ret_comp
, 10);
888 /* DEMANGLED_NAME is the name of a function, including parameters and
889 (optionally) a return type. Return the name of the function
890 without parameters or return type, or NULL if we can not parse the
893 gdb::unique_xmalloc_ptr
<char>
894 cp_remove_params (const char *demangled_name
)
896 return cp_remove_params_1 (demangled_name
, true);
899 /* See cp-support.h. */
901 gdb::unique_xmalloc_ptr
<char>
902 cp_remove_params_if_any (const char *demangled_name
, bool completion_mode
)
904 /* Trying to remove parameters from the empty string fails. If
905 we're completing / matching everything, avoid returning NULL
906 which would make callers interpret the result as an error. */
907 if (demangled_name
[0] == '\0' && completion_mode
)
908 return make_unique_xstrdup ("");
910 gdb::unique_xmalloc_ptr
<char> without_params
911 = cp_remove_params_1 (demangled_name
, false);
913 if (without_params
== NULL
&& completion_mode
)
915 std::string copy
= demangled_name
;
917 while (!copy
.empty ())
920 without_params
= cp_remove_params_1 (copy
.c_str (), false);
921 if (without_params
!= NULL
)
926 return without_params
;
929 /* Here are some random pieces of trivia to keep in mind while trying
930 to take apart demangled names:
932 - Names can contain function arguments or templates, so the process
933 has to be, to some extent recursive: maybe keep track of your
934 depth based on encountering <> and ().
936 - Parentheses don't just have to happen at the end of a name: they
937 can occur even if the name in question isn't a function, because
938 a template argument might be a type that's a function.
940 - Conversely, even if you're trying to deal with a function, its
941 demangled name might not end with ')': it could be a const or
942 volatile class method, in which case it ends with "const" or
945 - Parentheses are also used in anonymous namespaces: a variable
946 'foo' in an anonymous namespace gets demangled as "(anonymous
949 - And operator names can contain parentheses or angle brackets. */
951 /* FIXME: carlton/2003-03-13: We have several functions here with
952 overlapping functionality; can we combine them? Also, do they
953 handle all the above considerations correctly? */
956 /* This returns the length of first component of NAME, which should be
957 the demangled name of a C++ variable/function/method/etc.
958 Specifically, it returns the index of the first colon forming the
959 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
960 it returns the 1, and given 'foo', it returns 0. */
962 /* The character in NAME indexed by the return value is guaranteed to
963 always be either ':' or '\0'. */
965 /* NOTE: carlton/2003-03-13: This function is currently only intended
966 for internal use: it's probably not entirely safe when called on
967 user-generated input, because some of the 'index += 2' lines in
968 cp_find_first_component_aux might go past the end of malformed
972 cp_find_first_component (const char *name
)
974 return cp_find_first_component_aux (name
, 0);
977 /* Helper function for cp_find_first_component. Like that function,
978 it returns the length of the first component of NAME, but to make
979 the recursion easier, it also stops if it reaches an unexpected ')'
980 or '>' if the value of PERMISSIVE is nonzero. */
983 cp_find_first_component_aux (const char *name
, int permissive
)
985 unsigned int index
= 0;
986 /* Operator names can show up in unexpected places. Since these can
987 contain parentheses or angle brackets, they can screw up the
988 recursion. But not every string 'operator' is part of an
989 operator name: e.g. you could have a variable 'cooperator'. So
990 this variable tells us whether or not we should treat the string
991 'operator' as starting an operator. */
992 int operator_possible
= 1;
999 /* Template; eat it up. The calls to cp_first_component
1000 should only return (I hope!) when they reach the '>'
1001 terminating the component or a '::' between two
1002 components. (Hence the '+ 2'.) */
1004 for (index
+= cp_find_first_component_aux (name
+ index
, 1);
1006 index
+= cp_find_first_component_aux (name
+ index
, 1))
1008 if (name
[index
] != ':')
1010 demangled_name_complaint (name
);
1011 return strlen (name
);
1015 operator_possible
= 1;
1018 /* Similar comment as to '<'. */
1020 for (index
+= cp_find_first_component_aux (name
+ index
, 1);
1022 index
+= cp_find_first_component_aux (name
+ index
, 1))
1024 if (name
[index
] != ':')
1026 demangled_name_complaint (name
);
1027 return strlen (name
);
1031 operator_possible
= 1;
1039 demangled_name_complaint (name
);
1040 return strlen (name
);
1045 /* ':' marks a component iff the next character is also a ':'.
1046 Otherwise it is probably malformed input. */
1047 if (name
[index
+ 1] == ':')
1051 /* Operator names can screw up the recursion. */
1052 if (operator_possible
1053 && startswith (name
+ index
, CP_OPERATOR_STR
))
1055 index
+= CP_OPERATOR_LEN
;
1056 while (ISSPACE(name
[index
]))
1058 switch (name
[index
])
1062 /* Skip over one less than the appropriate number of
1063 characters: the for loop will skip over the last
1066 if (name
[index
+ 1] == '<')
1073 if (name
[index
+ 1] == '>')
1086 operator_possible
= 0;
1093 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1094 set of relevant characters are here: it's necessary to
1095 include any character that can show up before 'operator'
1096 in a demangled name, and it's safe to include any
1097 character that can't be part of an identifier's name. */
1098 operator_possible
= 1;
1101 operator_possible
= 0;
1107 /* Complain about a demangled name that we don't know how to parse.
1108 NAME is the demangled name in question. */
1111 demangled_name_complaint (const char *name
)
1113 complaint ("unexpected demangled name '%s'", name
);
1116 /* If NAME is the fully-qualified name of a C++
1117 function/variable/method/etc., this returns the length of its
1118 entire prefix: all of the namespaces and classes that make up its
1119 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1120 4, given 'foo', it returns 0. */
1123 cp_entire_prefix_len (const char *name
)
1125 unsigned int current_len
= cp_find_first_component (name
);
1126 unsigned int previous_len
= 0;
1128 while (name
[current_len
] != '\0')
1130 gdb_assert (name
[current_len
] == ':');
1131 previous_len
= current_len
;
1132 /* Skip the '::'. */
1134 current_len
+= cp_find_first_component (name
+ current_len
);
1137 return previous_len
;
1140 /* Overload resolution functions. */
1142 /* Test to see if SYM is a symbol that we haven't seen corresponding
1143 to a function named OLOAD_NAME. If so, add it to
1147 overload_list_add_symbol (struct symbol
*sym
,
1148 const char *oload_name
,
1149 std::vector
<symbol
*> *overload_list
)
1151 /* If there is no type information, we can't do anything, so
1153 if (SYMBOL_TYPE (sym
) == NULL
)
1156 /* skip any symbols that we've already considered. */
1157 for (symbol
*listed_sym
: *overload_list
)
1158 if (strcmp (sym
->linkage_name (), listed_sym
->linkage_name ()) == 0)
1161 /* Get the demangled name without parameters */
1162 gdb::unique_xmalloc_ptr
<char> sym_name
1163 = cp_remove_params (sym
->natural_name ());
1167 /* skip symbols that cannot match */
1168 if (strcmp (sym_name
.get (), oload_name
) != 0)
1171 overload_list
->push_back (sym
);
1174 /* Return a null-terminated list of pointers to function symbols that
1175 are named FUNC_NAME and are visible within NAMESPACE. */
1177 struct std::vector
<symbol
*>
1178 make_symbol_overload_list (const char *func_name
,
1179 const char *the_namespace
)
1182 std::vector
<symbol
*> overload_list
;
1184 overload_list
.reserve (100);
1186 add_symbol_overload_list_using (func_name
, the_namespace
, &overload_list
);
1188 if (the_namespace
[0] == '\0')
1192 char *concatenated_name
1193 = (char *) alloca (strlen (the_namespace
) + 2 + strlen (func_name
) + 1);
1194 strcpy (concatenated_name
, the_namespace
);
1195 strcat (concatenated_name
, "::");
1196 strcat (concatenated_name
, func_name
);
1197 name
= concatenated_name
;
1200 add_symbol_overload_list_qualified (name
, &overload_list
);
1201 return overload_list
;
1204 /* Add all symbols with a name matching NAME in BLOCK to the overload
1208 add_symbol_overload_list_block (const char *name
,
1209 const struct block
*block
,
1210 std::vector
<symbol
*> *overload_list
)
1212 struct block_iterator iter
;
1215 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
1217 ALL_BLOCK_SYMBOLS_WITH_NAME (block
, lookup_name
, iter
, sym
)
1218 overload_list_add_symbol (sym
, name
, overload_list
);
1221 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1224 add_symbol_overload_list_namespace (const char *func_name
,
1225 const char *the_namespace
,
1226 std::vector
<symbol
*> *overload_list
)
1229 const struct block
*block
= NULL
;
1231 if (the_namespace
[0] == '\0')
1235 char *concatenated_name
1236 = (char *) alloca (strlen (the_namespace
) + 2 + strlen (func_name
) + 1);
1238 strcpy (concatenated_name
, the_namespace
);
1239 strcat (concatenated_name
, "::");
1240 strcat (concatenated_name
, func_name
);
1241 name
= concatenated_name
;
1244 /* Look in the static block. */
1245 block
= block_static_block (get_selected_block (0));
1247 add_symbol_overload_list_block (name
, block
, overload_list
);
1249 /* Look in the global block. */
1250 block
= block_global_block (block
);
1252 add_symbol_overload_list_block (name
, block
, overload_list
);
1256 /* Search the namespace of the given type and namespace of and public
1260 add_symbol_overload_list_adl_namespace (struct type
*type
,
1261 const char *func_name
,
1262 std::vector
<symbol
*> *overload_list
)
1264 char *the_namespace
;
1265 const char *type_name
;
1268 while (TYPE_CODE (type
) == TYPE_CODE_PTR
1269 || TYPE_IS_REFERENCE (type
)
1270 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1271 || TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1273 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1274 type
= check_typedef(type
);
1276 type
= TYPE_TARGET_TYPE (type
);
1279 type_name
= TYPE_NAME (type
);
1281 if (type_name
== NULL
)
1284 prefix_len
= cp_entire_prefix_len (type_name
);
1286 if (prefix_len
!= 0)
1288 the_namespace
= (char *) alloca (prefix_len
+ 1);
1289 strncpy (the_namespace
, type_name
, prefix_len
);
1290 the_namespace
[prefix_len
] = '\0';
1292 add_symbol_overload_list_namespace (func_name
, the_namespace
,
1296 /* Check public base type */
1297 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1298 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1300 if (BASETYPE_VIA_PUBLIC (type
, i
))
1301 add_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type
, i
),
1307 /* Adds to OVERLOAD_LIST the overload list overload candidates for
1308 FUNC_NAME found through argument dependent lookup. */
1311 add_symbol_overload_list_adl (gdb::array_view
<type
*> arg_types
,
1312 const char *func_name
,
1313 std::vector
<symbol
*> *overload_list
)
1315 for (type
*arg_type
: arg_types
)
1316 add_symbol_overload_list_adl_namespace (arg_type
, func_name
,
1320 /* This applies the using directives to add namespaces to search in,
1321 and then searches for overloads in all of those namespaces. It
1322 adds the symbols found to sym_return_val. Arguments are as in
1323 make_symbol_overload_list. */
1326 add_symbol_overload_list_using (const char *func_name
,
1327 const char *the_namespace
,
1328 std::vector
<symbol
*> *overload_list
)
1330 struct using_direct
*current
;
1331 const struct block
*block
;
1333 /* First, go through the using directives. If any of them apply,
1334 look in the appropriate namespaces for new functions to match
1337 for (block
= get_selected_block (0);
1339 block
= BLOCK_SUPERBLOCK (block
))
1340 for (current
= block_using (block
);
1342 current
= current
->next
)
1344 /* Prevent recursive calls. */
1345 if (current
->searched
)
1348 /* If this is a namespace alias or imported declaration ignore
1350 if (current
->alias
!= NULL
|| current
->declaration
!= NULL
)
1353 if (strcmp (the_namespace
, current
->import_dest
) == 0)
1355 /* Mark this import as searched so that the recursive call
1356 does not search it again. */
1357 scoped_restore reset_directive_searched
1358 = make_scoped_restore (¤t
->searched
, 1);
1360 add_symbol_overload_list_using (func_name
,
1361 current
->import_src
,
1366 /* Now, add names for this namespace. */
1367 add_symbol_overload_list_namespace (func_name
, the_namespace
,
1371 /* This does the bulk of the work of finding overloaded symbols.
1372 FUNC_NAME is the name of the overloaded function we're looking for
1373 (possibly including namespace info). */
1376 add_symbol_overload_list_qualified (const char *func_name
,
1377 std::vector
<symbol
*> *overload_list
)
1379 const struct block
*b
, *surrounding_static_block
= 0;
1381 /* Look through the partial symtabs for all symbols which begin by
1382 matching FUNC_NAME. Make sure we read that symbol table in. */
1384 for (objfile
*objf
: current_program_space
->objfiles ())
1387 objf
->sf
->qf
->expand_symtabs_for_function (objf
, func_name
);
1390 /* Search upwards from currently selected frame (so that we can
1391 complete on local vars. */
1393 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
1394 add_symbol_overload_list_block (func_name
, b
, overload_list
);
1396 surrounding_static_block
= block_static_block (get_selected_block (0));
1398 /* Go through the symtabs and check the externs and statics for
1399 symbols which match. */
1401 for (objfile
*objfile
: current_program_space
->objfiles ())
1403 for (compunit_symtab
*cust
: objfile
->compunits ())
1406 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), GLOBAL_BLOCK
);
1407 add_symbol_overload_list_block (func_name
, b
, overload_list
);
1411 for (objfile
*objfile
: current_program_space
->objfiles ())
1413 for (compunit_symtab
*cust
: objfile
->compunits ())
1416 b
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), STATIC_BLOCK
);
1417 /* Don't do this block twice. */
1418 if (b
== surrounding_static_block
)
1420 add_symbol_overload_list_block (func_name
, b
, overload_list
);
1425 /* Lookup the rtti type for a class name. */
1428 cp_lookup_rtti_type (const char *name
, const struct block
*block
)
1430 struct symbol
* rtti_sym
;
1431 struct type
* rtti_type
;
1433 /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
1434 Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
1435 rtti_sym
= lookup_symbol (name
, block
, VAR_DOMAIN
, NULL
).symbol
;
1437 if (rtti_sym
== NULL
)
1439 warning (_("RTTI symbol not found for class '%s'"), name
);
1443 if (SYMBOL_CLASS (rtti_sym
) != LOC_TYPEDEF
)
1445 warning (_("RTTI symbol for class '%s' is not a type"), name
);
1449 rtti_type
= check_typedef (SYMBOL_TYPE (rtti_sym
));
1451 switch (TYPE_CODE (rtti_type
))
1453 case TYPE_CODE_STRUCT
:
1455 case TYPE_CODE_NAMESPACE
:
1456 /* chastain/2003-11-26: the symbol tables often contain fake
1457 symbols for namespaces with the same name as the struct.
1458 This warning is an indication of a bug in the lookup order
1459 or a bug in the way that the symbol tables are populated. */
1460 warning (_("RTTI symbol for class '%s' is a namespace"), name
);
1463 warning (_("RTTI symbol for class '%s' has bad type"), name
);
1470 #ifdef HAVE_WORKING_FORK
1472 /* If true, attempt to catch crashes in the demangler and print
1473 useful debugging information. */
1475 static bool catch_demangler_crashes
= true;
1477 /* Stack context and environment for demangler crash recovery. */
1479 static SIGJMP_BUF gdb_demangle_jmp_buf
;
1481 /* If nonzero, attempt to dump core from the signal handler. */
1483 static int gdb_demangle_attempt_core_dump
= 1;
1485 /* Signal handler for gdb_demangle. */
1488 gdb_demangle_signal_handler (int signo
)
1490 if (gdb_demangle_attempt_core_dump
)
1495 gdb_demangle_attempt_core_dump
= 0;
1498 SIGLONGJMP (gdb_demangle_jmp_buf
, signo
);
1503 /* A wrapper for bfd_demangle. */
1506 gdb_demangle (const char *name
, int options
)
1508 char *result
= NULL
;
1509 int crash_signal
= 0;
1511 #ifdef HAVE_WORKING_FORK
1512 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1513 struct sigaction sa
, old_sa
;
1517 static int core_dump_allowed
= -1;
1519 if (core_dump_allowed
== -1)
1521 core_dump_allowed
= can_dump_core (LIMIT_CUR
);
1523 if (!core_dump_allowed
)
1524 gdb_demangle_attempt_core_dump
= 0;
1527 if (catch_demangler_crashes
)
1529 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1530 sa
.sa_handler
= gdb_demangle_signal_handler
;
1531 sigemptyset (&sa
.sa_mask
);
1532 #ifdef HAVE_SIGALTSTACK
1533 sa
.sa_flags
= SA_ONSTACK
;
1537 sigaction (SIGSEGV
, &sa
, &old_sa
);
1539 ofunc
= signal (SIGSEGV
, gdb_demangle_signal_handler
);
1542 /* The signal handler may keep the signal blocked when we longjmp out
1543 of it. If we have sigprocmask, we can use it to unblock the signal
1544 afterwards and we can avoid the performance overhead of saving the
1545 signal mask just in case the signal gets triggered. Otherwise, just
1546 tell sigsetjmp to save the mask. */
1547 #ifdef HAVE_SIGPROCMASK
1548 crash_signal
= SIGSETJMP (gdb_demangle_jmp_buf
, 0);
1550 crash_signal
= SIGSETJMP (gdb_demangle_jmp_buf
, 1);
1555 if (crash_signal
== 0)
1556 result
= bfd_demangle (NULL
, name
, options
);
1558 #ifdef HAVE_WORKING_FORK
1559 if (catch_demangler_crashes
)
1561 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1562 sigaction (SIGSEGV
, &old_sa
, NULL
);
1564 signal (SIGSEGV
, ofunc
);
1567 if (crash_signal
!= 0)
1569 static int error_reported
= 0;
1571 #ifdef HAVE_SIGPROCMASK
1572 /* If we got the signal, SIGSEGV may still be blocked; restore it. */
1573 sigset_t segv_sig_set
;
1574 sigemptyset (&segv_sig_set
);
1575 sigaddset (&segv_sig_set
, SIGSEGV
);
1576 gdb_sigmask (SIG_UNBLOCK
, &segv_sig_set
, NULL
);
1579 if (!error_reported
)
1581 std::string short_msg
1582 = string_printf (_("unable to demangle '%s' "
1583 "(demangler failed with signal %d)"),
1584 name
, crash_signal
);
1586 std::string long_msg
1587 = string_printf ("%s:%d: %s: %s", __FILE__
, __LINE__
,
1588 "demangler-warning", short_msg
.c_str ());
1590 target_terminal::scoped_restore_terminal_state term_state
;
1591 target_terminal::ours_for_output ();
1594 if (core_dump_allowed
)
1595 fprintf_unfiltered (gdb_stderr
,
1596 _("%s\nAttempting to dump core.\n"),
1599 warn_cant_dump_core (long_msg
.c_str ());
1601 demangler_warning (__FILE__
, __LINE__
, "%s", short_msg
.c_str ());
1614 /* See cp-support.h. */
1617 gdb_sniff_from_mangled_name (const char *mangled
, char **demangled
)
1619 *demangled
= gdb_demangle (mangled
, DMGL_PARAMS
| DMGL_ANSI
);
1620 return *demangled
!= NULL
;
1623 /* See cp-support.h. */
1626 cp_search_name_hash (const char *search_name
)
1628 /* cp_entire_prefix_len assumes a fully-qualified name with no
1630 if (startswith (search_name
, "::"))
1633 unsigned int prefix_len
= cp_entire_prefix_len (search_name
);
1634 if (prefix_len
!= 0)
1635 search_name
+= prefix_len
+ 2;
1637 unsigned int hash
= 0;
1638 for (const char *string
= search_name
; *string
!= '\0'; ++string
)
1640 string
= skip_spaces (string
);
1645 /* Ignore ABI tags such as "[abi:cxx11]. */
1647 && startswith (string
+ 1, "abi:")
1648 && string
[5] != ':')
1651 hash
= SYMBOL_HASH_NEXT (hash
, *string
);
1656 /* Helper for cp_symbol_name_matches (i.e., symbol_name_matcher_ftype
1657 implementation for symbol_name_match_type::WILD matching). Split
1658 to a separate function for unit-testing convenience.
1660 If SYMBOL_SEARCH_NAME has more scopes than LOOKUP_NAME, we try to
1661 match ignoring the extra leading scopes of SYMBOL_SEARCH_NAME.
1662 This allows conveniently setting breakpoints on functions/methods
1663 inside any namespace/class without specifying the fully-qualified
1668 [symbol search name] [lookup name]
1669 foo::bar::func foo::bar::func
1670 foo::bar::func bar::func
1675 [symbol search name] [lookup name]
1676 foo::zbar::func bar::func
1677 foo::bar::func foo::func
1679 See more examples in the test_cp_symbol_name_matches selftest
1682 See symbol_name_matcher_ftype for description of SYMBOL_SEARCH_NAME
1685 LOOKUP_NAME/LOOKUP_NAME_LEN is the name we're looking up.
1687 See strncmp_iw_with_mode for description of MODE.
1691 cp_symbol_name_matches_1 (const char *symbol_search_name
,
1692 const char *lookup_name
,
1693 size_t lookup_name_len
,
1694 strncmp_iw_mode mode
,
1695 completion_match_result
*comp_match_res
)
1697 const char *sname
= symbol_search_name
;
1698 completion_match_for_lcd
*match_for_lcd
1699 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
1703 if (strncmp_iw_with_mode (sname
, lookup_name
, lookup_name_len
,
1704 mode
, language_cplus
, match_for_lcd
) == 0)
1706 if (comp_match_res
!= NULL
)
1708 /* Note here we set different MATCH and MATCH_FOR_LCD
1709 strings. This is because with
1711 (gdb) b push_bac[TAB]
1713 we want the completion matches to list
1715 std::vector<int>::push_back(...)
1716 std::vector<char>::push_back(...)
1718 etc., which are SYMBOL_SEARCH_NAMEs, while we want
1719 the input line to auto-complete to
1721 (gdb) push_back(...)
1723 which is SNAME, not to
1727 which would be the regular common prefix between all
1728 the matches otherwise. */
1729 comp_match_res
->set_match (symbol_search_name
, sname
);
1734 unsigned int len
= cp_find_first_component (sname
);
1736 if (sname
[len
] == '\0')
1739 gdb_assert (sname
[len
] == ':');
1740 /* Skip the '::'. */
1745 /* C++ symbol_name_matcher_ftype implementation. */
1748 cp_fq_symbol_name_matches (const char *symbol_search_name
,
1749 const lookup_name_info
&lookup_name
,
1750 completion_match_result
*comp_match_res
)
1752 /* Get the demangled name. */
1753 const std::string
&name
= lookup_name
.cplus ().lookup_name ();
1754 completion_match_for_lcd
*match_for_lcd
1755 = (comp_match_res
!= NULL
? &comp_match_res
->match_for_lcd
: NULL
);
1756 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
1757 ? strncmp_iw_mode::NORMAL
1758 : strncmp_iw_mode::MATCH_PARAMS
);
1760 if (strncmp_iw_with_mode (symbol_search_name
,
1761 name
.c_str (), name
.size (),
1762 mode
, language_cplus
, match_for_lcd
) == 0)
1764 if (comp_match_res
!= NULL
)
1765 comp_match_res
->set_match (symbol_search_name
);
1772 /* C++ symbol_name_matcher_ftype implementation for wild matches.
1773 Defers work to cp_symbol_name_matches_1. */
1776 cp_symbol_name_matches (const char *symbol_search_name
,
1777 const lookup_name_info
&lookup_name
,
1778 completion_match_result
*comp_match_res
)
1780 /* Get the demangled name. */
1781 const std::string
&name
= lookup_name
.cplus ().lookup_name ();
1783 strncmp_iw_mode mode
= (lookup_name
.completion_mode ()
1784 ? strncmp_iw_mode::NORMAL
1785 : strncmp_iw_mode::MATCH_PARAMS
);
1787 return cp_symbol_name_matches_1 (symbol_search_name
,
1788 name
.c_str (), name
.size (),
1789 mode
, comp_match_res
);
1792 /* See cp-support.h. */
1794 symbol_name_matcher_ftype
*
1795 cp_get_symbol_name_matcher (const lookup_name_info
&lookup_name
)
1797 switch (lookup_name
.match_type ())
1799 case symbol_name_match_type::FULL
:
1800 case symbol_name_match_type::EXPRESSION
:
1801 case symbol_name_match_type::SEARCH_NAME
:
1802 return cp_fq_symbol_name_matches
;
1803 case symbol_name_match_type::WILD
:
1804 return cp_symbol_name_matches
;
1807 gdb_assert_not_reached ("");
1812 namespace selftests
{
1815 test_cp_symbol_name_matches ()
1817 #define CHECK_MATCH(SYMBOL, INPUT) \
1818 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, \
1819 INPUT, sizeof (INPUT) - 1, \
1820 strncmp_iw_mode::MATCH_PARAMS, \
1823 #define CHECK_NOT_MATCH(SYMBOL, INPUT) \
1824 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, \
1825 INPUT, sizeof (INPUT) - 1, \
1826 strncmp_iw_mode::MATCH_PARAMS, \
1829 /* Like CHECK_MATCH, and also check that INPUT (and all substrings
1830 that start at index 0) completes to SYMBOL. */
1831 #define CHECK_MATCH_C(SYMBOL, INPUT) \
1834 CHECK_MATCH (SYMBOL, INPUT); \
1835 for (size_t i = 0; i < sizeof (INPUT) - 1; i++) \
1836 SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, INPUT, i, \
1837 strncmp_iw_mode::NORMAL, \
1841 /* Like CHECK_NOT_MATCH, and also check that INPUT does NOT complete
1843 #define CHECK_NOT_MATCH_C(SYMBOL, INPUT) \
1846 CHECK_NOT_MATCH (SYMBOL, INPUT); \
1847 SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, INPUT, \
1848 sizeof (INPUT) - 1, \
1849 strncmp_iw_mode::NORMAL, \
1853 /* Lookup name without parens matches all overloads. */
1854 CHECK_MATCH_C ("function()", "function");
1855 CHECK_MATCH_C ("function(int)", "function");
1857 /* Check whitespace around parameters is ignored. */
1858 CHECK_MATCH_C ("function()", "function ()");
1859 CHECK_MATCH_C ("function ( )", "function()");
1860 CHECK_MATCH_C ("function ()", "function( )");
1861 CHECK_MATCH_C ("func(int)", "func( int )");
1862 CHECK_MATCH_C ("func(int)", "func ( int ) ");
1863 CHECK_MATCH_C ("func ( int )", "func( int )");
1864 CHECK_MATCH_C ("func ( int )", "func ( int ) ");
1866 /* Check symbol name prefixes aren't incorrectly matched. */
1867 CHECK_NOT_MATCH ("func", "function");
1868 CHECK_NOT_MATCH ("function", "func");
1869 CHECK_NOT_MATCH ("function()", "func");
1871 /* Check that if the lookup name includes parameters, only the right
1872 overload matches. */
1873 CHECK_MATCH_C ("function(int)", "function(int)");
1874 CHECK_NOT_MATCH_C ("function(int)", "function()");
1876 /* Check that whitespace within symbol names is not ignored. */
1877 CHECK_NOT_MATCH_C ("function", "func tion");
1878 CHECK_NOT_MATCH_C ("func__tion", "func_ _tion");
1879 CHECK_NOT_MATCH_C ("func11tion", "func1 1tion");
1881 /* Check the converse, which can happen with template function,
1882 where the return type is part of the demangled name. */
1883 CHECK_NOT_MATCH_C ("func tion", "function");
1884 CHECK_NOT_MATCH_C ("func1 1tion", "func11tion");
1885 CHECK_NOT_MATCH_C ("func_ _tion", "func__tion");
1887 /* Within parameters too. */
1888 CHECK_NOT_MATCH_C ("func(param)", "func(par am)");
1890 /* Check handling of whitespace around C++ operators. */
1891 CHECK_NOT_MATCH_C ("operator<<", "opera tor<<");
1892 CHECK_NOT_MATCH_C ("operator<<", "operator< <");
1893 CHECK_NOT_MATCH_C ("operator<<", "operator < <");
1894 CHECK_NOT_MATCH_C ("operator==", "operator= =");
1895 CHECK_NOT_MATCH_C ("operator==", "operator = =");
1896 CHECK_MATCH_C ("operator<<", "operator <<");
1897 CHECK_MATCH_C ("operator<<()", "operator <<");
1898 CHECK_NOT_MATCH_C ("operator<<()", "operator<<(int)");
1899 CHECK_NOT_MATCH_C ("operator<<(int)", "operator<<()");
1900 CHECK_MATCH_C ("operator==", "operator ==");
1901 CHECK_MATCH_C ("operator==()", "operator ==");
1902 CHECK_MATCH_C ("operator <<", "operator<<");
1903 CHECK_MATCH_C ("operator ==", "operator==");
1904 CHECK_MATCH_C ("operator bool", "operator bool");
1905 CHECK_MATCH_C ("operator bool ()", "operator bool");
1906 CHECK_MATCH_C ("operatorX<<", "operatorX < <");
1907 CHECK_MATCH_C ("Xoperator<<", "Xoperator < <");
1909 CHECK_MATCH_C ("operator()(int)", "operator()(int)");
1910 CHECK_MATCH_C ("operator()(int)", "operator ( ) ( int )");
1911 CHECK_MATCH_C ("operator()<long>(int)", "operator ( ) < long > ( int )");
1912 /* The first "()" is not the parameter list. */
1913 CHECK_NOT_MATCH ("operator()(int)", "operator");
1915 /* Misc user-defined operator tests. */
1917 CHECK_NOT_MATCH_C ("operator/=()", "operator ^=");
1918 /* Same length at end of input. */
1919 CHECK_NOT_MATCH_C ("operator>>", "operator[]");
1920 /* Same length but not at end of input. */
1921 CHECK_NOT_MATCH_C ("operator>>()", "operator[]()");
1923 CHECK_MATCH_C ("base::operator char*()", "base::operator char*()");
1924 CHECK_MATCH_C ("base::operator char*()", "base::operator char * ()");
1925 CHECK_MATCH_C ("base::operator char**()", "base::operator char * * ()");
1926 CHECK_MATCH ("base::operator char**()", "base::operator char * *");
1927 CHECK_MATCH_C ("base::operator*()", "base::operator*()");
1928 CHECK_NOT_MATCH_C ("base::operator char*()", "base::operatorc");
1929 CHECK_NOT_MATCH ("base::operator char*()", "base::operator char");
1930 CHECK_NOT_MATCH ("base::operator char*()", "base::operat");
1932 /* Check handling of whitespace around C++ scope operators. */
1933 CHECK_NOT_MATCH_C ("foo::bar", "foo: :bar");
1934 CHECK_MATCH_C ("foo::bar", "foo :: bar");
1935 CHECK_MATCH_C ("foo :: bar", "foo::bar");
1937 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi()");
1938 CHECK_MATCH_C ("abc::def::ghi ( )", "abc::def::ghi()");
1939 CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi ( )");
1940 CHECK_MATCH_C ("function()", "function()");
1941 CHECK_MATCH_C ("bar::function()", "bar::function()");
1943 /* Wild matching tests follow. */
1945 /* Tests matching symbols in some scope. */
1946 CHECK_MATCH_C ("foo::function()", "function");
1947 CHECK_MATCH_C ("foo::function(int)", "function");
1948 CHECK_MATCH_C ("foo::bar::function()", "function");
1949 CHECK_MATCH_C ("bar::function()", "bar::function");
1950 CHECK_MATCH_C ("foo::bar::function()", "bar::function");
1951 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function");
1953 /* Same, with parameters in the lookup name. */
1954 CHECK_MATCH_C ("foo::function()", "function()");
1955 CHECK_MATCH_C ("foo::bar::function()", "function()");
1956 CHECK_MATCH_C ("foo::function(int)", "function(int)");
1957 CHECK_MATCH_C ("foo::function()", "foo::function()");
1958 CHECK_MATCH_C ("foo::bar::function()", "bar::function()");
1959 CHECK_MATCH_C ("foo::bar::function(int)", "bar::function(int)");
1960 CHECK_MATCH_C ("bar::function()", "bar::function()");
1962 CHECK_NOT_MATCH_C ("foo::bar::function(int)", "bar::function()");
1964 CHECK_MATCH_C ("(anonymous namespace)::bar::function(int)",
1965 "bar::function(int)");
1966 CHECK_MATCH_C ("foo::(anonymous namespace)::bar::function(int)",
1969 /* Lookup scope wider than symbol scope, should not match. */
1970 CHECK_NOT_MATCH_C ("function()", "bar::function");
1971 CHECK_NOT_MATCH_C ("function()", "bar::function()");
1973 /* Explicit global scope doesn't match. */
1974 CHECK_NOT_MATCH_C ("foo::function()", "::function");
1975 CHECK_NOT_MATCH_C ("foo::function()", "::function()");
1976 CHECK_NOT_MATCH_C ("foo::function(int)", "::function()");
1977 CHECK_NOT_MATCH_C ("foo::function(int)", "::function(int)");
1979 /* Test ABI tag matching/ignoring. */
1981 /* If the symbol name has an ABI tag, but the lookup name doesn't,
1982 then the ABI tag in the symbol name is ignored. */
1983 CHECK_MATCH_C ("function[abi:foo]()", "function");
1984 CHECK_MATCH_C ("function[abi:foo](int)", "function");
1985 CHECK_MATCH_C ("function[abi:foo]()", "function ()");
1986 CHECK_NOT_MATCH_C ("function[abi:foo]()", "function (int)");
1988 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo]");
1989 CHECK_MATCH_C ("function[abi:foo](int)", "function[abi:foo]");
1990 CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo] ()");
1991 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function");
1992 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function");
1993 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo]");
1994 CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function[abi:foo]");
1995 CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] ()");
1996 CHECK_NOT_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] (int)");
1998 CHECK_MATCH_C ("function [abi:foo][abi:bar] ( )", "function [abi:foo]");
2000 /* If the symbol name does not have an ABI tag, while the lookup
2001 name has one, then there's no match. */
2002 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]()");
2003 CHECK_NOT_MATCH_C ("function()", "function[abi:foo]");
2006 /* If non-NULL, return STR wrapped in quotes. Otherwise, return a
2007 "<null>" string (with no quotes). */
2010 quote (const char *str
)
2013 return std::string (1, '\"') + str
+ '\"';
2018 /* Check that removing parameter info out of NAME produces EXPECTED.
2019 COMPLETION_MODE indicates whether we're testing normal and
2020 completion mode. FILE and LINE are used to provide better test
2021 location information in case ithe check fails. */
2024 check_remove_params (const char *file
, int line
,
2025 const char *name
, const char *expected
,
2026 bool completion_mode
)
2028 gdb::unique_xmalloc_ptr
<char> result
2029 = cp_remove_params_if_any (name
, completion_mode
);
2031 if ((expected
== NULL
) != (result
== NULL
)
2032 || (expected
!= NULL
2033 && strcmp (result
.get (), expected
) != 0))
2035 error (_("%s:%d: make-paramless self-test failed: (completion=%d) "
2036 "\"%s\" -> %s, expected %s"),
2037 file
, line
, completion_mode
, name
,
2038 quote (result
.get ()).c_str (), quote (expected
).c_str ());
2042 /* Entry point for cp_remove_params unit tests. */
2045 test_cp_remove_params ()
2047 /* Check that removing parameter info out of NAME produces EXPECTED.
2048 Checks both normal and completion modes. */
2049 #define CHECK(NAME, EXPECTED) \
2052 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, false); \
2053 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2057 /* Similar, but used when NAME is incomplete -- i.e., is has
2058 unbalanced parentheses. In this case, looking for the exact name
2059 should fail / return empty. */
2060 #define CHECK_INCOMPL(NAME, EXPECTED) \
2063 check_remove_params (__FILE__, __LINE__, NAME, NULL, false); \
2064 check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true); \
2068 CHECK ("function()", "function");
2069 CHECK_INCOMPL ("function(", "function");
2070 CHECK ("function() const", "function");
2072 CHECK ("(anonymous namespace)::A::B::C",
2073 "(anonymous namespace)::A::B::C");
2075 CHECK ("A::(anonymous namespace)",
2076 "A::(anonymous namespace)");
2078 CHECK_INCOMPL ("A::(anonymou", "A");
2080 CHECK ("A::foo<int>()",
2083 CHECK_INCOMPL ("A::foo<int>(",
2086 CHECK ("A::foo<(anonymous namespace)::B>::func(int)",
2087 "A::foo<(anonymous namespace)::B>::func");
2089 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::func(in",
2090 "A::foo<(anonymous namespace)::B>::func");
2092 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::",
2093 "A::foo<(anonymous namespace)::B>");
2095 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>:",
2096 "A::foo<(anonymous namespace)::B>");
2098 CHECK ("A::foo<(anonymous namespace)::B>",
2099 "A::foo<(anonymous namespace)::B>");
2101 CHECK_INCOMPL ("A::foo<(anonymous namespace)::B",
2104 /* Shouldn't this parse? Looks like a bug in
2105 cp_demangled_name_to_comp. See PR c++/22411. */
2107 CHECK ("A::foo<void(int)>::func(int)",
2108 "A::foo<void(int)>::func");
2110 CHECK_INCOMPL ("A::foo<void(int)>::func(int)",
2114 CHECK_INCOMPL ("A::foo<void(int",
2118 #undef CHECK_INCOMPL
2121 } // namespace selftests
2123 #endif /* GDB_SELF_CHECK */
2125 /* Don't allow just "maintenance cplus". */
2128 maint_cplus_command (const char *arg
, int from_tty
)
2130 printf_unfiltered (_("\"maintenance cplus\" must be followed "
2131 "by the name of a command.\n"));
2132 help_list (maint_cplus_cmd_list
,
2133 "maintenance cplus ",
2134 all_commands
, gdb_stdout
);
2137 /* This is a front end for cp_find_first_component, for unit testing.
2138 Be careful when using it: see the NOTE above
2139 cp_find_first_component. */
2142 first_component_command (const char *arg
, int from_tty
)
2150 len
= cp_find_first_component (arg
);
2151 prefix
= (char *) alloca (len
+ 1);
2153 memcpy (prefix
, arg
, len
);
2156 printf_unfiltered ("%s\n", prefix
);
2159 /* Implement "info vtbl". */
2162 info_vtbl_command (const char *arg
, int from_tty
)
2164 struct value
*value
;
2166 value
= parse_and_eval (arg
);
2167 cplus_print_vtable (value
);
2171 _initialize_cp_support (void)
2173 add_prefix_cmd ("cplus", class_maintenance
,
2174 maint_cplus_command
,
2175 _("C++ maintenance commands."),
2176 &maint_cplus_cmd_list
,
2177 "maintenance cplus ",
2178 0, &maintenancelist
);
2179 add_alias_cmd ("cp", "cplus",
2180 class_maintenance
, 1,
2183 add_cmd ("first_component",
2185 first_component_command
,
2186 _("Print the first class/namespace component of NAME."),
2187 &maint_cplus_cmd_list
);
2189 add_info ("vtbl", info_vtbl_command
,
2190 _("Show the virtual function table for a C++ object.\n\
2191 Usage: info vtbl EXPRESSION\n\
2192 Evaluate EXPRESSION and display the virtual function table for the\n\
2193 resulting object."));
2195 #ifdef HAVE_WORKING_FORK
2196 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance
,
2197 &catch_demangler_crashes
, _("\
2198 Set whether to attempt to catch demangler crashes."), _("\
2199 Show whether to attempt to catch demangler crashes."), _("\
2200 If enabled GDB will attempt to catch demangler crashes and\n\
2201 display the offending symbol."),
2204 &maintenance_set_cmdlist
,
2205 &maintenance_show_cmdlist
);
2209 selftests::register_test ("cp_symbol_name_matches",
2210 selftests::test_cp_symbol_name_matches
);
2211 selftests::register_test ("cp_remove_params",
2212 selftests::test_cp_remove_params
);