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, int);
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, int flags)
168 tree inner_args = INNERMOST_TEMPLATE_ARGS (args);
169 int n = TREE_VEC_LENGTH (inner_args);
172 if (params == NULL_TREE
173 /* We use this flag when generating debug information. We don't
174 want to expand templates at this point, for this may generate
175 new decls, which gets decl counts out of sync, which may in
176 turn cause codegen differences between compilations with and
178 || (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
179 || !flag_pretty_templates)
182 for (last = n - 1; last >= 0; --last)
184 tree param = TREE_VEC_ELT (params, last);
185 tree def = TREE_PURPOSE (param);
189 if (uses_template_parms (def))
191 ++processing_template_decl;
192 /* This speculative substitution must not cause any classes to be
193 instantiated that otherwise wouldn't be. */
194 def = tsubst_copy_and_build (def, args, tf_no_class_instantiations,
195 NULL_TREE, false, true);
196 --processing_template_decl;
198 if (!cp_tree_equal (TREE_VEC_ELT (inner_args, last), def))
205 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
209 dump_template_argument_list (tree args, tree parms, int flags)
211 int n = count_non_default_template_args (args, parms, flags);
215 for (i = 0; i < n; ++i)
217 tree arg = TREE_VEC_ELT (args, i);
219 /* Only print a comma if we know there is an argument coming. In
220 the case of an empty template argument pack, no actual
221 argument will be printed. */
223 && (!ARGUMENT_PACK_P (arg)
224 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
225 pp_separate_with_comma (cxx_pp);
227 dump_template_argument (arg, flags);
232 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
235 dump_template_parameter (tree parm, int flags)
240 if (parm == error_mark_node)
243 p = TREE_VALUE (parm);
244 a = TREE_PURPOSE (parm);
246 if (TREE_CODE (p) == TYPE_DECL)
248 if (flags & TFF_DECL_SPECIFIERS)
250 pp_cxx_ws_string (cxx_pp, "class");
251 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
252 pp_cxx_ws_string (cxx_pp, "...");
254 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
256 else if (DECL_NAME (p))
257 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
259 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
262 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
264 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
266 pp_cxx_whitespace (cxx_pp);
268 pp_cxx_whitespace (cxx_pp);
269 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
270 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
272 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
276 /* Dump, under control of FLAGS, a template-parameter-list binding.
277 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
281 dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames)
289 tree p = TREE_VALUE (parms);
290 int lvl = TMPL_PARMS_DEPTH (parms);
293 tree lvl_args = NULL_TREE;
295 /* Don't crash if we had an invalid argument list. */
296 if (TMPL_ARGS_DEPTH (args) >= lvl)
297 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
299 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
301 tree arg = NULL_TREE;
303 /* Don't crash if we had an invalid argument list. */
304 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
305 arg = TREE_VEC_ELT (lvl_args, arg_idx);
308 pp_separate_with_comma (cxx_pp);
309 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
310 pp_cxx_whitespace (cxx_pp);
312 pp_cxx_whitespace (cxx_pp);
315 if (ARGUMENT_PACK_P (arg))
316 pp_cxx_left_brace (cxx_pp);
317 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
318 if (ARGUMENT_PACK_P (arg))
319 pp_cxx_right_brace (cxx_pp);
322 pp_string (cxx_pp, M_("<missing>"));
328 parms = TREE_CHAIN (parms);
331 for (i = 0; VEC_iterate (tree, typenames, i, t); ++i)
334 pp_separate_with_comma (cxx_pp);
335 dump_type (t, TFF_PLAIN_IDENTIFIER);
336 pp_cxx_whitespace (cxx_pp);
338 pp_cxx_whitespace (cxx_pp);
339 t = tsubst (t, args, tf_none, NULL_TREE);
340 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
341 pp_simple_type_specifier doesn't know about it. */
342 t = strip_typedefs (t);
343 dump_type (t, TFF_PLAIN_IDENTIFIER);
347 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
351 dump_type (tree t, int flags)
356 if (TYPE_PTRMEMFUNC_P (t))
359 switch (TREE_CODE (t))
362 if (t == init_list_type_node)
363 pp_string (cxx_pp, M_("<brace-enclosed initializer list>"));
365 pp_string (cxx_pp, M_("<unresolved overloaded function type>"));
369 /* A list of function parms. */
370 dump_parameters (t, flags);
373 case IDENTIFIER_NODE:
374 pp_cxx_tree_identifier (cxx_pp, t);
378 dump_type (BINFO_TYPE (t), flags);
384 dump_aggr_type (t, flags);
388 if (flags & TFF_CHASE_TYPEDEF)
390 dump_type (DECL_ORIGINAL_TYPE (t)
391 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
394 /* Else fall through. */
398 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
407 case FIXED_POINT_TYPE:
408 pp_type_specifier_seq (cxx_pp, t);
411 case TEMPLATE_TEMPLATE_PARM:
412 /* For parameters inside template signature. */
413 if (TYPE_IDENTIFIER (t))
414 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
416 pp_cxx_canonical_template_parameter (cxx_pp, t);
419 case BOUND_TEMPLATE_TEMPLATE_PARM:
421 tree args = TYPE_TI_ARGS (t);
422 pp_cxx_cv_qualifier_seq (cxx_pp, t);
423 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
424 pp_cxx_begin_template_argument_list (cxx_pp);
425 dump_template_argument_list (args, NULL_TREE, flags);
426 pp_cxx_end_template_argument_list (cxx_pp);
430 case TEMPLATE_TYPE_PARM:
431 pp_cxx_cv_qualifier_seq (cxx_pp, t);
432 if (TYPE_IDENTIFIER (t))
433 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
435 pp_cxx_canonical_template_parameter
436 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
439 /* This is not always necessary for pointers and such, but doing this
440 reduces code size. */
449 dump_type_prefix (t, flags);
450 dump_type_suffix (t, flags);
454 if (! (flags & TFF_CHASE_TYPEDEF)
455 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
457 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
460 pp_cxx_cv_qualifier_seq (cxx_pp, t);
461 pp_cxx_ws_string (cxx_pp,
462 TYPENAME_IS_ENUM_P (t) ? "enum"
463 : TYPENAME_IS_CLASS_P (t) ? "class"
465 dump_typename (t, flags);
468 case UNBOUND_CLASS_TEMPLATE:
469 if (! (flags & TFF_UNQUALIFIED_NAME))
471 dump_type (TYPE_CONTEXT (t), flags);
472 pp_cxx_colon_colon (cxx_pp);
474 pp_cxx_ws_string (cxx_pp, "template");
475 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
479 pp_cxx_ws_string (cxx_pp, "__typeof__");
480 pp_cxx_whitespace (cxx_pp);
481 pp_cxx_left_paren (cxx_pp);
482 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
483 pp_cxx_right_paren (cxx_pp);
486 case TYPE_PACK_EXPANSION:
487 dump_type (PACK_EXPANSION_PATTERN (t), flags);
488 pp_cxx_ws_string (cxx_pp, "...");
491 case TYPE_ARGUMENT_PACK:
492 dump_template_argument (t, flags);
496 pp_cxx_ws_string (cxx_pp, "decltype");
497 pp_cxx_whitespace (cxx_pp);
498 pp_cxx_left_paren (cxx_pp);
499 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
500 pp_cxx_right_paren (cxx_pp);
504 pp_unsupported_tree (cxx_pp, t);
505 /* Fall through to error. */
508 pp_string (cxx_pp, M_("<type error>"));
513 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
517 dump_typename (tree t, int flags)
519 tree ctx = TYPE_CONTEXT (t);
521 if (TREE_CODE (ctx) == TYPENAME_TYPE)
522 dump_typename (ctx, flags);
524 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
525 pp_cxx_colon_colon (cxx_pp);
526 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
529 /* Return the name of the supplied aggregate, or enumeral type. */
532 class_key_or_enum_as_string (tree t)
534 if (TREE_CODE (t) == ENUMERAL_TYPE)
536 if (SCOPED_ENUM_P (t))
541 else if (TREE_CODE (t) == UNION_TYPE)
543 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
549 /* Print out a class declaration T under the control of FLAGS,
550 in the form `class foo'. */
553 dump_aggr_type (tree t, int flags)
556 const char *variety = class_key_or_enum_as_string (t);
560 pp_cxx_cv_qualifier_seq (cxx_pp, t);
562 if (flags & TFF_CLASS_KEY_OR_ENUM)
563 pp_cxx_ws_string (cxx_pp, variety);
565 name = TYPE_NAME (t);
569 typdef = !DECL_ARTIFICIAL (name);
572 && ((flags & TFF_CHASE_TYPEDEF)
573 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
574 && DECL_TEMPLATE_INFO (name))))
576 t = TYPE_MAIN_VARIANT (t);
577 name = TYPE_NAME (t);
581 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
582 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
583 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
584 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
586 if (! (flags & TFF_UNQUALIFIED_NAME))
587 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
588 flags &= ~TFF_UNQUALIFIED_NAME;
591 /* Because the template names are mangled, we have to locate
592 the most general template, and use that name. */
593 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
595 while (DECL_TEMPLATE_INFO (tpl))
596 tpl = DECL_TI_TEMPLATE (tpl);
599 name = DECL_NAME (name);
602 if (name == 0 || ANON_AGGRNAME_P (name))
604 if (flags & TFF_CLASS_KEY_OR_ENUM)
605 pp_string (cxx_pp, M_("<anonymous>"));
607 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety);
609 else if (LAMBDANAME_P (name))
611 /* A lambda's "type" is essentially its signature. */
612 pp_string (cxx_pp, M_("<lambda"));
613 if (lambda_function (t))
614 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
616 pp_character(cxx_pp, '>');
619 pp_cxx_tree_identifier (cxx_pp, name);
621 dump_template_parms (TYPE_TEMPLATE_INFO (t),
622 !CLASSTYPE_USE_TEMPLATE (t),
623 flags & ~TFF_TEMPLATE_HEADER);
626 /* Dump into the obstack the initial part of the output for a given type.
627 This is necessary when dealing with things like functions returning
630 return type of `int (* fee ())()': pointer -> function -> int. Both
631 pointer (and reference and offset) and function (and member) types must
632 deal with prefix and suffix.
634 Arrays must also do this for DECL nodes, like int a[], and for things like
638 dump_type_prefix (tree t, int flags)
640 if (TYPE_PTRMEMFUNC_P (t))
642 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
646 switch (TREE_CODE (t))
651 tree sub = TREE_TYPE (t);
653 dump_type_prefix (sub, flags);
654 if (TREE_CODE (sub) == ARRAY_TYPE
655 || TREE_CODE (sub) == FUNCTION_TYPE)
657 pp_cxx_whitespace (cxx_pp);
658 pp_cxx_left_paren (cxx_pp);
660 if (TREE_CODE (t) == POINTER_TYPE)
661 pp_character(cxx_pp, '*');
662 else if (TREE_CODE (t) == REFERENCE_TYPE)
664 if (TYPE_REF_IS_RVALUE (t))
665 pp_string (cxx_pp, "&&");
667 pp_character (cxx_pp, '&');
669 pp_base (cxx_pp)->padding = pp_before;
670 pp_cxx_cv_qualifier_seq (cxx_pp, t);
676 dump_type_prefix (TREE_TYPE (t), flags);
677 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
679 pp_maybe_space (cxx_pp);
680 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
681 pp_cxx_left_paren (cxx_pp);
682 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
683 pp_cxx_colon_colon (cxx_pp);
685 pp_cxx_star (cxx_pp);
686 pp_cxx_cv_qualifier_seq (cxx_pp, t);
687 pp_base (cxx_pp)->padding = pp_before;
690 /* This can be reached without a pointer when dealing with
691 templates, e.g. std::is_function. */
693 dump_type_prefix (TREE_TYPE (t), flags);
697 dump_type_prefix (TREE_TYPE (t), flags);
698 pp_maybe_space (cxx_pp);
699 pp_cxx_left_paren (cxx_pp);
700 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
701 pp_cxx_colon_colon (cxx_pp);
705 dump_type_prefix (TREE_TYPE (t), flags);
709 case IDENTIFIER_NODE:
714 case TEMPLATE_TYPE_PARM:
715 case TEMPLATE_TEMPLATE_PARM:
716 case BOUND_TEMPLATE_TEMPLATE_PARM:
728 case TYPE_PACK_EXPANSION:
729 case FIXED_POINT_TYPE:
730 dump_type (t, flags);
731 pp_base (cxx_pp)->padding = pp_before;
735 pp_unsupported_tree (cxx_pp, t);
738 pp_string (cxx_pp, M_("<typeprefixerror>"));
743 /* Dump the suffix of type T, under control of FLAGS. This is the part
744 which appears after the identifier (or function parms). */
747 dump_type_suffix (tree t, int flags)
749 if (TYPE_PTRMEMFUNC_P (t))
750 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
752 switch (TREE_CODE (t))
757 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
758 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
759 pp_cxx_right_paren (cxx_pp);
760 dump_type_suffix (TREE_TYPE (t), flags);
767 if (TREE_CODE (t) == METHOD_TYPE)
768 /* Can only be reached through a pointer. */
769 pp_cxx_right_paren (cxx_pp);
770 arg = TYPE_ARG_TYPES (t);
771 if (TREE_CODE (t) == METHOD_TYPE)
772 arg = TREE_CHAIN (arg);
774 /* Function pointers don't have default args. Not in standard C++,
775 anyway; they may in g++, but we'll just pretend otherwise. */
776 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
778 if (TREE_CODE (t) == METHOD_TYPE)
779 pp_cxx_cv_qualifier_seq
780 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
782 pp_cxx_cv_qualifier_seq (cxx_pp, t);
783 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
784 dump_type_suffix (TREE_TYPE (t), flags);
789 pp_maybe_space (cxx_pp);
790 pp_cxx_left_bracket (cxx_pp);
793 tree dtype = TYPE_DOMAIN (t);
794 tree max = TYPE_MAX_VALUE (dtype);
795 if (host_integerp (max, 0))
796 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
797 else if (TREE_CODE (max) == MINUS_EXPR)
798 dump_expr (TREE_OPERAND (max, 0),
799 flags & ~TFF_EXPR_IN_PARENS);
801 dump_expr (fold_build2_loc (input_location,
802 PLUS_EXPR, dtype, max,
803 build_int_cst (dtype, 1)),
804 flags & ~TFF_EXPR_IN_PARENS);
806 pp_cxx_right_bracket (cxx_pp);
807 dump_type_suffix (TREE_TYPE (t), flags);
811 case IDENTIFIER_NODE:
816 case TEMPLATE_TYPE_PARM:
817 case TEMPLATE_TEMPLATE_PARM:
818 case BOUND_TEMPLATE_TEMPLATE_PARM:
830 case TYPE_PACK_EXPANSION:
831 case FIXED_POINT_TYPE:
835 pp_unsupported_tree (cxx_pp, t);
837 /* Don't mark it here, we should have already done in
844 dump_global_iord (tree t)
846 const char *p = NULL;
848 if (DECL_GLOBAL_CTOR_P (t))
849 p = M_("(static initializers for %s)");
850 else if (DECL_GLOBAL_DTOR_P (t))
851 p = M_("(static destructors for %s)");
855 pp_printf (pp_base (cxx_pp), p, input_filename);
859 dump_simple_decl (tree t, tree type, int flags)
861 if (flags & TFF_DECL_SPECIFIERS)
863 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
864 pp_maybe_space (cxx_pp);
866 if (! (flags & TFF_UNQUALIFIED_NAME)
867 && (!DECL_INITIAL (t)
868 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
869 dump_scope (CP_DECL_CONTEXT (t), flags);
870 flags &= ~TFF_UNQUALIFIED_NAME;
871 if ((flags & TFF_DECL_SPECIFIERS)
872 && DECL_TEMPLATE_PARM_P (t)
873 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
874 pp_string (cxx_pp, "...");
876 dump_decl (DECL_NAME (t), flags);
878 pp_string (cxx_pp, M_("<anonymous>"));
879 if (flags & TFF_DECL_SPECIFIERS)
880 dump_type_suffix (type, flags);
883 /* Dump a human readable string for the decl T under control of FLAGS. */
886 dump_decl (tree t, int flags)
891 switch (TREE_CODE (t))
894 /* Don't say 'typedef class A' */
895 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
897 if ((flags & TFF_DECL_SPECIFIERS)
898 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
900 /* Say `class T' not just `T'. */
901 pp_cxx_ws_string (cxx_pp, "class");
903 /* Emit the `...' for a parameter pack. */
904 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
905 pp_cxx_ws_string (cxx_pp, "...");
908 dump_type (TREE_TYPE (t), flags);
911 if ((flags & TFF_DECL_SPECIFIERS)
912 && !DECL_SELF_REFERENCE_P (t))
913 pp_cxx_ws_string (cxx_pp, "typedef");
914 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
915 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
920 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
922 pp_string (cxx_pp, M_("vtable for "));
923 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
924 dump_type (DECL_CONTEXT (t), flags);
927 /* Else fall through. */
930 dump_simple_decl (t, TREE_TYPE (t), flags);
934 pp_string (cxx_pp, M_("<return value> "));
935 dump_simple_decl (t, TREE_TYPE (t), flags);
939 if (flags & TFF_DECL_SPECIFIERS)
940 pp_cxx_declaration (cxx_pp, t);
943 if (! (flags & TFF_UNQUALIFIED_NAME))
944 dump_scope (CP_DECL_CONTEXT (t), flags);
945 flags &= ~TFF_UNQUALIFIED_NAME;
946 if (DECL_NAME (t) == NULL_TREE)
947 pp_string (cxx_pp, M_("<unnamed>"));
949 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
954 dump_type (TREE_OPERAND (t, 0), flags);
955 pp_string (cxx_pp, "::");
956 dump_decl (TREE_OPERAND (t, 1), flags|TFF_UNQUALIFIED_NAME);
960 dump_decl (TREE_OPERAND (t, 0), flags);
961 pp_cxx_left_bracket (cxx_pp);
962 dump_decl (TREE_OPERAND (t, 1), flags);
963 pp_cxx_right_bracket (cxx_pp);
966 /* So that we can do dump_decl on an aggr type. */
970 dump_type (t, flags);
974 /* This is a pseudo destructor call which has not been folded into
975 a PSEUDO_DTOR_EXPR yet. */
976 pp_cxx_complement (cxx_pp);
977 dump_type (TREE_OPERAND (t, 0), flags);
984 /* These special cases are duplicated here so that other functions
985 can feed identifiers to error and get them demangled properly. */
986 case IDENTIFIER_NODE:
987 if (IDENTIFIER_TYPENAME_P (t))
989 pp_cxx_ws_string (cxx_pp, "operator");
990 /* Not exactly IDENTIFIER_TYPE_VALUE. */
991 dump_type (TREE_TYPE (t), flags);
995 pp_cxx_tree_identifier (cxx_pp, t);
1001 t = OVL_CURRENT (t);
1002 if (DECL_CLASS_SCOPE_P (t))
1004 dump_type (DECL_CONTEXT (t), flags);
1005 pp_cxx_colon_colon (cxx_pp);
1007 else if (DECL_CONTEXT (t))
1009 dump_decl (DECL_CONTEXT (t), flags);
1010 pp_cxx_colon_colon (cxx_pp);
1012 dump_decl (DECL_NAME (t), flags);
1016 /* If there's only one function, just treat it like an ordinary
1018 t = OVL_CURRENT (t);
1022 if (! DECL_LANG_SPECIFIC (t))
1023 pp_string (cxx_pp, M_("<built-in>"));
1024 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1025 dump_global_iord (t);
1027 dump_function_decl (t, flags);
1031 dump_template_decl (t, flags);
1034 case TEMPLATE_ID_EXPR:
1036 tree name = TREE_OPERAND (t, 0);
1038 if (is_overloaded_fn (name))
1039 name = DECL_NAME (get_first_fn (name));
1040 dump_decl (name, flags);
1041 pp_cxx_begin_template_argument_list (cxx_pp);
1042 if (TREE_OPERAND (t, 1))
1043 dump_template_argument_list (TREE_OPERAND (t, 1), NULL_TREE, flags);
1044 pp_cxx_end_template_argument_list (cxx_pp);
1049 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1053 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1054 || (DECL_INITIAL (t) &&
1055 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1056 dump_simple_decl (t, TREE_TYPE (t), flags);
1057 else if (DECL_NAME (t))
1058 dump_decl (DECL_NAME (t), flags);
1059 else if (DECL_INITIAL (t))
1060 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1062 pp_string (cxx_pp, M_("<enumerator>"));
1066 pp_cxx_ws_string (cxx_pp, "using");
1067 dump_type (USING_DECL_SCOPE (t), flags);
1068 pp_cxx_colon_colon (cxx_pp);
1069 dump_decl (DECL_NAME (t), flags);
1073 pp_cxx_declaration (cxx_pp, t);
1077 dump_decl (BASELINK_FUNCTIONS (t), flags);
1080 case NON_DEPENDENT_EXPR:
1081 dump_expr (t, flags);
1084 case TEMPLATE_TYPE_PARM:
1085 if (flags & TFF_DECL_SPECIFIERS)
1086 pp_cxx_declaration (cxx_pp, t);
1088 pp_type_id (cxx_pp, t);
1091 case UNBOUND_CLASS_TEMPLATE:
1092 case TYPE_PACK_EXPANSION:
1094 dump_type (t, flags);
1098 pp_unsupported_tree (cxx_pp, t);
1099 /* Fall through to error. */
1102 pp_string (cxx_pp, M_("<declaration error>"));
1107 /* Dump a template declaration T under control of FLAGS. This means the
1108 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1111 dump_template_decl (tree t, int flags)
1113 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1117 if (flags & TFF_TEMPLATE_HEADER)
1119 for (parms = orig_parms = nreverse (orig_parms);
1121 parms = TREE_CHAIN (parms))
1123 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1124 int len = TREE_VEC_LENGTH (inner_parms);
1126 pp_cxx_ws_string (cxx_pp, "template");
1127 pp_cxx_begin_template_argument_list (cxx_pp);
1129 /* If we've shown the template prefix, we'd better show the
1130 parameters' and decl's type too. */
1131 flags |= TFF_DECL_SPECIFIERS;
1133 for (i = 0; i < len; i++)
1136 pp_separate_with_comma (cxx_pp);
1137 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1139 pp_cxx_end_template_argument_list (cxx_pp);
1140 pp_cxx_whitespace (cxx_pp);
1142 nreverse(orig_parms);
1144 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1146 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1147 pp_cxx_ws_string (cxx_pp, "class");
1149 /* If this is a parameter pack, print the ellipsis. */
1150 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1151 pp_cxx_ws_string (cxx_pp, "...");
1155 if (DECL_TEMPLATE_RESULT (t)
1156 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1157 dump_type (TREE_TYPE (t),
1158 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1159 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1160 else if (DECL_TEMPLATE_RESULT (t)
1161 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1162 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1165 gcc_assert (TREE_TYPE (t));
1166 switch (NEXT_CODE (t))
1170 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1173 /* This case can occur with some invalid code. */
1174 dump_type (TREE_TYPE (t),
1175 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1176 | (flags & TFF_DECL_SPECIFIERS
1177 ? TFF_CLASS_KEY_OR_ENUM : 0));
1182 /* find_typenames looks through the type of the function template T
1183 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1186 struct find_typenames_t
1188 struct pointer_set_t *p_set;
1189 VEC (tree,gc) *typenames;
1193 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1195 struct find_typenames_t *d = (struct find_typenames_t *)data;
1196 tree mv = NULL_TREE;
1198 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1199 /* Add the type of the typedef without any additional cv-quals. */
1200 mv = TREE_TYPE (TYPE_NAME (*tp));
1201 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1202 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1203 /* Add the typename without any cv-qualifiers. */
1204 mv = TYPE_MAIN_VARIANT (*tp);
1206 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1207 VEC_safe_push (tree, gc, d->typenames, mv);
1209 /* Search into class template arguments, which cp_walk_subtrees
1211 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1212 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1218 static VEC(tree,gc) *
1219 find_typenames (tree t)
1221 struct find_typenames_t ft;
1222 ft.p_set = pointer_set_create ();
1223 ft.typenames = NULL;
1224 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1225 find_typenames_r, &ft, ft.p_set);
1226 pointer_set_destroy (ft.p_set);
1227 return ft.typenames;
1230 /* Pretty print a function decl. There are several ways we want to print a
1231 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1232 As error can only apply the '#' flag once to give 0 and 1 for V, there
1233 is %D which doesn't print the throw specs, and %F which does. */
1236 dump_function_decl (tree t, int flags)
1240 tree cname = NULL_TREE;
1241 tree template_args = NULL_TREE;
1242 tree template_parms = NULL_TREE;
1243 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1244 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1246 VEC(tree,gc) *typenames = NULL;
1248 if (LAMBDA_FUNCTION_P (t))
1250 /* A lambda's signature is essentially its "type", so defer. */
1251 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t)));
1252 dump_type (DECL_CONTEXT (t), flags);
1256 flags &= ~TFF_UNQUALIFIED_NAME;
1257 if (TREE_CODE (t) == TEMPLATE_DECL)
1258 t = DECL_TEMPLATE_RESULT (t);
1260 /* Save the exceptions, in case t is a specialization and we are
1261 emitting an error about incompatible specifications. */
1262 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1264 /* Pretty print template instantiations only. */
1265 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1266 && flag_pretty_templates)
1270 template_args = DECL_TI_ARGS (t);
1271 tmpl = most_general_template (t);
1272 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1274 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1276 typenames = find_typenames (t);
1280 fntype = TREE_TYPE (t);
1281 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1283 if (DECL_CLASS_SCOPE_P (t))
1284 cname = DECL_CONTEXT (t);
1285 /* This is for partially instantiated template methods. */
1286 else if (TREE_CODE (fntype) == METHOD_TYPE)
1287 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1289 if (!(flags & TFF_DECL_SPECIFIERS))
1291 else if (DECL_STATIC_FUNCTION_P (t))
1292 pp_cxx_ws_string (cxx_pp, "static");
1293 else if (DECL_VIRTUAL_P (t))
1294 pp_cxx_ws_string (cxx_pp, "virtual");
1296 /* Print the return type? */
1298 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1299 && !DECL_DESTRUCTOR_P (t);
1301 dump_type_prefix (TREE_TYPE (fntype), flags);
1303 /* Print the function name. */
1304 if (!do_outer_scope)
1308 dump_type (cname, flags);
1309 pp_cxx_colon_colon (cxx_pp);
1312 dump_scope (CP_DECL_CONTEXT (t), flags);
1314 dump_function_name (t, flags);
1316 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1318 dump_parameters (parmtypes, flags);
1320 if (TREE_CODE (fntype) == METHOD_TYPE)
1322 pp_base (cxx_pp)->padding = pp_before;
1323 pp_cxx_cv_qualifier_seq
1324 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1327 if (flags & TFF_EXCEPTION_SPECIFICATION)
1329 pp_base (cxx_pp)->padding = pp_before;
1330 dump_exception_spec (exceptions, flags);
1334 dump_type_suffix (TREE_TYPE (fntype), flags);
1337 /* If T is a template instantiation, dump the parameter binding. */
1338 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1340 pp_cxx_whitespace (cxx_pp);
1341 pp_cxx_left_bracket (cxx_pp);
1342 pp_cxx_ws_string (cxx_pp, M_("with"));
1343 pp_cxx_whitespace (cxx_pp);
1344 dump_template_bindings (template_parms, template_args, typenames);
1345 pp_cxx_right_bracket (cxx_pp);
1349 /* Print a parameter list. If this is for a member function, the
1350 member object ptr (and any other hidden args) should have
1351 already been removed. */
1354 dump_parameters (tree parmtypes, int flags)
1357 pp_cxx_left_paren (cxx_pp);
1359 for (first = 1; parmtypes != void_list_node;
1360 parmtypes = TREE_CHAIN (parmtypes))
1363 pp_separate_with_comma (cxx_pp);
1367 pp_cxx_ws_string (cxx_pp, "...");
1371 dump_type (TREE_VALUE (parmtypes), flags);
1373 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1375 pp_cxx_whitespace (cxx_pp);
1377 pp_cxx_whitespace (cxx_pp);
1378 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1382 pp_cxx_right_paren (cxx_pp);
1385 /* Print an exception specification. T is the exception specification. */
1388 dump_exception_spec (tree t, int flags)
1392 pp_cxx_ws_string (cxx_pp, "throw");
1393 pp_cxx_whitespace (cxx_pp);
1394 pp_cxx_left_paren (cxx_pp);
1395 if (TREE_VALUE (t) != NULL_TREE)
1398 dump_type (TREE_VALUE (t), flags);
1402 pp_separate_with_comma (cxx_pp);
1404 pp_cxx_right_paren (cxx_pp);
1408 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1409 and destructors properly. */
1412 dump_function_name (tree t, int flags)
1414 tree name = DECL_NAME (t);
1416 /* We can get here with a decl that was synthesized by language-
1417 independent machinery (e.g. coverage.c) in which case it won't
1418 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1419 will crash. In this case it is safe just to print out the
1421 if (!DECL_LANG_SPECIFIC (t))
1423 pp_cxx_tree_identifier (cxx_pp, name);
1427 if (TREE_CODE (t) == TEMPLATE_DECL)
1428 t = DECL_TEMPLATE_RESULT (t);
1430 /* Don't let the user see __comp_ctor et al. */
1431 if (DECL_CONSTRUCTOR_P (t)
1432 || DECL_DESTRUCTOR_P (t))
1434 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1435 name = get_identifier ("<lambda>");
1437 name = constructor_name (DECL_CONTEXT (t));
1440 if (DECL_DESTRUCTOR_P (t))
1442 pp_cxx_complement (cxx_pp);
1443 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1445 else if (DECL_CONV_FN_P (t))
1447 /* This cannot use the hack that the operator's return
1448 type is stashed off of its name because it may be
1449 used for error reporting. In the case of conflicting
1450 declarations, both will have the same name, yet
1451 the types will be different, hence the TREE_TYPE field
1452 of the first name will be clobbered by the second. */
1453 pp_cxx_ws_string (cxx_pp, "operator");
1454 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1456 else if (name && IDENTIFIER_OPNAME_P (name))
1457 pp_cxx_tree_identifier (cxx_pp, name);
1459 dump_decl (name, flags);
1461 if (DECL_TEMPLATE_INFO (t)
1462 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1463 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1464 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1465 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1468 /* Dump the template parameters from the template info INFO under control of
1469 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1470 specialization (partial or complete). For partial specializations we show
1471 the specialized parameter values. For a primary template we show no
1475 dump_template_parms (tree info, int primary, int flags)
1477 tree args = info ? TI_ARGS (info) : NULL_TREE;
1479 if (primary && flags & TFF_TEMPLATE_NAME)
1481 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1482 pp_cxx_begin_template_argument_list (cxx_pp);
1484 /* Be careful only to print things when we have them, so as not
1485 to crash producing error messages. */
1486 if (args && !primary)
1489 /* We don't know the parms for a friend template specialization. */
1490 tree params = (TREE_CODE (TI_TEMPLATE (info)) == TEMPLATE_DECL
1491 ? DECL_INNERMOST_TEMPLATE_PARMS (TI_TEMPLATE (info))
1494 len = count_non_default_template_args (args, params, flags);
1496 args = INNERMOST_TEMPLATE_ARGS (args);
1497 for (ix = 0; ix != len; ix++)
1499 tree arg = TREE_VEC_ELT (args, ix);
1501 /* Only print a comma if we know there is an argument coming. In
1502 the case of an empty template argument pack, no actual
1503 argument will be printed. */
1505 && (!ARGUMENT_PACK_P (arg)
1506 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1507 pp_separate_with_comma (cxx_pp);
1510 pp_string (cxx_pp, M_("<template parameter error>"));
1512 dump_template_argument (arg, flags);
1517 tree tpl = TI_TEMPLATE (info);
1518 tree parms = DECL_TEMPLATE_PARMS (tpl);
1521 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1522 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1524 for (ix = 0; ix != len; ix++)
1528 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1530 pp_string (cxx_pp, M_("<template parameter error>"));
1534 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1537 pp_separate_with_comma (cxx_pp);
1539 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1542 pp_cxx_end_template_argument_list (cxx_pp);
1545 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1546 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1549 dump_call_expr_args (tree t, int flags, bool skipfirst)
1552 call_expr_arg_iterator iter;
1554 pp_cxx_left_paren (cxx_pp);
1555 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1561 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1562 if (more_call_expr_args_p (&iter))
1563 pp_separate_with_comma (cxx_pp);
1566 pp_cxx_right_paren (cxx_pp);
1569 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1570 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1574 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1577 aggr_init_expr_arg_iterator iter;
1579 pp_cxx_left_paren (cxx_pp);
1580 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1586 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1587 if (more_aggr_init_expr_args_p (&iter))
1588 pp_separate_with_comma (cxx_pp);
1591 pp_cxx_right_paren (cxx_pp);
1594 /* Print out a list of initializers (subr of dump_expr). */
1597 dump_expr_list (tree l, int flags)
1601 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1604 pp_separate_with_comma (cxx_pp);
1608 /* Print out a vector of initializers (subr of dump_expr). */
1611 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1613 unsigned HOST_WIDE_INT idx;
1616 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1618 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1619 if (idx != VEC_length (constructor_elt, v) - 1)
1620 pp_separate_with_comma (cxx_pp);
1625 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1626 function. Resolve it to a close relative -- in the sense of static
1627 type -- variant being overridden. That is close to what was written in
1628 the source code. Subroutine of dump_expr. */
1631 resolve_virtual_fun_from_obj_type_ref (tree ref)
1633 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1634 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1635 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1638 fun = TREE_CHAIN (fun);
1639 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1640 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1646 /* Print out an expression E under control of FLAGS. */
1649 dump_expr (tree t, int flags)
1654 if (STATEMENT_CLASS_P (t))
1656 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1660 switch (TREE_CODE (t))
1668 case NAMESPACE_DECL:
1671 case IDENTIFIER_NODE:
1672 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1679 pp_constant (cxx_pp, t);
1683 /* While waiting for caret diagnostics, avoid printing
1684 __cxa_allocate_exception, __cxa_throw, and the like. */
1685 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1689 pp_ampersand (cxx_pp);
1690 dump_type (PTRMEM_CST_CLASS (t), flags);
1691 pp_cxx_colon_colon (cxx_pp);
1692 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1696 pp_cxx_left_paren (cxx_pp);
1697 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1698 pp_separate_with_comma (cxx_pp);
1699 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1700 pp_cxx_right_paren (cxx_pp);
1704 pp_cxx_left_paren (cxx_pp);
1705 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1706 pp_string (cxx_pp, " ? ");
1707 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1708 pp_string (cxx_pp, " : ");
1709 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1710 pp_cxx_right_paren (cxx_pp);
1714 if (TREE_HAS_CONSTRUCTOR (t))
1716 pp_cxx_ws_string (cxx_pp, "new");
1717 pp_cxx_whitespace (cxx_pp);
1718 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1721 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1724 case AGGR_INIT_EXPR:
1726 tree fn = NULL_TREE;
1728 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1729 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1731 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1733 if (DECL_CONSTRUCTOR_P (fn))
1734 dump_type (DECL_CONTEXT (fn), flags);
1739 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1741 dump_aggr_init_expr_args (t, flags, true);
1746 tree fn = CALL_EXPR_FN (t);
1747 bool skipfirst = false;
1749 if (TREE_CODE (fn) == ADDR_EXPR)
1750 fn = TREE_OPERAND (fn, 0);
1752 /* Nobody is interested in seeing the guts of vcalls. */
1753 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1754 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1756 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1758 tree ob = CALL_EXPR_ARG (t, 0);
1759 if (TREE_CODE (ob) == ADDR_EXPR)
1761 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1762 pp_cxx_dot (cxx_pp);
1764 else if (TREE_CODE (ob) != PARM_DECL
1765 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1767 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1768 pp_cxx_arrow (cxx_pp);
1772 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1773 dump_call_expr_args (t, flags, skipfirst);
1778 /* Note that this only works for G++ target exprs. If somebody
1779 builds a general TARGET_EXPR, there's no way to represent that
1780 it initializes anything other that the parameter slot for the
1781 default argument. Note we may have cleared out the first
1782 operand in expand_expr, so don't go killing ourselves. */
1783 if (TREE_OPERAND (t, 1))
1784 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1787 case POINTER_PLUS_EXPR:
1788 dump_binary_op ("+", t, flags);
1796 case TRUNC_DIV_EXPR:
1797 case TRUNC_MOD_EXPR:
1805 case TRUTH_ANDIF_EXPR:
1806 case TRUTH_ORIF_EXPR:
1813 case EXACT_DIV_EXPR:
1814 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1818 case FLOOR_DIV_EXPR:
1819 case ROUND_DIV_EXPR:
1821 dump_binary_op ("/", t, flags);
1825 case FLOOR_MOD_EXPR:
1826 case ROUND_MOD_EXPR:
1827 dump_binary_op ("%", t, flags);
1832 tree ob = TREE_OPERAND (t, 0);
1833 if (TREE_CODE (ob) == INDIRECT_REF)
1835 ob = TREE_OPERAND (ob, 0);
1836 if (TREE_CODE (ob) != PARM_DECL
1838 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1840 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1841 pp_cxx_arrow (cxx_pp);
1846 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1847 pp_cxx_dot (cxx_pp);
1849 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1854 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1855 pp_cxx_left_bracket (cxx_pp);
1856 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1857 pp_cxx_right_bracket (cxx_pp);
1860 case UNARY_PLUS_EXPR:
1861 dump_unary_op ("+", t, flags);
1865 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1866 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1867 /* An ADDR_EXPR can have reference type. In that case, we
1868 shouldn't print the `&' doing so indicates to the user
1869 that the expression has pointer type. */
1871 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1872 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1873 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1874 dump_unary_op ("&&", t, flags);
1876 dump_unary_op ("&", t, flags);
1880 if (TREE_HAS_CONSTRUCTOR (t))
1882 t = TREE_OPERAND (t, 0);
1883 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1884 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1885 dump_call_expr_args (t, flags, true);
1889 if (TREE_OPERAND (t,0) != NULL_TREE
1890 && TREE_TYPE (TREE_OPERAND (t, 0))
1891 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1892 dump_expr (TREE_OPERAND (t, 0), flags);
1894 dump_unary_op ("*", t, flags);
1900 case TRUTH_NOT_EXPR:
1901 case PREDECREMENT_EXPR:
1902 case PREINCREMENT_EXPR:
1903 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1906 case POSTDECREMENT_EXPR:
1907 case POSTINCREMENT_EXPR:
1908 pp_cxx_left_paren (cxx_pp);
1909 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1910 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1911 pp_cxx_right_paren (cxx_pp);
1914 case NON_LVALUE_EXPR:
1915 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1916 should be another level of INDIRECT_REF so that I don't have to do
1918 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1920 tree next = TREE_TYPE (TREE_TYPE (t));
1922 while (TREE_CODE (next) == POINTER_TYPE)
1923 next = TREE_TYPE (next);
1925 if (TREE_CODE (next) == FUNCTION_TYPE)
1927 if (flags & TFF_EXPR_IN_PARENS)
1928 pp_cxx_left_paren (cxx_pp);
1929 pp_cxx_star (cxx_pp);
1930 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1931 if (flags & TFF_EXPR_IN_PARENS)
1932 pp_cxx_right_paren (cxx_pp);
1935 /* Else fall through. */
1937 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1941 case VIEW_CONVERT_EXPR:
1943 tree op = TREE_OPERAND (t, 0);
1945 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1947 /* It is a cast, but we cannot tell whether it is a
1948 reinterpret or static cast. Use the C style notation. */
1949 if (flags & TFF_EXPR_IN_PARENS)
1950 pp_cxx_left_paren (cxx_pp);
1951 pp_cxx_left_paren (cxx_pp);
1952 dump_type (TREE_TYPE (t), flags);
1953 pp_cxx_right_paren (cxx_pp);
1954 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1955 if (flags & TFF_EXPR_IN_PARENS)
1956 pp_cxx_right_paren (cxx_pp);
1959 dump_expr (op, flags);
1964 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1966 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1968 if (integer_zerop (idx))
1970 /* A NULL pointer-to-member constant. */
1971 pp_cxx_left_paren (cxx_pp);
1972 pp_cxx_left_paren (cxx_pp);
1973 dump_type (TREE_TYPE (t), flags);
1974 pp_cxx_right_paren (cxx_pp);
1975 pp_character (cxx_pp, '0');
1976 pp_cxx_right_paren (cxx_pp);
1979 else if (host_integerp (idx, 0))
1982 unsigned HOST_WIDE_INT n;
1984 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1985 t = TYPE_METHOD_BASETYPE (t);
1986 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1988 n = tree_low_cst (idx, 0);
1990 /* Map vtable index back one, to allow for the null pointer to
1994 while (n > 0 && virtuals)
1997 virtuals = TREE_CHAIN (virtuals);
2001 dump_expr (BV_FN (virtuals),
2002 flags | TFF_EXPR_IN_PARENS);
2007 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2009 dump_type (TREE_TYPE (t), 0);
2010 pp_cxx_left_paren (cxx_pp);
2011 pp_cxx_right_paren (cxx_pp);
2015 pp_cxx_left_brace (cxx_pp);
2016 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
2017 pp_cxx_right_brace (cxx_pp);
2024 tree ob = TREE_OPERAND (t, 0);
2025 if (is_dummy_object (ob))
2027 t = TREE_OPERAND (t, 1);
2028 if (TREE_CODE (t) == FUNCTION_DECL)
2030 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
2031 else if (BASELINK_P (t))
2032 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2033 flags | TFF_EXPR_IN_PARENS);
2035 dump_decl (t, flags);
2039 if (TREE_CODE (ob) == INDIRECT_REF)
2041 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2042 pp_cxx_arrow (cxx_pp);
2043 pp_cxx_star (cxx_pp);
2047 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2048 pp_cxx_dot (cxx_pp);
2049 pp_cxx_star (cxx_pp);
2051 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2056 case TEMPLATE_PARM_INDEX:
2057 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2061 if (TREE_OPERAND (t, 0) == NULL_TREE
2062 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2064 dump_type (TREE_TYPE (t), flags);
2065 pp_cxx_left_paren (cxx_pp);
2066 dump_expr_list (TREE_OPERAND (t, 0), flags);
2067 pp_cxx_right_paren (cxx_pp);
2071 pp_cxx_left_paren (cxx_pp);
2072 dump_type (TREE_TYPE (t), flags);
2073 pp_cxx_right_paren (cxx_pp);
2074 pp_cxx_left_paren (cxx_pp);
2075 dump_expr_list (TREE_OPERAND (t, 0), flags);
2076 pp_cxx_right_paren (cxx_pp);
2080 case STATIC_CAST_EXPR:
2081 pp_cxx_ws_string (cxx_pp, "static_cast");
2083 case REINTERPRET_CAST_EXPR:
2084 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2086 case CONST_CAST_EXPR:
2087 pp_cxx_ws_string (cxx_pp, "const_cast");
2089 case DYNAMIC_CAST_EXPR:
2090 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2092 pp_cxx_begin_template_argument_list (cxx_pp);
2093 dump_type (TREE_TYPE (t), flags);
2094 pp_cxx_end_template_argument_list (cxx_pp);
2095 pp_cxx_left_paren (cxx_pp);
2096 dump_expr (TREE_OPERAND (t, 0), flags);
2097 pp_cxx_right_paren (cxx_pp);
2101 dump_expr (TREE_OPERAND (t, 0), flags);
2102 pp_cxx_arrow (cxx_pp);
2107 if (TREE_CODE (t) == SIZEOF_EXPR)
2108 pp_cxx_ws_string (cxx_pp, "sizeof");
2111 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2112 pp_cxx_ws_string (cxx_pp, "__alignof__");
2114 pp_cxx_whitespace (cxx_pp);
2115 pp_cxx_left_paren (cxx_pp);
2116 if (TYPE_P (TREE_OPERAND (t, 0)))
2117 dump_type (TREE_OPERAND (t, 0), flags);
2119 dump_expr (TREE_OPERAND (t, 0), flags);
2120 pp_cxx_right_paren (cxx_pp);
2125 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2126 pp_cxx_whitespace (cxx_pp);
2127 dump_expr (TREE_OPERAND (t, 0), flags);
2131 pp_string (cxx_pp, M_("<unparsed>"));
2134 case TRY_CATCH_EXPR:
2135 case WITH_CLEANUP_EXPR:
2136 case CLEANUP_POINT_EXPR:
2137 dump_expr (TREE_OPERAND (t, 0), flags);
2140 case PSEUDO_DTOR_EXPR:
2141 dump_expr (TREE_OPERAND (t, 2), flags);
2142 pp_cxx_dot (cxx_pp);
2143 dump_type (TREE_OPERAND (t, 0), flags);
2144 pp_cxx_colon_colon (cxx_pp);
2145 pp_cxx_complement (cxx_pp);
2146 dump_type (TREE_OPERAND (t, 1), flags);
2149 case TEMPLATE_ID_EXPR:
2150 dump_decl (t, flags);
2156 case STATEMENT_LIST:
2157 /* We don't yet have a way of dumping statements in a
2158 human-readable format. */
2159 pp_string (cxx_pp, "({...})");
2163 pp_string (cxx_pp, "while (1) { ");
2164 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2165 pp_cxx_right_brace (cxx_pp);
2169 pp_string (cxx_pp, "if (");
2170 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2171 pp_string (cxx_pp, ") break; ");
2175 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2178 case EMPTY_CLASS_EXPR:
2179 dump_type (TREE_TYPE (t), flags);
2180 pp_cxx_left_paren (cxx_pp);
2181 pp_cxx_right_paren (cxx_pp);
2184 case NON_DEPENDENT_EXPR:
2185 dump_expr (TREE_OPERAND (t, 0), flags);
2188 case ARGUMENT_PACK_SELECT:
2189 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2201 pp_type_specifier_seq (cxx_pp, t);
2205 /* We get here when we want to print a dependent type as an
2206 id-expression, without any disambiguator decoration. */
2207 pp_id_expression (cxx_pp, t);
2210 case TEMPLATE_TYPE_PARM:
2211 case BOUND_TEMPLATE_TEMPLATE_PARM:
2212 dump_type (t, flags);
2216 pp_cxx_trait_expression (cxx_pp, t);
2220 pp_cxx_va_arg_expression (cxx_pp, t);
2224 pp_cxx_offsetof_expression (cxx_pp, t);
2228 dump_decl (t, flags);
2231 case EXPR_PACK_EXPANSION:
2238 case VEC_DELETE_EXPR:
2244 case UNORDERED_EXPR:
2254 case FIX_TRUNC_EXPR:
2256 pp_expression (cxx_pp, t);
2259 case TRUTH_AND_EXPR:
2261 case TRUTH_XOR_EXPR:
2262 if (flags & TFF_EXPR_IN_PARENS)
2263 pp_cxx_left_paren (cxx_pp);
2264 pp_expression (cxx_pp, t);
2265 if (flags & TFF_EXPR_IN_PARENS)
2266 pp_cxx_right_paren (cxx_pp);
2270 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2273 /* This list is incomplete, but should suffice for now.
2274 It is very important that `sorry' does not call
2275 `report_error_function'. That could cause an infinite loop. */
2277 pp_unsupported_tree (cxx_pp, t);
2278 /* fall through to ERROR_MARK... */
2280 pp_string (cxx_pp, M_("<expression error>"));
2286 dump_binary_op (const char *opstring, tree t, int flags)
2288 pp_cxx_left_paren (cxx_pp);
2289 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2290 pp_cxx_whitespace (cxx_pp);
2292 pp_cxx_ws_string (cxx_pp, opstring);
2294 pp_string (cxx_pp, M_("<unknown operator>"));
2295 pp_cxx_whitespace (cxx_pp);
2296 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2297 pp_cxx_right_paren (cxx_pp);
2301 dump_unary_op (const char *opstring, tree t, int flags)
2303 if (flags & TFF_EXPR_IN_PARENS)
2304 pp_cxx_left_paren (cxx_pp);
2305 pp_cxx_ws_string (cxx_pp, opstring);
2306 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2307 if (flags & TFF_EXPR_IN_PARENS)
2308 pp_cxx_right_paren (cxx_pp);
2312 reinit_cxx_pp (void)
2314 pp_clear_output_area (cxx_pp);
2315 pp_base (cxx_pp)->padding = pp_none;
2316 pp_indentation (cxx_pp) = 0;
2317 pp_needs_newline (cxx_pp) = false;
2318 cxx_pp->enclosing_scope = current_function_decl;
2322 /* Exported interface to stringifying types, exprs and decls under TFF_*
2326 type_as_string (tree typ, int flags)
2329 pp_translate_identifiers (cxx_pp) = false;
2330 dump_type (typ, flags);
2331 return pp_formatted_text (cxx_pp);
2335 type_as_string_translate (tree typ, int flags)
2338 dump_type (typ, flags);
2339 return pp_formatted_text (cxx_pp);
2343 expr_as_string (tree decl, int flags)
2346 pp_translate_identifiers (cxx_pp) = false;
2347 dump_expr (decl, flags);
2348 return pp_formatted_text (cxx_pp);
2352 decl_as_string (tree decl, int flags)
2355 pp_translate_identifiers (cxx_pp) = false;
2356 dump_decl (decl, flags);
2357 return pp_formatted_text (cxx_pp);
2361 decl_as_string_translate (tree decl, int flags)
2364 dump_decl (decl, flags);
2365 return pp_formatted_text (cxx_pp);
2368 /* Generate the three forms of printable names for cxx_printable_name. */
2371 lang_decl_name (tree decl, int v, bool translate)
2375 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2376 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2379 pp_translate_identifiers (cxx_pp) = translate;
2381 && (DECL_CLASS_SCOPE_P (decl)
2382 || (DECL_NAMESPACE_SCOPE_P (decl)
2383 && CP_DECL_CONTEXT (decl) != global_namespace)))
2385 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2386 pp_cxx_colon_colon (cxx_pp);
2389 if (TREE_CODE (decl) == FUNCTION_DECL)
2390 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2392 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2394 return pp_formatted_text (cxx_pp);
2397 /* Return the location of a tree passed to %+ formats. */
2400 location_of (tree t)
2402 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2403 t = DECL_CONTEXT (t);
2404 else if (TYPE_P (t))
2405 t = TYPE_MAIN_DECL (t);
2406 else if (TREE_CODE (t) == OVERLOAD)
2407 t = OVL_FUNCTION (t);
2409 return DECL_SOURCE_LOCATION (t);
2412 /* Now the interfaces from error et al to dump_type et al. Each takes an
2413 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2417 decl_to_string (tree decl, int verbose)
2421 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2422 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2423 flags = TFF_CLASS_KEY_OR_ENUM;
2425 flags |= TFF_DECL_SPECIFIERS;
2426 else if (TREE_CODE (decl) == FUNCTION_DECL)
2427 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2428 flags |= TFF_TEMPLATE_HEADER;
2431 dump_decl (decl, flags);
2432 return pp_formatted_text (cxx_pp);
2436 expr_to_string (tree decl)
2439 dump_expr (decl, 0);
2440 return pp_formatted_text (cxx_pp);
2444 fndecl_to_string (tree fndecl, int verbose)
2448 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2449 | TFF_TEMPLATE_HEADER;
2451 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2453 dump_decl (fndecl, flags);
2454 return pp_formatted_text (cxx_pp);
2459 code_to_string (enum tree_code c)
2461 return tree_code_name [c];
2465 language_to_string (enum languages c)
2472 case lang_cplusplus:
2484 /* Return the proper printed version of a parameter to a C++ function. */
2487 parm_to_string (int p)
2491 pp_string (cxx_pp, "'this'");
2493 pp_decimal_int (cxx_pp, p + 1);
2494 return pp_formatted_text (cxx_pp);
2498 op_to_string (enum tree_code p)
2500 tree id = operator_name_info[(int) p].identifier;
2501 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2505 type_to_string (tree typ, int verbose)
2509 flags |= TFF_CLASS_KEY_OR_ENUM;
2510 flags |= TFF_TEMPLATE_HEADER;
2513 dump_type (typ, flags);
2514 return pp_formatted_text (cxx_pp);
2518 assop_to_string (enum tree_code p)
2520 tree id = assignment_operator_name_info[(int) p].identifier;
2521 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2525 args_to_string (tree p, int verbose)
2529 flags |= TFF_CLASS_KEY_OR_ENUM;
2534 if (TYPE_P (TREE_VALUE (p)))
2535 return type_as_string_translate (p, flags);
2538 for (; p; p = TREE_CHAIN (p))
2540 if (TREE_VALUE (p) == null_node)
2541 pp_cxx_ws_string (cxx_pp, "NULL");
2543 dump_type (error_type (TREE_VALUE (p)), flags);
2545 pp_separate_with_comma (cxx_pp);
2547 return pp_formatted_text (cxx_pp);
2551 cv_to_string (tree p, int v)
2554 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2555 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2556 return pp_formatted_text (cxx_pp);
2559 /* Langhook for print_error_function. */
2561 cxx_print_error_function (diagnostic_context *context, const char *file,
2562 diagnostic_info *diagnostic)
2564 lhd_print_error_function (context, file, diagnostic);
2565 pp_base_set_prefix (context->printer, file);
2566 maybe_print_instantiation_context (context);
2570 cp_diagnostic_starter (diagnostic_context *context,
2571 diagnostic_info *diagnostic)
2573 diagnostic_report_current_module (context);
2574 cp_print_error_function (context, diagnostic);
2575 maybe_print_instantiation_context (context);
2576 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2580 cp_diagnostic_finalizer (diagnostic_context *context,
2581 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2583 pp_base_destroy_prefix (context->printer);
2586 /* Print current function onto BUFFER, in the process of reporting
2587 a diagnostic message. Called from cp_diagnostic_starter. */
2589 cp_print_error_function (diagnostic_context *context,
2590 diagnostic_info *diagnostic)
2592 if (diagnostic_last_function_changed (context, diagnostic))
2594 const char *old_prefix = context->printer->prefix;
2595 const char *file = LOCATION_FILE (diagnostic->location);
2596 tree abstract_origin = diagnostic->abstract_origin;
2597 char *new_prefix = (file && abstract_origin == NULL)
2598 ? file_name_as_prefix (file) : NULL;
2600 pp_base_set_prefix (context->printer, new_prefix);
2602 if (current_function_decl == NULL)
2603 pp_base_string (context->printer, _("At global scope:"));
2608 if (abstract_origin)
2610 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2611 while (TREE_CODE (ao) == BLOCK
2612 && BLOCK_ABSTRACT_ORIGIN (ao)
2613 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2614 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2615 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2619 fndecl = current_function_decl;
2621 pp_printf (context->printer, function_category (fndecl),
2622 cxx_printable_name_translate (fndecl, 2));
2624 while (abstract_origin)
2627 tree block = abstract_origin;
2629 locus = &BLOCK_SOURCE_LOCATION (block);
2631 block = BLOCK_SUPERCONTEXT (block);
2632 while (block && TREE_CODE (block) == BLOCK
2633 && BLOCK_ABSTRACT_ORIGIN (block))
2635 ao = BLOCK_ABSTRACT_ORIGIN (block);
2637 while (TREE_CODE (ao) == BLOCK
2638 && BLOCK_ABSTRACT_ORIGIN (ao)
2639 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2640 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2642 if (TREE_CODE (ao) == FUNCTION_DECL)
2647 else if (TREE_CODE (ao) != BLOCK)
2650 block = BLOCK_SUPERCONTEXT (block);
2653 abstract_origin = block;
2656 while (block && TREE_CODE (block) == BLOCK)
2657 block = BLOCK_SUPERCONTEXT (block);
2659 if (block && TREE_CODE (block) == FUNCTION_DECL)
2661 abstract_origin = NULL;
2665 expanded_location s = expand_location (*locus);
2666 pp_base_character (context->printer, ',');
2667 pp_base_newline (context->printer);
2670 if (flag_show_column && s.column != 0)
2671 pp_printf (context->printer,
2672 _(" inlined from %qs at %s:%d:%d"),
2673 cxx_printable_name_translate (fndecl, 2),
2674 s.file, s.line, s.column);
2676 pp_printf (context->printer,
2677 _(" inlined from %qs at %s:%d"),
2678 cxx_printable_name_translate (fndecl, 2),
2683 pp_printf (context->printer, _(" inlined from %qs"),
2684 cxx_printable_name_translate (fndecl, 2));
2687 pp_base_character (context->printer, ':');
2689 pp_base_newline (context->printer);
2691 diagnostic_set_last_function (context, diagnostic);
2692 pp_base_destroy_prefix (context->printer);
2693 context->printer->prefix = old_prefix;
2697 /* Returns a description of FUNCTION using standard terminology. The
2698 result is a format string of the form "In CATEGORY %qs". */
2700 function_category (tree fn)
2702 /* We can get called from the middle-end for diagnostics of function
2703 clones. Make sure we have language specific information before
2704 dereferencing it. */
2705 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
2706 && DECL_FUNCTION_MEMBER_P (fn))
2708 if (DECL_STATIC_FUNCTION_P (fn))
2709 return _("In static member function %qs");
2710 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2711 return _("In copy constructor %qs");
2712 else if (DECL_CONSTRUCTOR_P (fn))
2713 return _("In constructor %qs");
2714 else if (DECL_DESTRUCTOR_P (fn))
2715 return _("In destructor %qs");
2716 else if (LAMBDA_FUNCTION_P (fn))
2717 return _("In lambda function");
2719 return _("In member function %qs");
2722 return _("In function %qs");
2725 /* Report the full context of a current template instantiation,
2728 print_instantiation_full_context (diagnostic_context *context)
2730 struct tinst_level *p = current_instantiation ();
2731 location_t location = input_location;
2735 if (current_function_decl != p->decl
2736 && current_function_decl != NULL_TREE)
2737 /* We can get here during the processing of some synthesized
2738 method. Then, P->DECL will be the function that's causing
2743 if (current_function_decl == p->decl)
2744 /* Avoid redundancy with the "In function" line. */;
2746 pp_verbatim (context->printer,
2747 _("%s: In instantiation of %qs:\n"),
2748 LOCATION_FILE (location),
2749 decl_as_string_translate (p->decl,
2750 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2752 location = p->locus;
2757 print_instantiation_partial_context (context, p, location);
2760 /* Same as above but less verbose. */
2762 print_instantiation_partial_context (diagnostic_context *context,
2763 struct tinst_level *t, location_t loc)
2765 expanded_location xloc;
2767 for (; ; t = t->next)
2769 xloc = expand_location (loc);
2772 str = decl_as_string_translate (t->decl,
2773 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE);
2774 if (flag_show_column)
2775 pp_verbatim (context->printer,
2776 _("%s:%d:%d: instantiated from %qs\n"),
2777 xloc.file, xloc.line, xloc.column, str);
2779 pp_verbatim (context->printer,
2780 _("%s:%d: instantiated from %qs\n"),
2781 xloc.file, xloc.line, str);
2784 if (flag_show_column)
2785 pp_verbatim (context->printer, _("%s:%d:%d: instantiated from here"),
2786 xloc.file, xloc.line, xloc.column);
2788 pp_verbatim (context->printer, _("%s:%d: instantiated from here"),
2789 xloc.file, xloc.line);
2790 pp_base_newline (context->printer);
2793 /* Called from cp_thing to print the template context for an error. */
2795 maybe_print_instantiation_context (diagnostic_context *context)
2797 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2800 record_last_problematic_instantiation ();
2801 print_instantiation_full_context (context);
2804 /* Report the bare minimum context of a template instantiation. */
2806 print_instantiation_context (void)
2808 print_instantiation_partial_context
2809 (global_dc, current_instantiation (), input_location);
2810 diagnostic_flush_buffer (global_dc);
2813 /* Called from output_format -- during diagnostic message processing --
2814 to handle C++ specific format specifier with the following meanings:
2815 %A function argument-list.
2819 %F function declaration.
2820 %L language as used in extern "lang".
2822 %P function parameter whose position is indicated by an integer.
2823 %Q assignment operator.
2827 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2828 int precision, bool wide, bool set_locus, bool verbose)
2832 #define next_tree (t = va_arg (*text->args_ptr, tree))
2833 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
2834 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
2835 #define next_int va_arg (*text->args_ptr, int)
2837 if (precision != 0 || wide)
2840 if (text->locus == NULL)
2845 case 'A': result = args_to_string (next_tree, verbose); break;
2846 case 'C': result = code_to_string (next_tcode); break;
2849 tree temp = next_tree;
2851 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2853 temp = DECL_DEBUG_EXPR (temp);
2856 result = expr_to_string (temp);
2860 result = decl_to_string (temp, verbose);
2863 case 'E': result = expr_to_string (next_tree); break;
2864 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2865 case 'L': result = language_to_string (next_lang); break;
2866 case 'O': result = op_to_string (next_tcode); break;
2867 case 'P': result = parm_to_string (next_int); break;
2868 case 'Q': result = assop_to_string (next_tcode); break;
2869 case 'T': result = type_to_string (next_tree, verbose); break;
2870 case 'V': result = cv_to_string (next_tree, verbose); break;
2876 pp_base_string (pp, result);
2877 if (set_locus && t != NULL)
2878 *text->locus = location_of (t);
2886 /* Warn about the use of C++0x features when appropriate. */
2888 maybe_warn_cpp0x (cpp0x_warn_str str)
2890 if ((cxx_dialect == cxx98) && !in_system_header)
2891 /* We really want to suppress this warning in system headers,
2892 because libstdc++ uses variadic templates even when we aren't
2896 case CPP0X_INITIALIZER_LISTS:
2897 pedwarn (input_location, 0,
2898 "extended initializer lists "
2899 "only available with -std=c++0x or -std=gnu++0x");
2901 case CPP0X_EXPLICIT_CONVERSION:
2902 pedwarn (input_location, 0,
2903 "explicit conversion operators "
2904 "only available with -std=c++0x or -std=gnu++0x");
2906 case CPP0X_VARIADIC_TEMPLATES:
2907 pedwarn (input_location, 0,
2908 "variadic templates "
2909 "only available with -std=c++0x or -std=gnu++0x");
2911 case CPP0X_LAMBDA_EXPR:
2912 pedwarn (input_location, 0,
2913 "lambda expressions "
2914 "only available with -std=c++0x or -std=gnu++0x");
2917 pedwarn (input_location, 0,
2918 "C++0x auto only available with -std=c++0x or -std=gnu++0x");
2920 case CPP0X_SCOPED_ENUMS:
2921 pedwarn (input_location, 0,
2922 "scoped enums only available with -std=c++0x or -std=gnu++0x");
2924 case CPP0X_DEFAULTED_DELETED:
2925 pedwarn (input_location, 0,
2926 "defaulted and deleted functions "
2927 "only available with -std=c++0x or -std=gnu++0x");
2934 /* Warn about the use of variadic templates when appropriate. */
2936 maybe_warn_variadic_templates (void)
2938 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
2942 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
2943 option OPT with text GMSGID. Use this function to report
2944 diagnostics for constructs that are invalid C++98, but valid
2947 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
2949 diagnostic_info diagnostic;
2952 va_start (ap, gmsgid);
2953 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
2954 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
2955 diagnostic.option_index = opt;
2957 return report_diagnostic (&diagnostic);