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;
197 /* Get the real type of the typedef. */
198 type = check_typedef (otype);
200 /* If the symbol is a namespace and its type name is no different
201 than the name we looked up, this symbol is not a namespace
202 alias and does not need to be substituted. */
203 if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE
204 && strcmp (TYPE_NAME (type), name) == 0)
207 is_anon = (TYPE_TAG_NAME (type) == NULL
208 && (TYPE_CODE (type) == TYPE_CODE_ENUM
209 || TYPE_CODE (type) == TYPE_CODE_STRUCT
210 || TYPE_CODE (type) == TYPE_CODE_UNION));
213 struct type *last = otype;
215 /* Find the last typedef for the type. */
216 while (TYPE_TARGET_TYPE (last) != NULL
217 && (TYPE_CODE (TYPE_TARGET_TYPE (last))
218 == TYPE_CODE_TYPEDEF))
219 last = TYPE_TARGET_TYPE (last);
221 /* If there is only one typedef for this anonymous type,
222 do not substitute it. */
226 /* Use the last typedef seen as the type for this
231 buf = mem_fileopen ();
234 type_print (type, "", buf, -1);
237 /* If type_print threw an exception, there is little point
238 in continuing, so just bow out gracefully. */
239 CATCH (except, RETURN_MASK_ERROR)
241 ui_file_delete (buf);
246 name = ui_file_obsavestring (buf, &info->obstack, &len);
247 ui_file_delete (buf);
249 /* Turn the result into a new tree. Note that this
250 tree will contain pointers into NAME, so NAME cannot
251 be free'd until all typedef conversion is done and
252 the final result is converted into a string. */
253 i = cp_demangled_name_to_comp (name, NULL);
256 /* Merge the two trees. */
257 cp_merge_demangle_parse_infos (info, ret_comp, i.get ());
259 /* Replace any newly introduced typedefs -- but not
260 if the type is anonymous (that would lead to infinite
263 replace_typedefs (info, ret_comp, finder, data);
267 /* This shouldn't happen unless the type printer has
268 output something that the name parser cannot grok.
269 Nonetheless, an ounce of prevention...
271 Canonicalize the name again, and store it in the
272 current node (RET_COMP). */
273 std::string canon = cp_canonicalize_string_no_typedefs (name);
277 /* Copy the canonicalization into the obstack. */
278 name = copy_string_to_obstack (&info->obstack, canon.c_str (), &len);
281 ret_comp->u.s_name.s = name;
282 ret_comp->u.s_name.len = len;
292 /* Replace any typedefs appearing in the qualified name
293 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
297 replace_typedefs_qualified_name (struct demangle_parse_info *info,
298 struct demangle_component *ret_comp,
299 canonicalization_ftype *finder,
304 struct ui_file *buf = mem_fileopen ();
305 struct demangle_component *comp = ret_comp;
307 /* Walk each node of the qualified name, reconstructing the name of
308 this element. With every node, check for any typedef substitutions.
309 If a substitution has occurred, replace the qualified name node
310 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
312 while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
314 if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
316 struct demangle_component newobj;
318 ui_file_write (buf, d_left (comp)->u.s_name.s,
319 d_left (comp)->u.s_name.len);
320 name = ui_file_obsavestring (buf, &info->obstack, &len);
321 newobj.type = DEMANGLE_COMPONENT_NAME;
322 newobj.u.s_name.s = name;
323 newobj.u.s_name.len = len;
324 if (inspect_type (info, &newobj, finder, data))
329 /* A typedef was substituted in NEW. Convert it to a
330 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
333 ui_file_rewind (buf);
334 n = cp_comp_to_string (&newobj, 100);
337 /* If something went astray, abort typedef substitutions. */
338 ui_file_delete (buf);
342 s = copy_string_to_obstack (&info->obstack, n, &slen);
345 d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
346 d_left (ret_comp)->u.s_name.s = s;
347 d_left (ret_comp)->u.s_name.len = slen;
348 d_right (ret_comp) = d_right (comp);
355 /* The current node is not a name, so simply replace any
356 typedefs in it. Then print it to the stream to continue
357 checking for more typedefs in the tree. */
358 replace_typedefs (info, d_left (comp), finder, data);
359 name = cp_comp_to_string (d_left (comp), 100);
362 /* If something went astray, abort typedef substitutions. */
363 ui_file_delete (buf);
366 fputs_unfiltered (name, buf);
370 ui_file_write (buf, "::", 2);
371 comp = d_right (comp);
374 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
375 name assembled above and append the name given by COMP. Then use this
376 reassembled name to check for a typedef. */
378 if (comp->type == DEMANGLE_COMPONENT_NAME)
380 ui_file_write (buf, comp->u.s_name.s, comp->u.s_name.len);
381 name = ui_file_obsavestring (buf, &info->obstack, &len);
383 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
384 with a DEMANGLE_COMPONENT_NAME node containing the whole
386 ret_comp->type = DEMANGLE_COMPONENT_NAME;
387 ret_comp->u.s_name.s = name;
388 ret_comp->u.s_name.len = len;
389 inspect_type (info, ret_comp, finder, data);
392 replace_typedefs (info, comp, finder, data);
394 ui_file_delete (buf);
398 /* A function to check const and volatile qualifiers for argument types.
400 "Parameter declarations that differ only in the presence
401 or absence of `const' and/or `volatile' are equivalent."
402 C++ Standard N3290, clause 13.1.3 #4. */
405 check_cv_qualifiers (struct demangle_component *ret_comp)
407 while (d_left (ret_comp) != NULL
408 && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST
409 || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE))
411 d_left (ret_comp) = d_left (d_left (ret_comp));
415 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
416 their basic types. */
419 replace_typedefs (struct demangle_parse_info *info,
420 struct demangle_component *ret_comp,
421 canonicalization_ftype *finder,
427 && (ret_comp->type == DEMANGLE_COMPONENT_NAME
428 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
429 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE
430 || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE))
432 char *local_name = cp_comp_to_string (ret_comp, 10);
434 if (local_name != NULL)
436 struct symbol *sym = NULL;
441 sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0).symbol;
443 CATCH (except, RETURN_MASK_ALL)
452 struct type *otype = SYMBOL_TYPE (sym);
453 const char *new_name = (*finder) (otype, data);
455 if (new_name != NULL)
457 ret_comp->type = DEMANGLE_COMPONENT_NAME;
458 ret_comp->u.s_name.s = new_name;
459 ret_comp->u.s_name.len = strlen (new_name);
466 switch (ret_comp->type)
468 case DEMANGLE_COMPONENT_ARGLIST:
469 check_cv_qualifiers (ret_comp);
472 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
473 case DEMANGLE_COMPONENT_TEMPLATE:
474 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
475 case DEMANGLE_COMPONENT_TYPED_NAME:
476 replace_typedefs (info, d_left (ret_comp), finder, data);
477 replace_typedefs (info, d_right (ret_comp), finder, data);
480 case DEMANGLE_COMPONENT_NAME:
481 inspect_type (info, ret_comp, finder, data);
484 case DEMANGLE_COMPONENT_QUAL_NAME:
485 replace_typedefs_qualified_name (info, ret_comp, finder, data);
488 case DEMANGLE_COMPONENT_LOCAL_NAME:
489 case DEMANGLE_COMPONENT_CTOR:
490 case DEMANGLE_COMPONENT_ARRAY_TYPE:
491 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
492 replace_typedefs (info, d_right (ret_comp), finder, data);
495 case DEMANGLE_COMPONENT_CONST:
496 case DEMANGLE_COMPONENT_RESTRICT:
497 case DEMANGLE_COMPONENT_VOLATILE:
498 case DEMANGLE_COMPONENT_VOLATILE_THIS:
499 case DEMANGLE_COMPONENT_CONST_THIS:
500 case DEMANGLE_COMPONENT_RESTRICT_THIS:
501 case DEMANGLE_COMPONENT_POINTER:
502 case DEMANGLE_COMPONENT_REFERENCE:
503 replace_typedefs (info, d_left (ret_comp), finder, data);
512 /* Parse STRING and convert it to canonical form, resolving any
513 typedefs. If parsing fails, or if STRING is already canonical,
514 return the empty string. Otherwise return the canonical form. If
515 FINDER is not NULL, then type components are passed to FINDER to be
516 looked up. DATA is passed verbatim to FINDER. */
519 cp_canonicalize_string_full (const char *string,
520 canonicalization_ftype *finder,
524 unsigned int estimated_len;
525 std::unique_ptr<demangle_parse_info> info;
527 estimated_len = strlen (string) * 2;
528 info = cp_demangled_name_to_comp (string, NULL);
531 /* Replace all the typedefs in the tree. */
532 replace_typedefs (info.get (), info->tree, finder, data);
534 /* Convert the tree back into a string. */
535 ret = cp_comp_to_string (info->tree, estimated_len);
536 gdb_assert (!ret.empty ());
538 /* Finally, compare the original string with the computed
539 name, returning NULL if they are the same. */
541 return std::string ();
547 /* Like cp_canonicalize_string_full, but always passes NULL for
551 cp_canonicalize_string_no_typedefs (const char *string)
553 return cp_canonicalize_string_full (string, NULL, NULL);
556 /* Parse STRING and convert it to canonical form. If parsing fails,
557 or if STRING is already canonical, return the empty string.
558 Otherwise return the canonical form. */
561 cp_canonicalize_string (const char *string)
563 std::unique_ptr<demangle_parse_info> info;
564 unsigned int estimated_len;
566 if (cp_already_canonical (string))
567 return std::string ();
569 info = cp_demangled_name_to_comp (string, NULL);
571 return std::string ();
573 estimated_len = strlen (string) * 2;
574 std::string ret = cp_comp_to_string (info->tree, estimated_len);
578 warning (_("internal error: string \"%s\" failed to be canonicalized"),
580 return std::string ();
584 return std::string ();
589 /* Convert a mangled name to a demangle_component tree. *MEMORY is
590 set to the block of used memory that should be freed when finished
591 with the tree. DEMANGLED_P is set to the char * that should be
592 freed when finished with the tree, or NULL if none was needed.
593 OPTIONS will be passed to the demangler. */
595 static std::unique_ptr<demangle_parse_info>
596 mangled_name_to_comp (const char *mangled_name, int options,
597 void **memory, char **demangled_p)
599 char *demangled_name;
601 /* If it looks like a v3 mangled name, then try to go directly
603 if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
605 struct demangle_component *ret;
607 ret = cplus_demangle_v3_components (mangled_name,
611 std::unique_ptr<demangle_parse_info> info (new demangle_parse_info);
618 /* If it doesn't, or if that failed, then try to demangle the
620 demangled_name = gdb_demangle (mangled_name, options);
621 if (demangled_name == NULL)
624 /* If we could demangle the name, parse it to build the component
626 std::unique_ptr<demangle_parse_info> info
627 = cp_demangled_name_to_comp (demangled_name, NULL);
631 xfree (demangled_name);
635 *demangled_p = demangled_name;
639 /* Return the name of the class containing method PHYSNAME. */
642 cp_class_name_from_physname (const char *physname)
644 void *storage = NULL;
645 char *demangled_name = NULL, *ret;
646 struct demangle_component *ret_comp, *prev_comp, *cur_comp;
647 std::unique_ptr<demangle_parse_info> info;
650 info = mangled_name_to_comp (physname, DMGL_ANSI,
651 &storage, &demangled_name);
656 ret_comp = info->tree;
658 /* First strip off any qualifiers, if we have a function or
661 switch (ret_comp->type)
663 case DEMANGLE_COMPONENT_CONST:
664 case DEMANGLE_COMPONENT_RESTRICT:
665 case DEMANGLE_COMPONENT_VOLATILE:
666 case DEMANGLE_COMPONENT_CONST_THIS:
667 case DEMANGLE_COMPONENT_RESTRICT_THIS:
668 case DEMANGLE_COMPONENT_VOLATILE_THIS:
669 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
670 ret_comp = d_left (ret_comp);
677 /* If what we have now is a function, discard the argument list. */
678 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
679 ret_comp = d_left (ret_comp);
681 /* If what we have now is a template, strip off the template
682 arguments. The left subtree may be a qualified name. */
683 if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
684 ret_comp = d_left (ret_comp);
686 /* What we have now should be a name, possibly qualified.
687 Additional qualifiers could live in the left subtree or the right
688 subtree. Find the last piece. */
693 switch (cur_comp->type)
695 case DEMANGLE_COMPONENT_QUAL_NAME:
696 case DEMANGLE_COMPONENT_LOCAL_NAME:
697 prev_comp = cur_comp;
698 cur_comp = d_right (cur_comp);
700 case DEMANGLE_COMPONENT_TEMPLATE:
701 case DEMANGLE_COMPONENT_NAME:
702 case DEMANGLE_COMPONENT_CTOR:
703 case DEMANGLE_COMPONENT_DTOR:
704 case DEMANGLE_COMPONENT_OPERATOR:
705 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
715 if (cur_comp != NULL && prev_comp != NULL)
717 /* We want to discard the rightmost child of PREV_COMP. */
718 *prev_comp = *d_left (prev_comp);
719 /* The ten is completely arbitrary; we don't have a good
721 ret = cp_comp_to_string (ret_comp, 10);
725 xfree (demangled_name);
729 /* Return the child of COMP which is the basename of a method,
730 variable, et cetera. All scope qualifiers are discarded, but
731 template arguments will be included. The component tree may be
734 static struct demangle_component *
735 unqualified_name_from_comp (struct demangle_component *comp)
737 struct demangle_component *ret_comp = comp, *last_template;
741 last_template = NULL;
743 switch (ret_comp->type)
745 case DEMANGLE_COMPONENT_QUAL_NAME:
746 case DEMANGLE_COMPONENT_LOCAL_NAME:
747 ret_comp = d_right (ret_comp);
749 case DEMANGLE_COMPONENT_TYPED_NAME:
750 ret_comp = d_left (ret_comp);
752 case DEMANGLE_COMPONENT_TEMPLATE:
753 gdb_assert (last_template == NULL);
754 last_template = ret_comp;
755 ret_comp = d_left (ret_comp);
757 case DEMANGLE_COMPONENT_CONST:
758 case DEMANGLE_COMPONENT_RESTRICT:
759 case DEMANGLE_COMPONENT_VOLATILE:
760 case DEMANGLE_COMPONENT_CONST_THIS:
761 case DEMANGLE_COMPONENT_RESTRICT_THIS:
762 case DEMANGLE_COMPONENT_VOLATILE_THIS:
763 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
764 ret_comp = d_left (ret_comp);
766 case DEMANGLE_COMPONENT_NAME:
767 case DEMANGLE_COMPONENT_CTOR:
768 case DEMANGLE_COMPONENT_DTOR:
769 case DEMANGLE_COMPONENT_OPERATOR:
770 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
780 d_left (last_template) = ret_comp;
781 return last_template;
787 /* Return the name of the method whose linkage name is PHYSNAME. */
790 method_name_from_physname (const char *physname)
792 void *storage = NULL;
793 char *demangled_name = NULL, *ret;
794 struct demangle_component *ret_comp;
795 std::unique_ptr<demangle_parse_info> info;
797 info = mangled_name_to_comp (physname, DMGL_ANSI,
798 &storage, &demangled_name);
802 ret_comp = unqualified_name_from_comp (info->tree);
805 if (ret_comp != NULL)
806 /* The ten is completely arbitrary; we don't have a good
808 ret = cp_comp_to_string (ret_comp, 10);
811 xfree (demangled_name);
815 /* If FULL_NAME is the demangled name of a C++ function (including an
816 arg list, possibly including namespace/class qualifications),
817 return a new string containing only the function name (without the
818 arg list/class qualifications). Otherwise, return NULL. The
819 caller is responsible for freeing the memory in question. */
822 cp_func_name (const char *full_name)
825 struct demangle_component *ret_comp;
826 std::unique_ptr<demangle_parse_info> info;
828 info = cp_demangled_name_to_comp (full_name, NULL);
832 ret_comp = unqualified_name_from_comp (info->tree);
835 if (ret_comp != NULL)
836 ret = cp_comp_to_string (ret_comp, 10);
841 /* DEMANGLED_NAME is the name of a function, including parameters and
842 (optionally) a return type. Return the name of the function without
843 parameters or return type, or NULL if we can not parse the name. */
846 cp_remove_params (const char *demangled_name)
849 struct demangle_component *ret_comp;
850 std::unique_ptr<demangle_parse_info> info;
853 if (demangled_name == NULL)
856 info = cp_demangled_name_to_comp (demangled_name, NULL);
860 /* First strip off any qualifiers, if we have a function or method. */
861 ret_comp = info->tree;
863 switch (ret_comp->type)
865 case DEMANGLE_COMPONENT_CONST:
866 case DEMANGLE_COMPONENT_RESTRICT:
867 case DEMANGLE_COMPONENT_VOLATILE:
868 case DEMANGLE_COMPONENT_CONST_THIS:
869 case DEMANGLE_COMPONENT_RESTRICT_THIS:
870 case DEMANGLE_COMPONENT_VOLATILE_THIS:
871 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
872 ret_comp = d_left (ret_comp);
879 /* What we have now should be a function. Return its name. */
880 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
881 ret = cp_comp_to_string (d_left (ret_comp), 10);
886 /* Here are some random pieces of trivia to keep in mind while trying
887 to take apart demangled names:
889 - Names can contain function arguments or templates, so the process
890 has to be, to some extent recursive: maybe keep track of your
891 depth based on encountering <> and ().
893 - Parentheses don't just have to happen at the end of a name: they
894 can occur even if the name in question isn't a function, because
895 a template argument might be a type that's a function.
897 - Conversely, even if you're trying to deal with a function, its
898 demangled name might not end with ')': it could be a const or
899 volatile class method, in which case it ends with "const" or
902 - Parentheses are also used in anonymous namespaces: a variable
903 'foo' in an anonymous namespace gets demangled as "(anonymous
906 - And operator names can contain parentheses or angle brackets. */
908 /* FIXME: carlton/2003-03-13: We have several functions here with
909 overlapping functionality; can we combine them? Also, do they
910 handle all the above considerations correctly? */
913 /* This returns the length of first component of NAME, which should be
914 the demangled name of a C++ variable/function/method/etc.
915 Specifically, it returns the index of the first colon forming the
916 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
917 it returns the 1, and given 'foo', it returns 0. */
919 /* The character in NAME indexed by the return value is guaranteed to
920 always be either ':' or '\0'. */
922 /* NOTE: carlton/2003-03-13: This function is currently only intended
923 for internal use: it's probably not entirely safe when called on
924 user-generated input, because some of the 'index += 2' lines in
925 cp_find_first_component_aux might go past the end of malformed
929 cp_find_first_component (const char *name)
931 return cp_find_first_component_aux (name, 0);
934 /* Helper function for cp_find_first_component. Like that function,
935 it returns the length of the first component of NAME, but to make
936 the recursion easier, it also stops if it reaches an unexpected ')'
937 or '>' if the value of PERMISSIVE is nonzero. */
939 /* Let's optimize away calls to strlen("operator"). */
941 #define LENGTH_OF_OPERATOR 8
944 cp_find_first_component_aux (const char *name, int permissive)
946 unsigned int index = 0;
947 /* Operator names can show up in unexpected places. Since these can
948 contain parentheses or angle brackets, they can screw up the
949 recursion. But not every string 'operator' is part of an
950 operater name: e.g. you could have a variable 'cooperator'. So
951 this variable tells us whether or not we should treat the string
952 'operator' as starting an operator. */
953 int operator_possible = 1;
960 /* Template; eat it up. The calls to cp_first_component
961 should only return (I hope!) when they reach the '>'
962 terminating the component or a '::' between two
963 components. (Hence the '+ 2'.) */
965 for (index += cp_find_first_component_aux (name + index, 1);
967 index += cp_find_first_component_aux (name + index, 1))
969 if (name[index] != ':')
971 demangled_name_complaint (name);
972 return strlen (name);
976 operator_possible = 1;
979 /* Similar comment as to '<'. */
981 for (index += cp_find_first_component_aux (name + index, 1);
983 index += cp_find_first_component_aux (name + index, 1))
985 if (name[index] != ':')
987 demangled_name_complaint (name);
988 return strlen (name);
992 operator_possible = 1;
1000 demangled_name_complaint (name);
1001 return strlen (name);
1006 /* ':' marks a component iff the next character is also a ':'.
1007 Otherwise it is probably malformed input. */
1008 if (name[index + 1] == ':')
1012 /* Operator names can screw up the recursion. */
1013 if (operator_possible
1014 && strncmp (name + index, "operator",
1015 LENGTH_OF_OPERATOR) == 0)
1017 index += LENGTH_OF_OPERATOR;
1018 while (ISSPACE(name[index]))
1020 switch (name[index])
1022 /* Skip over one less than the appropriate number of
1023 characters: the for loop will skip over the last
1026 if (name[index + 1] == '<')
1033 if (name[index + 1] == '>')
1046 operator_possible = 0;
1053 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1054 set of relevant characters are here: it's necessary to
1055 include any character that can show up before 'operator'
1056 in a demangled name, and it's safe to include any
1057 character that can't be part of an identifier's name. */
1058 operator_possible = 1;
1061 operator_possible = 0;
1067 /* Complain about a demangled name that we don't know how to parse.
1068 NAME is the demangled name in question. */
1071 demangled_name_complaint (const char *name)
1073 complaint (&symfile_complaints,
1074 "unexpected demangled name '%s'", name);
1077 /* If NAME is the fully-qualified name of a C++
1078 function/variable/method/etc., this returns the length of its
1079 entire prefix: all of the namespaces and classes that make up its
1080 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1081 4, given 'foo', it returns 0. */
1084 cp_entire_prefix_len (const char *name)
1086 unsigned int current_len = cp_find_first_component (name);
1087 unsigned int previous_len = 0;
1089 while (name[current_len] != '\0')
1091 gdb_assert (name[current_len] == ':');
1092 previous_len = current_len;
1093 /* Skip the '::'. */
1095 current_len += cp_find_first_component (name + current_len);
1098 return previous_len;
1101 /* Overload resolution functions. */
1103 /* Test to see if SYM is a symbol that we haven't seen corresponding
1104 to a function named OLOAD_NAME. If so, add it to the current
1108 overload_list_add_symbol (struct symbol *sym,
1109 const char *oload_name)
1115 /* If there is no type information, we can't do anything, so
1117 if (SYMBOL_TYPE (sym) == NULL)
1120 /* skip any symbols that we've already considered. */
1121 for (i = 0; i < sym_return_val_index; ++i)
1122 if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1123 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
1126 /* Get the demangled name without parameters */
1127 sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1131 /* skip symbols that cannot match */
1132 if (strcmp (sym_name, oload_name) != 0)
1140 /* We have a match for an overload instance, so add SYM to the
1141 current list of overload instances */
1142 if (sym_return_val_index + 3 > sym_return_val_size)
1144 newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
1145 sym_return_val = (struct symbol **)
1146 xrealloc ((char *) sym_return_val, newsize);
1148 sym_return_val[sym_return_val_index++] = sym;
1149 sym_return_val[sym_return_val_index] = NULL;
1152 /* Return a null-terminated list of pointers to function symbols that
1153 are named FUNC_NAME and are visible within NAMESPACE. */
1156 make_symbol_overload_list (const char *func_name,
1157 const char *the_namespace)
1159 struct cleanup *old_cleanups;
1162 sym_return_val_size = 100;
1163 sym_return_val_index = 0;
1164 sym_return_val = XNEWVEC (struct symbol *, sym_return_val_size + 1);
1165 sym_return_val[0] = NULL;
1167 old_cleanups = make_cleanup (xfree, sym_return_val);
1169 make_symbol_overload_list_using (func_name, the_namespace);
1171 if (the_namespace[0] == '\0')
1175 char *concatenated_name
1176 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1177 strcpy (concatenated_name, the_namespace);
1178 strcat (concatenated_name, "::");
1179 strcat (concatenated_name, func_name);
1180 name = concatenated_name;
1183 make_symbol_overload_list_qualified (name);
1185 discard_cleanups (old_cleanups);
1187 return sym_return_val;
1190 /* Add all symbols with a name matching NAME in BLOCK to the overload
1194 make_symbol_overload_list_block (const char *name,
1195 const struct block *block)
1197 struct block_iterator iter;
1200 ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
1201 overload_list_add_symbol (sym, name);
1204 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1207 make_symbol_overload_list_namespace (const char *func_name,
1208 const char *the_namespace)
1211 const struct block *block = NULL;
1213 if (the_namespace[0] == '\0')
1217 char *concatenated_name
1218 = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1220 strcpy (concatenated_name, the_namespace);
1221 strcat (concatenated_name, "::");
1222 strcat (concatenated_name, func_name);
1223 name = concatenated_name;
1226 /* Look in the static block. */
1227 block = block_static_block (get_selected_block (0));
1229 make_symbol_overload_list_block (name, block);
1231 /* Look in the global block. */
1232 block = block_global_block (block);
1234 make_symbol_overload_list_block (name, block);
1238 /* Search the namespace of the given type and namespace of and public
1242 make_symbol_overload_list_adl_namespace (struct type *type,
1243 const char *func_name)
1245 char *the_namespace;
1246 const char *type_name;
1249 while (TYPE_CODE (type) == TYPE_CODE_PTR
1250 || TYPE_CODE (type) == TYPE_CODE_REF
1251 || TYPE_CODE (type) == TYPE_CODE_ARRAY
1252 || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1254 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1255 type = check_typedef(type);
1257 type = TYPE_TARGET_TYPE (type);
1260 type_name = TYPE_NAME (type);
1262 if (type_name == NULL)
1265 prefix_len = cp_entire_prefix_len (type_name);
1267 if (prefix_len != 0)
1269 the_namespace = (char *) alloca (prefix_len + 1);
1270 strncpy (the_namespace, type_name, prefix_len);
1271 the_namespace[prefix_len] = '\0';
1273 make_symbol_overload_list_namespace (func_name, the_namespace);
1276 /* Check public base type */
1277 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1278 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1280 if (BASETYPE_VIA_PUBLIC (type, i))
1281 make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type,
1287 /* Adds the overload list overload candidates for FUNC_NAME found
1288 through argument dependent lookup. */
1291 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
1292 const char *func_name)
1296 gdb_assert (sym_return_val_size != -1);
1298 for (i = 1; i <= nargs; i++)
1299 make_symbol_overload_list_adl_namespace (arg_types[i - 1],
1302 return sym_return_val;
1305 /* Used for cleanups to reset the "searched" flag in case of an
1309 reset_directive_searched (void *data)
1311 struct using_direct *direct = (struct using_direct *) data;
1312 direct->searched = 0;
1315 /* This applies the using directives to add namespaces to search in,
1316 and then searches for overloads in all of those namespaces. It
1317 adds the symbols found to sym_return_val. Arguments are as in
1318 make_symbol_overload_list. */
1321 make_symbol_overload_list_using (const char *func_name,
1322 const char *the_namespace)
1324 struct using_direct *current;
1325 const struct block *block;
1327 /* First, go through the using directives. If any of them apply,
1328 look in the appropriate namespaces for new functions to match
1331 for (block = get_selected_block (0);
1333 block = BLOCK_SUPERBLOCK (block))
1334 for (current = block_using (block);
1336 current = current->next)
1338 /* Prevent recursive calls. */
1339 if (current->searched)
1342 /* If this is a namespace alias or imported declaration ignore
1344 if (current->alias != NULL || current->declaration != NULL)
1347 if (strcmp (the_namespace, current->import_dest) == 0)
1349 /* Mark this import as searched so that the recursive call
1350 does not search it again. */
1351 struct cleanup *old_chain;
1352 current->searched = 1;
1353 old_chain = make_cleanup (reset_directive_searched,
1356 make_symbol_overload_list_using (func_name,
1357 current->import_src);
1359 current->searched = 0;
1360 discard_cleanups (old_chain);
1364 /* Now, add names for this namespace. */
1365 make_symbol_overload_list_namespace (func_name, the_namespace);
1368 /* This does the bulk of the work of finding overloaded symbols.
1369 FUNC_NAME is the name of the overloaded function we're looking for
1370 (possibly including namespace info). */
1373 make_symbol_overload_list_qualified (const char *func_name)
1375 struct compunit_symtab *cust;
1376 struct objfile *objfile;
1377 const struct block *b, *surrounding_static_block = 0;
1379 /* Look through the partial symtabs for all symbols which begin by
1380 matching FUNC_NAME. Make sure we read that symbol table in. */
1382 ALL_OBJFILES (objfile)
1385 objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1388 /* Search upwards from currently selected frame (so that we can
1389 complete on local vars. */
1391 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1392 make_symbol_overload_list_block (func_name, b);
1394 surrounding_static_block = block_static_block (get_selected_block (0));
1396 /* Go through the symtabs and check the externs and statics for
1397 symbols which match. */
1399 ALL_COMPUNITS (objfile, cust)
1402 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), GLOBAL_BLOCK);
1403 make_symbol_overload_list_block (func_name, b);
1406 ALL_COMPUNITS (objfile, cust)
1409 b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
1410 /* Don't do this block twice. */
1411 if (b == surrounding_static_block)
1413 make_symbol_overload_list_block (func_name, b);
1417 /* Lookup the rtti type for a class name. */
1420 cp_lookup_rtti_type (const char *name, struct block *block)
1422 struct symbol * rtti_sym;
1423 struct type * rtti_type;
1425 /* Use VAR_DOMAIN here as NAME may be a typedef. PR 18141, 18417.
1426 Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN. */
1427 rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
1429 if (rtti_sym == NULL)
1431 warning (_("RTTI symbol not found for class '%s'"), name);
1435 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1437 warning (_("RTTI symbol for class '%s' is not a type"), name);
1441 rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym));
1443 switch (TYPE_CODE (rtti_type))
1445 case TYPE_CODE_STRUCT:
1447 case TYPE_CODE_NAMESPACE:
1448 /* chastain/2003-11-26: the symbol tables often contain fake
1449 symbols for namespaces with the same name as the struct.
1450 This warning is an indication of a bug in the lookup order
1451 or a bug in the way that the symbol tables are populated. */
1452 warning (_("RTTI symbol for class '%s' is a namespace"), name);
1455 warning (_("RTTI symbol for class '%s' has bad type"), name);
1462 #ifdef HAVE_WORKING_FORK
1464 /* If nonzero, attempt to catch crashes in the demangler and print
1465 useful debugging information. */
1467 static int catch_demangler_crashes = 1;
1469 /* Stack context and environment for demangler crash recovery. */
1471 static SIGJMP_BUF gdb_demangle_jmp_buf;
1473 /* If nonzero, attempt to dump core from the signal handler. */
1475 static int gdb_demangle_attempt_core_dump = 1;
1477 /* Signal handler for gdb_demangle. */
1480 gdb_demangle_signal_handler (int signo)
1482 if (gdb_demangle_attempt_core_dump)
1487 gdb_demangle_attempt_core_dump = 0;
1490 SIGLONGJMP (gdb_demangle_jmp_buf, signo);
1495 /* A wrapper for bfd_demangle. */
1498 gdb_demangle (const char *name, int options)
1500 char *result = NULL;
1501 int crash_signal = 0;
1503 #ifdef HAVE_WORKING_FORK
1504 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1505 struct sigaction sa, old_sa;
1509 static int core_dump_allowed = -1;
1511 if (core_dump_allowed == -1)
1513 core_dump_allowed = can_dump_core (LIMIT_CUR);
1515 if (!core_dump_allowed)
1516 gdb_demangle_attempt_core_dump = 0;
1519 if (catch_demangler_crashes)
1521 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1522 sa.sa_handler = gdb_demangle_signal_handler;
1523 sigemptyset (&sa.sa_mask);
1524 #ifdef HAVE_SIGALTSTACK
1525 sa.sa_flags = SA_ONSTACK;
1529 sigaction (SIGSEGV, &sa, &old_sa);
1531 ofunc = signal (SIGSEGV, gdb_demangle_signal_handler);
1534 crash_signal = SIGSETJMP (gdb_demangle_jmp_buf);
1538 if (crash_signal == 0)
1539 result = bfd_demangle (NULL, name, options);
1541 #ifdef HAVE_WORKING_FORK
1542 if (catch_demangler_crashes)
1544 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1545 sigaction (SIGSEGV, &old_sa, NULL);
1547 signal (SIGSEGV, ofunc);
1550 if (crash_signal != 0)
1552 static int error_reported = 0;
1554 if (!error_reported)
1556 char *short_msg, *long_msg;
1557 struct cleanup *back_to;
1559 short_msg = xstrprintf (_("unable to demangle '%s' "
1560 "(demangler failed with signal %d)"),
1561 name, crash_signal);
1562 back_to = make_cleanup (xfree, short_msg);
1564 long_msg = xstrprintf ("%s:%d: %s: %s", __FILE__, __LINE__,
1565 "demangler-warning", short_msg);
1566 make_cleanup (xfree, long_msg);
1568 make_cleanup_restore_target_terminal ();
1569 target_terminal_ours_for_output ();
1572 if (core_dump_allowed)
1573 fprintf_unfiltered (gdb_stderr,
1574 _("%s\nAttempting to dump core.\n"),
1577 warn_cant_dump_core (long_msg);
1579 demangler_warning (__FILE__, __LINE__, "%s", short_msg);
1581 do_cleanups (back_to);
1594 /* See cp-support.h. */
1597 gdb_sniff_from_mangled_name (const char *mangled, char **demangled)
1599 *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
1600 return *demangled != NULL;
1603 /* Don't allow just "maintenance cplus". */
1606 maint_cplus_command (char *arg, int from_tty)
1608 printf_unfiltered (_("\"maintenance cplus\" must be followed "
1609 "by the name of a command.\n"));
1610 help_list (maint_cplus_cmd_list,
1611 "maintenance cplus ",
1612 all_commands, gdb_stdout);
1615 /* This is a front end for cp_find_first_component, for unit testing.
1616 Be careful when using it: see the NOTE above
1617 cp_find_first_component. */
1620 first_component_command (char *arg, int from_tty)
1628 len = cp_find_first_component (arg);
1629 prefix = (char *) alloca (len + 1);
1631 memcpy (prefix, arg, len);
1634 printf_unfiltered ("%s\n", prefix);
1637 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
1640 /* Implement "info vtbl". */
1643 info_vtbl_command (char *arg, int from_tty)
1645 struct value *value;
1647 value = parse_and_eval (arg);
1648 cplus_print_vtable (value);
1652 _initialize_cp_support (void)
1654 add_prefix_cmd ("cplus", class_maintenance,
1655 maint_cplus_command,
1656 _("C++ maintenance commands."),
1657 &maint_cplus_cmd_list,
1658 "maintenance cplus ",
1659 0, &maintenancelist);
1660 add_alias_cmd ("cp", "cplus",
1661 class_maintenance, 1,
1664 add_cmd ("first_component",
1666 first_component_command,
1667 _("Print the first class/namespace component of NAME."),
1668 &maint_cplus_cmd_list);
1670 add_info ("vtbl", info_vtbl_command,
1671 _("Show the virtual function table for a C++ object.\n\
1672 Usage: info vtbl EXPRESSION\n\
1673 Evaluate EXPRESSION and display the virtual function table for the\n\
1674 resulting object."));
1676 #ifdef HAVE_WORKING_FORK
1677 add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance,
1678 &catch_demangler_crashes, _("\
1679 Set whether to attempt to catch demangler crashes."), _("\
1680 Show whether to attempt to catch demangler crashes."), _("\
1681 If enabled GDB will attempt to catch demangler crashes and\n\
1682 display the offending symbol."),
1685 &maintenance_set_cmdlist,
1686 &maintenance_show_cmdlist);