1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2002-2017 Free Software Foundation, Inc.
4 Contributed by MontaVista Software.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "cp-support.h"
25 #include "dictionary.h"
30 #include "complaints.h"
32 #include "expression.h"
35 #include "namespace.h"
37 #include "gdb_setjmp.h"
38 #include "safe-ctype.h"
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 *the_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 (char *) obstack_copy (obstack, string, *len);
98 /* Return 1 if STRING is clearly already in canonical form. This
99 function is conservative; things which it does not recognize are
100 assumed to be non-canonical, and the parser will sort them out
101 afterwards. This speeds up the critical path for alphanumeric
105 cp_already_canonical (const char *string)
107 /* Identifier start character [a-zA-Z_]. */
108 if (!ISIDST (string[0]))
111 /* These are the only two identifiers which canonicalize to other
112 than themselves or an error: unsigned -> unsigned int and
114 if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
116 else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
119 /* Identifier character [a-zA-Z0-9_]. */
120 while (ISIDNUM (string[1]))
123 if (string[1] == '\0')
129 /* Inspect the given RET_COMP for its type. If it is a typedef,
130 replace the node with the typedef's tree.
132 Returns 1 if any typedef substitutions were made, 0 otherwise. */
135 inspect_type (struct demangle_parse_info *info,
136 struct demangle_component *ret_comp,
137 canonicalization_ftype *finder,
144 /* Copy the symbol's name from RET_COMP and look it up
145 in the symbol table. */
146 name = (char *) alloca (ret_comp->u.s_name.len + 1);
147 memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len);
148 name[ret_comp->u.s_name.len] = '\0';
150 /* Ignore any typedefs that should not be substituted. */
151 for (i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i)
153 if (strcmp (name, ignore_typedefs[i]) == 0)
161 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
163 CATCH (except, RETURN_MASK_ALL)
171 struct type *otype = SYMBOL_TYPE (sym);
175 const char *new_name = (*finder) (otype, data);
177 if (new_name != NULL)
179 ret_comp->u.s_name.s = new_name;
180 ret_comp->u.s_name.len = strlen (new_name);
187 /* If the type is a typedef or namespace alias, replace it. */
188 if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF
189 || TYPE_CODE (otype) == TYPE_CODE_NAMESPACE)
194 std::unique_ptr<demangle_parse_info> i;
196 /* Get the real type of the typedef. */
197 type = check_typedef (otype);
199 /* If the symbol is a namespace and its type name is no different
200 than the name we looked up, this symbol is not a namespace
201 alias and does not need to be substituted. */
202 if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE
203 && strcmp (TYPE_NAME (type), name) == 0)
206 is_anon = (TYPE_TAG_NAME (type) == NULL
207 && (TYPE_CODE (type) == TYPE_CODE_ENUM
208 || TYPE_CODE (type) == TYPE_CODE_STRUCT
209 || TYPE_CODE (type) == TYPE_CODE_UNION));
212 struct type *last = otype;
214 /* Find the last typedef for the type. */
215 while (TYPE_TARGET_TYPE (last) != NULL
216 && (TYPE_CODE (TYPE_TARGET_TYPE (last))
217 == TYPE_CODE_TYPEDEF))
218 last = TYPE_TARGET_TYPE (last);
220 /* If there is only one typedef for this anonymous type,
221 do not substitute it. */
225 /* Use the last typedef seen as the type for this
233 type_print (type, "", &buf, -1);
235 /* If type_print threw an exception, there is little point
236 in continuing, so just bow out gracefully. */
237 CATCH (except, RETURN_MASK_ERROR)
244 name = (char *) obstack_copy0 (&info->obstack, buf.c_str (), len);
246 /* Turn the result into a new tree. Note that this
247 tree will contain pointers into NAME, so NAME cannot
248 be free'd until all typedef conversion is done and
249 the final result is converted into a string. */
250 i = cp_demangled_name_to_comp (name, NULL);
253 /* Merge the two trees. */
254 cp_merge_demangle_parse_infos (info, ret_comp, i.get ());
256 /* Replace any newly introduced typedefs -- but not
257 if the type is anonymous (that would lead to infinite
260 replace_typedefs (info, ret_comp, finder, data);
264 /* This shouldn't happen unless the type printer has
265 output something that the name parser cannot grok.
266 Nonetheless, an ounce of prevention...
268 Canonicalize the name again, and store it in the
269 current node (RET_COMP). */
270 std::string canon = cp_canonicalize_string_no_typedefs (name);
274 /* Copy the canonicalization into the obstack. */
275 name = copy_string_to_obstack (&info->obstack, canon.c_str (), &len);
278 ret_comp->u.s_name.s = name;
279 ret_comp->u.s_name.len = len;
289 /* Replace any typedefs appearing in the qualified name
290 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
294 replace_typedefs_qualified_name (struct demangle_parse_info *info,
295 struct demangle_component *ret_comp,
296 canonicalization_ftype *finder,
300 struct demangle_component *comp = ret_comp;
302 /* Walk each node of the qualified name, reconstructing the name of
303 this element. With every node, check for any typedef substitutions.
304 If a substitution has occurred, replace the qualified name node
305 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
307 while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
309 if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
311 struct demangle_component newobj;
313 buf.write (d_left (comp)->u.s_name.s, d_left (comp)->u.s_name.len);
314 newobj.type = DEMANGLE_COMPONENT_NAME;
316 = (char *) obstack_copy0 (&info->obstack,
317 buf.c_str (), buf.size ());
318 newobj.u.s_name.len = buf.size ();
319 if (inspect_type (info, &newobj, finder, data))
324 /* A typedef was substituted in NEW. Convert it to a
325 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
329 gdb::unique_xmalloc_ptr<char> n
330 = cp_comp_to_string (&newobj, 100);
333 /* If something went astray, abort typedef substitutions. */
337 s = copy_string_to_obstack (&info->obstack, n.get (), &slen);
339 d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
340 d_left (ret_comp)->u.s_name.s = s;
341 d_left (ret_comp)->u.s_name.len = slen;
342 d_right (ret_comp) = d_right (comp);
349 /* The current node is not a name, so simply replace any
350 typedefs in it. Then print it to the stream to continue
351 checking for more typedefs in the tree. */
352 replace_typedefs (info, d_left (comp), finder, data);
353 gdb::unique_xmalloc_ptr<char> name
354 = cp_comp_to_string (d_left (comp), 100);
357 /* If something went astray, abort typedef substitutions. */
360 buf.puts (name.get ());
364 comp = d_right (comp);
367 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
368 name assembled above and append the name given by COMP. Then use this
369 reassembled name to check for a typedef. */
371 if (comp->type == DEMANGLE_COMPONENT_NAME)
373 buf.write (comp->u.s_name.s, comp->u.s_name.len);
375 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
376 with a DEMANGLE_COMPONENT_NAME node containing the whole
378 ret_comp->type = DEMANGLE_COMPONENT_NAME;
380 = (char *) obstack_copy0 (&info->obstack,
381 buf.c_str (), buf.size ());
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 (except, RETURN_MASK_ALL)
444 struct type *otype = SYMBOL_TYPE (sym);
445 const char *new_name = (*finder) (otype, data);
447 if (new_name != NULL)
449 ret_comp->type = DEMANGLE_COMPONENT_NAME;
450 ret_comp->u.s_name.s = new_name;
451 ret_comp->u.s_name.len = strlen (new_name);
458 switch (ret_comp->type)
460 case DEMANGLE_COMPONENT_ARGLIST:
461 check_cv_qualifiers (ret_comp);
464 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
465 case DEMANGLE_COMPONENT_TEMPLATE:
466 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
467 case DEMANGLE_COMPONENT_TYPED_NAME:
468 replace_typedefs (info, d_left (ret_comp), finder, data);
469 replace_typedefs (info, d_right (ret_comp), finder, data);
472 case DEMANGLE_COMPONENT_NAME:
473 inspect_type (info, ret_comp, finder, data);
476 case DEMANGLE_COMPONENT_QUAL_NAME:
477 replace_typedefs_qualified_name (info, ret_comp, finder, data);
480 case DEMANGLE_COMPONENT_LOCAL_NAME:
481 case DEMANGLE_COMPONENT_CTOR:
482 case DEMANGLE_COMPONENT_ARRAY_TYPE:
483 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
484 replace_typedefs (info, d_right (ret_comp), finder, data);
487 case DEMANGLE_COMPONENT_CONST:
488 case DEMANGLE_COMPONENT_RESTRICT:
489 case DEMANGLE_COMPONENT_VOLATILE:
490 case DEMANGLE_COMPONENT_VOLATILE_THIS:
491 case DEMANGLE_COMPONENT_CONST_THIS:
492 case DEMANGLE_COMPONENT_RESTRICT_THIS:
493 case DEMANGLE_COMPONENT_POINTER:
494 case DEMANGLE_COMPONENT_REFERENCE:
495 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
496 replace_typedefs (info, d_left (ret_comp), finder, data);
505 /* Parse STRING and convert it to canonical form, resolving any
506 typedefs. If parsing fails, or if STRING is already canonical,
507 return the empty string. Otherwise return the canonical form. If
508 FINDER is not NULL, then type components are passed to FINDER to be
509 looked up. DATA is passed verbatim to FINDER. */
512 cp_canonicalize_string_full (const char *string,
513 canonicalization_ftype *finder,
517 unsigned int estimated_len;
518 std::unique_ptr<demangle_parse_info> info;
520 estimated_len = strlen (string) * 2;
521 info = cp_demangled_name_to_comp (string, NULL);
524 /* Replace all the typedefs in the tree. */
525 replace_typedefs (info.get (), info->tree, finder, data);
527 /* Convert the tree back into a string. */
528 gdb::unique_xmalloc_ptr<char> us = cp_comp_to_string (info->tree,
533 /* Finally, compare the original string with the computed
534 name, returning NULL if they are the same. */
536 return std::string ();
542 /* Like cp_canonicalize_string_full, but always passes NULL for
546 cp_canonicalize_string_no_typedefs (const char *string)
548 return cp_canonicalize_string_full (string, NULL, NULL);
551 /* Parse STRING and convert it to canonical form. If parsing fails,
552 or if STRING is already canonical, return the empty string.
553 Otherwise return the canonical form. */
556 cp_canonicalize_string (const char *string)
558 std::unique_ptr<demangle_parse_info> info;
559 unsigned int estimated_len;
561 if (cp_already_canonical (string))
562 return std::string ();
564 info = cp_demangled_name_to_comp (string, NULL);
566 return std::string ();
568 estimated_len = strlen (string) * 2;
569 gdb::unique_xmalloc_ptr<char> us (cp_comp_to_string (info->tree,
574 warning (_("internal error: string \"%s\" failed to be canonicalized"),
576 return std::string ();
579 std::string ret (us.get ());
582 return std::string ();
587 /* Convert a mangled name to a demangle_component tree. *MEMORY is
588 set to the block of used memory that should be freed when finished
589 with the tree. DEMANGLED_P is set to the char * that should be
590 freed when finished with the tree, or NULL if none was needed.
591 OPTIONS will be passed to the demangler. */
593 static std::unique_ptr<demangle_parse_info>
594 mangled_name_to_comp (const char *mangled_name, int options,
595 void **memory, char **demangled_p)
597 char *demangled_name;
599 /* If it looks like a v3 mangled name, then try to go directly
601 if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
603 struct demangle_component *ret;
605 ret = cplus_demangle_v3_components (mangled_name,
609 std::unique_ptr<demangle_parse_info> info (new demangle_parse_info);
616 /* If it doesn't, or if that failed, then try to demangle the
618 demangled_name = gdb_demangle (mangled_name, options);
619 if (demangled_name == NULL)
622 /* If we could demangle the name, parse it to build the component
624 std::unique_ptr<demangle_parse_info> info
625 = cp_demangled_name_to_comp (demangled_name, NULL);
629 xfree (demangled_name);
633 *demangled_p = demangled_name;
637 /* Return the name of the class containing method PHYSNAME. */
640 cp_class_name_from_physname (const char *physname)
642 void *storage = NULL;
643 char *demangled_name = NULL;
644 gdb::unique_xmalloc_ptr<char> ret;
645 struct demangle_component *ret_comp, *prev_comp, *cur_comp;
646 std::unique_ptr<demangle_parse_info> info;
649 info = mangled_name_to_comp (physname, DMGL_ANSI,
650 &storage, &demangled_name);
655 ret_comp = info->tree;
657 /* First strip off any qualifiers, if we have a function or
660 switch (ret_comp->type)
662 case DEMANGLE_COMPONENT_CONST:
663 case DEMANGLE_COMPONENT_RESTRICT:
664 case DEMANGLE_COMPONENT_VOLATILE:
665 case DEMANGLE_COMPONENT_CONST_THIS:
666 case DEMANGLE_COMPONENT_RESTRICT_THIS:
667 case DEMANGLE_COMPONENT_VOLATILE_THIS:
668 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
669 ret_comp = d_left (ret_comp);
676 /* If what we have now is a function, discard the argument list. */
677 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
678 ret_comp = d_left (ret_comp);
680 /* If what we have now is a template, strip off the template
681 arguments. The left subtree may be a qualified name. */
682 if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
683 ret_comp = d_left (ret_comp);
685 /* What we have now should be a name, possibly qualified.
686 Additional qualifiers could live in the left subtree or the right
687 subtree. Find the last piece. */
692 switch (cur_comp->type)
694 case DEMANGLE_COMPONENT_QUAL_NAME:
695 case DEMANGLE_COMPONENT_LOCAL_NAME:
696 prev_comp = cur_comp;
697 cur_comp = d_right (cur_comp);
699 case DEMANGLE_COMPONENT_TEMPLATE:
700 case DEMANGLE_COMPONENT_NAME:
701 case DEMANGLE_COMPONENT_CTOR:
702 case DEMANGLE_COMPONENT_DTOR:
703 case DEMANGLE_COMPONENT_OPERATOR:
704 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
713 if (cur_comp != NULL && prev_comp != NULL)
715 /* We want to discard the rightmost child of PREV_COMP. */
716 *prev_comp = *d_left (prev_comp);
717 /* The ten is completely arbitrary; we don't have a good
719 ret = cp_comp_to_string (ret_comp, 10);
723 xfree (demangled_name);
724 return ret.release ();
727 /* Return the child of COMP which is the basename of a method,
728 variable, et cetera. All scope qualifiers are discarded, but
729 template arguments will be included. The component tree may be
732 static struct demangle_component *
733 unqualified_name_from_comp (struct demangle_component *comp)
735 struct demangle_component *ret_comp = comp, *last_template;
739 last_template = NULL;
741 switch (ret_comp->type)
743 case DEMANGLE_COMPONENT_QUAL_NAME:
744 case DEMANGLE_COMPONENT_LOCAL_NAME:
745 ret_comp = d_right (ret_comp);
747 case DEMANGLE_COMPONENT_TYPED_NAME:
748 ret_comp = d_left (ret_comp);
750 case DEMANGLE_COMPONENT_TEMPLATE:
751 gdb_assert (last_template == NULL);
752 last_template = ret_comp;
753 ret_comp = d_left (ret_comp);
755 case DEMANGLE_COMPONENT_CONST:
756 case DEMANGLE_COMPONENT_RESTRICT:
757 case DEMANGLE_COMPONENT_VOLATILE:
758 case DEMANGLE_COMPONENT_CONST_THIS:
759 case DEMANGLE_COMPONENT_RESTRICT_THIS:
760 case DEMANGLE_COMPONENT_VOLATILE_THIS:
761 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
762 ret_comp = d_left (ret_comp);
764 case DEMANGLE_COMPONENT_NAME:
765 case DEMANGLE_COMPONENT_CTOR:
766 case DEMANGLE_COMPONENT_DTOR:
767 case DEMANGLE_COMPONENT_OPERATOR:
768 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
778 d_left (last_template) = ret_comp;
779 return last_template;
785 /* Return the name of the method whose linkage name is PHYSNAME. */
788 method_name_from_physname (const char *physname)
790 void *storage = NULL;
791 char *demangled_name = NULL;
792 gdb::unique_xmalloc_ptr<char> ret;
793 struct demangle_component *ret_comp;
794 std::unique_ptr<demangle_parse_info> info;
796 info = mangled_name_to_comp (physname, DMGL_ANSI,
797 &storage, &demangled_name);
801 ret_comp = unqualified_name_from_comp (info->tree);
803 if (ret_comp != NULL)
804 /* The ten is completely arbitrary; we don't have a good
806 ret = cp_comp_to_string (ret_comp, 10);
809 xfree (demangled_name);
810 return ret.release ();
813 /* If FULL_NAME is the demangled name of a C++ function (including an
814 arg list, possibly including namespace/class qualifications),
815 return a new string containing only the function name (without the
816 arg list/class qualifications). Otherwise, return NULL. The
817 caller is responsible for freeing the memory in question. */
820 cp_func_name (const char *full_name)
822 gdb::unique_xmalloc_ptr<char> ret;
823 struct demangle_component *ret_comp;
824 std::unique_ptr<demangle_parse_info> info;
826 info = cp_demangled_name_to_comp (full_name, NULL);
830 ret_comp = unqualified_name_from_comp (info->tree);
832 if (ret_comp != NULL)
833 ret = cp_comp_to_string (ret_comp, 10);
835 return ret.release ();
838 /* DEMANGLED_NAME is the name of a function, including parameters and
839 (optionally) a return type. Return the name of the function without
840 parameters or return type, or NULL if we can not parse the name. */
843 cp_remove_params (const char *demangled_name)
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);
880 return ret.release ();
883 /* Here are some random pieces of trivia to keep in mind while trying
884 to take apart demangled names:
886 - Names can contain function arguments or templates, so the process
887 has to be, to some extent recursive: maybe keep track of your
888 depth based on encountering <> and ().
890 - Parentheses don't just have to happen at the end of a name: they
891 can occur even if the name in question isn't a function, because
892 a template argument might be a type that's a function.
894 - Conversely, even if you're trying to deal with a function, its
895 demangled name might not end with ')': it could be a const or
896 volatile class method, in which case it ends with "const" or
899 - Parentheses are also used in anonymous namespaces: a variable
900 'foo' in an anonymous namespace gets demangled as "(anonymous
903 - And operator names can contain parentheses or angle brackets. */
905 /* FIXME: carlton/2003-03-13: We have several functions here with
906 overlapping functionality; can we combine them? Also, do they
907 handle all the above considerations correctly? */
910 /* This returns the length of first component of NAME, which should be
911 the demangled name of a C++ variable/function/method/etc.
912 Specifically, it returns the index of the first colon forming the
913 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
914 it returns the 1, and given 'foo', it returns 0. */
916 /* The character in NAME indexed by the return value is guaranteed to
917 always be either ':' or '\0'. */
919 /* NOTE: carlton/2003-03-13: This function is currently only intended
920 for internal use: it's probably not entirely safe when called on
921 user-generated input, because some of the 'index += 2' lines in
922 cp_find_first_component_aux might go past the end of malformed
926 cp_find_first_component (const char *name)
928 return cp_find_first_component_aux (name, 0);
931 /* Helper function for cp_find_first_component. Like that function,
932 it returns the length of the first component of NAME, but to make
933 the recursion easier, it also stops if it reaches an unexpected ')'
934 or '>' if the value of PERMISSIVE is nonzero. */
937 cp_find_first_component_aux (const char *name, int permissive)
939 unsigned int index = 0;
940 /* Operator names can show up in unexpected places. Since these can
941 contain parentheses or angle brackets, they can screw up the
942 recursion. But not every string 'operator' is part of an
943 operater name: e.g. you could have a variable 'cooperator'. So
944 this variable tells us whether or not we should treat the string
945 'operator' as starting an operator. */
946 int operator_possible = 1;
953 /* Template; eat it up. The calls to cp_first_component
954 should only return (I hope!) when they reach the '>'
955 terminating the component or a '::' between two
956 components. (Hence the '+ 2'.) */
958 for (index += cp_find_first_component_aux (name + index, 1);
960 index += cp_find_first_component_aux (name + index, 1))
962 if (name[index] != ':')
964 demangled_name_complaint (name);
965 return strlen (name);
969 operator_possible = 1;
972 /* Similar comment as to '<'. */
974 for (index += cp_find_first_component_aux (name + index, 1);
976 index += cp_find_first_component_aux (name + index, 1))
978 if (name[index] != ':')
980 demangled_name_complaint (name);
981 return strlen (name);
985 operator_possible = 1;
993 demangled_name_complaint (name);
994 return strlen (name);
999 /* ':' marks a component iff the next character is also a ':'.
1000 Otherwise it is probably malformed input. */
1001 if (name[index + 1] == ':')
1005 /* Operator names can screw up the recursion. */
1006 if (operator_possible
1007 && startswith (name + index, CP_OPERATOR_STR))
1009 index += CP_OPERATOR_LEN;
1010 while (ISSPACE(name[index]))
1012 switch (name[index])
1016 /* Skip over one less than the appropriate number of
1017 characters: the for loop will skip over the last
1020 if (name[index + 1] == '<')
1027 if (name[index + 1] == '>')
1040 operator_possible = 0;
1047 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1048 set of relevant characters are here: it's necessary to
1049 include any character that can show up before 'operator'
1050 in a demangled name, and it's safe to include any
1051 character that can't be part of an identifier's name. */
1052 operator_possible = 1;
1055 operator_possible = 0;
1061 /* Complain about a demangled name that we don't know how to parse.
1062 NAME is the demangled name in question. */
1065 demangled_name_complaint (const char *name)
1067 complaint (&symfile_complaints,
1068 "unexpected demangled name '%s'", name);
1071 /* If NAME is the fully-qualified name of a C++
1072 function/variable/method/etc., this returns the length of its
1073 entire prefix: all of the namespaces and classes that make up its
1074 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1075 4, given 'foo', it returns 0. */
1078 cp_entire_prefix_len (const char *name)
1080 unsigned int current_len = cp_find_first_component (name);
1081 unsigned int previous_len = 0;
1083 while (name[current_len] != '\0')
1085 gdb_assert (name[current_len] == ':');
1086 previous_len = current_len;
1087 /* Skip the '::'. */
1089 current_len += cp_find_first_component (name + current_len);
1092 return previous_len;
1095 /* Overload resolution functions. */
1097 /* Test to see if SYM is a symbol that we haven't seen corresponding
1098 to a function named OLOAD_NAME. If so, add it to the current
1102 overload_list_add_symbol (struct symbol *sym,
1103 const char *oload_name)
1109 /* If there is no type information, we can't do anything, so
1111 if (SYMBOL_TYPE (sym) == NULL)
1114 /* skip any symbols that we've already considered. */
1115 for (i = 0; i < sym_return_val_index; ++i)
1116 if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1117 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
1120 /* Get the demangled name without parameters */
1121 sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1125 /* skip symbols that cannot match */
1126 if (strcmp (sym_name, oload_name) != 0)
1134 /* We have a match for an overload instance, so add SYM to the
1135 current list of overload instances */
1136 if (sym_return_val_index + 3 > sym_return_val_size)
1138 newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
1139 sym_return_val = (struct symbol **)
1140 xrealloc ((char *) sym_return_val, newsize);
1142 sym_return_val[sym_return_val_index++] = sym;
1143 sym_return_val[sym_return_val_index] = NULL;
1146 /* Return a null-terminated list of pointers to function symbols that
1147 are named FUNC_NAME and are visible within NAMESPACE. */
1150 make_symbol_overload_list (const char *func_name,
1151 const char *the_namespace)
1153 struct cleanup *old_cleanups;
1156 sym_return_val_size = 100;
1157 sym_return_val_index = 0;
1158 sym_return_val = XNEWVEC (struct symbol *, sym_return_val_size + 1);
1159 sym_return_val[0] = NULL;
1161 old_cleanups = make_cleanup (xfree, sym_return_val);
1163 make_symbol_overload_list_using (func_name, the_namespace);
1165 if (the_namespace[0] == '\0')
1169 char *concatenated_name
1170 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1171 strcpy (concatenated_name, the_namespace);
1172 strcat (concatenated_name, "::");
1173 strcat (concatenated_name, func_name);
1174 name = concatenated_name;
1177 make_symbol_overload_list_qualified (name);
1179 discard_cleanups (old_cleanups);
1181 return sym_return_val;
1184 /* Add all symbols with a name matching NAME in BLOCK to the overload
1188 make_symbol_overload_list_block (const char *name,
1189 const struct block *block)
1191 struct block_iterator iter;
1194 ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
1195 overload_list_add_symbol (sym, name);
1198 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1201 make_symbol_overload_list_namespace (const char *func_name,
1202 const char *the_namespace)
1205 const struct block *block = NULL;
1207 if (the_namespace[0] == '\0')
1211 char *concatenated_name
1212 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1214 strcpy (concatenated_name, the_namespace);
1215 strcat (concatenated_name, "::");
1216 strcat (concatenated_name, func_name);
1217 name = concatenated_name;
1220 /* Look in the static block. */
1221 block = block_static_block (get_selected_block (0));
1223 make_symbol_overload_list_block (name, block);
1225 /* Look in the global block. */
1226 block = block_global_block (block);
1228 make_symbol_overload_list_block (name, block);
1232 /* Search the namespace of the given type and namespace of and public
1236 make_symbol_overload_list_adl_namespace (struct type *type,
1237 const char *func_name)
1239 char *the_namespace;
1240 const char *type_name;
1243 while (TYPE_CODE (type) == TYPE_CODE_PTR
1244 || TYPE_IS_REFERENCE (type)
1245 || TYPE_CODE (type) == TYPE_CODE_ARRAY
1246 || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1248 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1249 type = check_typedef(type);
1251 type = TYPE_TARGET_TYPE (type);
1254 type_name = TYPE_NAME (type);
1256 if (type_name == NULL)
1259 prefix_len = cp_entire_prefix_len (type_name);
1261 if (prefix_len != 0)
1263 the_namespace = (char *) alloca (prefix_len + 1);
1264 strncpy (the_namespace, type_name, prefix_len);
1265 the_namespace[prefix_len] = '\0';
1267 make_symbol_overload_list_namespace (func_name, the_namespace);
1270 /* Check public base type */
1271 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1272 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1274 if (BASETYPE_VIA_PUBLIC (type, i))
1275 make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type,
1281 /* Adds the overload list overload candidates for FUNC_NAME found
1282 through argument dependent lookup. */
1285 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
1286 const char *func_name)
1290 gdb_assert (sym_return_val_size != -1);
1292 for (i = 1; i <= nargs; i++)
1293 make_symbol_overload_list_adl_namespace (arg_types[i - 1],
1296 return sym_return_val;
1299 /* Used for cleanups to reset the "searched" flag in case of an
1303 reset_directive_searched (void *data)
1305 struct using_direct *direct = (struct using_direct *) data;
1306 direct->searched = 0;
1309 /* This applies the using directives to add namespaces to search in,
1310 and then searches for overloads in all of those namespaces. It
1311 adds the symbols found to sym_return_val. Arguments are as in
1312 make_symbol_overload_list. */
1315 make_symbol_overload_list_using (const char *func_name,
1316 const char *the_namespace)
1318 struct using_direct *current;
1319 const struct block *block;
1321 /* First, go through the using directives. If any of them apply,
1322 look in the appropriate namespaces for new functions to match
1325 for (block = get_selected_block (0);
1327 block = BLOCK_SUPERBLOCK (block))
1328 for (current = block_using (block);
1330 current = current->next)
1332 /* Prevent recursive calls. */
1333 if (current->searched)
1336 /* If this is a namespace alias or imported declaration ignore
1338 if (current->alias != NULL || current->declaration != NULL)
1341 if (strcmp (the_namespace, current->import_dest) == 0)
1343 /* Mark this import as searched so that the recursive call
1344 does not search it again. */
1345 struct cleanup *old_chain;
1346 current->searched = 1;
1347 old_chain = make_cleanup (reset_directive_searched,
1350 make_symbol_overload_list_using (func_name,
1351 current->import_src);
1353 current->searched = 0;
1354 discard_cleanups (old_chain);
1358 /* Now, add names for this namespace. */
1359 make_symbol_overload_list_namespace (func_name, the_namespace);
1362 /* This does the bulk of the work of finding overloaded symbols.
1363 FUNC_NAME is the name of the overloaded function we're looking for
1364 (possibly including namespace info). */
1367 make_symbol_overload_list_qualified (const char *func_name)
1369 struct compunit_symtab *cust;
1370 struct objfile *objfile;
1371 const struct block *b, *surrounding_static_block = 0;
1373 /* Look through the partial symtabs for all symbols which begin by
1374 matching FUNC_NAME. Make sure we read that symbol table in. */
1376 ALL_OBJFILES (objfile)
1379 objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1382 /* Search upwards from currently selected frame (so that we can
1383 complete on local vars. */
1385 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1386 make_symbol_overload_list_block (func_name, b);
1388 surrounding_static_block = block_static_block (get_selected_block (0));
1390 /* Go through the symtabs and check the externs and statics for
1391 symbols which match. */
1393 ALL_COMPUNITS (objfile, cust)
1396 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), GLOBAL_BLOCK);
1397 make_symbol_overload_list_block (func_name, b);
1400 ALL_COMPUNITS (objfile, cust)
1403 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
1404 /* Don't do this block twice. */
1405 if (b == surrounding_static_block)
1407 make_symbol_overload_list_block (func_name, b);
1411 /* Lookup the rtti type for a class name. */
1414 cp_lookup_rtti_type (const char *name, struct block *block)
1416 struct symbol * rtti_sym;
1417 struct type * rtti_type;
1419 /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
1420 Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
1421 rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
1423 if (rtti_sym == NULL)
1425 warning (_("RTTI symbol not found for class '%s'"), name);
1429 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1431 warning (_("RTTI symbol for class '%s' is not a type"), name);
1435 rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym));
1437 switch (TYPE_CODE (rtti_type))
1439 case TYPE_CODE_STRUCT:
1441 case TYPE_CODE_NAMESPACE:
1442 /* chastain/2003-11-26: the symbol tables often contain fake
1443 symbols for namespaces with the same name as the struct.
1444 This warning is an indication of a bug in the lookup order
1445 or a bug in the way that the symbol tables are populated. */
1446 warning (_("RTTI symbol for class '%s' is a namespace"), name);
1449 warning (_("RTTI symbol for class '%s' has bad type"), name);
1456 #ifdef HAVE_WORKING_FORK
1458 /* If nonzero, attempt to catch crashes in the demangler and print
1459 useful debugging information. */
1461 static int catch_demangler_crashes = 1;
1463 /* Stack context and environment for demangler crash recovery. */
1465 static SIGJMP_BUF gdb_demangle_jmp_buf;
1467 /* If nonzero, attempt to dump core from the signal handler. */
1469 static int gdb_demangle_attempt_core_dump = 1;
1471 /* Signal handler for gdb_demangle. */
1474 gdb_demangle_signal_handler (int signo)
1476 if (gdb_demangle_attempt_core_dump)
1481 gdb_demangle_attempt_core_dump = 0;
1484 SIGLONGJMP (gdb_demangle_jmp_buf, signo);
1489 /* A wrapper for bfd_demangle. */
1492 gdb_demangle (const char *name, int options)
1494 char *result = NULL;
1495 int crash_signal = 0;
1497 #ifdef HAVE_WORKING_FORK
1498 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1499 struct sigaction sa, old_sa;
1503 static int core_dump_allowed = -1;
1505 if (core_dump_allowed == -1)
1507 core_dump_allowed = can_dump_core (LIMIT_CUR);
1509 if (!core_dump_allowed)
1510 gdb_demangle_attempt_core_dump = 0;
1513 if (catch_demangler_crashes)
1515 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1516 sa.sa_handler = gdb_demangle_signal_handler;
1517 sigemptyset (&sa.sa_mask);
1518 #ifdef HAVE_SIGALTSTACK
1519 sa.sa_flags = SA_ONSTACK;
1523 sigaction (SIGSEGV, &sa, &old_sa);
1525 ofunc = signal (SIGSEGV, gdb_demangle_signal_handler);
1528 crash_signal = SIGSETJMP (gdb_demangle_jmp_buf);
1532 if (crash_signal == 0)
1533 result = bfd_demangle (NULL, name, options);
1535 #ifdef HAVE_WORKING_FORK
1536 if (catch_demangler_crashes)
1538 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1539 sigaction (SIGSEGV, &old_sa, NULL);
1541 signal (SIGSEGV, ofunc);
1544 if (crash_signal != 0)
1546 static int error_reported = 0;
1548 if (!error_reported)
1550 char *short_msg, *long_msg;
1551 struct cleanup *back_to;
1553 short_msg = xstrprintf (_("unable to demangle '%s' "
1554 "(demangler failed with signal %d)"),
1555 name, crash_signal);
1556 back_to = make_cleanup (xfree, short_msg);
1558 long_msg = xstrprintf ("%s:%d: %s: %s", __FILE__, __LINE__,
1559 "demangler-warning", short_msg);
1560 make_cleanup (xfree, long_msg);
1562 make_cleanup_restore_target_terminal ();
1563 target_terminal_ours_for_output ();
1566 if (core_dump_allowed)
1567 fprintf_unfiltered (gdb_stderr,
1568 _("%s\nAttempting to dump core.\n"),
1571 warn_cant_dump_core (long_msg);
1573 demangler_warning (__FILE__, __LINE__, "%s", short_msg);
1575 do_cleanups (back_to);
1588 /* See cp-support.h. */
1591 gdb_sniff_from_mangled_name (const char *mangled, char **demangled)
1593 *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
1594 return *demangled != NULL;
1597 /* Don't allow just "maintenance cplus". */
1600 maint_cplus_command (char *arg, int from_tty)
1602 printf_unfiltered (_("\"maintenance cplus\" must be followed "
1603 "by the name of a command.\n"));
1604 help_list (maint_cplus_cmd_list,
1605 "maintenance cplus ",
1606 all_commands, gdb_stdout);
1609 /* This is a front end for cp_find_first_component, for unit testing.
1610 Be careful when using it: see the NOTE above
1611 cp_find_first_component. */
1614 first_component_command (char *arg, int from_tty)
1622 len = cp_find_first_component (arg);
1623 prefix = (char *) alloca (len + 1);
1625 memcpy (prefix, arg, len);
1628 printf_unfiltered ("%s\n", prefix);
1631 /* Implement "info vtbl". */
1634 info_vtbl_command (char *arg, int from_tty)
1636 struct value *value;
1638 value = parse_and_eval (arg);
1639 cplus_print_vtable (value);
1643 _initialize_cp_support (void)
1645 add_prefix_cmd ("cplus", class_maintenance,
1646 maint_cplus_command,
1647 _("C++ maintenance commands."),
1648 &maint_cplus_cmd_list,
1649 "maintenance cplus ",
1650 0, &maintenancelist);
1651 add_alias_cmd ("cp", "cplus",
1652 class_maintenance, 1,
1655 add_cmd ("first_component",
1657 first_component_command,
1658 _("Print the first class/namespace component of NAME."),
1659 &maint_cplus_cmd_list);
1661 add_info ("vtbl", info_vtbl_command,
1662 _("Show the virtual function table for a C++ object.\n\
1663 Usage: info vtbl EXPRESSION\n\
1664 Evaluate EXPRESSION and display the virtual function table for the\n\
1665 resulting object."));
1667 #ifdef HAVE_WORKING_FORK
1668 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance,
1669 &catch_demangler_crashes, _("\
1670 Set whether to attempt to catch demangler crashes."), _("\
1671 Show whether to attempt to catch demangler crashes."), _("\
1672 If enabled GDB will attempt to catch demangler crashes and\n\
1673 display the offending symbol."),
1676 &maintenance_set_cmdlist,
1677 &maintenance_show_cmdlist);