1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2002-2014 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 "exceptions.h"
33 #include "expression.h"
38 #include "safe-ctype.h"
40 #define d_left(dc) (dc)->u.s_binary.left
41 #define d_right(dc) (dc)->u.s_binary.right
43 /* Functions related to demangled name parsing. */
45 static unsigned int cp_find_first_component_aux (const char *name
,
48 static void demangled_name_complaint (const char *name
);
50 /* Functions/variables related to overload resolution. */
52 static int sym_return_val_size
= -1;
53 static int sym_return_val_index
;
54 static struct symbol
**sym_return_val
;
56 static void overload_list_add_symbol (struct symbol
*sym
,
57 const char *oload_name
);
59 static void make_symbol_overload_list_using (const char *func_name
,
60 const char *namespace);
62 static void make_symbol_overload_list_qualified (const char *func_name
);
64 /* The list of "maint cplus" commands. */
66 struct cmd_list_element
*maint_cplus_cmd_list
= NULL
;
68 /* The actual commands. */
70 static void maint_cplus_command (char *arg
, int from_tty
);
71 static void first_component_command (char *arg
, int from_tty
);
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 obstack_copy (obstack
, string
, *len
);
98 /* A cleanup wrapper for cp_demangled_name_parse_free. */
101 do_demangled_name_parse_free_cleanup (void *data
)
103 struct demangle_parse_info
*info
= (struct demangle_parse_info
*) data
;
105 cp_demangled_name_parse_free (info
);
108 /* Create a cleanup for C++ name parsing. */
111 make_cleanup_cp_demangled_name_parse_free (struct demangle_parse_info
*info
)
113 return make_cleanup (do_demangled_name_parse_free_cleanup
, info
);
116 /* Return 1 if STRING is clearly already in canonical form. This
117 function is conservative; things which it does not recognize are
118 assumed to be non-canonical, and the parser will sort them out
119 afterwards. This speeds up the critical path for alphanumeric
123 cp_already_canonical (const char *string
)
125 /* Identifier start character [a-zA-Z_]. */
126 if (!ISIDST (string
[0]))
129 /* These are the only two identifiers which canonicalize to other
130 than themselves or an error: unsigned -> unsigned int and
132 if (string
[0] == 'u' && strcmp (&string
[1], "nsigned") == 0)
134 else if (string
[0] == 's' && strcmp (&string
[1], "igned") == 0)
137 /* Identifier character [a-zA-Z0-9_]. */
138 while (ISIDNUM (string
[1]))
141 if (string
[1] == '\0')
147 /* Inspect the given RET_COMP for its type. If it is a typedef,
148 replace the node with the typedef's tree.
150 Returns 1 if any typedef substitutions were made, 0 otherwise. */
153 inspect_type (struct demangle_parse_info
*info
,
154 struct demangle_component
*ret_comp
,
155 canonicalization_ftype
*finder
,
161 volatile struct gdb_exception except
;
163 /* Copy the symbol's name from RET_COMP and look it up
164 in the symbol table. */
165 name
= (char *) alloca (ret_comp
->u
.s_name
.len
+ 1);
166 memcpy (name
, ret_comp
->u
.s_name
.s
, ret_comp
->u
.s_name
.len
);
167 name
[ret_comp
->u
.s_name
.len
] = '\0';
169 /* Ignore any typedefs that should not be substituted. */
170 for (i
= 0; i
< ARRAY_SIZE (ignore_typedefs
); ++i
)
172 if (strcmp (name
, ignore_typedefs
[i
]) == 0)
177 TRY_CATCH (except
, RETURN_MASK_ALL
)
179 sym
= lookup_symbol (name
, 0, VAR_DOMAIN
, 0);
182 if (except
.reason
>= 0 && sym
!= NULL
)
184 struct type
*otype
= SYMBOL_TYPE (sym
);
188 const char *new_name
= (*finder
) (otype
, data
);
190 if (new_name
!= NULL
)
192 ret_comp
->u
.s_name
.s
= new_name
;
193 ret_comp
->u
.s_name
.len
= strlen (new_name
);
200 /* If the type is a typedef or namespace alias, replace it. */
201 if (TYPE_CODE (otype
) == TYPE_CODE_TYPEDEF
202 || TYPE_CODE (otype
) == TYPE_CODE_NAMESPACE
)
207 struct demangle_parse_info
*i
;
210 /* Get the real type of the typedef. */
211 type
= check_typedef (otype
);
213 /* If the symbol is a namespace and its type name is no different
214 than the name we looked up, this symbol is not a namespace
215 alias and does not need to be substituted. */
216 if (TYPE_CODE (otype
) == TYPE_CODE_NAMESPACE
217 && strcmp (TYPE_NAME (type
), name
) == 0)
220 is_anon
= (TYPE_TAG_NAME (type
) == NULL
221 && (TYPE_CODE (type
) == TYPE_CODE_ENUM
222 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
223 || TYPE_CODE (type
) == TYPE_CODE_UNION
));
226 struct type
*last
= otype
;
228 /* Find the last typedef for the type. */
229 while (TYPE_TARGET_TYPE (last
) != NULL
230 && (TYPE_CODE (TYPE_TARGET_TYPE (last
))
231 == TYPE_CODE_TYPEDEF
))
232 last
= TYPE_TARGET_TYPE (last
);
234 /* If there is only one typedef for this anonymous type,
235 do not substitute it. */
239 /* Use the last typedef seen as the type for this
244 buf
= mem_fileopen ();
245 TRY_CATCH (except
, RETURN_MASK_ERROR
)
247 type_print (type
, "", buf
, -1);
250 /* If type_print threw an exception, there is little point
251 in continuing, so just bow out gracefully. */
252 if (except
.reason
< 0)
254 ui_file_delete (buf
);
258 name
= ui_file_obsavestring (buf
, &info
->obstack
, &len
);
259 ui_file_delete (buf
);
261 /* Turn the result into a new tree. Note that this
262 tree will contain pointers into NAME, so NAME cannot
263 be free'd until all typedef conversion is done and
264 the final result is converted into a string. */
265 i
= cp_demangled_name_to_comp (name
, NULL
);
268 /* Merge the two trees. */
269 cp_merge_demangle_parse_infos (info
, ret_comp
, i
);
271 /* Replace any newly introduced typedefs -- but not
272 if the type is anonymous (that would lead to infinite
275 replace_typedefs (info
, ret_comp
, finder
, data
);
279 /* This shouldn't happen unless the type printer has
280 output something that the name parser cannot grok.
281 Nonetheless, an ounce of prevention...
283 Canonicalize the name again, and store it in the
284 current node (RET_COMP). */
285 char *canon
= cp_canonicalize_string_no_typedefs (name
);
289 /* Copy the canonicalization into the obstack and
291 name
= copy_string_to_obstack (&info
->obstack
, canon
, &len
);
295 ret_comp
->u
.s_name
.s
= name
;
296 ret_comp
->u
.s_name
.len
= len
;
306 /* Replace any typedefs appearing in the qualified name
307 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
311 replace_typedefs_qualified_name (struct demangle_parse_info
*info
,
312 struct demangle_component
*ret_comp
,
313 canonicalization_ftype
*finder
,
318 struct ui_file
*buf
= mem_fileopen ();
319 struct demangle_component
*comp
= ret_comp
;
321 /* Walk each node of the qualified name, reconstructing the name of
322 this element. With every node, check for any typedef substitutions.
323 If a substitution has occurred, replace the qualified name node
324 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
326 while (comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
)
328 if (d_left (comp
)->type
== DEMANGLE_COMPONENT_NAME
)
330 struct demangle_component
new;
332 ui_file_write (buf
, d_left (comp
)->u
.s_name
.s
,
333 d_left (comp
)->u
.s_name
.len
);
334 name
= ui_file_obsavestring (buf
, &info
->obstack
, &len
);
335 new.type
= DEMANGLE_COMPONENT_NAME
;
336 new.u
.s_name
.s
= name
;
337 new.u
.s_name
.len
= len
;
338 if (inspect_type (info
, &new, finder
, data
))
343 /* A typedef was substituted in NEW. Convert it to a
344 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
347 ui_file_rewind (buf
);
348 n
= cp_comp_to_string (&new, 100);
351 /* If something went astray, abort typedef substitutions. */
352 ui_file_delete (buf
);
356 s
= copy_string_to_obstack (&info
->obstack
, n
, &slen
);
359 d_left (ret_comp
)->type
= DEMANGLE_COMPONENT_NAME
;
360 d_left (ret_comp
)->u
.s_name
.s
= s
;
361 d_left (ret_comp
)->u
.s_name
.len
= slen
;
362 d_right (ret_comp
) = d_right (comp
);
369 /* The current node is not a name, so simply replace any
370 typedefs in it. Then print it to the stream to continue
371 checking for more typedefs in the tree. */
372 replace_typedefs (info
, d_left (comp
), finder
, data
);
373 name
= cp_comp_to_string (d_left (comp
), 100);
376 /* If something went astray, abort typedef substitutions. */
377 ui_file_delete (buf
);
380 fputs_unfiltered (name
, buf
);
384 ui_file_write (buf
, "::", 2);
385 comp
= d_right (comp
);
388 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
389 name assembled above and append the name given by COMP. Then use this
390 reassembled name to check for a typedef. */
392 if (comp
->type
== DEMANGLE_COMPONENT_NAME
)
394 ui_file_write (buf
, comp
->u
.s_name
.s
, comp
->u
.s_name
.len
);
395 name
= ui_file_obsavestring (buf
, &info
->obstack
, &len
);
397 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
398 with a DEMANGLE_COMPONENT_NAME node containing the whole
400 ret_comp
->type
= DEMANGLE_COMPONENT_NAME
;
401 ret_comp
->u
.s_name
.s
= name
;
402 ret_comp
->u
.s_name
.len
= len
;
403 inspect_type (info
, ret_comp
, finder
, data
);
406 replace_typedefs (info
, comp
, finder
, data
);
408 ui_file_delete (buf
);
412 /* A function to check const and volatile qualifiers for argument types.
414 "Parameter declarations that differ only in the presence
415 or absence of `const' and/or `volatile' are equivalent."
416 C++ Standard N3290, clause 13.1.3 #4. */
419 check_cv_qualifiers (struct demangle_component
*ret_comp
)
421 while (d_left (ret_comp
) != NULL
422 && (d_left (ret_comp
)->type
== DEMANGLE_COMPONENT_CONST
423 || d_left (ret_comp
)->type
== DEMANGLE_COMPONENT_VOLATILE
))
425 d_left (ret_comp
) = d_left (d_left (ret_comp
));
429 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
430 their basic types. */
433 replace_typedefs (struct demangle_parse_info
*info
,
434 struct demangle_component
*ret_comp
,
435 canonicalization_ftype
*finder
,
441 && (ret_comp
->type
== DEMANGLE_COMPONENT_NAME
442 || ret_comp
->type
== DEMANGLE_COMPONENT_QUAL_NAME
443 || ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
444 || ret_comp
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
))
446 char *local_name
= cp_comp_to_string (ret_comp
, 10);
448 if (local_name
!= NULL
)
451 volatile struct gdb_exception except
;
454 TRY_CATCH (except
, RETURN_MASK_ALL
)
456 sym
= lookup_symbol (local_name
, 0, VAR_DOMAIN
, 0);
460 if (except
.reason
>= 0 && sym
!= NULL
)
462 struct type
*otype
= SYMBOL_TYPE (sym
);
463 const char *new_name
= (*finder
) (otype
, data
);
465 if (new_name
!= NULL
)
467 ret_comp
->type
= DEMANGLE_COMPONENT_NAME
;
468 ret_comp
->u
.s_name
.s
= new_name
;
469 ret_comp
->u
.s_name
.len
= strlen (new_name
);
476 switch (ret_comp
->type
)
478 case DEMANGLE_COMPONENT_ARGLIST
:
479 check_cv_qualifiers (ret_comp
);
482 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
483 case DEMANGLE_COMPONENT_TEMPLATE
:
484 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
485 case DEMANGLE_COMPONENT_TYPED_NAME
:
486 replace_typedefs (info
, d_left (ret_comp
), finder
, data
);
487 replace_typedefs (info
, d_right (ret_comp
), finder
, data
);
490 case DEMANGLE_COMPONENT_NAME
:
491 inspect_type (info
, ret_comp
, finder
, data
);
494 case DEMANGLE_COMPONENT_QUAL_NAME
:
495 replace_typedefs_qualified_name (info
, ret_comp
, finder
, data
);
498 case DEMANGLE_COMPONENT_LOCAL_NAME
:
499 case DEMANGLE_COMPONENT_CTOR
:
500 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
501 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
502 replace_typedefs (info
, d_right (ret_comp
), finder
, data
);
505 case DEMANGLE_COMPONENT_CONST
:
506 case DEMANGLE_COMPONENT_RESTRICT
:
507 case DEMANGLE_COMPONENT_VOLATILE
:
508 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
509 case DEMANGLE_COMPONENT_CONST_THIS
:
510 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
511 case DEMANGLE_COMPONENT_POINTER
:
512 case DEMANGLE_COMPONENT_REFERENCE
:
513 replace_typedefs (info
, d_left (ret_comp
), finder
, data
);
522 /* Parse STRING and convert it to canonical form, resolving any typedefs.
523 If parsing fails, or if STRING is already canonical, return NULL.
524 Otherwise return the canonical form. The return value is allocated via
525 xmalloc. If FINDER is not NULL, then type components are passed to
526 FINDER to be looked up. DATA is passed verbatim to FINDER. */
529 cp_canonicalize_string_full (const char *string
,
530 canonicalization_ftype
*finder
,
534 unsigned int estimated_len
;
535 struct demangle_parse_info
*info
;
538 estimated_len
= strlen (string
) * 2;
539 info
= cp_demangled_name_to_comp (string
, NULL
);
542 /* Replace all the typedefs in the tree. */
543 replace_typedefs (info
, info
->tree
, finder
, data
);
545 /* Convert the tree back into a string. */
546 ret
= cp_comp_to_string (info
->tree
, estimated_len
);
547 gdb_assert (ret
!= NULL
);
549 /* Free the parse information. */
550 cp_demangled_name_parse_free (info
);
552 /* Finally, compare the original string with the computed
553 name, returning NULL if they are the same. */
554 if (strcmp (string
, ret
) == 0)
564 /* Like cp_canonicalize_string_full, but always passes NULL for
568 cp_canonicalize_string_no_typedefs (const char *string
)
570 return cp_canonicalize_string_full (string
, NULL
, NULL
);
573 /* Parse STRING and convert it to canonical form. If parsing fails,
574 or if STRING is already canonical, return NULL. Otherwise return
575 the canonical form. The return value is allocated via xmalloc. */
578 cp_canonicalize_string (const char *string
)
580 struct demangle_parse_info
*info
;
581 unsigned int estimated_len
;
584 if (cp_already_canonical (string
))
587 info
= cp_demangled_name_to_comp (string
, NULL
);
591 estimated_len
= strlen (string
) * 2;
592 ret
= cp_comp_to_string (info
->tree
, estimated_len
);
593 cp_demangled_name_parse_free (info
);
597 warning (_("internal error: string \"%s\" failed to be canonicalized"),
602 if (strcmp (string
, ret
) == 0)
611 /* Convert a mangled name to a demangle_component tree. *MEMORY is
612 set to the block of used memory that should be freed when finished
613 with the tree. DEMANGLED_P is set to the char * that should be
614 freed when finished with the tree, or NULL if none was needed.
615 OPTIONS will be passed to the demangler. */
617 static struct demangle_parse_info
*
618 mangled_name_to_comp (const char *mangled_name
, int options
,
619 void **memory
, char **demangled_p
)
621 char *demangled_name
;
622 struct demangle_parse_info
*info
;
624 /* If it looks like a v3 mangled name, then try to go directly
626 if (mangled_name
[0] == '_' && mangled_name
[1] == 'Z')
628 struct demangle_component
*ret
;
630 ret
= cplus_demangle_v3_components (mangled_name
,
634 info
= cp_new_demangle_parse_info ();
641 /* If it doesn't, or if that failed, then try to demangle the
643 demangled_name
= gdb_demangle (mangled_name
, options
);
644 if (demangled_name
== NULL
)
647 /* If we could demangle the name, parse it to build the component
649 info
= cp_demangled_name_to_comp (demangled_name
, NULL
);
653 xfree (demangled_name
);
657 *demangled_p
= demangled_name
;
661 /* Return the name of the class containing method PHYSNAME. */
664 cp_class_name_from_physname (const char *physname
)
666 void *storage
= NULL
;
667 char *demangled_name
= NULL
, *ret
;
668 struct demangle_component
*ret_comp
, *prev_comp
, *cur_comp
;
669 struct demangle_parse_info
*info
;
672 info
= mangled_name_to_comp (physname
, DMGL_ANSI
,
673 &storage
, &demangled_name
);
678 ret_comp
= info
->tree
;
680 /* First strip off any qualifiers, if we have a function or
683 switch (ret_comp
->type
)
685 case DEMANGLE_COMPONENT_CONST
:
686 case DEMANGLE_COMPONENT_RESTRICT
:
687 case DEMANGLE_COMPONENT_VOLATILE
:
688 case DEMANGLE_COMPONENT_CONST_THIS
:
689 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
690 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
691 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
692 ret_comp
= d_left (ret_comp
);
699 /* If what we have now is a function, discard the argument list. */
700 if (ret_comp
->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
701 ret_comp
= d_left (ret_comp
);
703 /* If what we have now is a template, strip off the template
704 arguments. The left subtree may be a qualified name. */
705 if (ret_comp
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
706 ret_comp
= d_left (ret_comp
);
708 /* What we have now should be a name, possibly qualified.
709 Additional qualifiers could live in the left subtree or the right
710 subtree. Find the last piece. */
715 switch (cur_comp
->type
)
717 case DEMANGLE_COMPONENT_QUAL_NAME
:
718 case DEMANGLE_COMPONENT_LOCAL_NAME
:
719 prev_comp
= cur_comp
;
720 cur_comp
= d_right (cur_comp
);
722 case DEMANGLE_COMPONENT_TEMPLATE
:
723 case DEMANGLE_COMPONENT_NAME
:
724 case DEMANGLE_COMPONENT_CTOR
:
725 case DEMANGLE_COMPONENT_DTOR
:
726 case DEMANGLE_COMPONENT_OPERATOR
:
727 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
737 if (cur_comp
!= NULL
&& prev_comp
!= NULL
)
739 /* We want to discard the rightmost child of PREV_COMP. */
740 *prev_comp
= *d_left (prev_comp
);
741 /* The ten is completely arbitrary; we don't have a good
743 ret
= cp_comp_to_string (ret_comp
, 10);
747 xfree (demangled_name
);
748 cp_demangled_name_parse_free (info
);
752 /* Return the child of COMP which is the basename of a method,
753 variable, et cetera. All scope qualifiers are discarded, but
754 template arguments will be included. The component tree may be
757 static struct demangle_component
*
758 unqualified_name_from_comp (struct demangle_component
*comp
)
760 struct demangle_component
*ret_comp
= comp
, *last_template
;
764 last_template
= NULL
;
766 switch (ret_comp
->type
)
768 case DEMANGLE_COMPONENT_QUAL_NAME
:
769 case DEMANGLE_COMPONENT_LOCAL_NAME
:
770 ret_comp
= d_right (ret_comp
);
772 case DEMANGLE_COMPONENT_TYPED_NAME
:
773 ret_comp
= d_left (ret_comp
);
775 case DEMANGLE_COMPONENT_TEMPLATE
:
776 gdb_assert (last_template
== NULL
);
777 last_template
= ret_comp
;
778 ret_comp
= d_left (ret_comp
);
780 case DEMANGLE_COMPONENT_CONST
:
781 case DEMANGLE_COMPONENT_RESTRICT
:
782 case DEMANGLE_COMPONENT_VOLATILE
:
783 case DEMANGLE_COMPONENT_CONST_THIS
:
784 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
785 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
786 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
787 ret_comp
= d_left (ret_comp
);
789 case DEMANGLE_COMPONENT_NAME
:
790 case DEMANGLE_COMPONENT_CTOR
:
791 case DEMANGLE_COMPONENT_DTOR
:
792 case DEMANGLE_COMPONENT_OPERATOR
:
793 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
803 d_left (last_template
) = ret_comp
;
804 return last_template
;
810 /* Return the name of the method whose linkage name is PHYSNAME. */
813 method_name_from_physname (const char *physname
)
815 void *storage
= NULL
;
816 char *demangled_name
= NULL
, *ret
;
817 struct demangle_component
*ret_comp
;
818 struct demangle_parse_info
*info
;
820 info
= mangled_name_to_comp (physname
, DMGL_ANSI
,
821 &storage
, &demangled_name
);
825 ret_comp
= unqualified_name_from_comp (info
->tree
);
828 if (ret_comp
!= NULL
)
829 /* The ten is completely arbitrary; we don't have a good
831 ret
= cp_comp_to_string (ret_comp
, 10);
834 xfree (demangled_name
);
835 cp_demangled_name_parse_free (info
);
839 /* If FULL_NAME is the demangled name of a C++ function (including an
840 arg list, possibly including namespace/class qualifications),
841 return a new string containing only the function name (without the
842 arg list/class qualifications). Otherwise, return NULL. The
843 caller is responsible for freeing the memory in question. */
846 cp_func_name (const char *full_name
)
849 struct demangle_component
*ret_comp
;
850 struct demangle_parse_info
*info
;
852 info
= cp_demangled_name_to_comp (full_name
, NULL
);
856 ret_comp
= unqualified_name_from_comp (info
->tree
);
859 if (ret_comp
!= NULL
)
860 ret
= cp_comp_to_string (ret_comp
, 10);
862 cp_demangled_name_parse_free (info
);
866 /* DEMANGLED_NAME is the name of a function, including parameters and
867 (optionally) a return type. Return the name of the function without
868 parameters or return type, or NULL if we can not parse the name. */
871 cp_remove_params (const char *demangled_name
)
874 struct demangle_component
*ret_comp
;
875 struct demangle_parse_info
*info
;
878 if (demangled_name
== NULL
)
881 info
= cp_demangled_name_to_comp (demangled_name
, NULL
);
885 /* First strip off any qualifiers, if we have a function or method. */
886 ret_comp
= info
->tree
;
888 switch (ret_comp
->type
)
890 case DEMANGLE_COMPONENT_CONST
:
891 case DEMANGLE_COMPONENT_RESTRICT
:
892 case DEMANGLE_COMPONENT_VOLATILE
:
893 case DEMANGLE_COMPONENT_CONST_THIS
:
894 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
895 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
896 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
897 ret_comp
= d_left (ret_comp
);
904 /* What we have now should be a function. Return its name. */
905 if (ret_comp
->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
906 ret
= cp_comp_to_string (d_left (ret_comp
), 10);
908 cp_demangled_name_parse_free (info
);
912 /* Here are some random pieces of trivia to keep in mind while trying
913 to take apart demangled names:
915 - Names can contain function arguments or templates, so the process
916 has to be, to some extent recursive: maybe keep track of your
917 depth based on encountering <> and ().
919 - Parentheses don't just have to happen at the end of a name: they
920 can occur even if the name in question isn't a function, because
921 a template argument might be a type that's a function.
923 - Conversely, even if you're trying to deal with a function, its
924 demangled name might not end with ')': it could be a const or
925 volatile class method, in which case it ends with "const" or
928 - Parentheses are also used in anonymous namespaces: a variable
929 'foo' in an anonymous namespace gets demangled as "(anonymous
932 - And operator names can contain parentheses or angle brackets. */
934 /* FIXME: carlton/2003-03-13: We have several functions here with
935 overlapping functionality; can we combine them? Also, do they
936 handle all the above considerations correctly? */
939 /* This returns the length of first component of NAME, which should be
940 the demangled name of a C++ variable/function/method/etc.
941 Specifically, it returns the index of the first colon forming the
942 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
943 it returns the 1, and given 'foo', it returns 0. */
945 /* The character in NAME indexed by the return value is guaranteed to
946 always be either ':' or '\0'. */
948 /* NOTE: carlton/2003-03-13: This function is currently only intended
949 for internal use: it's probably not entirely safe when called on
950 user-generated input, because some of the 'index += 2' lines in
951 cp_find_first_component_aux might go past the end of malformed
955 cp_find_first_component (const char *name
)
957 return cp_find_first_component_aux (name
, 0);
960 /* Helper function for cp_find_first_component. Like that function,
961 it returns the length of the first component of NAME, but to make
962 the recursion easier, it also stops if it reaches an unexpected ')'
963 or '>' if the value of PERMISSIVE is nonzero. */
965 /* Let's optimize away calls to strlen("operator"). */
967 #define LENGTH_OF_OPERATOR 8
970 cp_find_first_component_aux (const char *name
, int permissive
)
972 unsigned int index
= 0;
973 /* Operator names can show up in unexpected places. Since these can
974 contain parentheses or angle brackets, they can screw up the
975 recursion. But not every string 'operator' is part of an
976 operater name: e.g. you could have a variable 'cooperator'. So
977 this variable tells us whether or not we should treat the string
978 'operator' as starting an operator. */
979 int operator_possible
= 1;
986 /* Template; eat it up. The calls to cp_first_component
987 should only return (I hope!) when they reach the '>'
988 terminating the component or a '::' between two
989 components. (Hence the '+ 2'.) */
991 for (index
+= cp_find_first_component_aux (name
+ index
, 1);
993 index
+= cp_find_first_component_aux (name
+ index
, 1))
995 if (name
[index
] != ':')
997 demangled_name_complaint (name
);
998 return strlen (name
);
1002 operator_possible
= 1;
1005 /* Similar comment as to '<'. */
1007 for (index
+= cp_find_first_component_aux (name
+ index
, 1);
1009 index
+= cp_find_first_component_aux (name
+ index
, 1))
1011 if (name
[index
] != ':')
1013 demangled_name_complaint (name
);
1014 return strlen (name
);
1018 operator_possible
= 1;
1026 demangled_name_complaint (name
);
1027 return strlen (name
);
1033 /* Operator names can screw up the recursion. */
1034 if (operator_possible
1035 && strncmp (name
+ index
, "operator",
1036 LENGTH_OF_OPERATOR
) == 0)
1038 index
+= LENGTH_OF_OPERATOR
;
1039 while (ISSPACE(name
[index
]))
1041 switch (name
[index
])
1043 /* Skip over one less than the appropriate number of
1044 characters: the for loop will skip over the last
1047 if (name
[index
+ 1] == '<')
1054 if (name
[index
+ 1] == '>')
1067 operator_possible
= 0;
1074 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1075 set of relevant characters are here: it's necessary to
1076 include any character that can show up before 'operator'
1077 in a demangled name, and it's safe to include any
1078 character that can't be part of an identifier's name. */
1079 operator_possible
= 1;
1082 operator_possible
= 0;
1088 /* Complain about a demangled name that we don't know how to parse.
1089 NAME is the demangled name in question. */
1092 demangled_name_complaint (const char *name
)
1094 complaint (&symfile_complaints
,
1095 "unexpected demangled name '%s'", name
);
1098 /* If NAME is the fully-qualified name of a C++
1099 function/variable/method/etc., this returns the length of its
1100 entire prefix: all of the namespaces and classes that make up its
1101 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1102 4, given 'foo', it returns 0. */
1105 cp_entire_prefix_len (const char *name
)
1107 unsigned int current_len
= cp_find_first_component (name
);
1108 unsigned int previous_len
= 0;
1110 while (name
[current_len
] != '\0')
1112 gdb_assert (name
[current_len
] == ':');
1113 previous_len
= current_len
;
1114 /* Skip the '::'. */
1116 current_len
+= cp_find_first_component (name
+ current_len
);
1119 return previous_len
;
1122 /* Overload resolution functions. */
1124 /* Test to see if SYM is a symbol that we haven't seen corresponding
1125 to a function named OLOAD_NAME. If so, add it to the current
1129 overload_list_add_symbol (struct symbol
*sym
,
1130 const char *oload_name
)
1136 /* If there is no type information, we can't do anything, so
1138 if (SYMBOL_TYPE (sym
) == NULL
)
1141 /* skip any symbols that we've already considered. */
1142 for (i
= 0; i
< sym_return_val_index
; ++i
)
1143 if (strcmp (SYMBOL_LINKAGE_NAME (sym
),
1144 SYMBOL_LINKAGE_NAME (sym_return_val
[i
])) == 0)
1147 /* Get the demangled name without parameters */
1148 sym_name
= cp_remove_params (SYMBOL_NATURAL_NAME (sym
));
1152 /* skip symbols that cannot match */
1153 if (strcmp (sym_name
, oload_name
) != 0)
1161 /* We have a match for an overload instance, so add SYM to the
1162 current list of overload instances */
1163 if (sym_return_val_index
+ 3 > sym_return_val_size
)
1165 newsize
= (sym_return_val_size
*= 2) * sizeof (struct symbol
*);
1166 sym_return_val
= (struct symbol
**)
1167 xrealloc ((char *) sym_return_val
, newsize
);
1169 sym_return_val
[sym_return_val_index
++] = sym
;
1170 sym_return_val
[sym_return_val_index
] = NULL
;
1173 /* Return a null-terminated list of pointers to function symbols that
1174 are named FUNC_NAME and are visible within NAMESPACE. */
1177 make_symbol_overload_list (const char *func_name
,
1178 const char *namespace)
1180 struct cleanup
*old_cleanups
;
1183 sym_return_val_size
= 100;
1184 sym_return_val_index
= 0;
1185 sym_return_val
= xmalloc ((sym_return_val_size
+ 1) *
1186 sizeof (struct symbol
*));
1187 sym_return_val
[0] = NULL
;
1189 old_cleanups
= make_cleanup (xfree
, sym_return_val
);
1191 make_symbol_overload_list_using (func_name
, namespace);
1193 if (namespace[0] == '\0')
1197 char *concatenated_name
1198 = alloca (strlen (namespace) + 2 + strlen (func_name
) + 1);
1199 strcpy (concatenated_name
, namespace);
1200 strcat (concatenated_name
, "::");
1201 strcat (concatenated_name
, func_name
);
1202 name
= concatenated_name
;
1205 make_symbol_overload_list_qualified (name
);
1207 discard_cleanups (old_cleanups
);
1209 return sym_return_val
;
1212 /* Add all symbols with a name matching NAME in BLOCK to the overload
1216 make_symbol_overload_list_block (const char *name
,
1217 const struct block
*block
)
1219 struct block_iterator iter
;
1222 for (sym
= block_iter_name_first (block
, name
, &iter
);
1224 sym
= block_iter_name_next (name
, &iter
))
1225 overload_list_add_symbol (sym
, name
);
1228 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1231 make_symbol_overload_list_namespace (const char *func_name
,
1232 const char *namespace)
1235 const struct block
*block
= NULL
;
1237 if (namespace[0] == '\0')
1241 char *concatenated_name
1242 = alloca (strlen (namespace) + 2 + strlen (func_name
) + 1);
1244 strcpy (concatenated_name
, namespace);
1245 strcat (concatenated_name
, "::");
1246 strcat (concatenated_name
, func_name
);
1247 name
= concatenated_name
;
1250 /* Look in the static block. */
1251 block
= block_static_block (get_selected_block (0));
1253 make_symbol_overload_list_block (name
, block
);
1255 /* Look in the global block. */
1256 block
= block_global_block (block
);
1258 make_symbol_overload_list_block (name
, block
);
1262 /* Search the namespace of the given type and namespace of and public
1266 make_symbol_overload_list_adl_namespace (struct type
*type
,
1267 const char *func_name
)
1270 const char *type_name
;
1273 while (TYPE_CODE (type
) == TYPE_CODE_PTR
1274 || TYPE_CODE (type
) == TYPE_CODE_REF
1275 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1276 || TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1278 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1279 type
= check_typedef(type
);
1281 type
= TYPE_TARGET_TYPE (type
);
1284 type_name
= TYPE_NAME (type
);
1286 if (type_name
== NULL
)
1289 prefix_len
= cp_entire_prefix_len (type_name
);
1291 if (prefix_len
!= 0)
1293 namespace = alloca (prefix_len
+ 1);
1294 strncpy (namespace, type_name
, prefix_len
);
1295 namespace[prefix_len
] = '\0';
1297 make_symbol_overload_list_namespace (func_name
, namespace);
1300 /* Check public base type */
1301 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
1302 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
1304 if (BASETYPE_VIA_PUBLIC (type
, i
))
1305 make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type
,
1311 /* Adds the overload list overload candidates for FUNC_NAME found
1312 through argument dependent lookup. */
1315 make_symbol_overload_list_adl (struct type
**arg_types
, int nargs
,
1316 const char *func_name
)
1320 gdb_assert (sym_return_val_size
!= -1);
1322 for (i
= 1; i
<= nargs
; i
++)
1323 make_symbol_overload_list_adl_namespace (arg_types
[i
- 1],
1326 return sym_return_val
;
1329 /* Used for cleanups to reset the "searched" flag in case of an
1333 reset_directive_searched (void *data
)
1335 struct using_direct
*direct
= data
;
1336 direct
->searched
= 0;
1339 /* This applies the using directives to add namespaces to search in,
1340 and then searches for overloads in all of those namespaces. It
1341 adds the symbols found to sym_return_val. Arguments are as in
1342 make_symbol_overload_list. */
1345 make_symbol_overload_list_using (const char *func_name
,
1346 const char *namespace)
1348 struct using_direct
*current
;
1349 const struct block
*block
;
1351 /* First, go through the using directives. If any of them apply,
1352 look in the appropriate namespaces for new functions to match
1355 for (block
= get_selected_block (0);
1357 block
= BLOCK_SUPERBLOCK (block
))
1358 for (current
= block_using (block
);
1360 current
= current
->next
)
1362 /* Prevent recursive calls. */
1363 if (current
->searched
)
1366 /* If this is a namespace alias or imported declaration ignore
1368 if (current
->alias
!= NULL
|| current
->declaration
!= NULL
)
1371 if (strcmp (namespace, current
->import_dest
) == 0)
1373 /* Mark this import as searched so that the recursive call
1374 does not search it again. */
1375 struct cleanup
*old_chain
;
1376 current
->searched
= 1;
1377 old_chain
= make_cleanup (reset_directive_searched
,
1380 make_symbol_overload_list_using (func_name
,
1381 current
->import_src
);
1383 current
->searched
= 0;
1384 discard_cleanups (old_chain
);
1388 /* Now, add names for this namespace. */
1389 make_symbol_overload_list_namespace (func_name
, namespace);
1392 /* This does the bulk of the work of finding overloaded symbols.
1393 FUNC_NAME is the name of the overloaded function we're looking for
1394 (possibly including namespace info). */
1397 make_symbol_overload_list_qualified (const char *func_name
)
1400 struct objfile
*objfile
;
1401 const struct block
*b
, *surrounding_static_block
= 0;
1403 /* Look through the partial symtabs for all symbols which begin by
1404 matching FUNC_NAME. Make sure we read that symbol table in. */
1406 ALL_OBJFILES (objfile
)
1409 objfile
->sf
->qf
->expand_symtabs_for_function (objfile
, func_name
);
1412 /* Search upwards from currently selected frame (so that we can
1413 complete on local vars. */
1415 for (b
= get_selected_block (0); b
!= NULL
; b
= BLOCK_SUPERBLOCK (b
))
1416 make_symbol_overload_list_block (func_name
, b
);
1418 surrounding_static_block
= block_static_block (get_selected_block (0));
1420 /* Go through the symtabs and check the externs and statics for
1421 symbols which match. */
1423 ALL_PRIMARY_SYMTABS (objfile
, s
)
1426 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), GLOBAL_BLOCK
);
1427 make_symbol_overload_list_block (func_name
, b
);
1430 ALL_PRIMARY_SYMTABS (objfile
, s
)
1433 b
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
);
1434 /* Don't do this block twice. */
1435 if (b
== surrounding_static_block
)
1437 make_symbol_overload_list_block (func_name
, b
);
1441 /* Lookup the rtti type for a class name. */
1444 cp_lookup_rtti_type (const char *name
, struct block
*block
)
1446 struct symbol
* rtti_sym
;
1447 struct type
* rtti_type
;
1449 rtti_sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, NULL
);
1451 if (rtti_sym
== NULL
)
1453 warning (_("RTTI symbol not found for class '%s'"), name
);
1457 if (SYMBOL_CLASS (rtti_sym
) != LOC_TYPEDEF
)
1459 warning (_("RTTI symbol for class '%s' is not a type"), name
);
1463 rtti_type
= SYMBOL_TYPE (rtti_sym
);
1465 switch (TYPE_CODE (rtti_type
))
1467 case TYPE_CODE_CLASS
:
1469 case TYPE_CODE_NAMESPACE
:
1470 /* chastain/2003-11-26: the symbol tables often contain fake
1471 symbols for namespaces with the same name as the struct.
1472 This warning is an indication of a bug in the lookup order
1473 or a bug in the way that the symbol tables are populated. */
1474 warning (_("RTTI symbol for class '%s' is a namespace"), name
);
1477 warning (_("RTTI symbol for class '%s' has bad type"), name
);
1484 #ifdef HAVE_WORKING_FORK
1486 /* If nonzero, attempt to catch crashes in the demangler and print
1487 useful debugging information. */
1489 static int catch_demangler_crashes
= 1;
1491 /* Wrap set/long jmp so that it's more portable. */
1493 #if defined(HAVE_SIGSETJMP)
1494 #define SIGJMP_BUF sigjmp_buf
1495 #define SIGSETJMP(buf) sigsetjmp((buf), 1)
1496 #define SIGLONGJMP(buf,val) siglongjmp((buf), (val))
1498 #define SIGJMP_BUF jmp_buf
1499 #define SIGSETJMP(buf) setjmp(buf)
1500 #define SIGLONGJMP(buf,val) longjmp((buf), (val))
1503 /* Stack context and environment for demangler crash recovery. */
1505 static SIGJMP_BUF gdb_demangle_jmp_buf
;
1507 /* If nonzero, attempt to dump core from the signal handler. */
1509 static int gdb_demangle_attempt_core_dump
= 1;
1511 /* Signal handler for gdb_demangle. */
1514 gdb_demangle_signal_handler (int signo
)
1516 if (gdb_demangle_attempt_core_dump
)
1521 gdb_demangle_attempt_core_dump
= 0;
1524 SIGLONGJMP (gdb_demangle_jmp_buf
, signo
);
1529 /* A wrapper for bfd_demangle. */
1532 gdb_demangle (const char *name
, int options
)
1534 char *result
= NULL
;
1535 int crash_signal
= 0;
1537 #ifdef HAVE_WORKING_FORK
1538 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1539 struct sigaction sa
, old_sa
;
1543 static int core_dump_allowed
= -1;
1545 if (core_dump_allowed
== -1)
1547 core_dump_allowed
= can_dump_core (LIMIT_CUR
);
1549 if (!core_dump_allowed
)
1550 gdb_demangle_attempt_core_dump
= 0;
1553 if (catch_demangler_crashes
)
1555 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1556 sa
.sa_handler
= gdb_demangle_signal_handler
;
1557 sigemptyset (&sa
.sa_mask
);
1558 #ifdef HAVE_SIGALTSTACK
1559 sa
.sa_flags
= SA_ONSTACK
;
1563 sigaction (SIGSEGV
, &sa
, &old_sa
);
1565 ofunc
= (void (*)()) signal (SIGSEGV
, gdb_demangle_signal_handler
);
1568 crash_signal
= SIGSETJMP (gdb_demangle_jmp_buf
);
1572 if (crash_signal
== 0)
1573 result
= bfd_demangle (NULL
, name
, options
);
1575 #ifdef HAVE_WORKING_FORK
1576 if (catch_demangler_crashes
)
1578 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1579 sigaction (SIGSEGV
, &old_sa
, NULL
);
1581 signal (SIGSEGV
, ofunc
);
1584 if (crash_signal
!= 0)
1586 static int error_reported
= 0;
1588 if (!error_reported
)
1590 char *short_msg
, *long_msg
;
1591 struct cleanup
*back_to
;
1593 short_msg
= xstrprintf (_("unable to demangle '%s' "
1594 "(demangler failed with signal %d)"),
1595 name
, crash_signal
);
1596 back_to
= make_cleanup (xfree
, short_msg
);
1598 long_msg
= xstrprintf ("%s:%d: %s: %s", __FILE__
, __LINE__
,
1599 "demangler-warning", short_msg
);
1600 make_cleanup (xfree
, long_msg
);
1602 target_terminal_ours ();
1604 if (core_dump_allowed
)
1605 fprintf_unfiltered (gdb_stderr
,
1606 _("%s\nAttempting to dump core.\n"),
1609 warn_cant_dump_core (long_msg
);
1611 demangler_warning (__FILE__
, __LINE__
, "%s", short_msg
);
1613 do_cleanups (back_to
);
1626 /* Don't allow just "maintenance cplus". */
1629 maint_cplus_command (char *arg
, int from_tty
)
1631 printf_unfiltered (_("\"maintenance cplus\" must be followed "
1632 "by the name of a command.\n"));
1633 help_list (maint_cplus_cmd_list
,
1634 "maintenance cplus ",
1635 all_commands
, gdb_stdout
);
1638 /* This is a front end for cp_find_first_component, for unit testing.
1639 Be careful when using it: see the NOTE above
1640 cp_find_first_component. */
1643 first_component_command (char *arg
, int from_tty
)
1651 len
= cp_find_first_component (arg
);
1652 prefix
= alloca (len
+ 1);
1654 memcpy (prefix
, arg
, len
);
1657 printf_unfiltered ("%s\n", prefix
);
1660 extern initialize_file_ftype _initialize_cp_support
; /* -Wmissing-prototypes */
1663 /* Implement "info vtbl". */
1666 info_vtbl_command (char *arg
, int from_tty
)
1668 struct value
*value
;
1670 value
= parse_and_eval (arg
);
1671 cplus_print_vtable (value
);
1675 _initialize_cp_support (void)
1677 add_prefix_cmd ("cplus", class_maintenance
,
1678 maint_cplus_command
,
1679 _("C++ maintenance commands."),
1680 &maint_cplus_cmd_list
,
1681 "maintenance cplus ",
1682 0, &maintenancelist
);
1683 add_alias_cmd ("cp", "cplus",
1684 class_maintenance
, 1,
1687 add_cmd ("first_component",
1689 first_component_command
,
1690 _("Print the first class/namespace component of NAME."),
1691 &maint_cplus_cmd_list
);
1693 add_info ("vtbl", info_vtbl_command
,
1694 _("Show the virtual function table for a C++ object.\n\
1695 Usage: info vtbl EXPRESSION\n\
1696 Evaluate EXPRESSION and display the virtual function table for the\n\
1697 resulting object."));
1699 #ifdef HAVE_WORKING_FORK
1700 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance
,
1701 &catch_demangler_crashes
, _("\
1702 Set whether to attempt to catch demangler crashes."), _("\
1703 Show whether to attempt to catch demangler crashes."), _("\
1704 If enabled GDB will attempt to catch demangler crashes and\n\
1705 display the offending symbol."),
1708 &maintenance_set_cmdlist
,
1709 &maintenance_show_cmdlist
);