1 /* Helper routines for C++ support in GDB.
2 Copyright (C) 2002-2013 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"
23 #include "gdb_string.h"
25 #include "gdb_assert.h"
27 #include "dictionary.h"
32 #include "complaints.h"
34 #include "exceptions.h"
35 #include "expression.h"
39 #include "safe-ctype.h"
41 #define d_left(dc) (dc)->u.s_binary.left
42 #define d_right(dc) (dc)->u.s_binary.right
44 /* Functions related to demangled name parsing. */
46 static unsigned int cp_find_first_component_aux (const char *name,
49 static void demangled_name_complaint (const char *name);
51 /* Functions/variables related to overload resolution. */
53 static int sym_return_val_size = -1;
54 static int sym_return_val_index;
55 static struct symbol **sym_return_val;
57 static void overload_list_add_symbol (struct symbol *sym,
58 const char *oload_name);
60 static void make_symbol_overload_list_using (const char *func_name,
61 const char *namespace);
63 static void make_symbol_overload_list_qualified (const char *func_name);
65 /* The list of "maint cplus" commands. */
67 struct cmd_list_element *maint_cplus_cmd_list = NULL;
69 /* The actual commands. */
71 static void maint_cplus_command (char *arg, int from_tty);
72 static void first_component_command (char *arg, int from_tty);
74 /* A list of typedefs which should not be substituted by replace_typedefs. */
75 static const char * const ignore_typedefs[] =
77 "std::istream", "std::iostream", "std::ostream", "std::string"
81 replace_typedefs (struct demangle_parse_info *info,
82 struct demangle_component *ret_comp,
83 canonicalization_ftype *finder,
86 /* A convenience function to copy STRING into OBSTACK, returning a pointer
87 to the newly allocated string and saving the number of bytes saved in LEN.
89 It does not copy the terminating '\0' byte! */
92 copy_string_to_obstack (struct obstack *obstack, const char *string,
95 *len = strlen (string);
96 return obstack_copy (obstack, string, *len);
99 /* A cleanup wrapper for cp_demangled_name_parse_free. */
102 do_demangled_name_parse_free_cleanup (void *data)
104 struct demangle_parse_info *info = (struct demangle_parse_info *) data;
106 cp_demangled_name_parse_free (info);
109 /* Create a cleanup for C++ name parsing. */
112 make_cleanup_cp_demangled_name_parse_free (struct demangle_parse_info *info)
114 return make_cleanup (do_demangled_name_parse_free_cleanup, info);
117 /* Return 1 if STRING is clearly already in canonical form. This
118 function is conservative; things which it does not recognize are
119 assumed to be non-canonical, and the parser will sort them out
120 afterwards. This speeds up the critical path for alphanumeric
124 cp_already_canonical (const char *string)
126 /* Identifier start character [a-zA-Z_]. */
127 if (!ISIDST (string[0]))
130 /* These are the only two identifiers which canonicalize to other
131 than themselves or an error: unsigned -> unsigned int and
133 if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
135 else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
138 /* Identifier character [a-zA-Z0-9_]. */
139 while (ISIDNUM (string[1]))
142 if (string[1] == '\0')
148 /* Inspect the given RET_COMP for its type. If it is a typedef,
149 replace the node with the typedef's tree.
151 Returns 1 if any typedef substitutions were made, 0 otherwise. */
154 inspect_type (struct demangle_parse_info *info,
155 struct demangle_component *ret_comp,
156 canonicalization_ftype *finder,
162 volatile struct gdb_exception except;
164 /* Copy the symbol's name from RET_COMP and look it up
165 in the symbol table. */
166 name = (char *) alloca (ret_comp->u.s_name.len + 1);
167 memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len);
168 name[ret_comp->u.s_name.len] = '\0';
170 /* Ignore any typedefs that should not be substituted. */
171 for (i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i)
173 if (strcmp (name, ignore_typedefs[i]) == 0)
178 TRY_CATCH (except, RETURN_MASK_ALL)
180 sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
183 if (except.reason >= 0 && sym != NULL)
185 struct type *otype = SYMBOL_TYPE (sym);
189 const char *new_name = (*finder) (otype, data);
191 if (new_name != NULL)
193 ret_comp->u.s_name.s = new_name;
194 ret_comp->u.s_name.len = strlen (new_name);
201 /* If the type is a typedef, replace it. */
202 if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF)
207 struct demangle_parse_info *i;
210 /* Get the real type of the typedef. */
211 type = check_typedef (otype);
213 is_anon = (TYPE_TAG_NAME (type) == NULL
214 && (TYPE_CODE (type) == TYPE_CODE_ENUM
215 || TYPE_CODE (type) == TYPE_CODE_STRUCT
216 || TYPE_CODE (type) == TYPE_CODE_UNION));
219 struct type *last = otype;
221 /* Find the last typedef for the type. */
222 while (TYPE_TARGET_TYPE (last) != NULL
223 && (TYPE_CODE (TYPE_TARGET_TYPE (last))
224 == TYPE_CODE_TYPEDEF))
225 last = TYPE_TARGET_TYPE (last);
227 /* If there is only one typedef for this anonymous type,
228 do not substitute it. */
232 /* Use the last typedef seen as the type for this
237 buf = mem_fileopen ();
238 TRY_CATCH (except, RETURN_MASK_ERROR)
240 type_print (type, "", buf, -1);
243 /* If type_print threw an exception, there is little point
244 in continuing, so just bow out gracefully. */
245 if (except.reason < 0)
247 ui_file_delete (buf);
251 name = ui_file_obsavestring (buf, &info->obstack, &len);
252 ui_file_delete (buf);
254 /* Turn the result into a new tree. Note that this
255 tree will contain pointers into NAME, so NAME cannot
256 be free'd until all typedef conversion is done and
257 the final result is converted into a string. */
258 i = cp_demangled_name_to_comp (name, NULL);
261 /* Merge the two trees. */
262 cp_merge_demangle_parse_infos (info, ret_comp, i);
264 /* Replace any newly introduced typedefs -- but not
265 if the type is anonymous (that would lead to infinite
268 replace_typedefs (info, ret_comp, finder, data);
272 /* This shouldn't happen unless the type printer has
273 output something that the name parser cannot grok.
274 Nonetheless, an ounce of prevention...
276 Canonicalize the name again, and store it in the
277 current node (RET_COMP). */
278 char *canon = cp_canonicalize_string_no_typedefs (name);
282 /* Copy the canonicalization into the obstack and
284 name = copy_string_to_obstack (&info->obstack, canon, &len);
288 ret_comp->u.s_name.s = name;
289 ret_comp->u.s_name.len = len;
299 /* Replace any typedefs appearing in the qualified name
300 (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
304 replace_typedefs_qualified_name (struct demangle_parse_info *info,
305 struct demangle_component *ret_comp,
306 canonicalization_ftype *finder,
311 struct ui_file *buf = mem_fileopen ();
312 struct demangle_component *comp = ret_comp;
314 /* Walk each node of the qualified name, reconstructing the name of
315 this element. With every node, check for any typedef substitutions.
316 If a substitution has occurred, replace the qualified name node
317 with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
319 while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
321 if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
323 struct demangle_component new;
325 ui_file_write (buf, d_left (comp)->u.s_name.s,
326 d_left (comp)->u.s_name.len);
327 name = ui_file_obsavestring (buf, &info->obstack, &len);
328 new.type = DEMANGLE_COMPONENT_NAME;
329 new.u.s_name.s = name;
330 new.u.s_name.len = len;
331 if (inspect_type (info, &new, finder, data))
336 /* A typedef was substituted in NEW. Convert it to a
337 string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
340 ui_file_rewind (buf);
341 n = cp_comp_to_string (&new, 100);
344 /* If something went astray, abort typedef substitutions. */
345 ui_file_delete (buf);
349 s = copy_string_to_obstack (&info->obstack, n, &slen);
352 d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
353 d_left (ret_comp)->u.s_name.s = s;
354 d_left (ret_comp)->u.s_name.len = slen;
355 d_right (ret_comp) = d_right (comp);
362 /* The current node is not a name, so simply replace any
363 typedefs in it. Then print it to the stream to continue
364 checking for more typedefs in the tree. */
365 replace_typedefs (info, d_left (comp), finder, data);
366 name = cp_comp_to_string (d_left (comp), 100);
369 /* If something went astray, abort typedef substitutions. */
370 ui_file_delete (buf);
373 fputs_unfiltered (name, buf);
377 ui_file_write (buf, "::", 2);
378 comp = d_right (comp);
381 /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
382 name assembled above and append the name given by COMP. Then use this
383 reassembled name to check for a typedef. */
385 if (comp->type == DEMANGLE_COMPONENT_NAME)
387 ui_file_write (buf, comp->u.s_name.s, comp->u.s_name.len);
388 name = ui_file_obsavestring (buf, &info->obstack, &len);
390 /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
391 with a DEMANGLE_COMPONENT_NAME node containing the whole
393 ret_comp->type = DEMANGLE_COMPONENT_NAME;
394 ret_comp->u.s_name.s = name;
395 ret_comp->u.s_name.len = len;
396 inspect_type (info, ret_comp, finder, data);
399 replace_typedefs (info, comp, finder, data);
401 ui_file_delete (buf);
405 /* A function to check const and volatile qualifiers for argument types.
407 "Parameter declarations that differ only in the presence
408 or absence of `const' and/or `volatile' are equivalent."
409 C++ Standard N3290, clause 13.1.3 #4. */
412 check_cv_qualifiers (struct demangle_component *ret_comp)
414 while (d_left (ret_comp) != NULL
415 && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST
416 || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE))
418 d_left (ret_comp) = d_left (d_left (ret_comp));
422 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
423 their basic types. */
426 replace_typedefs (struct demangle_parse_info *info,
427 struct demangle_component *ret_comp,
428 canonicalization_ftype *finder,
434 && (ret_comp->type == DEMANGLE_COMPONENT_NAME
435 || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
436 || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE
437 || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE))
439 char *local_name = cp_comp_to_string (ret_comp, 10);
441 if (local_name != NULL)
444 volatile struct gdb_exception except;
447 TRY_CATCH (except, RETURN_MASK_ALL)
449 sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0);
453 if (except.reason >= 0 && sym != NULL)
455 struct type *otype = SYMBOL_TYPE (sym);
456 const char *new_name = (*finder) (otype, data);
458 if (new_name != NULL)
460 ret_comp->type = DEMANGLE_COMPONENT_NAME;
461 ret_comp->u.s_name.s = new_name;
462 ret_comp->u.s_name.len = strlen (new_name);
469 switch (ret_comp->type)
471 case DEMANGLE_COMPONENT_ARGLIST:
472 check_cv_qualifiers (ret_comp);
475 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
476 case DEMANGLE_COMPONENT_TEMPLATE:
477 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
478 case DEMANGLE_COMPONENT_TYPED_NAME:
479 replace_typedefs (info, d_left (ret_comp), finder, data);
480 replace_typedefs (info, d_right (ret_comp), finder, data);
483 case DEMANGLE_COMPONENT_NAME:
484 inspect_type (info, ret_comp, finder, data);
487 case DEMANGLE_COMPONENT_QUAL_NAME:
488 replace_typedefs_qualified_name (info, ret_comp, finder, data);
491 case DEMANGLE_COMPONENT_LOCAL_NAME:
492 case DEMANGLE_COMPONENT_CTOR:
493 case DEMANGLE_COMPONENT_ARRAY_TYPE:
494 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
495 replace_typedefs (info, d_right (ret_comp), finder, data);
498 case DEMANGLE_COMPONENT_CONST:
499 case DEMANGLE_COMPONENT_RESTRICT:
500 case DEMANGLE_COMPONENT_VOLATILE:
501 case DEMANGLE_COMPONENT_VOLATILE_THIS:
502 case DEMANGLE_COMPONENT_CONST_THIS:
503 case DEMANGLE_COMPONENT_RESTRICT_THIS:
504 case DEMANGLE_COMPONENT_POINTER:
505 case DEMANGLE_COMPONENT_REFERENCE:
506 replace_typedefs (info, d_left (ret_comp), finder, data);
515 /* Parse STRING and convert it to canonical form, resolving any typedefs.
516 If parsing fails, or if STRING is already canonical, return NULL.
517 Otherwise return the canonical form. The return value is allocated via
518 xmalloc. If FINDER is not NULL, then type components are passed to
519 FINDER to be looked up. DATA is passed verbatim to FINDER. */
522 cp_canonicalize_string_full (const char *string,
523 canonicalization_ftype *finder,
527 unsigned int estimated_len;
528 struct demangle_parse_info *info;
531 estimated_len = strlen (string) * 2;
532 info = cp_demangled_name_to_comp (string, NULL);
535 /* Replace all the typedefs in the tree. */
536 replace_typedefs (info, info->tree, finder, data);
538 /* Convert the tree back into a string. */
539 ret = cp_comp_to_string (info->tree, estimated_len);
540 gdb_assert (ret != NULL);
542 /* Free the parse information. */
543 cp_demangled_name_parse_free (info);
545 /* Finally, compare the original string with the computed
546 name, returning NULL if they are the same. */
547 if (strcmp (string, ret) == 0)
557 /* Like cp_canonicalize_string_full, but always passes NULL for
561 cp_canonicalize_string_no_typedefs (const char *string)
563 return cp_canonicalize_string_full (string, NULL, NULL);
566 /* Parse STRING and convert it to canonical form. If parsing fails,
567 or if STRING is already canonical, return NULL. Otherwise return
568 the canonical form. The return value is allocated via xmalloc. */
571 cp_canonicalize_string (const char *string)
573 struct demangle_parse_info *info;
574 unsigned int estimated_len;
577 if (cp_already_canonical (string))
580 info = cp_demangled_name_to_comp (string, NULL);
584 estimated_len = strlen (string) * 2;
585 ret = cp_comp_to_string (info->tree, estimated_len);
586 cp_demangled_name_parse_free (info);
590 warning (_("internal error: string \"%s\" failed to be canonicalized"),
595 if (strcmp (string, ret) == 0)
604 /* Convert a mangled name to a demangle_component tree. *MEMORY is
605 set to the block of used memory that should be freed when finished
606 with the tree. DEMANGLED_P is set to the char * that should be
607 freed when finished with the tree, or NULL if none was needed.
608 OPTIONS will be passed to the demangler. */
610 static struct demangle_parse_info *
611 mangled_name_to_comp (const char *mangled_name, int options,
612 void **memory, char **demangled_p)
614 char *demangled_name;
615 struct demangle_parse_info *info;
617 /* If it looks like a v3 mangled name, then try to go directly
619 if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
621 struct demangle_component *ret;
623 ret = cplus_demangle_v3_components (mangled_name,
627 info = cp_new_demangle_parse_info ();
634 /* If it doesn't, or if that failed, then try to demangle the
636 demangled_name = gdb_demangle (mangled_name, options);
637 if (demangled_name == NULL)
640 /* If we could demangle the name, parse it to build the component
642 info = cp_demangled_name_to_comp (demangled_name, NULL);
646 xfree (demangled_name);
650 *demangled_p = demangled_name;
654 /* Return the name of the class containing method PHYSNAME. */
657 cp_class_name_from_physname (const char *physname)
659 void *storage = NULL;
660 char *demangled_name = NULL, *ret;
661 struct demangle_component *ret_comp, *prev_comp, *cur_comp;
662 struct demangle_parse_info *info;
665 info = mangled_name_to_comp (physname, DMGL_ANSI,
666 &storage, &demangled_name);
671 ret_comp = info->tree;
673 /* First strip off any qualifiers, if we have a function or
676 switch (ret_comp->type)
678 case DEMANGLE_COMPONENT_CONST:
679 case DEMANGLE_COMPONENT_RESTRICT:
680 case DEMANGLE_COMPONENT_VOLATILE:
681 case DEMANGLE_COMPONENT_CONST_THIS:
682 case DEMANGLE_COMPONENT_RESTRICT_THIS:
683 case DEMANGLE_COMPONENT_VOLATILE_THIS:
684 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
685 ret_comp = d_left (ret_comp);
692 /* If what we have now is a function, discard the argument list. */
693 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
694 ret_comp = d_left (ret_comp);
696 /* If what we have now is a template, strip off the template
697 arguments. The left subtree may be a qualified name. */
698 if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
699 ret_comp = d_left (ret_comp);
701 /* What we have now should be a name, possibly qualified.
702 Additional qualifiers could live in the left subtree or the right
703 subtree. Find the last piece. */
708 switch (cur_comp->type)
710 case DEMANGLE_COMPONENT_QUAL_NAME:
711 case DEMANGLE_COMPONENT_LOCAL_NAME:
712 prev_comp = cur_comp;
713 cur_comp = d_right (cur_comp);
715 case DEMANGLE_COMPONENT_TEMPLATE:
716 case DEMANGLE_COMPONENT_NAME:
717 case DEMANGLE_COMPONENT_CTOR:
718 case DEMANGLE_COMPONENT_DTOR:
719 case DEMANGLE_COMPONENT_OPERATOR:
720 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
730 if (cur_comp != NULL && prev_comp != NULL)
732 /* We want to discard the rightmost child of PREV_COMP. */
733 *prev_comp = *d_left (prev_comp);
734 /* The ten is completely arbitrary; we don't have a good
736 ret = cp_comp_to_string (ret_comp, 10);
740 xfree (demangled_name);
741 cp_demangled_name_parse_free (info);
745 /* Return the child of COMP which is the basename of a method,
746 variable, et cetera. All scope qualifiers are discarded, but
747 template arguments will be included. The component tree may be
750 static struct demangle_component *
751 unqualified_name_from_comp (struct demangle_component *comp)
753 struct demangle_component *ret_comp = comp, *last_template;
757 last_template = NULL;
759 switch (ret_comp->type)
761 case DEMANGLE_COMPONENT_QUAL_NAME:
762 case DEMANGLE_COMPONENT_LOCAL_NAME:
763 ret_comp = d_right (ret_comp);
765 case DEMANGLE_COMPONENT_TYPED_NAME:
766 ret_comp = d_left (ret_comp);
768 case DEMANGLE_COMPONENT_TEMPLATE:
769 gdb_assert (last_template == NULL);
770 last_template = ret_comp;
771 ret_comp = d_left (ret_comp);
773 case DEMANGLE_COMPONENT_CONST:
774 case DEMANGLE_COMPONENT_RESTRICT:
775 case DEMANGLE_COMPONENT_VOLATILE:
776 case DEMANGLE_COMPONENT_CONST_THIS:
777 case DEMANGLE_COMPONENT_RESTRICT_THIS:
778 case DEMANGLE_COMPONENT_VOLATILE_THIS:
779 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
780 ret_comp = d_left (ret_comp);
782 case DEMANGLE_COMPONENT_NAME:
783 case DEMANGLE_COMPONENT_CTOR:
784 case DEMANGLE_COMPONENT_DTOR:
785 case DEMANGLE_COMPONENT_OPERATOR:
786 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
796 d_left (last_template) = ret_comp;
797 return last_template;
803 /* Return the name of the method whose linkage name is PHYSNAME. */
806 method_name_from_physname (const char *physname)
808 void *storage = NULL;
809 char *demangled_name = NULL, *ret;
810 struct demangle_component *ret_comp;
811 struct demangle_parse_info *info;
813 info = mangled_name_to_comp (physname, DMGL_ANSI,
814 &storage, &demangled_name);
818 ret_comp = unqualified_name_from_comp (info->tree);
821 if (ret_comp != NULL)
822 /* The ten is completely arbitrary; we don't have a good
824 ret = cp_comp_to_string (ret_comp, 10);
827 xfree (demangled_name);
828 cp_demangled_name_parse_free (info);
832 /* If FULL_NAME is the demangled name of a C++ function (including an
833 arg list, possibly including namespace/class qualifications),
834 return a new string containing only the function name (without the
835 arg list/class qualifications). Otherwise, return NULL. The
836 caller is responsible for freeing the memory in question. */
839 cp_func_name (const char *full_name)
842 struct demangle_component *ret_comp;
843 struct demangle_parse_info *info;
845 info = cp_demangled_name_to_comp (full_name, NULL);
849 ret_comp = unqualified_name_from_comp (info->tree);
852 if (ret_comp != NULL)
853 ret = cp_comp_to_string (ret_comp, 10);
855 cp_demangled_name_parse_free (info);
859 /* DEMANGLED_NAME is the name of a function, including parameters and
860 (optionally) a return type. Return the name of the function without
861 parameters or return type, or NULL if we can not parse the name. */
864 cp_remove_params (const char *demangled_name)
867 struct demangle_component *ret_comp;
868 struct demangle_parse_info *info;
871 if (demangled_name == NULL)
874 info = cp_demangled_name_to_comp (demangled_name, NULL);
878 /* First strip off any qualifiers, if we have a function or method. */
879 ret_comp = info->tree;
881 switch (ret_comp->type)
883 case DEMANGLE_COMPONENT_CONST:
884 case DEMANGLE_COMPONENT_RESTRICT:
885 case DEMANGLE_COMPONENT_VOLATILE:
886 case DEMANGLE_COMPONENT_CONST_THIS:
887 case DEMANGLE_COMPONENT_RESTRICT_THIS:
888 case DEMANGLE_COMPONENT_VOLATILE_THIS:
889 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
890 ret_comp = d_left (ret_comp);
897 /* What we have now should be a function. Return its name. */
898 if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
899 ret = cp_comp_to_string (d_left (ret_comp), 10);
901 cp_demangled_name_parse_free (info);
905 /* Here are some random pieces of trivia to keep in mind while trying
906 to take apart demangled names:
908 - Names can contain function arguments or templates, so the process
909 has to be, to some extent recursive: maybe keep track of your
910 depth based on encountering <> and ().
912 - Parentheses don't just have to happen at the end of a name: they
913 can occur even if the name in question isn't a function, because
914 a template argument might be a type that's a function.
916 - Conversely, even if you're trying to deal with a function, its
917 demangled name might not end with ')': it could be a const or
918 volatile class method, in which case it ends with "const" or
921 - Parentheses are also used in anonymous namespaces: a variable
922 'foo' in an anonymous namespace gets demangled as "(anonymous
925 - And operator names can contain parentheses or angle brackets. */
927 /* FIXME: carlton/2003-03-13: We have several functions here with
928 overlapping functionality; can we combine them? Also, do they
929 handle all the above considerations correctly? */
932 /* This returns the length of first component of NAME, which should be
933 the demangled name of a C++ variable/function/method/etc.
934 Specifically, it returns the index of the first colon forming the
935 boundary of the first component: so, given 'A::foo' or 'A::B::foo'
936 it returns the 1, and given 'foo', it returns 0. */
938 /* The character in NAME indexed by the return value is guaranteed to
939 always be either ':' or '\0'. */
941 /* NOTE: carlton/2003-03-13: This function is currently only intended
942 for internal use: it's probably not entirely safe when called on
943 user-generated input, because some of the 'index += 2' lines in
944 cp_find_first_component_aux might go past the end of malformed
948 cp_find_first_component (const char *name)
950 return cp_find_first_component_aux (name, 0);
953 /* Helper function for cp_find_first_component. Like that function,
954 it returns the length of the first component of NAME, but to make
955 the recursion easier, it also stops if it reaches an unexpected ')'
956 or '>' if the value of PERMISSIVE is nonzero. */
958 /* Let's optimize away calls to strlen("operator"). */
960 #define LENGTH_OF_OPERATOR 8
963 cp_find_first_component_aux (const char *name, int permissive)
965 unsigned int index = 0;
966 /* Operator names can show up in unexpected places. Since these can
967 contain parentheses or angle brackets, they can screw up the
968 recursion. But not every string 'operator' is part of an
969 operater name: e.g. you could have a variable 'cooperator'. So
970 this variable tells us whether or not we should treat the string
971 'operator' as starting an operator. */
972 int operator_possible = 1;
979 /* Template; eat it up. The calls to cp_first_component
980 should only return (I hope!) when they reach the '>'
981 terminating the component or a '::' between two
982 components. (Hence the '+ 2'.) */
984 for (index += cp_find_first_component_aux (name + index, 1);
986 index += cp_find_first_component_aux (name + index, 1))
988 if (name[index] != ':')
990 demangled_name_complaint (name);
991 return strlen (name);
995 operator_possible = 1;
998 /* Similar comment as to '<'. */
1000 for (index += cp_find_first_component_aux (name + index, 1);
1002 index += cp_find_first_component_aux (name + index, 1))
1004 if (name[index] != ':')
1006 demangled_name_complaint (name);
1007 return strlen (name);
1011 operator_possible = 1;
1019 demangled_name_complaint (name);
1020 return strlen (name);
1026 /* Operator names can screw up the recursion. */
1027 if (operator_possible
1028 && strncmp (name + index, "operator",
1029 LENGTH_OF_OPERATOR) == 0)
1031 index += LENGTH_OF_OPERATOR;
1032 while (ISSPACE(name[index]))
1034 switch (name[index])
1036 /* Skip over one less than the appropriate number of
1037 characters: the for loop will skip over the last
1040 if (name[index + 1] == '<')
1047 if (name[index + 1] == '>')
1060 operator_possible = 0;
1067 /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1068 set of relevant characters are here: it's necessary to
1069 include any character that can show up before 'operator'
1070 in a demangled name, and it's safe to include any
1071 character that can't be part of an identifier's name. */
1072 operator_possible = 1;
1075 operator_possible = 0;
1081 /* Complain about a demangled name that we don't know how to parse.
1082 NAME is the demangled name in question. */
1085 demangled_name_complaint (const char *name)
1087 complaint (&symfile_complaints,
1088 "unexpected demangled name '%s'", name);
1091 /* If NAME is the fully-qualified name of a C++
1092 function/variable/method/etc., this returns the length of its
1093 entire prefix: all of the namespaces and classes that make up its
1094 name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1095 4, given 'foo', it returns 0. */
1098 cp_entire_prefix_len (const char *name)
1100 unsigned int current_len = cp_find_first_component (name);
1101 unsigned int previous_len = 0;
1103 while (name[current_len] != '\0')
1105 gdb_assert (name[current_len] == ':');
1106 previous_len = current_len;
1107 /* Skip the '::'. */
1109 current_len += cp_find_first_component (name + current_len);
1112 return previous_len;
1115 /* Overload resolution functions. */
1117 /* Test to see if SYM is a symbol that we haven't seen corresponding
1118 to a function named OLOAD_NAME. If so, add it to the current
1122 overload_list_add_symbol (struct symbol *sym,
1123 const char *oload_name)
1129 /* If there is no type information, we can't do anything, so
1131 if (SYMBOL_TYPE (sym) == NULL)
1134 /* skip any symbols that we've already considered. */
1135 for (i = 0; i < sym_return_val_index; ++i)
1136 if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1137 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
1140 /* Get the demangled name without parameters */
1141 sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1145 /* skip symbols that cannot match */
1146 if (strcmp (sym_name, oload_name) != 0)
1154 /* We have a match for an overload instance, so add SYM to the
1155 current list of overload instances */
1156 if (sym_return_val_index + 3 > sym_return_val_size)
1158 newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
1159 sym_return_val = (struct symbol **)
1160 xrealloc ((char *) sym_return_val, newsize);
1162 sym_return_val[sym_return_val_index++] = sym;
1163 sym_return_val[sym_return_val_index] = NULL;
1166 /* Return a null-terminated list of pointers to function symbols that
1167 are named FUNC_NAME and are visible within NAMESPACE. */
1170 make_symbol_overload_list (const char *func_name,
1171 const char *namespace)
1173 struct cleanup *old_cleanups;
1176 sym_return_val_size = 100;
1177 sym_return_val_index = 0;
1178 sym_return_val = xmalloc ((sym_return_val_size + 1) *
1179 sizeof (struct symbol *));
1180 sym_return_val[0] = NULL;
1182 old_cleanups = make_cleanup (xfree, sym_return_val);
1184 make_symbol_overload_list_using (func_name, namespace);
1186 if (namespace[0] == '\0')
1190 char *concatenated_name
1191 = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
1192 strcpy (concatenated_name, namespace);
1193 strcat (concatenated_name, "::");
1194 strcat (concatenated_name, func_name);
1195 name = concatenated_name;
1198 make_symbol_overload_list_qualified (name);
1200 discard_cleanups (old_cleanups);
1202 return sym_return_val;
1205 /* Add all symbols with a name matching NAME in BLOCK to the overload
1209 make_symbol_overload_list_block (const char *name,
1210 const struct block *block)
1212 struct block_iterator iter;
1215 for (sym = block_iter_name_first (block, name, &iter);
1217 sym = block_iter_name_next (name, &iter))
1218 overload_list_add_symbol (sym, name);
1221 /* Adds the function FUNC_NAME from NAMESPACE to the overload set. */
1224 make_symbol_overload_list_namespace (const char *func_name,
1225 const char *namespace)
1228 const struct block *block = NULL;
1230 if (namespace[0] == '\0')
1234 char *concatenated_name
1235 = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
1237 strcpy (concatenated_name, namespace);
1238 strcat (concatenated_name, "::");
1239 strcat (concatenated_name, func_name);
1240 name = concatenated_name;
1243 /* Look in the static block. */
1244 block = block_static_block (get_selected_block (0));
1246 make_symbol_overload_list_block (name, block);
1248 /* Look in the global block. */
1249 block = block_global_block (block);
1251 make_symbol_overload_list_block (name, block);
1255 /* Search the namespace of the given type and namespace of and public
1259 make_symbol_overload_list_adl_namespace (struct type *type,
1260 const char *func_name)
1263 const char *type_name;
1266 while (TYPE_CODE (type) == TYPE_CODE_PTR
1267 || TYPE_CODE (type) == TYPE_CODE_REF
1268 || TYPE_CODE (type) == TYPE_CODE_ARRAY
1269 || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1271 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1272 type = check_typedef(type);
1274 type = TYPE_TARGET_TYPE (type);
1277 type_name = TYPE_NAME (type);
1279 if (type_name == NULL)
1282 prefix_len = cp_entire_prefix_len (type_name);
1284 if (prefix_len != 0)
1286 namespace = alloca (prefix_len + 1);
1287 strncpy (namespace, type_name, prefix_len);
1288 namespace[prefix_len] = '\0';
1290 make_symbol_overload_list_namespace (func_name, namespace);
1293 /* Check public base type */
1294 if (TYPE_CODE (type) == TYPE_CODE_CLASS)
1295 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1297 if (BASETYPE_VIA_PUBLIC (type, i))
1298 make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type,
1304 /* Adds the overload list overload candidates for FUNC_NAME found
1305 through argument dependent lookup. */
1308 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
1309 const char *func_name)
1313 gdb_assert (sym_return_val_size != -1);
1315 for (i = 1; i <= nargs; i++)
1316 make_symbol_overload_list_adl_namespace (arg_types[i - 1],
1319 return sym_return_val;
1322 /* Used for cleanups to reset the "searched" flag in case of an
1326 reset_directive_searched (void *data)
1328 struct using_direct *direct = data;
1329 direct->searched = 0;
1332 /* This applies the using directives to add namespaces to search in,
1333 and then searches for overloads in all of those namespaces. It
1334 adds the symbols found to sym_return_val. Arguments are as in
1335 make_symbol_overload_list. */
1338 make_symbol_overload_list_using (const char *func_name,
1339 const char *namespace)
1341 struct using_direct *current;
1342 const struct block *block;
1344 /* First, go through the using directives. If any of them apply,
1345 look in the appropriate namespaces for new functions to match
1348 for (block = get_selected_block (0);
1350 block = BLOCK_SUPERBLOCK (block))
1351 for (current = block_using (block);
1353 current = current->next)
1355 /* Prevent recursive calls. */
1356 if (current->searched)
1359 /* If this is a namespace alias or imported declaration ignore
1361 if (current->alias != NULL || current->declaration != NULL)
1364 if (strcmp (namespace, current->import_dest) == 0)
1366 /* Mark this import as searched so that the recursive call
1367 does not search it again. */
1368 struct cleanup *old_chain;
1369 current->searched = 1;
1370 old_chain = make_cleanup (reset_directive_searched,
1373 make_symbol_overload_list_using (func_name,
1374 current->import_src);
1376 current->searched = 0;
1377 discard_cleanups (old_chain);
1381 /* Now, add names for this namespace. */
1382 make_symbol_overload_list_namespace (func_name, namespace);
1385 /* This does the bulk of the work of finding overloaded symbols.
1386 FUNC_NAME is the name of the overloaded function we're looking for
1387 (possibly including namespace info). */
1390 make_symbol_overload_list_qualified (const char *func_name)
1393 struct objfile *objfile;
1394 const struct block *b, *surrounding_static_block = 0;
1396 /* Look through the partial symtabs for all symbols which begin by
1397 matching FUNC_NAME. Make sure we read that symbol table in. */
1399 ALL_OBJFILES (objfile)
1402 objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1405 /* Search upwards from currently selected frame (so that we can
1406 complete on local vars. */
1408 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1409 make_symbol_overload_list_block (func_name, b);
1411 surrounding_static_block = block_static_block (get_selected_block (0));
1413 /* Go through the symtabs and check the externs and statics for
1414 symbols which match. */
1416 ALL_PRIMARY_SYMTABS (objfile, s)
1419 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
1420 make_symbol_overload_list_block (func_name, b);
1423 ALL_PRIMARY_SYMTABS (objfile, s)
1426 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
1427 /* Don't do this block twice. */
1428 if (b == surrounding_static_block)
1430 make_symbol_overload_list_block (func_name, b);
1434 /* Lookup the rtti type for a class name. */
1437 cp_lookup_rtti_type (const char *name, struct block *block)
1439 struct symbol * rtti_sym;
1440 struct type * rtti_type;
1442 rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
1444 if (rtti_sym == NULL)
1446 warning (_("RTTI symbol not found for class '%s'"), name);
1450 if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1452 warning (_("RTTI symbol for class '%s' is not a type"), name);
1456 rtti_type = SYMBOL_TYPE (rtti_sym);
1458 switch (TYPE_CODE (rtti_type))
1460 case TYPE_CODE_CLASS:
1462 case TYPE_CODE_NAMESPACE:
1463 /* chastain/2003-11-26: the symbol tables often contain fake
1464 symbols for namespaces with the same name as the struct.
1465 This warning is an indication of a bug in the lookup order
1466 or a bug in the way that the symbol tables are populated. */
1467 warning (_("RTTI symbol for class '%s' is a namespace"), name);
1470 warning (_("RTTI symbol for class '%s' has bad type"), name);
1477 /* A wrapper for bfd_demangle. */
1480 gdb_demangle (const char *name, int options)
1482 return bfd_demangle (NULL, name, options);
1485 /* Don't allow just "maintenance cplus". */
1488 maint_cplus_command (char *arg, int from_tty)
1490 printf_unfiltered (_("\"maintenance cplus\" must be followed "
1491 "by the name of a command.\n"));
1492 help_list (maint_cplus_cmd_list,
1493 "maintenance cplus ",
1497 /* This is a front end for cp_find_first_component, for unit testing.
1498 Be careful when using it: see the NOTE above
1499 cp_find_first_component. */
1502 first_component_command (char *arg, int from_tty)
1510 len = cp_find_first_component (arg);
1511 prefix = alloca (len + 1);
1513 memcpy (prefix, arg, len);
1516 printf_unfiltered ("%s\n", prefix);
1519 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
1522 /* Implement "info vtbl". */
1525 info_vtbl_command (char *arg, int from_tty)
1527 struct value *value;
1529 value = parse_and_eval (arg);
1530 cplus_print_vtable (value);
1534 _initialize_cp_support (void)
1536 add_prefix_cmd ("cplus", class_maintenance,
1537 maint_cplus_command,
1538 _("C++ maintenance commands."),
1539 &maint_cplus_cmd_list,
1540 "maintenance cplus ",
1541 0, &maintenancelist);
1542 add_alias_cmd ("cp", "cplus",
1543 class_maintenance, 1,
1546 add_cmd ("first_component",
1548 first_component_command,
1549 _("Print the first class/namespace component of NAME."),
1550 &maint_cplus_cmd_list);
1552 add_info ("vtbl", info_vtbl_command,
1553 _("Show the virtual function table for a C++ object.\n\
1554 Usage: info vtbl EXPRESSION\n\
1555 Evaluate EXPRESSION and display the virtual function table for the\n\
1556 resulting object."));