1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "diagnostic.h"
31 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
34 #include "pointer-set.h"
36 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
38 /* The global buffer where we dump everything. It is there only for
39 transitional purpose. It is expected, in the near future, to be
40 completely removed. */
41 static cxx_pretty_printer scratch_pretty_printer;
42 #define cxx_pp (&scratch_pretty_printer)
44 /* Translate if being used for diagnostics, but not for dump files or
46 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
48 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
50 static const char *args_to_string (tree, int);
51 static const char *assop_to_string (enum tree_code);
52 static const char *code_to_string (enum tree_code);
53 static const char *cv_to_string (tree, int);
54 static const char *decl_to_string (tree, int);
55 static const char *expr_to_string (tree);
56 static const char *fndecl_to_string (tree, int);
57 static const char *op_to_string (enum tree_code);
58 static const char *parm_to_string (int);
59 static const char *type_to_string (tree, int);
61 static void dump_type (tree, int);
62 static void dump_typename (tree, int);
63 static void dump_simple_decl (tree, tree, int);
64 static void dump_decl (tree, int);
65 static void dump_template_decl (tree, int);
66 static void dump_function_decl (tree, int);
67 static void dump_expr (tree, int);
68 static void dump_unary_op (const char *, tree, int);
69 static void dump_binary_op (const char *, tree, int);
70 static void dump_aggr_type (tree, int);
71 static void dump_type_prefix (tree, int);
72 static void dump_type_suffix (tree, int);
73 static void dump_function_name (tree, int);
74 static void dump_call_expr_args (tree, int, bool);
75 static void dump_aggr_init_expr_args (tree, int, bool);
76 static void dump_expr_list (tree, int);
77 static void dump_global_iord (tree);
78 static void dump_parameters (tree, int);
79 static void dump_exception_spec (tree, int);
80 static void dump_template_argument (tree, int);
81 static void dump_template_argument_list (tree, tree, int);
82 static void dump_template_parameter (tree, int);
83 static void dump_template_bindings (tree, tree, VEC(tree,gc) *);
84 static void dump_scope (tree, int);
85 static void dump_template_parms (tree, int, int);
87 static int count_non_default_template_args (tree, tree);
89 static const char *function_category (tree);
90 static void maybe_print_instantiation_context (diagnostic_context *);
91 static void print_instantiation_full_context (diagnostic_context *);
92 static void print_instantiation_partial_context (diagnostic_context *,
95 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
96 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
97 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
99 static bool cp_printer (pretty_printer *, text_info *, const char *,
100 int, bool, bool, bool);
101 static location_t location_of (tree);
106 diagnostic_starter (global_dc) = cp_diagnostic_starter;
107 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
108 diagnostic_format_decoder (global_dc) = cp_printer;
110 pp_construct (pp_base (cxx_pp), NULL, 0);
111 pp_cxx_pretty_printer_init (cxx_pp);
114 /* Dump a scope, if deemed necessary. */
117 dump_scope (tree scope, int flags)
119 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
121 if (scope == NULL_TREE)
124 if (TREE_CODE (scope) == NAMESPACE_DECL)
126 if (scope != global_namespace)
128 dump_decl (scope, f);
129 pp_cxx_colon_colon (cxx_pp);
132 else if (AGGREGATE_TYPE_P (scope))
134 dump_type (scope, f);
135 pp_cxx_colon_colon (cxx_pp);
137 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
139 dump_function_decl (scope, f);
140 pp_cxx_colon_colon (cxx_pp);
144 /* Dump the template ARGument under control of FLAGS. */
147 dump_template_argument (tree arg, int flags)
149 if (ARGUMENT_PACK_P (arg))
150 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), NULL_TREE, flags);
151 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
152 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
155 if (TREE_CODE (arg) == TREE_LIST)
156 arg = TREE_VALUE (arg);
158 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
162 /* Count the number of template arguments ARGS whose value does not
163 match the (optional) default template parameter in PARAMS */
166 count_non_default_template_args (tree args, tree params)
168 tree inner_args = INNERMOST_TEMPLATE_ARGS (args);
169 int n = TREE_VEC_LENGTH (inner_args);
172 if (params == NULL_TREE || !flag_pretty_templates)
175 for (last = n - 1; last >= 0; --last)
177 tree param = TREE_VEC_ELT (params, last);
178 tree def = TREE_PURPOSE (param);
182 if (uses_template_parms (def))
184 ++processing_template_decl;
185 def = tsubst_copy_and_build (def, args, tf_none, NULL_TREE, false, true);
186 --processing_template_decl;
188 if (!cp_tree_equal (TREE_VEC_ELT (inner_args, last), def))
195 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
199 dump_template_argument_list (tree args, tree parms, int flags)
201 int n = count_non_default_template_args (args, parms);
205 for (i = 0; i < n; ++i)
207 tree arg = TREE_VEC_ELT (args, i);
209 /* Only print a comma if we know there is an argument coming. In
210 the case of an empty template argument pack, no actual
211 argument will be printed. */
213 && (!ARGUMENT_PACK_P (arg)
214 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
215 pp_separate_with_comma (cxx_pp);
217 dump_template_argument (arg, flags);
222 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
225 dump_template_parameter (tree parm, int flags)
230 if (parm == error_mark_node)
233 p = TREE_VALUE (parm);
234 a = TREE_PURPOSE (parm);
236 if (TREE_CODE (p) == TYPE_DECL)
238 if (flags & TFF_DECL_SPECIFIERS)
240 pp_cxx_ws_string (cxx_pp, "class");
241 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
242 pp_cxx_ws_string (cxx_pp, "...");
244 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
246 else if (DECL_NAME (p))
247 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
249 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
252 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
254 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
256 pp_cxx_whitespace (cxx_pp);
258 pp_cxx_whitespace (cxx_pp);
259 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
260 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
262 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
266 /* Dump, under control of FLAGS, a template-parameter-list binding.
267 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
271 dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames)
279 tree p = TREE_VALUE (parms);
280 int lvl = TMPL_PARMS_DEPTH (parms);
283 tree lvl_args = NULL_TREE;
285 /* Don't crash if we had an invalid argument list. */
286 if (TMPL_ARGS_DEPTH (args) >= lvl)
287 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
289 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
291 tree arg = NULL_TREE;
293 /* Don't crash if we had an invalid argument list. */
294 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
295 arg = TREE_VEC_ELT (lvl_args, arg_idx);
298 pp_separate_with_comma (cxx_pp);
299 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
300 pp_cxx_whitespace (cxx_pp);
302 pp_cxx_whitespace (cxx_pp);
304 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
306 pp_string (cxx_pp, M_("<missing>"));
312 parms = TREE_CHAIN (parms);
315 for (i = 0; VEC_iterate (tree, typenames, i, t); ++i)
318 pp_separate_with_comma (cxx_pp);
319 dump_type (t, TFF_PLAIN_IDENTIFIER);
320 pp_cxx_whitespace (cxx_pp);
322 pp_cxx_whitespace (cxx_pp);
323 t = tsubst (t, args, tf_none, NULL_TREE);
324 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
325 pp_simple_type_specifier doesn't know about it. */
326 t = strip_typedefs (t);
327 dump_type (t, TFF_PLAIN_IDENTIFIER);
331 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
335 dump_type (tree t, int flags)
340 if (TYPE_PTRMEMFUNC_P (t))
343 switch (TREE_CODE (t))
346 if (t == init_list_type_node)
347 pp_string (cxx_pp, M_("<brace-enclosed initializer list>"));
349 pp_string (cxx_pp, M_("<unresolved overloaded function type>"));
353 /* A list of function parms. */
354 dump_parameters (t, flags);
357 case IDENTIFIER_NODE:
358 pp_cxx_tree_identifier (cxx_pp, t);
362 dump_type (BINFO_TYPE (t), flags);
368 dump_aggr_type (t, flags);
372 if (flags & TFF_CHASE_TYPEDEF)
374 dump_type (DECL_ORIGINAL_TYPE (t)
375 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
378 /* Else fall through. */
382 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
391 case FIXED_POINT_TYPE:
392 pp_type_specifier_seq (cxx_pp, t);
395 case TEMPLATE_TEMPLATE_PARM:
396 /* For parameters inside template signature. */
397 if (TYPE_IDENTIFIER (t))
398 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
400 pp_cxx_canonical_template_parameter (cxx_pp, t);
403 case BOUND_TEMPLATE_TEMPLATE_PARM:
405 tree args = TYPE_TI_ARGS (t);
406 pp_cxx_cv_qualifier_seq (cxx_pp, t);
407 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
408 pp_cxx_begin_template_argument_list (cxx_pp);
409 dump_template_argument_list (args, NULL_TREE, flags);
410 pp_cxx_end_template_argument_list (cxx_pp);
414 case TEMPLATE_TYPE_PARM:
415 pp_cxx_cv_qualifier_seq (cxx_pp, t);
416 if (TYPE_IDENTIFIER (t))
417 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
419 pp_cxx_canonical_template_parameter
420 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
423 /* This is not always necessary for pointers and such, but doing this
424 reduces code size. */
433 dump_type_prefix (t, flags);
434 dump_type_suffix (t, flags);
438 if (! (flags & TFF_CHASE_TYPEDEF)
439 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
441 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
444 pp_cxx_cv_qualifier_seq (cxx_pp, t);
445 pp_cxx_ws_string (cxx_pp,
446 TYPENAME_IS_ENUM_P (t) ? "enum"
447 : TYPENAME_IS_CLASS_P (t) ? "class"
449 dump_typename (t, flags);
452 case UNBOUND_CLASS_TEMPLATE:
453 dump_type (TYPE_CONTEXT (t), flags);
454 pp_cxx_colon_colon (cxx_pp);
455 pp_cxx_ws_string (cxx_pp, "template");
456 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
460 pp_cxx_ws_string (cxx_pp, "__typeof__");
461 pp_cxx_whitespace (cxx_pp);
462 pp_cxx_left_paren (cxx_pp);
463 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
464 pp_cxx_right_paren (cxx_pp);
467 case TYPE_PACK_EXPANSION:
468 dump_type (PACK_EXPANSION_PATTERN (t), flags);
469 pp_cxx_ws_string (cxx_pp, "...");
472 case TYPE_ARGUMENT_PACK:
473 dump_template_argument (t, flags);
477 pp_cxx_ws_string (cxx_pp, "decltype");
478 pp_cxx_whitespace (cxx_pp);
479 pp_cxx_left_paren (cxx_pp);
480 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
481 pp_cxx_right_paren (cxx_pp);
485 pp_unsupported_tree (cxx_pp, t);
486 /* Fall through to error. */
489 pp_string (cxx_pp, M_("<type error>"));
494 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
498 dump_typename (tree t, int flags)
500 tree ctx = TYPE_CONTEXT (t);
502 if (TREE_CODE (ctx) == TYPENAME_TYPE)
503 dump_typename (ctx, flags);
505 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
506 pp_cxx_colon_colon (cxx_pp);
507 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
510 /* Return the name of the supplied aggregate, or enumeral type. */
513 class_key_or_enum_as_string (tree t)
515 if (TREE_CODE (t) == ENUMERAL_TYPE)
517 if (SCOPED_ENUM_P (t))
522 else if (TREE_CODE (t) == UNION_TYPE)
524 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
530 /* Print out a class declaration T under the control of FLAGS,
531 in the form `class foo'. */
534 dump_aggr_type (tree t, int flags)
537 const char *variety = class_key_or_enum_as_string (t);
541 pp_cxx_cv_qualifier_seq (cxx_pp, t);
543 if (flags & TFF_CLASS_KEY_OR_ENUM)
544 pp_cxx_ws_string (cxx_pp, variety);
546 name = TYPE_NAME (t);
550 typdef = !DECL_ARTIFICIAL (name);
553 && ((flags & TFF_CHASE_TYPEDEF)
554 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
555 && DECL_TEMPLATE_INFO (name))))
557 t = TYPE_MAIN_VARIANT (t);
558 name = TYPE_NAME (t);
562 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
563 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
564 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
565 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
567 if (! (flags & TFF_UNQUALIFIED_NAME))
568 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
569 flags &= ~TFF_UNQUALIFIED_NAME;
572 /* Because the template names are mangled, we have to locate
573 the most general template, and use that name. */
574 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
576 while (DECL_TEMPLATE_INFO (tpl))
577 tpl = DECL_TI_TEMPLATE (tpl);
580 name = DECL_NAME (name);
583 if (name == 0 || ANON_AGGRNAME_P (name))
585 if (flags & TFF_CLASS_KEY_OR_ENUM)
586 pp_string (cxx_pp, M_("<anonymous>"));
588 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety);
591 pp_cxx_tree_identifier (cxx_pp, name);
593 dump_template_parms (TYPE_TEMPLATE_INFO (t),
594 !CLASSTYPE_USE_TEMPLATE (t),
595 flags & ~TFF_TEMPLATE_HEADER);
598 /* Dump into the obstack the initial part of the output for a given type.
599 This is necessary when dealing with things like functions returning
602 return type of `int (* fee ())()': pointer -> function -> int. Both
603 pointer (and reference and offset) and function (and member) types must
604 deal with prefix and suffix.
606 Arrays must also do this for DECL nodes, like int a[], and for things like
610 dump_type_prefix (tree t, int flags)
612 if (TYPE_PTRMEMFUNC_P (t))
614 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
618 switch (TREE_CODE (t))
623 tree sub = TREE_TYPE (t);
625 dump_type_prefix (sub, flags);
626 if (TREE_CODE (sub) == ARRAY_TYPE
627 || TREE_CODE (sub) == FUNCTION_TYPE)
629 pp_cxx_whitespace (cxx_pp);
630 pp_cxx_left_paren (cxx_pp);
632 if (TREE_CODE (t) == POINTER_TYPE)
633 pp_character(cxx_pp, '*');
634 else if (TREE_CODE (t) == REFERENCE_TYPE)
636 if (TYPE_REF_IS_RVALUE (t))
637 pp_string (cxx_pp, "&&");
639 pp_character (cxx_pp, '&');
641 pp_base (cxx_pp)->padding = pp_before;
642 pp_cxx_cv_qualifier_seq (cxx_pp, t);
648 dump_type_prefix (TREE_TYPE (t), flags);
649 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
651 pp_maybe_space (cxx_pp);
652 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
653 pp_cxx_left_paren (cxx_pp);
654 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
655 pp_cxx_colon_colon (cxx_pp);
657 pp_cxx_star (cxx_pp);
658 pp_cxx_cv_qualifier_seq (cxx_pp, t);
659 pp_base (cxx_pp)->padding = pp_before;
662 /* This can be reached without a pointer when dealing with
663 templates, e.g. std::is_function. */
665 dump_type_prefix (TREE_TYPE (t), flags);
669 dump_type_prefix (TREE_TYPE (t), flags);
670 pp_maybe_space (cxx_pp);
671 pp_cxx_left_paren (cxx_pp);
672 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
673 pp_cxx_colon_colon (cxx_pp);
677 dump_type_prefix (TREE_TYPE (t), flags);
681 case IDENTIFIER_NODE:
686 case TEMPLATE_TYPE_PARM:
687 case TEMPLATE_TEMPLATE_PARM:
688 case BOUND_TEMPLATE_TEMPLATE_PARM:
700 case TYPE_PACK_EXPANSION:
701 case FIXED_POINT_TYPE:
702 dump_type (t, flags);
703 pp_base (cxx_pp)->padding = pp_before;
707 pp_unsupported_tree (cxx_pp, t);
710 pp_string (cxx_pp, M_("<typeprefixerror>"));
715 /* Dump the suffix of type T, under control of FLAGS. This is the part
716 which appears after the identifier (or function parms). */
719 dump_type_suffix (tree t, int flags)
721 if (TYPE_PTRMEMFUNC_P (t))
722 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
724 switch (TREE_CODE (t))
729 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
730 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
731 pp_cxx_right_paren (cxx_pp);
732 dump_type_suffix (TREE_TYPE (t), flags);
739 if (TREE_CODE (t) == METHOD_TYPE)
740 /* Can only be reached through a pointer. */
741 pp_cxx_right_paren (cxx_pp);
742 arg = TYPE_ARG_TYPES (t);
743 if (TREE_CODE (t) == METHOD_TYPE)
744 arg = TREE_CHAIN (arg);
746 /* Function pointers don't have default args. Not in standard C++,
747 anyway; they may in g++, but we'll just pretend otherwise. */
748 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
750 if (TREE_CODE (t) == METHOD_TYPE)
751 pp_cxx_cv_qualifier_seq
752 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
754 pp_cxx_cv_qualifier_seq (cxx_pp, t);
755 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
756 dump_type_suffix (TREE_TYPE (t), flags);
761 pp_maybe_space (cxx_pp);
762 pp_cxx_left_bracket (cxx_pp);
765 tree dtype = TYPE_DOMAIN (t);
766 tree max = TYPE_MAX_VALUE (dtype);
767 if (host_integerp (max, 0))
768 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
769 else if (TREE_CODE (max) == MINUS_EXPR)
770 dump_expr (TREE_OPERAND (max, 0),
771 flags & ~TFF_EXPR_IN_PARENS);
773 dump_expr (fold_build2 (PLUS_EXPR, dtype, max,
774 build_int_cst (dtype, 1)),
775 flags & ~TFF_EXPR_IN_PARENS);
777 pp_cxx_right_bracket (cxx_pp);
778 dump_type_suffix (TREE_TYPE (t), flags);
782 case IDENTIFIER_NODE:
787 case TEMPLATE_TYPE_PARM:
788 case TEMPLATE_TEMPLATE_PARM:
789 case BOUND_TEMPLATE_TEMPLATE_PARM:
801 case TYPE_PACK_EXPANSION:
802 case FIXED_POINT_TYPE:
806 pp_unsupported_tree (cxx_pp, t);
808 /* Don't mark it here, we should have already done in
815 dump_global_iord (tree t)
817 const char *p = NULL;
819 if (DECL_GLOBAL_CTOR_P (t))
820 p = M_("(static initializers for %s)");
821 else if (DECL_GLOBAL_DTOR_P (t))
822 p = M_("(static destructors for %s)");
826 pp_printf (pp_base (cxx_pp), p, input_filename);
830 dump_simple_decl (tree t, tree type, int flags)
832 if (flags & TFF_DECL_SPECIFIERS)
834 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
835 pp_maybe_space (cxx_pp);
837 if (! (flags & TFF_UNQUALIFIED_NAME)
838 && (!DECL_INITIAL (t)
839 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
840 dump_scope (CP_DECL_CONTEXT (t), flags);
841 flags &= ~TFF_UNQUALIFIED_NAME;
842 if ((flags & TFF_DECL_SPECIFIERS)
843 && DECL_TEMPLATE_PARM_P (t)
844 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
845 pp_string (cxx_pp, "...");
847 dump_decl (DECL_NAME (t), flags);
849 pp_string (cxx_pp, M_("<anonymous>"));
850 if (flags & TFF_DECL_SPECIFIERS)
851 dump_type_suffix (type, flags);
854 /* Dump a human readable string for the decl T under control of FLAGS. */
857 dump_decl (tree t, int flags)
862 switch (TREE_CODE (t))
865 /* Don't say 'typedef class A' */
866 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
868 if ((flags & TFF_DECL_SPECIFIERS)
869 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
871 /* Say `class T' not just `T'. */
872 pp_cxx_ws_string (cxx_pp, "class");
874 /* Emit the `...' for a parameter pack. */
875 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
876 pp_cxx_ws_string (cxx_pp, "...");
879 dump_type (TREE_TYPE (t), flags);
882 if (flags & TFF_DECL_SPECIFIERS)
883 pp_cxx_ws_string (cxx_pp, "typedef");
884 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
885 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
890 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
892 pp_string (cxx_pp, M_("vtable for "));
893 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
894 dump_type (DECL_CONTEXT (t), flags);
897 /* Else fall through. */
900 dump_simple_decl (t, TREE_TYPE (t), flags);
904 pp_string (cxx_pp, M_("<return value> "));
905 dump_simple_decl (t, TREE_TYPE (t), flags);
909 if (flags & TFF_DECL_SPECIFIERS)
910 pp_cxx_declaration (cxx_pp, t);
913 if (! (flags & TFF_UNQUALIFIED_NAME))
914 dump_scope (CP_DECL_CONTEXT (t), flags);
915 flags &= ~TFF_UNQUALIFIED_NAME;
916 if (DECL_NAME (t) == NULL_TREE)
917 pp_string (cxx_pp, M_("<unnamed>"));
919 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
924 pp_expression (cxx_pp, t);
928 dump_decl (TREE_OPERAND (t, 0), flags);
929 pp_cxx_left_bracket (cxx_pp);
930 dump_decl (TREE_OPERAND (t, 1), flags);
931 pp_cxx_right_bracket (cxx_pp);
934 /* So that we can do dump_decl on an aggr type. */
938 dump_type (t, flags);
942 /* This is a pseudo destructor call which has not been folded into
943 a PSEUDO_DTOR_EXPR yet. */
944 pp_cxx_complement (cxx_pp);
945 dump_type (TREE_OPERAND (t, 0), flags);
952 /* These special cases are duplicated here so that other functions
953 can feed identifiers to error and get them demangled properly. */
954 case IDENTIFIER_NODE:
955 if (IDENTIFIER_TYPENAME_P (t))
957 pp_cxx_ws_string (cxx_pp, "operator");
958 /* Not exactly IDENTIFIER_TYPE_VALUE. */
959 dump_type (TREE_TYPE (t), flags);
963 pp_cxx_tree_identifier (cxx_pp, t);
970 if (DECL_CLASS_SCOPE_P (t))
972 dump_type (DECL_CONTEXT (t), flags);
973 pp_cxx_colon_colon (cxx_pp);
975 else if (DECL_CONTEXT (t))
977 dump_decl (DECL_CONTEXT (t), flags);
978 pp_cxx_colon_colon (cxx_pp);
980 dump_decl (DECL_NAME (t), flags);
984 /* If there's only one function, just treat it like an ordinary
990 if (! DECL_LANG_SPECIFIC (t))
991 pp_string (cxx_pp, M_("<built-in>"));
992 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
993 dump_global_iord (t);
995 dump_function_decl (t, flags);
999 dump_template_decl (t, flags);
1002 case TEMPLATE_ID_EXPR:
1004 tree name = TREE_OPERAND (t, 0);
1006 if (is_overloaded_fn (name))
1007 name = DECL_NAME (get_first_fn (name));
1008 dump_decl (name, flags);
1009 pp_cxx_begin_template_argument_list (cxx_pp);
1010 if (TREE_OPERAND (t, 1))
1011 dump_template_argument_list (TREE_OPERAND (t, 1), NULL_TREE, flags);
1012 pp_cxx_end_template_argument_list (cxx_pp);
1017 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1021 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1022 || (DECL_INITIAL (t) &&
1023 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1024 dump_simple_decl (t, TREE_TYPE (t), flags);
1025 else if (DECL_NAME (t))
1026 dump_decl (DECL_NAME (t), flags);
1027 else if (DECL_INITIAL (t))
1028 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1030 pp_string (cxx_pp, M_("<enumerator>"));
1034 pp_cxx_ws_string (cxx_pp, "using");
1035 dump_type (USING_DECL_SCOPE (t), flags);
1036 pp_cxx_colon_colon (cxx_pp);
1037 dump_decl (DECL_NAME (t), flags);
1041 pp_cxx_declaration (cxx_pp, t);
1045 dump_decl (BASELINK_FUNCTIONS (t), flags);
1048 case NON_DEPENDENT_EXPR:
1049 dump_expr (t, flags);
1052 case TEMPLATE_TYPE_PARM:
1053 if (flags & TFF_DECL_SPECIFIERS)
1054 pp_cxx_declaration (cxx_pp, t);
1056 pp_type_id (cxx_pp, t);
1059 case UNBOUND_CLASS_TEMPLATE:
1060 case TYPE_PACK_EXPANSION:
1062 dump_type (t, flags);
1066 pp_unsupported_tree (cxx_pp, t);
1067 /* Fall through to error. */
1070 pp_string (cxx_pp, M_("<declaration error>"));
1075 /* Dump a template declaration T under control of FLAGS. This means the
1076 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1079 dump_template_decl (tree t, int flags)
1081 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1085 if (flags & TFF_TEMPLATE_HEADER)
1087 for (parms = orig_parms = nreverse (orig_parms);
1089 parms = TREE_CHAIN (parms))
1091 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1092 int len = TREE_VEC_LENGTH (inner_parms);
1094 pp_cxx_ws_string (cxx_pp, "template");
1095 pp_cxx_begin_template_argument_list (cxx_pp);
1097 /* If we've shown the template prefix, we'd better show the
1098 parameters' and decl's type too. */
1099 flags |= TFF_DECL_SPECIFIERS;
1101 for (i = 0; i < len; i++)
1104 pp_separate_with_comma (cxx_pp);
1105 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1107 pp_cxx_end_template_argument_list (cxx_pp);
1108 pp_cxx_whitespace (cxx_pp);
1110 nreverse(orig_parms);
1112 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1114 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1115 pp_cxx_ws_string (cxx_pp, "class");
1117 /* If this is a parameter pack, print the ellipsis. */
1118 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1119 pp_cxx_ws_string (cxx_pp, "...");
1123 if (DECL_TEMPLATE_RESULT (t)
1124 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1125 dump_type (TREE_TYPE (t),
1126 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1127 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1128 else if (DECL_TEMPLATE_RESULT (t)
1129 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1130 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1133 gcc_assert (TREE_TYPE (t));
1134 switch (NEXT_CODE (t))
1138 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1141 /* This case can occur with some invalid code. */
1142 dump_type (TREE_TYPE (t),
1143 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1144 | (flags & TFF_DECL_SPECIFIERS
1145 ? TFF_CLASS_KEY_OR_ENUM : 0));
1150 /* find_typenames looks through the type of the function template T
1151 and returns a VEC containing any typedefs or TYPENAME_TYPEs it finds. */
1153 struct find_typenames_t
1155 struct pointer_set_t *p_set;
1156 VEC (tree,gc) *typenames;
1160 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1162 struct find_typenames_t *d = (struct find_typenames_t *)data;
1163 tree mv = NULL_TREE;
1165 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1166 /* Add the type of the typedef without any additional cv-quals. */
1167 mv = TREE_TYPE (TYPE_NAME (*tp));
1168 else if (TREE_CODE (*tp) == TYPENAME_TYPE)
1169 /* Add the typename without any cv-qualifiers. */
1170 mv = TYPE_MAIN_VARIANT (*tp);
1172 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1173 VEC_safe_push (tree, gc, d->typenames, mv);
1175 /* Search into class template arguments, which cp_walk_subtrees
1177 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1178 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1184 static VEC(tree,gc) *
1185 find_typenames (tree t)
1187 struct find_typenames_t ft;
1188 ft.p_set = pointer_set_create ();
1189 ft.typenames = NULL;
1190 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1191 find_typenames_r, &ft, ft.p_set);
1192 pointer_set_destroy (ft.p_set);
1193 return ft.typenames;
1196 /* Pretty print a function decl. There are several ways we want to print a
1197 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1198 As error can only apply the '#' flag once to give 0 and 1 for V, there
1199 is %D which doesn't print the throw specs, and %F which does. */
1202 dump_function_decl (tree t, int flags)
1206 tree cname = NULL_TREE;
1207 tree template_args = NULL_TREE;
1208 tree template_parms = NULL_TREE;
1209 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1210 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1212 VEC(tree,gc) *typenames = NULL;
1214 flags &= ~TFF_UNQUALIFIED_NAME;
1215 if (TREE_CODE (t) == TEMPLATE_DECL)
1216 t = DECL_TEMPLATE_RESULT (t);
1218 /* Save the exceptions, in case t is a specialization and we are
1219 emitting an error about incompatible specifications. */
1220 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1222 /* Pretty print template instantiations only. */
1223 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1224 && flag_pretty_templates)
1228 template_args = DECL_TI_ARGS (t);
1229 tmpl = most_general_template (t);
1230 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1232 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1234 typenames = find_typenames (t);
1238 fntype = TREE_TYPE (t);
1239 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1241 if (DECL_CLASS_SCOPE_P (t))
1242 cname = DECL_CONTEXT (t);
1243 /* This is for partially instantiated template methods. */
1244 else if (TREE_CODE (fntype) == METHOD_TYPE)
1245 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1247 if (!(flags & TFF_DECL_SPECIFIERS))
1249 else if (DECL_STATIC_FUNCTION_P (t))
1250 pp_cxx_ws_string (cxx_pp, "static");
1251 else if (DECL_VIRTUAL_P (t))
1252 pp_cxx_ws_string (cxx_pp, "virtual");
1254 /* Print the return type? */
1256 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1257 && !DECL_DESTRUCTOR_P (t);
1259 dump_type_prefix (TREE_TYPE (fntype), flags);
1261 /* Print the function name. */
1262 if (!do_outer_scope)
1266 dump_type (cname, flags);
1267 pp_cxx_colon_colon (cxx_pp);
1270 dump_scope (CP_DECL_CONTEXT (t), flags);
1272 dump_function_name (t, flags);
1274 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1276 dump_parameters (parmtypes, flags);
1278 if (TREE_CODE (fntype) == METHOD_TYPE)
1280 pp_base (cxx_pp)->padding = pp_before;
1281 pp_cxx_cv_qualifier_seq
1282 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1285 if (flags & TFF_EXCEPTION_SPECIFICATION)
1287 pp_base (cxx_pp)->padding = pp_before;
1288 dump_exception_spec (exceptions, flags);
1292 dump_type_suffix (TREE_TYPE (fntype), flags);
1295 /* If T is a template instantiation, dump the parameter binding. */
1296 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1298 pp_cxx_whitespace (cxx_pp);
1299 pp_cxx_left_bracket (cxx_pp);
1300 pp_cxx_ws_string (cxx_pp, M_("with"));
1301 pp_cxx_whitespace (cxx_pp);
1302 dump_template_bindings (template_parms, template_args, typenames);
1303 pp_cxx_right_bracket (cxx_pp);
1307 /* Print a parameter list. If this is for a member function, the
1308 member object ptr (and any other hidden args) should have
1309 already been removed. */
1312 dump_parameters (tree parmtypes, int flags)
1315 pp_cxx_left_paren (cxx_pp);
1317 for (first = 1; parmtypes != void_list_node;
1318 parmtypes = TREE_CHAIN (parmtypes))
1321 pp_separate_with_comma (cxx_pp);
1325 pp_cxx_ws_string (cxx_pp, "...");
1329 dump_type (TREE_VALUE (parmtypes), flags);
1331 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1333 pp_cxx_whitespace (cxx_pp);
1335 pp_cxx_whitespace (cxx_pp);
1336 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1340 pp_cxx_right_paren (cxx_pp);
1343 /* Print an exception specification. T is the exception specification. */
1346 dump_exception_spec (tree t, int flags)
1350 pp_cxx_ws_string (cxx_pp, "throw");
1351 pp_cxx_whitespace (cxx_pp);
1352 pp_cxx_left_paren (cxx_pp);
1353 if (TREE_VALUE (t) != NULL_TREE)
1356 dump_type (TREE_VALUE (t), flags);
1360 pp_separate_with_comma (cxx_pp);
1362 pp_cxx_right_paren (cxx_pp);
1366 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1367 and destructors properly. */
1370 dump_function_name (tree t, int flags)
1372 tree name = DECL_NAME (t);
1374 /* We can get here with a decl that was synthesized by language-
1375 independent machinery (e.g. coverage.c) in which case it won't
1376 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1377 will crash. In this case it is safe just to print out the
1379 if (!DECL_LANG_SPECIFIC (t))
1381 pp_cxx_tree_identifier (cxx_pp, name);
1385 if (TREE_CODE (t) == TEMPLATE_DECL)
1386 t = DECL_TEMPLATE_RESULT (t);
1388 /* Don't let the user see __comp_ctor et al. */
1389 if (DECL_CONSTRUCTOR_P (t)
1390 || DECL_DESTRUCTOR_P (t))
1391 name = constructor_name (DECL_CONTEXT (t));
1393 if (DECL_DESTRUCTOR_P (t))
1395 pp_cxx_complement (cxx_pp);
1396 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1398 else if (DECL_CONV_FN_P (t))
1400 /* This cannot use the hack that the operator's return
1401 type is stashed off of its name because it may be
1402 used for error reporting. In the case of conflicting
1403 declarations, both will have the same name, yet
1404 the types will be different, hence the TREE_TYPE field
1405 of the first name will be clobbered by the second. */
1406 pp_cxx_ws_string (cxx_pp, "operator");
1407 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1409 else if (IDENTIFIER_OPNAME_P (name))
1410 pp_cxx_tree_identifier (cxx_pp, name);
1412 dump_decl (name, flags);
1414 if (DECL_TEMPLATE_INFO (t)
1415 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1416 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1417 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1418 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1421 /* Dump the template parameters from the template info INFO under control of
1422 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1423 specialization (partial or complete). For partial specializations we show
1424 the specialized parameter values. For a primary template we show no
1428 dump_template_parms (tree info, int primary, int flags)
1430 tree args = info ? TI_ARGS (info) : NULL_TREE;
1432 if (primary && flags & TFF_TEMPLATE_NAME)
1434 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1435 pp_cxx_begin_template_argument_list (cxx_pp);
1437 /* Be careful only to print things when we have them, so as not
1438 to crash producing error messages. */
1439 if (args && !primary)
1442 /* We don't know the parms for a friend template specialization. */
1443 tree params = (TREE_CODE (TI_TEMPLATE (info)) == TEMPLATE_DECL
1444 ? DECL_INNERMOST_TEMPLATE_PARMS (TI_TEMPLATE (info))
1447 len = count_non_default_template_args (args, params);
1449 args = INNERMOST_TEMPLATE_ARGS (args);
1450 for (ix = 0; ix != len; ix++)
1452 tree arg = TREE_VEC_ELT (args, ix);
1454 /* Only print a comma if we know there is an argument coming. In
1455 the case of an empty template argument pack, no actual
1456 argument will be printed. */
1458 && (!ARGUMENT_PACK_P (arg)
1459 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1460 pp_separate_with_comma (cxx_pp);
1463 pp_string (cxx_pp, M_("<template parameter error>"));
1465 dump_template_argument (arg, flags);
1470 tree tpl = TI_TEMPLATE (info);
1471 tree parms = DECL_TEMPLATE_PARMS (tpl);
1474 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1475 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1477 for (ix = 0; ix != len; ix++)
1481 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1483 pp_string (cxx_pp, M_("<template parameter error>"));
1487 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1490 pp_separate_with_comma (cxx_pp);
1492 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1495 pp_cxx_end_template_argument_list (cxx_pp);
1498 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1499 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1502 dump_call_expr_args (tree t, int flags, bool skipfirst)
1505 call_expr_arg_iterator iter;
1507 pp_cxx_left_paren (cxx_pp);
1508 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1514 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1515 if (more_call_expr_args_p (&iter))
1516 pp_separate_with_comma (cxx_pp);
1519 pp_cxx_right_paren (cxx_pp);
1522 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1523 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1527 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1530 aggr_init_expr_arg_iterator iter;
1532 pp_cxx_left_paren (cxx_pp);
1533 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1539 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1540 if (more_aggr_init_expr_args_p (&iter))
1541 pp_separate_with_comma (cxx_pp);
1544 pp_cxx_right_paren (cxx_pp);
1547 /* Print out a list of initializers (subr of dump_expr). */
1550 dump_expr_list (tree l, int flags)
1554 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1557 pp_separate_with_comma (cxx_pp);
1561 /* Print out a vector of initializers (subr of dump_expr). */
1564 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1566 unsigned HOST_WIDE_INT idx;
1569 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1571 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1572 if (idx != VEC_length (constructor_elt, v) - 1)
1573 pp_separate_with_comma (cxx_pp);
1578 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1579 function. Resolve it to a close relative -- in the sense of static
1580 type -- variant being overridden. That is close to what was written in
1581 the source code. Subroutine of dump_expr. */
1584 resolve_virtual_fun_from_obj_type_ref (tree ref)
1586 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1587 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1588 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1591 fun = TREE_CHAIN (fun);
1592 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1593 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1599 /* Print out an expression E under control of FLAGS. */
1602 dump_expr (tree t, int flags)
1607 if (STATEMENT_CLASS_P (t))
1609 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1613 switch (TREE_CODE (t))
1621 case NAMESPACE_DECL:
1624 case IDENTIFIER_NODE:
1625 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1632 pp_constant (cxx_pp, t);
1636 /* While waiting for caret diagnostics, avoid printing
1637 __cxa_allocate_exception, __cxa_throw, and the like. */
1638 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1642 pp_ampersand (cxx_pp);
1643 dump_type (PTRMEM_CST_CLASS (t), flags);
1644 pp_cxx_colon_colon (cxx_pp);
1645 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1649 pp_cxx_left_paren (cxx_pp);
1650 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1651 pp_separate_with_comma (cxx_pp);
1652 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1653 pp_cxx_right_paren (cxx_pp);
1657 pp_cxx_left_paren (cxx_pp);
1658 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1659 pp_string (cxx_pp, " ? ");
1660 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1661 pp_string (cxx_pp, " : ");
1662 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1663 pp_cxx_right_paren (cxx_pp);
1667 if (TREE_HAS_CONSTRUCTOR (t))
1669 pp_cxx_ws_string (cxx_pp, "new");
1670 pp_cxx_whitespace (cxx_pp);
1671 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1674 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1677 case AGGR_INIT_EXPR:
1679 tree fn = NULL_TREE;
1681 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1682 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1684 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1686 if (DECL_CONSTRUCTOR_P (fn))
1687 dump_type (DECL_CONTEXT (fn), flags);
1692 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1694 dump_aggr_init_expr_args (t, flags, true);
1699 tree fn = CALL_EXPR_FN (t);
1700 bool skipfirst = false;
1702 if (TREE_CODE (fn) == ADDR_EXPR)
1703 fn = TREE_OPERAND (fn, 0);
1705 /* Nobody is interested in seeing the guts of vcalls. */
1706 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1707 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1709 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1711 tree ob = CALL_EXPR_ARG (t, 0);
1712 if (TREE_CODE (ob) == ADDR_EXPR)
1714 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1715 pp_cxx_dot (cxx_pp);
1717 else if (TREE_CODE (ob) != PARM_DECL
1718 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1720 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1721 pp_cxx_arrow (cxx_pp);
1725 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1726 dump_call_expr_args (t, flags, skipfirst);
1731 /* Note that this only works for G++ target exprs. If somebody
1732 builds a general TARGET_EXPR, there's no way to represent that
1733 it initializes anything other that the parameter slot for the
1734 default argument. Note we may have cleared out the first
1735 operand in expand_expr, so don't go killing ourselves. */
1736 if (TREE_OPERAND (t, 1))
1737 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1740 case POINTER_PLUS_EXPR:
1741 dump_binary_op ("+", t, flags);
1749 case TRUNC_DIV_EXPR:
1750 case TRUNC_MOD_EXPR:
1758 case TRUTH_ANDIF_EXPR:
1759 case TRUTH_ORIF_EXPR:
1766 case EXACT_DIV_EXPR:
1767 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1771 case FLOOR_DIV_EXPR:
1772 case ROUND_DIV_EXPR:
1774 dump_binary_op ("/", t, flags);
1778 case FLOOR_MOD_EXPR:
1779 case ROUND_MOD_EXPR:
1780 dump_binary_op ("%", t, flags);
1785 tree ob = TREE_OPERAND (t, 0);
1786 if (TREE_CODE (ob) == INDIRECT_REF)
1788 ob = TREE_OPERAND (ob, 0);
1789 if (TREE_CODE (ob) != PARM_DECL
1791 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1793 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1794 pp_cxx_arrow (cxx_pp);
1799 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1800 pp_cxx_dot (cxx_pp);
1802 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1807 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1808 pp_cxx_left_bracket (cxx_pp);
1809 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1810 pp_cxx_right_bracket (cxx_pp);
1813 case UNARY_PLUS_EXPR:
1814 dump_unary_op ("+", t, flags);
1818 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1819 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1820 /* An ADDR_EXPR can have reference type. In that case, we
1821 shouldn't print the `&' doing so indicates to the user
1822 that the expression has pointer type. */
1824 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1825 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1826 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1827 dump_unary_op ("&&", t, flags);
1829 dump_unary_op ("&", t, flags);
1833 if (TREE_HAS_CONSTRUCTOR (t))
1835 t = TREE_OPERAND (t, 0);
1836 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1837 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1838 dump_call_expr_args (t, flags, true);
1842 if (TREE_OPERAND (t,0) != NULL_TREE
1843 && TREE_TYPE (TREE_OPERAND (t, 0))
1844 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1845 dump_expr (TREE_OPERAND (t, 0), flags);
1847 dump_unary_op ("*", t, flags);
1853 case TRUTH_NOT_EXPR:
1854 case PREDECREMENT_EXPR:
1855 case PREINCREMENT_EXPR:
1856 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1859 case POSTDECREMENT_EXPR:
1860 case POSTINCREMENT_EXPR:
1861 pp_cxx_left_paren (cxx_pp);
1862 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1863 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1864 pp_cxx_right_paren (cxx_pp);
1867 case NON_LVALUE_EXPR:
1868 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1869 should be another level of INDIRECT_REF so that I don't have to do
1871 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1873 tree next = TREE_TYPE (TREE_TYPE (t));
1875 while (TREE_CODE (next) == POINTER_TYPE)
1876 next = TREE_TYPE (next);
1878 if (TREE_CODE (next) == FUNCTION_TYPE)
1880 if (flags & TFF_EXPR_IN_PARENS)
1881 pp_cxx_left_paren (cxx_pp);
1882 pp_cxx_star (cxx_pp);
1883 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1884 if (flags & TFF_EXPR_IN_PARENS)
1885 pp_cxx_right_paren (cxx_pp);
1888 /* Else fall through. */
1890 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1894 case VIEW_CONVERT_EXPR:
1896 tree op = TREE_OPERAND (t, 0);
1898 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1900 /* It is a cast, but we cannot tell whether it is a
1901 reinterpret or static cast. Use the C style notation. */
1902 if (flags & TFF_EXPR_IN_PARENS)
1903 pp_cxx_left_paren (cxx_pp);
1904 pp_cxx_left_paren (cxx_pp);
1905 dump_type (TREE_TYPE (t), flags);
1906 pp_cxx_right_paren (cxx_pp);
1907 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1908 if (flags & TFF_EXPR_IN_PARENS)
1909 pp_cxx_right_paren (cxx_pp);
1912 dump_expr (op, flags);
1917 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1919 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1921 if (integer_zerop (idx))
1923 /* A NULL pointer-to-member constant. */
1924 pp_cxx_left_paren (cxx_pp);
1925 pp_cxx_left_paren (cxx_pp);
1926 dump_type (TREE_TYPE (t), flags);
1927 pp_cxx_right_paren (cxx_pp);
1928 pp_character (cxx_pp, '0');
1929 pp_cxx_right_paren (cxx_pp);
1932 else if (host_integerp (idx, 0))
1935 unsigned HOST_WIDE_INT n;
1937 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1938 t = TYPE_METHOD_BASETYPE (t);
1939 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1941 n = tree_low_cst (idx, 0);
1943 /* Map vtable index back one, to allow for the null pointer to
1947 while (n > 0 && virtuals)
1950 virtuals = TREE_CHAIN (virtuals);
1954 dump_expr (BV_FN (virtuals),
1955 flags | TFF_EXPR_IN_PARENS);
1960 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1962 dump_type (TREE_TYPE (t), 0);
1963 pp_cxx_left_paren (cxx_pp);
1964 pp_cxx_right_paren (cxx_pp);
1968 pp_cxx_left_brace (cxx_pp);
1969 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1970 pp_cxx_right_brace (cxx_pp);
1977 tree ob = TREE_OPERAND (t, 0);
1978 if (is_dummy_object (ob))
1980 t = TREE_OPERAND (t, 1);
1981 if (TREE_CODE (t) == FUNCTION_DECL)
1983 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1984 else if (BASELINK_P (t))
1985 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1986 flags | TFF_EXPR_IN_PARENS);
1988 dump_decl (t, flags);
1992 if (TREE_CODE (ob) == INDIRECT_REF)
1994 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1995 pp_cxx_arrow (cxx_pp);
1996 pp_cxx_star (cxx_pp);
2000 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2001 pp_cxx_dot (cxx_pp);
2002 pp_cxx_star (cxx_pp);
2004 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2009 case TEMPLATE_PARM_INDEX:
2010 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2014 if (TREE_OPERAND (t, 0) == NULL_TREE
2015 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2017 dump_type (TREE_TYPE (t), flags);
2018 pp_cxx_left_paren (cxx_pp);
2019 dump_expr_list (TREE_OPERAND (t, 0), flags);
2020 pp_cxx_right_paren (cxx_pp);
2024 pp_cxx_left_paren (cxx_pp);
2025 dump_type (TREE_TYPE (t), flags);
2026 pp_cxx_right_paren (cxx_pp);
2027 pp_cxx_left_paren (cxx_pp);
2028 dump_expr_list (TREE_OPERAND (t, 0), flags);
2029 pp_cxx_right_paren (cxx_pp);
2033 case STATIC_CAST_EXPR:
2034 pp_cxx_ws_string (cxx_pp, "static_cast");
2036 case REINTERPRET_CAST_EXPR:
2037 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2039 case CONST_CAST_EXPR:
2040 pp_cxx_ws_string (cxx_pp, "const_cast");
2042 case DYNAMIC_CAST_EXPR:
2043 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2045 pp_cxx_begin_template_argument_list (cxx_pp);
2046 dump_type (TREE_TYPE (t), flags);
2047 pp_cxx_end_template_argument_list (cxx_pp);
2048 pp_cxx_left_paren (cxx_pp);
2049 dump_expr (TREE_OPERAND (t, 0), flags);
2050 pp_cxx_right_paren (cxx_pp);
2054 dump_expr (TREE_OPERAND (t, 0), flags);
2055 pp_cxx_arrow (cxx_pp);
2060 if (TREE_CODE (t) == SIZEOF_EXPR)
2061 pp_cxx_ws_string (cxx_pp, "sizeof");
2064 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2065 pp_cxx_ws_string (cxx_pp, "__alignof__");
2067 pp_cxx_whitespace (cxx_pp);
2068 pp_cxx_left_paren (cxx_pp);
2069 if (TYPE_P (TREE_OPERAND (t, 0)))
2070 dump_type (TREE_OPERAND (t, 0), flags);
2072 dump_expr (TREE_OPERAND (t, 0), flags);
2073 pp_cxx_right_paren (cxx_pp);
2078 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2079 pp_cxx_whitespace (cxx_pp);
2080 dump_expr (TREE_OPERAND (t, 0), flags);
2084 pp_string (cxx_pp, M_("<unparsed>"));
2087 case TRY_CATCH_EXPR:
2088 case WITH_CLEANUP_EXPR:
2089 case CLEANUP_POINT_EXPR:
2090 dump_expr (TREE_OPERAND (t, 0), flags);
2093 case PSEUDO_DTOR_EXPR:
2094 dump_expr (TREE_OPERAND (t, 2), flags);
2095 pp_cxx_dot (cxx_pp);
2096 dump_type (TREE_OPERAND (t, 0), flags);
2097 pp_cxx_colon_colon (cxx_pp);
2098 pp_cxx_complement (cxx_pp);
2099 dump_type (TREE_OPERAND (t, 1), flags);
2102 case TEMPLATE_ID_EXPR:
2103 dump_decl (t, flags);
2109 case STATEMENT_LIST:
2110 /* We don't yet have a way of dumping statements in a
2111 human-readable format. */
2112 pp_string (cxx_pp, "({...})");
2116 pp_string (cxx_pp, "while (1) { ");
2117 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2118 pp_cxx_right_brace (cxx_pp);
2122 pp_string (cxx_pp, "if (");
2123 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2124 pp_string (cxx_pp, ") break; ");
2128 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2131 case EMPTY_CLASS_EXPR:
2132 dump_type (TREE_TYPE (t), flags);
2133 pp_cxx_left_paren (cxx_pp);
2134 pp_cxx_right_paren (cxx_pp);
2137 case NON_DEPENDENT_EXPR:
2138 dump_expr (TREE_OPERAND (t, 0), flags);
2141 case ARGUMENT_PACK_SELECT:
2142 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2154 pp_type_specifier_seq (cxx_pp, t);
2158 /* We get here when we want to print a dependent type as an
2159 id-expression, without any disambiguator decoration. */
2160 pp_id_expression (cxx_pp, t);
2163 case TEMPLATE_TYPE_PARM:
2164 case BOUND_TEMPLATE_TEMPLATE_PARM:
2165 dump_type (t, flags);
2169 pp_cxx_trait_expression (cxx_pp, t);
2173 pp_cxx_va_arg_expression (cxx_pp, t);
2177 pp_cxx_offsetof_expression (cxx_pp, t);
2181 case EXPR_PACK_EXPANSION:
2188 case VEC_DELETE_EXPR:
2194 case UNORDERED_EXPR:
2204 case FIX_TRUNC_EXPR:
2206 pp_expression (cxx_pp, t);
2209 case TRUTH_AND_EXPR:
2211 case TRUTH_XOR_EXPR:
2212 if (flags & TFF_EXPR_IN_PARENS)
2213 pp_cxx_left_paren (cxx_pp);
2214 pp_expression (cxx_pp, t);
2215 if (flags & TFF_EXPR_IN_PARENS)
2216 pp_cxx_right_paren (cxx_pp);
2220 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2223 /* This list is incomplete, but should suffice for now.
2224 It is very important that `sorry' does not call
2225 `report_error_function'. That could cause an infinite loop. */
2227 pp_unsupported_tree (cxx_pp, t);
2228 /* fall through to ERROR_MARK... */
2230 pp_string (cxx_pp, M_("<expression error>"));
2236 dump_binary_op (const char *opstring, tree t, int flags)
2238 pp_cxx_left_paren (cxx_pp);
2239 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2240 pp_cxx_whitespace (cxx_pp);
2242 pp_cxx_ws_string (cxx_pp, opstring);
2244 pp_string (cxx_pp, M_("<unknown operator>"));
2245 pp_cxx_whitespace (cxx_pp);
2246 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2247 pp_cxx_right_paren (cxx_pp);
2251 dump_unary_op (const char *opstring, tree t, int flags)
2253 if (flags & TFF_EXPR_IN_PARENS)
2254 pp_cxx_left_paren (cxx_pp);
2255 pp_cxx_ws_string (cxx_pp, opstring);
2256 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2257 if (flags & TFF_EXPR_IN_PARENS)
2258 pp_cxx_right_paren (cxx_pp);
2262 reinit_cxx_pp (void)
2264 pp_clear_output_area (cxx_pp);
2265 pp_base (cxx_pp)->padding = pp_none;
2266 pp_indentation (cxx_pp) = 0;
2267 pp_needs_newline (cxx_pp) = false;
2268 cxx_pp->enclosing_scope = current_function_decl;
2272 /* Exported interface to stringifying types, exprs and decls under TFF_*
2276 type_as_string (tree typ, int flags)
2279 pp_translate_identifiers (cxx_pp) = false;
2280 dump_type (typ, flags);
2281 return pp_formatted_text (cxx_pp);
2285 type_as_string_translate (tree typ, int flags)
2288 dump_type (typ, flags);
2289 return pp_formatted_text (cxx_pp);
2293 expr_as_string (tree decl, int flags)
2296 pp_translate_identifiers (cxx_pp) = false;
2297 dump_expr (decl, flags);
2298 return pp_formatted_text (cxx_pp);
2302 decl_as_string (tree decl, int flags)
2305 pp_translate_identifiers (cxx_pp) = false;
2306 dump_decl (decl, flags);
2307 return pp_formatted_text (cxx_pp);
2311 decl_as_string_translate (tree decl, int flags)
2314 dump_decl (decl, flags);
2315 return pp_formatted_text (cxx_pp);
2318 /* Generate the three forms of printable names for cxx_printable_name. */
2321 lang_decl_name (tree decl, int v, bool translate)
2325 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2326 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2329 pp_translate_identifiers (cxx_pp) = translate;
2330 if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2332 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2333 pp_cxx_colon_colon (cxx_pp);
2336 if (TREE_CODE (decl) == FUNCTION_DECL)
2337 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2339 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2341 return pp_formatted_text (cxx_pp);
2344 /* Return the location of a tree passed to %+ formats. */
2347 location_of (tree t)
2349 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2350 t = DECL_CONTEXT (t);
2351 else if (TYPE_P (t))
2352 t = TYPE_MAIN_DECL (t);
2353 else if (TREE_CODE (t) == OVERLOAD)
2354 t = OVL_FUNCTION (t);
2356 return DECL_SOURCE_LOCATION (t);
2359 /* Now the interfaces from error et al to dump_type et al. Each takes an
2360 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2364 decl_to_string (tree decl, int verbose)
2368 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2369 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2370 flags = TFF_CLASS_KEY_OR_ENUM;
2372 flags |= TFF_DECL_SPECIFIERS;
2373 else if (TREE_CODE (decl) == FUNCTION_DECL)
2374 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2375 flags |= TFF_TEMPLATE_HEADER;
2378 dump_decl (decl, flags);
2379 return pp_formatted_text (cxx_pp);
2383 expr_to_string (tree decl)
2386 dump_expr (decl, 0);
2387 return pp_formatted_text (cxx_pp);
2391 fndecl_to_string (tree fndecl, int verbose)
2395 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2396 | TFF_TEMPLATE_HEADER;
2398 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2400 dump_decl (fndecl, flags);
2401 return pp_formatted_text (cxx_pp);
2406 code_to_string (enum tree_code c)
2408 return tree_code_name [c];
2412 language_to_string (enum languages c)
2419 case lang_cplusplus:
2431 /* Return the proper printed version of a parameter to a C++ function. */
2434 parm_to_string (int p)
2438 pp_string (cxx_pp, "'this'");
2440 pp_decimal_int (cxx_pp, p + 1);
2441 return pp_formatted_text (cxx_pp);
2445 op_to_string (enum tree_code p)
2447 tree id = operator_name_info[(int) p].identifier;
2448 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2452 type_to_string (tree typ, int verbose)
2456 flags |= TFF_CLASS_KEY_OR_ENUM;
2457 flags |= TFF_TEMPLATE_HEADER;
2460 dump_type (typ, flags);
2461 return pp_formatted_text (cxx_pp);
2465 assop_to_string (enum tree_code p)
2467 tree id = assignment_operator_name_info[(int) p].identifier;
2468 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2472 args_to_string (tree p, int verbose)
2476 flags |= TFF_CLASS_KEY_OR_ENUM;
2481 if (TYPE_P (TREE_VALUE (p)))
2482 return type_as_string_translate (p, flags);
2485 for (; p; p = TREE_CHAIN (p))
2487 if (TREE_VALUE (p) == null_node)
2488 pp_cxx_ws_string (cxx_pp, "NULL");
2490 dump_type (error_type (TREE_VALUE (p)), flags);
2492 pp_separate_with_comma (cxx_pp);
2494 return pp_formatted_text (cxx_pp);
2498 cv_to_string (tree p, int v)
2501 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2502 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2503 return pp_formatted_text (cxx_pp);
2506 /* Langhook for print_error_function. */
2508 cxx_print_error_function (diagnostic_context *context, const char *file,
2509 diagnostic_info *diagnostic)
2511 lhd_print_error_function (context, file, diagnostic);
2512 pp_base_set_prefix (context->printer, file);
2513 maybe_print_instantiation_context (context);
2517 cp_diagnostic_starter (diagnostic_context *context,
2518 diagnostic_info *diagnostic)
2520 diagnostic_report_current_module (context);
2521 cp_print_error_function (context, diagnostic);
2522 maybe_print_instantiation_context (context);
2523 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2527 cp_diagnostic_finalizer (diagnostic_context *context,
2528 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2530 pp_base_destroy_prefix (context->printer);
2533 /* Print current function onto BUFFER, in the process of reporting
2534 a diagnostic message. Called from cp_diagnostic_starter. */
2536 cp_print_error_function (diagnostic_context *context,
2537 diagnostic_info *diagnostic)
2539 if (diagnostic_last_function_changed (context, diagnostic))
2541 const char *old_prefix = context->printer->prefix;
2542 const char *file = LOCATION_FILE (diagnostic->location);
2543 tree abstract_origin = diagnostic->abstract_origin;
2544 char *new_prefix = (file && abstract_origin == NULL)
2545 ? file_name_as_prefix (file) : NULL;
2547 pp_base_set_prefix (context->printer, new_prefix);
2549 if (current_function_decl == NULL)
2550 pp_base_string (context->printer, _("At global scope:"));
2555 if (abstract_origin)
2557 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2558 while (TREE_CODE (ao) == BLOCK
2559 && BLOCK_ABSTRACT_ORIGIN (ao)
2560 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2561 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2562 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2566 fndecl = current_function_decl;
2568 pp_printf (context->printer, function_category (fndecl),
2569 cxx_printable_name_translate (fndecl, 2));
2571 while (abstract_origin)
2574 tree block = abstract_origin;
2576 locus = &BLOCK_SOURCE_LOCATION (block);
2578 block = BLOCK_SUPERCONTEXT (block);
2579 while (block && TREE_CODE (block) == BLOCK
2580 && BLOCK_ABSTRACT_ORIGIN (block))
2582 ao = BLOCK_ABSTRACT_ORIGIN (block);
2584 while (TREE_CODE (ao) == BLOCK
2585 && BLOCK_ABSTRACT_ORIGIN (ao)
2586 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2587 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2589 if (TREE_CODE (ao) == FUNCTION_DECL)
2594 else if (TREE_CODE (ao) != BLOCK)
2597 block = BLOCK_SUPERCONTEXT (block);
2600 abstract_origin = block;
2603 while (block && TREE_CODE (block) == BLOCK)
2604 block = BLOCK_SUPERCONTEXT (block);
2606 if (TREE_CODE (block) == FUNCTION_DECL)
2608 abstract_origin = NULL;
2612 expanded_location s = expand_location (*locus);
2613 pp_base_character (context->printer, ',');
2614 pp_base_newline (context->printer);
2617 if (flag_show_column && s.column != 0)
2618 pp_printf (context->printer,
2619 _(" inlined from %qs at %s:%d:%d"),
2620 cxx_printable_name_translate (fndecl, 2),
2621 s.file, s.line, s.column);
2623 pp_printf (context->printer,
2624 _(" inlined from %qs at %s:%d"),
2625 cxx_printable_name_translate (fndecl, 2),
2630 pp_printf (context->printer, _(" inlined from %qs"),
2631 cxx_printable_name_translate (fndecl, 2));
2634 pp_base_character (context->printer, ':');
2636 pp_base_newline (context->printer);
2638 diagnostic_set_last_function (context, diagnostic);
2639 pp_base_destroy_prefix (context->printer);
2640 context->printer->prefix = old_prefix;
2644 /* Returns a description of FUNCTION using standard terminology. The
2645 result is a format string of the form "In CATEGORY %qs". */
2647 function_category (tree fn)
2649 if (DECL_FUNCTION_MEMBER_P (fn))
2651 if (DECL_STATIC_FUNCTION_P (fn))
2652 return _("In static member function %qs");
2653 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2654 return _("In copy constructor %qs");
2655 else if (DECL_CONSTRUCTOR_P (fn))
2656 return _("In constructor %qs");
2657 else if (DECL_DESTRUCTOR_P (fn))
2658 return _("In destructor %qs");
2660 return _("In member function %qs");
2663 return _("In function %qs");
2666 /* Report the full context of a current template instantiation,
2669 print_instantiation_full_context (diagnostic_context *context)
2671 struct tinst_level *p = current_instantiation ();
2672 location_t location = input_location;
2676 if (current_function_decl != p->decl
2677 && current_function_decl != NULL_TREE)
2678 /* We can get here during the processing of some synthesized
2679 method. Then, P->DECL will be the function that's causing
2684 if (current_function_decl == p->decl)
2685 /* Avoid redundancy with the "In function" line. */;
2687 pp_verbatim (context->printer,
2688 _("%s: In instantiation of %qs:\n"),
2689 LOCATION_FILE (location),
2690 decl_as_string_translate (p->decl,
2691 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2693 location = p->locus;
2698 print_instantiation_partial_context (context, p, location);
2701 /* Same as above but less verbose. */
2703 print_instantiation_partial_context (diagnostic_context *context,
2704 struct tinst_level *t, location_t loc)
2706 expanded_location xloc;
2708 for (; ; t = t->next)
2710 xloc = expand_location (loc);
2713 str = decl_as_string_translate (t->decl,
2714 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE);
2715 if (flag_show_column)
2716 pp_verbatim (context->printer,
2717 _("%s:%d:%d: instantiated from %qs\n"),
2718 xloc.file, xloc.line, xloc.column, str);
2720 pp_verbatim (context->printer,
2721 _("%s:%d: instantiated from %qs\n"),
2722 xloc.file, xloc.line, str);
2725 if (flag_show_column)
2726 pp_verbatim (context->printer, _("%s:%d:%d: instantiated from here"),
2727 xloc.file, xloc.line, xloc.column);
2729 pp_verbatim (context->printer, _("%s:%d: instantiated from here"),
2730 xloc.file, xloc.line);
2731 pp_base_newline (context->printer);
2734 /* Called from cp_thing to print the template context for an error. */
2736 maybe_print_instantiation_context (diagnostic_context *context)
2738 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2741 record_last_problematic_instantiation ();
2742 print_instantiation_full_context (context);
2745 /* Report the bare minimum context of a template instantiation. */
2747 print_instantiation_context (void)
2749 print_instantiation_partial_context
2750 (global_dc, current_instantiation (), input_location);
2751 diagnostic_flush_buffer (global_dc);
2754 /* Called from output_format -- during diagnostic message processing --
2755 to handle C++ specific format specifier with the following meanings:
2756 %A function argument-list.
2760 %F function declaration.
2761 %L language as used in extern "lang".
2763 %P function parameter whose position is indicated by an integer.
2764 %Q assignment operator.
2768 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2769 int precision, bool wide, bool set_locus, bool verbose)
2773 #define next_tree (t = va_arg (*text->args_ptr, tree))
2774 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
2775 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
2776 #define next_int va_arg (*text->args_ptr, int)
2778 if (precision != 0 || wide)
2781 if (text->locus == NULL)
2786 case 'A': result = args_to_string (next_tree, verbose); break;
2787 case 'C': result = code_to_string (next_tcode); break;
2790 tree temp = next_tree;
2792 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2794 temp = DECL_DEBUG_EXPR (temp);
2797 result = expr_to_string (temp);
2801 result = decl_to_string (temp, verbose);
2804 case 'E': result = expr_to_string (next_tree); break;
2805 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2806 case 'L': result = language_to_string (next_lang); break;
2807 case 'O': result = op_to_string (next_tcode); break;
2808 case 'P': result = parm_to_string (next_int); break;
2809 case 'Q': result = assop_to_string (next_tcode); break;
2810 case 'T': result = type_to_string (next_tree, verbose); break;
2811 case 'V': result = cv_to_string (next_tree, verbose); break;
2817 pp_base_string (pp, result);
2818 if (set_locus && t != NULL)
2819 *text->locus = location_of (t);
2827 /* Warn about the use of C++0x features when appropriate. */
2829 maybe_warn_cpp0x (const char* str)
2831 if ((cxx_dialect == cxx98) && !in_system_header)
2832 /* We really want to suppress this warning in system headers,
2833 because libstdc++ uses variadic templates even when we aren't
2835 pedwarn (input_location, 0, "%s only available with -std=c++0x or -std=gnu++0x", str);
2838 /* Warn about the use of variadic templates when appropriate. */
2840 maybe_warn_variadic_templates (void)
2842 maybe_warn_cpp0x ("variadic templates");
2846 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
2847 option OPT with text GMSGID. Use this function to report
2848 diagnostics for constructs that are invalid C++98, but valid
2851 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
2853 diagnostic_info diagnostic;
2856 va_start (ap, gmsgid);
2857 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
2858 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
2859 diagnostic.option_index = opt;
2861 return report_diagnostic (&diagnostic);