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))))
575 || DECL_SELF_REFERENCE_P (name))
577 t = TYPE_MAIN_VARIANT (t);
578 name = TYPE_NAME (t);
582 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
583 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
584 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
585 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
587 if (! (flags & TFF_UNQUALIFIED_NAME))
588 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
589 flags &= ~TFF_UNQUALIFIED_NAME;
592 /* Because the template names are mangled, we have to locate
593 the most general template, and use that name. */
594 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
596 while (DECL_TEMPLATE_INFO (tpl))
597 tpl = DECL_TI_TEMPLATE (tpl);
600 name = DECL_NAME (name);
603 if (name == 0 || ANON_AGGRNAME_P (name))
605 if (flags & TFF_CLASS_KEY_OR_ENUM)
606 pp_string (cxx_pp, M_("<anonymous>"));
608 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety);
610 else if (LAMBDANAME_P (name))
612 /* A lambda's "type" is essentially its signature. */
613 pp_string (cxx_pp, M_("<lambda"));
614 if (lambda_function (t))
615 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
617 pp_character(cxx_pp, '>');
620 pp_cxx_tree_identifier (cxx_pp, name);
622 dump_template_parms (TYPE_TEMPLATE_INFO (t),
623 !CLASSTYPE_USE_TEMPLATE (t),
624 flags & ~TFF_TEMPLATE_HEADER);
627 /* Dump into the obstack the initial part of the output for a given type.
628 This is necessary when dealing with things like functions returning
631 return type of `int (* fee ())()': pointer -> function -> int. Both
632 pointer (and reference and offset) and function (and member) types must
633 deal with prefix and suffix.
635 Arrays must also do this for DECL nodes, like int a[], and for things like
639 dump_type_prefix (tree t, int flags)
641 if (TYPE_PTRMEMFUNC_P (t))
643 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
647 switch (TREE_CODE (t))
652 tree sub = TREE_TYPE (t);
654 dump_type_prefix (sub, flags);
655 if (TREE_CODE (sub) == ARRAY_TYPE
656 || TREE_CODE (sub) == FUNCTION_TYPE)
658 pp_cxx_whitespace (cxx_pp);
659 pp_cxx_left_paren (cxx_pp);
661 if (TREE_CODE (t) == POINTER_TYPE)
662 pp_character(cxx_pp, '*');
663 else if (TREE_CODE (t) == REFERENCE_TYPE)
665 if (TYPE_REF_IS_RVALUE (t))
666 pp_string (cxx_pp, "&&");
668 pp_character (cxx_pp, '&');
670 pp_base (cxx_pp)->padding = pp_before;
671 pp_cxx_cv_qualifier_seq (cxx_pp, t);
677 dump_type_prefix (TREE_TYPE (t), flags);
678 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
680 pp_maybe_space (cxx_pp);
681 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
682 pp_cxx_left_paren (cxx_pp);
683 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
684 pp_cxx_colon_colon (cxx_pp);
686 pp_cxx_star (cxx_pp);
687 pp_cxx_cv_qualifier_seq (cxx_pp, t);
688 pp_base (cxx_pp)->padding = pp_before;
691 /* This can be reached without a pointer when dealing with
692 templates, e.g. std::is_function. */
694 dump_type_prefix (TREE_TYPE (t), flags);
698 dump_type_prefix (TREE_TYPE (t), flags);
699 pp_maybe_space (cxx_pp);
700 pp_cxx_left_paren (cxx_pp);
701 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
702 pp_cxx_colon_colon (cxx_pp);
706 dump_type_prefix (TREE_TYPE (t), flags);
710 case IDENTIFIER_NODE:
715 case TEMPLATE_TYPE_PARM:
716 case TEMPLATE_TEMPLATE_PARM:
717 case BOUND_TEMPLATE_TEMPLATE_PARM:
729 case TYPE_PACK_EXPANSION:
730 case FIXED_POINT_TYPE:
731 dump_type (t, flags);
732 pp_base (cxx_pp)->padding = pp_before;
736 pp_unsupported_tree (cxx_pp, t);
739 pp_string (cxx_pp, M_("<typeprefixerror>"));
744 /* Dump the suffix of type T, under control of FLAGS. This is the part
745 which appears after the identifier (or function parms). */
748 dump_type_suffix (tree t, int flags)
750 if (TYPE_PTRMEMFUNC_P (t))
751 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
753 switch (TREE_CODE (t))
758 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
759 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
760 pp_cxx_right_paren (cxx_pp);
761 dump_type_suffix (TREE_TYPE (t), flags);
768 if (TREE_CODE (t) == METHOD_TYPE)
769 /* Can only be reached through a pointer. */
770 pp_cxx_right_paren (cxx_pp);
771 arg = TYPE_ARG_TYPES (t);
772 if (TREE_CODE (t) == METHOD_TYPE)
773 arg = TREE_CHAIN (arg);
775 /* Function pointers don't have default args. Not in standard C++,
776 anyway; they may in g++, but we'll just pretend otherwise. */
777 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
779 if (TREE_CODE (t) == METHOD_TYPE)
780 pp_cxx_cv_qualifier_seq
781 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
783 pp_cxx_cv_qualifier_seq (cxx_pp, t);
784 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
785 dump_type_suffix (TREE_TYPE (t), flags);
790 pp_maybe_space (cxx_pp);
791 pp_cxx_left_bracket (cxx_pp);
794 tree dtype = TYPE_DOMAIN (t);
795 tree max = TYPE_MAX_VALUE (dtype);
796 if (host_integerp (max, 0))
797 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
798 else if (TREE_CODE (max) == MINUS_EXPR)
799 dump_expr (TREE_OPERAND (max, 0),
800 flags & ~TFF_EXPR_IN_PARENS);
802 dump_expr (fold_build2_loc (input_location,
803 PLUS_EXPR, dtype, max,
804 build_int_cst (dtype, 1)),
805 flags & ~TFF_EXPR_IN_PARENS);
807 pp_cxx_right_bracket (cxx_pp);
808 dump_type_suffix (TREE_TYPE (t), flags);
812 case IDENTIFIER_NODE:
817 case TEMPLATE_TYPE_PARM:
818 case TEMPLATE_TEMPLATE_PARM:
819 case BOUND_TEMPLATE_TEMPLATE_PARM:
831 case TYPE_PACK_EXPANSION:
832 case FIXED_POINT_TYPE:
836 pp_unsupported_tree (cxx_pp, t);
838 /* Don't mark it here, we should have already done in
845 dump_global_iord (tree t)
847 const char *p = NULL;
849 if (DECL_GLOBAL_CTOR_P (t))
850 p = M_("(static initializers for %s)");
851 else if (DECL_GLOBAL_DTOR_P (t))
852 p = M_("(static destructors for %s)");
856 pp_printf (pp_base (cxx_pp), p, input_filename);
860 dump_simple_decl (tree t, tree type, int flags)
862 if (flags & TFF_DECL_SPECIFIERS)
864 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
865 pp_maybe_space (cxx_pp);
867 if (! (flags & TFF_UNQUALIFIED_NAME)
868 && (!DECL_INITIAL (t)
869 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
870 dump_scope (CP_DECL_CONTEXT (t), flags);
871 flags &= ~TFF_UNQUALIFIED_NAME;
872 if ((flags & TFF_DECL_SPECIFIERS)
873 && DECL_TEMPLATE_PARM_P (t)
874 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
875 pp_string (cxx_pp, "...");
877 dump_decl (DECL_NAME (t), flags);
879 pp_string (cxx_pp, M_("<anonymous>"));
880 if (flags & TFF_DECL_SPECIFIERS)
881 dump_type_suffix (type, flags);
884 /* Dump a human readable string for the decl T under control of FLAGS. */
887 dump_decl (tree t, int flags)
892 switch (TREE_CODE (t))
895 /* Don't say 'typedef class A' */
896 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
898 if ((flags & TFF_DECL_SPECIFIERS)
899 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
901 /* Say `class T' not just `T'. */
902 pp_cxx_ws_string (cxx_pp, "class");
904 /* Emit the `...' for a parameter pack. */
905 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
906 pp_cxx_ws_string (cxx_pp, "...");
909 dump_type (TREE_TYPE (t), flags);
912 if ((flags & TFF_DECL_SPECIFIERS)
913 && !DECL_SELF_REFERENCE_P (t))
914 pp_cxx_ws_string (cxx_pp, "typedef");
915 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
916 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
921 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
923 pp_string (cxx_pp, M_("vtable for "));
924 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
925 dump_type (DECL_CONTEXT (t), flags);
928 /* Else fall through. */
931 dump_simple_decl (t, TREE_TYPE (t), flags);
935 pp_string (cxx_pp, M_("<return value> "));
936 dump_simple_decl (t, TREE_TYPE (t), flags);
940 if (flags & TFF_DECL_SPECIFIERS)
941 pp_cxx_declaration (cxx_pp, t);
944 if (! (flags & TFF_UNQUALIFIED_NAME))
945 dump_scope (CP_DECL_CONTEXT (t), flags);
946 flags &= ~TFF_UNQUALIFIED_NAME;
947 if (DECL_NAME (t) == NULL_TREE)
948 pp_string (cxx_pp, M_("<unnamed>"));
950 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
955 dump_type (TREE_OPERAND (t, 0), flags);
956 pp_string (cxx_pp, "::");
957 dump_decl (TREE_OPERAND (t, 1), flags|TFF_UNQUALIFIED_NAME);
961 dump_decl (TREE_OPERAND (t, 0), flags);
962 pp_cxx_left_bracket (cxx_pp);
963 dump_decl (TREE_OPERAND (t, 1), flags);
964 pp_cxx_right_bracket (cxx_pp);
967 /* So that we can do dump_decl on an aggr type. */
971 dump_type (t, flags);
975 /* This is a pseudo destructor call which has not been folded into
976 a PSEUDO_DTOR_EXPR yet. */
977 pp_cxx_complement (cxx_pp);
978 dump_type (TREE_OPERAND (t, 0), flags);
985 /* These special cases are duplicated here so that other functions
986 can feed identifiers to error and get them demangled properly. */
987 case IDENTIFIER_NODE:
988 if (IDENTIFIER_TYPENAME_P (t))
990 pp_cxx_ws_string (cxx_pp, "operator");
991 /* Not exactly IDENTIFIER_TYPE_VALUE. */
992 dump_type (TREE_TYPE (t), flags);
996 pp_cxx_tree_identifier (cxx_pp, t);
1002 t = OVL_CURRENT (t);
1003 if (DECL_CLASS_SCOPE_P (t))
1005 dump_type (DECL_CONTEXT (t), flags);
1006 pp_cxx_colon_colon (cxx_pp);
1008 else if (DECL_CONTEXT (t))
1010 dump_decl (DECL_CONTEXT (t), flags);
1011 pp_cxx_colon_colon (cxx_pp);
1013 dump_decl (DECL_NAME (t), flags);
1017 /* If there's only one function, just treat it like an ordinary
1019 t = OVL_CURRENT (t);
1023 if (! DECL_LANG_SPECIFIC (t))
1024 pp_string (cxx_pp, M_("<built-in>"));
1025 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1026 dump_global_iord (t);
1028 dump_function_decl (t, flags);
1032 dump_template_decl (t, flags);
1035 case TEMPLATE_ID_EXPR:
1037 tree name = TREE_OPERAND (t, 0);
1039 if (is_overloaded_fn (name))
1040 name = DECL_NAME (get_first_fn (name));
1041 dump_decl (name, flags);
1042 pp_cxx_begin_template_argument_list (cxx_pp);
1043 if (TREE_OPERAND (t, 1))
1044 dump_template_argument_list (TREE_OPERAND (t, 1), NULL_TREE, flags);
1045 pp_cxx_end_template_argument_list (cxx_pp);
1050 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1054 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1055 || (DECL_INITIAL (t) &&
1056 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1057 dump_simple_decl (t, TREE_TYPE (t), flags);
1058 else if (DECL_NAME (t))
1059 dump_decl (DECL_NAME (t), flags);
1060 else if (DECL_INITIAL (t))
1061 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1063 pp_string (cxx_pp, M_("<enumerator>"));
1067 pp_cxx_ws_string (cxx_pp, "using");
1068 dump_type (USING_DECL_SCOPE (t), flags);
1069 pp_cxx_colon_colon (cxx_pp);
1070 dump_decl (DECL_NAME (t), flags);
1074 pp_cxx_declaration (cxx_pp, t);
1078 dump_decl (BASELINK_FUNCTIONS (t), flags);
1081 case NON_DEPENDENT_EXPR:
1082 dump_expr (t, flags);
1085 case TEMPLATE_TYPE_PARM:
1086 if (flags & TFF_DECL_SPECIFIERS)
1087 pp_cxx_declaration (cxx_pp, t);
1089 pp_type_id (cxx_pp, t);
1092 case UNBOUND_CLASS_TEMPLATE:
1093 case TYPE_PACK_EXPANSION:
1095 dump_type (t, flags);
1099 pp_unsupported_tree (cxx_pp, t);
1100 /* Fall through to error. */
1103 pp_string (cxx_pp, M_("<declaration error>"));
1108 /* Dump a template declaration T under control of FLAGS. This means the
1109 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1112 dump_template_decl (tree t, int flags)
1114 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1118 if (flags & TFF_TEMPLATE_HEADER)
1120 for (parms = orig_parms = nreverse (orig_parms);
1122 parms = TREE_CHAIN (parms))
1124 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1125 int len = TREE_VEC_LENGTH (inner_parms);
1127 pp_cxx_ws_string (cxx_pp, "template");
1128 pp_cxx_begin_template_argument_list (cxx_pp);
1130 /* If we've shown the template prefix, we'd better show the
1131 parameters' and decl's type too. */
1132 flags |= TFF_DECL_SPECIFIERS;
1134 for (i = 0; i < len; i++)
1137 pp_separate_with_comma (cxx_pp);
1138 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1140 pp_cxx_end_template_argument_list (cxx_pp);
1141 pp_cxx_whitespace (cxx_pp);
1143 nreverse(orig_parms);
1145 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1147 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1148 pp_cxx_ws_string (cxx_pp, "class");
1150 /* If this is a parameter pack, print the ellipsis. */
1151 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1152 pp_cxx_ws_string (cxx_pp, "...");
1156 if (DECL_TEMPLATE_RESULT (t)
1157 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1158 dump_type (TREE_TYPE (t),
1159 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1160 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1161 else if (DECL_TEMPLATE_RESULT (t)
1162 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1163 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1166 gcc_assert (TREE_TYPE (t));
1167 switch (NEXT_CODE (t))
1171 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1174 /* This case can occur with some invalid code. */
1175 dump_type (TREE_TYPE (t),
1176 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1177 | (flags & TFF_DECL_SPECIFIERS
1178 ? TFF_CLASS_KEY_OR_ENUM : 0));
1183 /* find_typenames looks through the type of the function template T
1184 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1187 struct find_typenames_t
1189 struct pointer_set_t *p_set;
1190 VEC (tree,gc) *typenames;
1194 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1196 struct find_typenames_t *d = (struct find_typenames_t *)data;
1197 tree mv = NULL_TREE;
1199 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1200 /* Add the type of the typedef without any additional cv-quals. */
1201 mv = TREE_TYPE (TYPE_NAME (*tp));
1202 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1203 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1204 /* Add the typename without any cv-qualifiers. */
1205 mv = TYPE_MAIN_VARIANT (*tp);
1207 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1208 VEC_safe_push (tree, gc, d->typenames, mv);
1210 /* Search into class template arguments, which cp_walk_subtrees
1212 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1213 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1219 static VEC(tree,gc) *
1220 find_typenames (tree t)
1222 struct find_typenames_t ft;
1223 ft.p_set = pointer_set_create ();
1224 ft.typenames = NULL;
1225 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1226 find_typenames_r, &ft, ft.p_set);
1227 pointer_set_destroy (ft.p_set);
1228 return ft.typenames;
1231 /* Pretty print a function decl. There are several ways we want to print a
1232 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1233 As error can only apply the '#' flag once to give 0 and 1 for V, there
1234 is %D which doesn't print the throw specs, and %F which does. */
1237 dump_function_decl (tree t, int flags)
1241 tree cname = NULL_TREE;
1242 tree template_args = NULL_TREE;
1243 tree template_parms = NULL_TREE;
1244 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1245 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1247 VEC(tree,gc) *typenames = NULL;
1249 if (LAMBDA_FUNCTION_P (t))
1251 /* A lambda's signature is essentially its "type", so defer. */
1252 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t)));
1253 dump_type (DECL_CONTEXT (t), flags);
1257 flags &= ~TFF_UNQUALIFIED_NAME;
1258 if (TREE_CODE (t) == TEMPLATE_DECL)
1259 t = DECL_TEMPLATE_RESULT (t);
1261 /* Save the exceptions, in case t is a specialization and we are
1262 emitting an error about incompatible specifications. */
1263 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1265 /* Pretty print template instantiations only. */
1266 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1267 && flag_pretty_templates)
1271 template_args = DECL_TI_ARGS (t);
1272 tmpl = most_general_template (t);
1273 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1275 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1277 typenames = find_typenames (t);
1281 fntype = TREE_TYPE (t);
1282 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1284 if (DECL_CLASS_SCOPE_P (t))
1285 cname = DECL_CONTEXT (t);
1286 /* This is for partially instantiated template methods. */
1287 else if (TREE_CODE (fntype) == METHOD_TYPE)
1288 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1290 if (!(flags & TFF_DECL_SPECIFIERS))
1292 else if (DECL_STATIC_FUNCTION_P (t))
1293 pp_cxx_ws_string (cxx_pp, "static");
1294 else if (DECL_VIRTUAL_P (t))
1295 pp_cxx_ws_string (cxx_pp, "virtual");
1297 /* Print the return type? */
1299 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1300 && !DECL_DESTRUCTOR_P (t);
1302 dump_type_prefix (TREE_TYPE (fntype), flags);
1304 /* Print the function name. */
1305 if (!do_outer_scope)
1309 dump_type (cname, flags);
1310 pp_cxx_colon_colon (cxx_pp);
1313 dump_scope (CP_DECL_CONTEXT (t), flags);
1315 dump_function_name (t, flags);
1317 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1319 dump_parameters (parmtypes, flags);
1321 if (TREE_CODE (fntype) == METHOD_TYPE)
1323 pp_base (cxx_pp)->padding = pp_before;
1324 pp_cxx_cv_qualifier_seq
1325 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1328 if (flags & TFF_EXCEPTION_SPECIFICATION)
1330 pp_base (cxx_pp)->padding = pp_before;
1331 dump_exception_spec (exceptions, flags);
1335 dump_type_suffix (TREE_TYPE (fntype), flags);
1338 /* If T is a template instantiation, dump the parameter binding. */
1339 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1341 pp_cxx_whitespace (cxx_pp);
1342 pp_cxx_left_bracket (cxx_pp);
1343 pp_cxx_ws_string (cxx_pp, M_("with"));
1344 pp_cxx_whitespace (cxx_pp);
1345 dump_template_bindings (template_parms, template_args, typenames);
1346 pp_cxx_right_bracket (cxx_pp);
1350 /* Print a parameter list. If this is for a member function, the
1351 member object ptr (and any other hidden args) should have
1352 already been removed. */
1355 dump_parameters (tree parmtypes, int flags)
1358 pp_cxx_left_paren (cxx_pp);
1360 for (first = 1; parmtypes != void_list_node;
1361 parmtypes = TREE_CHAIN (parmtypes))
1364 pp_separate_with_comma (cxx_pp);
1368 pp_cxx_ws_string (cxx_pp, "...");
1372 dump_type (TREE_VALUE (parmtypes), flags);
1374 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1376 pp_cxx_whitespace (cxx_pp);
1378 pp_cxx_whitespace (cxx_pp);
1379 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1383 pp_cxx_right_paren (cxx_pp);
1386 /* Print an exception specification. T is the exception specification. */
1389 dump_exception_spec (tree t, int flags)
1393 pp_cxx_ws_string (cxx_pp, "throw");
1394 pp_cxx_whitespace (cxx_pp);
1395 pp_cxx_left_paren (cxx_pp);
1396 if (TREE_VALUE (t) != NULL_TREE)
1399 dump_type (TREE_VALUE (t), flags);
1403 pp_separate_with_comma (cxx_pp);
1405 pp_cxx_right_paren (cxx_pp);
1409 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1410 and destructors properly. */
1413 dump_function_name (tree t, int flags)
1415 tree name = DECL_NAME (t);
1417 /* We can get here with a decl that was synthesized by language-
1418 independent machinery (e.g. coverage.c) in which case it won't
1419 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1420 will crash. In this case it is safe just to print out the
1422 if (!DECL_LANG_SPECIFIC (t))
1424 pp_cxx_tree_identifier (cxx_pp, name);
1428 if (TREE_CODE (t) == TEMPLATE_DECL)
1429 t = DECL_TEMPLATE_RESULT (t);
1431 /* Don't let the user see __comp_ctor et al. */
1432 if (DECL_CONSTRUCTOR_P (t)
1433 || DECL_DESTRUCTOR_P (t))
1435 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1436 name = get_identifier ("<lambda>");
1438 name = constructor_name (DECL_CONTEXT (t));
1441 if (DECL_DESTRUCTOR_P (t))
1443 pp_cxx_complement (cxx_pp);
1444 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1446 else if (DECL_CONV_FN_P (t))
1448 /* This cannot use the hack that the operator's return
1449 type is stashed off of its name because it may be
1450 used for error reporting. In the case of conflicting
1451 declarations, both will have the same name, yet
1452 the types will be different, hence the TREE_TYPE field
1453 of the first name will be clobbered by the second. */
1454 pp_cxx_ws_string (cxx_pp, "operator");
1455 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1457 else if (name && IDENTIFIER_OPNAME_P (name))
1458 pp_cxx_tree_identifier (cxx_pp, name);
1460 dump_decl (name, flags);
1462 if (DECL_TEMPLATE_INFO (t)
1463 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1464 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1465 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1466 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1469 /* Dump the template parameters from the template info INFO under control of
1470 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1471 specialization (partial or complete). For partial specializations we show
1472 the specialized parameter values. For a primary template we show no
1476 dump_template_parms (tree info, int primary, int flags)
1478 tree args = info ? TI_ARGS (info) : NULL_TREE;
1480 if (primary && flags & TFF_TEMPLATE_NAME)
1482 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1483 pp_cxx_begin_template_argument_list (cxx_pp);
1485 /* Be careful only to print things when we have them, so as not
1486 to crash producing error messages. */
1487 if (args && !primary)
1490 /* We don't know the parms for a friend template specialization. */
1491 tree params = (TREE_CODE (TI_TEMPLATE (info)) == TEMPLATE_DECL
1492 ? DECL_INNERMOST_TEMPLATE_PARMS (TI_TEMPLATE (info))
1495 len = count_non_default_template_args (args, params, flags);
1497 args = INNERMOST_TEMPLATE_ARGS (args);
1498 for (ix = 0; ix != len; ix++)
1500 tree arg = TREE_VEC_ELT (args, ix);
1502 /* Only print a comma if we know there is an argument coming. In
1503 the case of an empty template argument pack, no actual
1504 argument will be printed. */
1506 && (!ARGUMENT_PACK_P (arg)
1507 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1508 pp_separate_with_comma (cxx_pp);
1511 pp_string (cxx_pp, M_("<template parameter error>"));
1513 dump_template_argument (arg, flags);
1518 tree tpl = TI_TEMPLATE (info);
1519 tree parms = DECL_TEMPLATE_PARMS (tpl);
1522 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1523 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1525 for (ix = 0; ix != len; ix++)
1529 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1531 pp_string (cxx_pp, M_("<template parameter error>"));
1535 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1538 pp_separate_with_comma (cxx_pp);
1540 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1543 pp_cxx_end_template_argument_list (cxx_pp);
1546 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1547 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1550 dump_call_expr_args (tree t, int flags, bool skipfirst)
1553 call_expr_arg_iterator iter;
1555 pp_cxx_left_paren (cxx_pp);
1556 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1562 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1563 if (more_call_expr_args_p (&iter))
1564 pp_separate_with_comma (cxx_pp);
1567 pp_cxx_right_paren (cxx_pp);
1570 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1571 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1575 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1578 aggr_init_expr_arg_iterator iter;
1580 pp_cxx_left_paren (cxx_pp);
1581 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1587 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1588 if (more_aggr_init_expr_args_p (&iter))
1589 pp_separate_with_comma (cxx_pp);
1592 pp_cxx_right_paren (cxx_pp);
1595 /* Print out a list of initializers (subr of dump_expr). */
1598 dump_expr_list (tree l, int flags)
1602 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1605 pp_separate_with_comma (cxx_pp);
1609 /* Print out a vector of initializers (subr of dump_expr). */
1612 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1614 unsigned HOST_WIDE_INT idx;
1617 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1619 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1620 if (idx != VEC_length (constructor_elt, v) - 1)
1621 pp_separate_with_comma (cxx_pp);
1626 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1627 function. Resolve it to a close relative -- in the sense of static
1628 type -- variant being overridden. That is close to what was written in
1629 the source code. Subroutine of dump_expr. */
1632 resolve_virtual_fun_from_obj_type_ref (tree ref)
1634 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1635 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1636 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1639 fun = TREE_CHAIN (fun);
1640 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1641 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1647 /* Print out an expression E under control of FLAGS. */
1650 dump_expr (tree t, int flags)
1655 if (STATEMENT_CLASS_P (t))
1657 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1661 switch (TREE_CODE (t))
1669 case NAMESPACE_DECL:
1672 case IDENTIFIER_NODE:
1673 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1680 pp_constant (cxx_pp, t);
1684 /* While waiting for caret diagnostics, avoid printing
1685 __cxa_allocate_exception, __cxa_throw, and the like. */
1686 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1690 pp_ampersand (cxx_pp);
1691 dump_type (PTRMEM_CST_CLASS (t), flags);
1692 pp_cxx_colon_colon (cxx_pp);
1693 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1697 pp_cxx_left_paren (cxx_pp);
1698 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1699 pp_separate_with_comma (cxx_pp);
1700 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1701 pp_cxx_right_paren (cxx_pp);
1705 pp_cxx_left_paren (cxx_pp);
1706 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1707 pp_string (cxx_pp, " ? ");
1708 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1709 pp_string (cxx_pp, " : ");
1710 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1711 pp_cxx_right_paren (cxx_pp);
1715 if (TREE_HAS_CONSTRUCTOR (t))
1717 pp_cxx_ws_string (cxx_pp, "new");
1718 pp_cxx_whitespace (cxx_pp);
1719 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1722 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1725 case AGGR_INIT_EXPR:
1727 tree fn = NULL_TREE;
1729 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1730 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1732 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1734 if (DECL_CONSTRUCTOR_P (fn))
1735 dump_type (DECL_CONTEXT (fn), flags);
1740 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1742 dump_aggr_init_expr_args (t, flags, true);
1747 tree fn = CALL_EXPR_FN (t);
1748 bool skipfirst = false;
1750 if (TREE_CODE (fn) == ADDR_EXPR)
1751 fn = TREE_OPERAND (fn, 0);
1753 /* Nobody is interested in seeing the guts of vcalls. */
1754 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1755 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1757 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1759 tree ob = CALL_EXPR_ARG (t, 0);
1760 if (TREE_CODE (ob) == ADDR_EXPR)
1762 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1763 pp_cxx_dot (cxx_pp);
1765 else if (TREE_CODE (ob) != PARM_DECL
1766 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1768 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1769 pp_cxx_arrow (cxx_pp);
1773 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1774 dump_call_expr_args (t, flags, skipfirst);
1779 /* Note that this only works for G++ target exprs. If somebody
1780 builds a general TARGET_EXPR, there's no way to represent that
1781 it initializes anything other that the parameter slot for the
1782 default argument. Note we may have cleared out the first
1783 operand in expand_expr, so don't go killing ourselves. */
1784 if (TREE_OPERAND (t, 1))
1785 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1788 case POINTER_PLUS_EXPR:
1789 dump_binary_op ("+", t, flags);
1797 case TRUNC_DIV_EXPR:
1798 case TRUNC_MOD_EXPR:
1806 case TRUTH_ANDIF_EXPR:
1807 case TRUTH_ORIF_EXPR:
1814 case EXACT_DIV_EXPR:
1815 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1819 case FLOOR_DIV_EXPR:
1820 case ROUND_DIV_EXPR:
1822 dump_binary_op ("/", t, flags);
1826 case FLOOR_MOD_EXPR:
1827 case ROUND_MOD_EXPR:
1828 dump_binary_op ("%", t, flags);
1833 tree ob = TREE_OPERAND (t, 0);
1834 if (TREE_CODE (ob) == INDIRECT_REF)
1836 ob = TREE_OPERAND (ob, 0);
1837 if (TREE_CODE (ob) != PARM_DECL
1839 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1841 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1842 pp_cxx_arrow (cxx_pp);
1847 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1848 pp_cxx_dot (cxx_pp);
1850 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1855 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1856 pp_cxx_left_bracket (cxx_pp);
1857 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1858 pp_cxx_right_bracket (cxx_pp);
1861 case UNARY_PLUS_EXPR:
1862 dump_unary_op ("+", t, flags);
1866 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1867 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1868 /* An ADDR_EXPR can have reference type. In that case, we
1869 shouldn't print the `&' doing so indicates to the user
1870 that the expression has pointer type. */
1872 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1873 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1874 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1875 dump_unary_op ("&&", t, flags);
1877 dump_unary_op ("&", t, flags);
1881 if (TREE_HAS_CONSTRUCTOR (t))
1883 t = TREE_OPERAND (t, 0);
1884 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1885 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1886 dump_call_expr_args (t, flags, true);
1890 if (TREE_OPERAND (t,0) != NULL_TREE
1891 && TREE_TYPE (TREE_OPERAND (t, 0))
1892 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1893 dump_expr (TREE_OPERAND (t, 0), flags);
1895 dump_unary_op ("*", t, flags);
1901 case TRUTH_NOT_EXPR:
1902 case PREDECREMENT_EXPR:
1903 case PREINCREMENT_EXPR:
1904 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1907 case POSTDECREMENT_EXPR:
1908 case POSTINCREMENT_EXPR:
1909 pp_cxx_left_paren (cxx_pp);
1910 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1911 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1912 pp_cxx_right_paren (cxx_pp);
1915 case NON_LVALUE_EXPR:
1916 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1917 should be another level of INDIRECT_REF so that I don't have to do
1919 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1921 tree next = TREE_TYPE (TREE_TYPE (t));
1923 while (TREE_CODE (next) == POINTER_TYPE)
1924 next = TREE_TYPE (next);
1926 if (TREE_CODE (next) == FUNCTION_TYPE)
1928 if (flags & TFF_EXPR_IN_PARENS)
1929 pp_cxx_left_paren (cxx_pp);
1930 pp_cxx_star (cxx_pp);
1931 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1932 if (flags & TFF_EXPR_IN_PARENS)
1933 pp_cxx_right_paren (cxx_pp);
1936 /* Else fall through. */
1938 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1942 case VIEW_CONVERT_EXPR:
1944 tree op = TREE_OPERAND (t, 0);
1946 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1948 /* It is a cast, but we cannot tell whether it is a
1949 reinterpret or static cast. Use the C style notation. */
1950 if (flags & TFF_EXPR_IN_PARENS)
1951 pp_cxx_left_paren (cxx_pp);
1952 pp_cxx_left_paren (cxx_pp);
1953 dump_type (TREE_TYPE (t), flags);
1954 pp_cxx_right_paren (cxx_pp);
1955 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1956 if (flags & TFF_EXPR_IN_PARENS)
1957 pp_cxx_right_paren (cxx_pp);
1960 dump_expr (op, flags);
1965 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1967 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1969 if (integer_zerop (idx))
1971 /* A NULL pointer-to-member constant. */
1972 pp_cxx_left_paren (cxx_pp);
1973 pp_cxx_left_paren (cxx_pp);
1974 dump_type (TREE_TYPE (t), flags);
1975 pp_cxx_right_paren (cxx_pp);
1976 pp_character (cxx_pp, '0');
1977 pp_cxx_right_paren (cxx_pp);
1980 else if (host_integerp (idx, 0))
1983 unsigned HOST_WIDE_INT n;
1985 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1986 t = TYPE_METHOD_BASETYPE (t);
1987 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1989 n = tree_low_cst (idx, 0);
1991 /* Map vtable index back one, to allow for the null pointer to
1995 while (n > 0 && virtuals)
1998 virtuals = TREE_CHAIN (virtuals);
2002 dump_expr (BV_FN (virtuals),
2003 flags | TFF_EXPR_IN_PARENS);
2008 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2010 dump_type (TREE_TYPE (t), 0);
2011 pp_cxx_left_paren (cxx_pp);
2012 pp_cxx_right_paren (cxx_pp);
2016 pp_cxx_left_brace (cxx_pp);
2017 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
2018 pp_cxx_right_brace (cxx_pp);
2025 tree ob = TREE_OPERAND (t, 0);
2026 if (is_dummy_object (ob))
2028 t = TREE_OPERAND (t, 1);
2029 if (TREE_CODE (t) == FUNCTION_DECL)
2031 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
2032 else if (BASELINK_P (t))
2033 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2034 flags | TFF_EXPR_IN_PARENS);
2036 dump_decl (t, flags);
2040 if (TREE_CODE (ob) == INDIRECT_REF)
2042 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2043 pp_cxx_arrow (cxx_pp);
2044 pp_cxx_star (cxx_pp);
2048 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2049 pp_cxx_dot (cxx_pp);
2050 pp_cxx_star (cxx_pp);
2052 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2057 case TEMPLATE_PARM_INDEX:
2058 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2062 if (TREE_OPERAND (t, 0) == NULL_TREE
2063 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2065 dump_type (TREE_TYPE (t), flags);
2066 pp_cxx_left_paren (cxx_pp);
2067 dump_expr_list (TREE_OPERAND (t, 0), flags);
2068 pp_cxx_right_paren (cxx_pp);
2072 pp_cxx_left_paren (cxx_pp);
2073 dump_type (TREE_TYPE (t), flags);
2074 pp_cxx_right_paren (cxx_pp);
2075 pp_cxx_left_paren (cxx_pp);
2076 dump_expr_list (TREE_OPERAND (t, 0), flags);
2077 pp_cxx_right_paren (cxx_pp);
2081 case STATIC_CAST_EXPR:
2082 pp_cxx_ws_string (cxx_pp, "static_cast");
2084 case REINTERPRET_CAST_EXPR:
2085 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2087 case CONST_CAST_EXPR:
2088 pp_cxx_ws_string (cxx_pp, "const_cast");
2090 case DYNAMIC_CAST_EXPR:
2091 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2093 pp_cxx_begin_template_argument_list (cxx_pp);
2094 dump_type (TREE_TYPE (t), flags);
2095 pp_cxx_end_template_argument_list (cxx_pp);
2096 pp_cxx_left_paren (cxx_pp);
2097 dump_expr (TREE_OPERAND (t, 0), flags);
2098 pp_cxx_right_paren (cxx_pp);
2102 dump_expr (TREE_OPERAND (t, 0), flags);
2103 pp_cxx_arrow (cxx_pp);
2108 if (TREE_CODE (t) == SIZEOF_EXPR)
2109 pp_cxx_ws_string (cxx_pp, "sizeof");
2112 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2113 pp_cxx_ws_string (cxx_pp, "__alignof__");
2115 pp_cxx_whitespace (cxx_pp);
2116 pp_cxx_left_paren (cxx_pp);
2117 if (TYPE_P (TREE_OPERAND (t, 0)))
2118 dump_type (TREE_OPERAND (t, 0), flags);
2120 dump_expr (TREE_OPERAND (t, 0), flags);
2121 pp_cxx_right_paren (cxx_pp);
2126 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2127 pp_cxx_whitespace (cxx_pp);
2128 dump_expr (TREE_OPERAND (t, 0), flags);
2132 pp_string (cxx_pp, M_("<unparsed>"));
2135 case TRY_CATCH_EXPR:
2136 case WITH_CLEANUP_EXPR:
2137 case CLEANUP_POINT_EXPR:
2138 dump_expr (TREE_OPERAND (t, 0), flags);
2141 case PSEUDO_DTOR_EXPR:
2142 dump_expr (TREE_OPERAND (t, 2), flags);
2143 pp_cxx_dot (cxx_pp);
2144 dump_type (TREE_OPERAND (t, 0), flags);
2145 pp_cxx_colon_colon (cxx_pp);
2146 pp_cxx_complement (cxx_pp);
2147 dump_type (TREE_OPERAND (t, 1), flags);
2150 case TEMPLATE_ID_EXPR:
2151 dump_decl (t, flags);
2157 case STATEMENT_LIST:
2158 /* We don't yet have a way of dumping statements in a
2159 human-readable format. */
2160 pp_string (cxx_pp, "({...})");
2164 pp_string (cxx_pp, "while (1) { ");
2165 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2166 pp_cxx_right_brace (cxx_pp);
2170 pp_string (cxx_pp, "if (");
2171 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2172 pp_string (cxx_pp, ") break; ");
2176 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2179 case EMPTY_CLASS_EXPR:
2180 dump_type (TREE_TYPE (t), flags);
2181 pp_cxx_left_paren (cxx_pp);
2182 pp_cxx_right_paren (cxx_pp);
2185 case NON_DEPENDENT_EXPR:
2186 dump_expr (TREE_OPERAND (t, 0), flags);
2189 case ARGUMENT_PACK_SELECT:
2190 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2202 pp_type_specifier_seq (cxx_pp, t);
2206 /* We get here when we want to print a dependent type as an
2207 id-expression, without any disambiguator decoration. */
2208 pp_id_expression (cxx_pp, t);
2211 case TEMPLATE_TYPE_PARM:
2212 case BOUND_TEMPLATE_TEMPLATE_PARM:
2213 dump_type (t, flags);
2217 pp_cxx_trait_expression (cxx_pp, t);
2221 pp_cxx_va_arg_expression (cxx_pp, t);
2225 pp_cxx_offsetof_expression (cxx_pp, t);
2229 dump_decl (t, flags);
2232 case EXPR_PACK_EXPANSION:
2239 case VEC_DELETE_EXPR:
2245 case UNORDERED_EXPR:
2255 case FIX_TRUNC_EXPR:
2257 pp_expression (cxx_pp, t);
2260 case TRUTH_AND_EXPR:
2262 case TRUTH_XOR_EXPR:
2263 if (flags & TFF_EXPR_IN_PARENS)
2264 pp_cxx_left_paren (cxx_pp);
2265 pp_expression (cxx_pp, t);
2266 if (flags & TFF_EXPR_IN_PARENS)
2267 pp_cxx_right_paren (cxx_pp);
2271 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2274 /* This list is incomplete, but should suffice for now.
2275 It is very important that `sorry' does not call
2276 `report_error_function'. That could cause an infinite loop. */
2278 pp_unsupported_tree (cxx_pp, t);
2279 /* fall through to ERROR_MARK... */
2281 pp_string (cxx_pp, M_("<expression error>"));
2287 dump_binary_op (const char *opstring, tree t, int flags)
2289 pp_cxx_left_paren (cxx_pp);
2290 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2291 pp_cxx_whitespace (cxx_pp);
2293 pp_cxx_ws_string (cxx_pp, opstring);
2295 pp_string (cxx_pp, M_("<unknown operator>"));
2296 pp_cxx_whitespace (cxx_pp);
2297 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2298 pp_cxx_right_paren (cxx_pp);
2302 dump_unary_op (const char *opstring, tree t, int flags)
2304 if (flags & TFF_EXPR_IN_PARENS)
2305 pp_cxx_left_paren (cxx_pp);
2306 pp_cxx_ws_string (cxx_pp, opstring);
2307 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2308 if (flags & TFF_EXPR_IN_PARENS)
2309 pp_cxx_right_paren (cxx_pp);
2313 reinit_cxx_pp (void)
2315 pp_clear_output_area (cxx_pp);
2316 pp_base (cxx_pp)->padding = pp_none;
2317 pp_indentation (cxx_pp) = 0;
2318 pp_needs_newline (cxx_pp) = false;
2319 cxx_pp->enclosing_scope = current_function_decl;
2323 /* Exported interface to stringifying types, exprs and decls under TFF_*
2327 type_as_string (tree typ, int flags)
2330 pp_translate_identifiers (cxx_pp) = false;
2331 dump_type (typ, flags);
2332 return pp_formatted_text (cxx_pp);
2336 type_as_string_translate (tree typ, int flags)
2339 dump_type (typ, flags);
2340 return pp_formatted_text (cxx_pp);
2344 expr_as_string (tree decl, int flags)
2347 pp_translate_identifiers (cxx_pp) = false;
2348 dump_expr (decl, flags);
2349 return pp_formatted_text (cxx_pp);
2353 decl_as_string (tree decl, int flags)
2356 pp_translate_identifiers (cxx_pp) = false;
2357 dump_decl (decl, flags);
2358 return pp_formatted_text (cxx_pp);
2362 decl_as_string_translate (tree decl, int flags)
2365 dump_decl (decl, flags);
2366 return pp_formatted_text (cxx_pp);
2369 /* Generate the three forms of printable names for cxx_printable_name. */
2372 lang_decl_name (tree decl, int v, bool translate)
2376 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2377 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2380 pp_translate_identifiers (cxx_pp) = translate;
2382 && (DECL_CLASS_SCOPE_P (decl)
2383 || (DECL_NAMESPACE_SCOPE_P (decl)
2384 && CP_DECL_CONTEXT (decl) != global_namespace)))
2386 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2387 pp_cxx_colon_colon (cxx_pp);
2390 if (TREE_CODE (decl) == FUNCTION_DECL)
2391 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2393 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2395 return pp_formatted_text (cxx_pp);
2398 /* Return the location of a tree passed to %+ formats. */
2401 location_of (tree t)
2403 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2404 t = DECL_CONTEXT (t);
2405 else if (TYPE_P (t))
2406 t = TYPE_MAIN_DECL (t);
2407 else if (TREE_CODE (t) == OVERLOAD)
2408 t = OVL_FUNCTION (t);
2410 return DECL_SOURCE_LOCATION (t);
2413 /* Now the interfaces from error et al to dump_type et al. Each takes an
2414 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2418 decl_to_string (tree decl, int verbose)
2422 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2423 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2424 flags = TFF_CLASS_KEY_OR_ENUM;
2426 flags |= TFF_DECL_SPECIFIERS;
2427 else if (TREE_CODE (decl) == FUNCTION_DECL)
2428 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2429 flags |= TFF_TEMPLATE_HEADER;
2432 dump_decl (decl, flags);
2433 return pp_formatted_text (cxx_pp);
2437 expr_to_string (tree decl)
2440 dump_expr (decl, 0);
2441 return pp_formatted_text (cxx_pp);
2445 fndecl_to_string (tree fndecl, int verbose)
2449 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2450 | TFF_TEMPLATE_HEADER;
2452 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2454 dump_decl (fndecl, flags);
2455 return pp_formatted_text (cxx_pp);
2460 code_to_string (enum tree_code c)
2462 return tree_code_name [c];
2466 language_to_string (enum languages c)
2473 case lang_cplusplus:
2485 /* Return the proper printed version of a parameter to a C++ function. */
2488 parm_to_string (int p)
2492 pp_string (cxx_pp, "'this'");
2494 pp_decimal_int (cxx_pp, p + 1);
2495 return pp_formatted_text (cxx_pp);
2499 op_to_string (enum tree_code p)
2501 tree id = operator_name_info[(int) p].identifier;
2502 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2506 type_to_string (tree typ, int verbose)
2510 flags |= TFF_CLASS_KEY_OR_ENUM;
2511 flags |= TFF_TEMPLATE_HEADER;
2514 dump_type (typ, flags);
2515 return pp_formatted_text (cxx_pp);
2519 assop_to_string (enum tree_code p)
2521 tree id = assignment_operator_name_info[(int) p].identifier;
2522 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2526 args_to_string (tree p, int verbose)
2530 flags |= TFF_CLASS_KEY_OR_ENUM;
2535 if (TYPE_P (TREE_VALUE (p)))
2536 return type_as_string_translate (p, flags);
2539 for (; p; p = TREE_CHAIN (p))
2541 if (TREE_VALUE (p) == null_node)
2542 pp_cxx_ws_string (cxx_pp, "NULL");
2544 dump_type (error_type (TREE_VALUE (p)), flags);
2546 pp_separate_with_comma (cxx_pp);
2548 return pp_formatted_text (cxx_pp);
2552 cv_to_string (tree p, int v)
2555 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2556 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2557 return pp_formatted_text (cxx_pp);
2560 /* Langhook for print_error_function. */
2562 cxx_print_error_function (diagnostic_context *context, const char *file,
2563 diagnostic_info *diagnostic)
2565 lhd_print_error_function (context, file, diagnostic);
2566 pp_base_set_prefix (context->printer, file);
2567 maybe_print_instantiation_context (context);
2571 cp_diagnostic_starter (diagnostic_context *context,
2572 diagnostic_info *diagnostic)
2574 diagnostic_report_current_module (context);
2575 cp_print_error_function (context, diagnostic);
2576 maybe_print_instantiation_context (context);
2577 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2581 cp_diagnostic_finalizer (diagnostic_context *context,
2582 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2584 pp_base_destroy_prefix (context->printer);
2587 /* Print current function onto BUFFER, in the process of reporting
2588 a diagnostic message. Called from cp_diagnostic_starter. */
2590 cp_print_error_function (diagnostic_context *context,
2591 diagnostic_info *diagnostic)
2593 if (diagnostic_last_function_changed (context, diagnostic))
2595 const char *old_prefix = context->printer->prefix;
2596 const char *file = LOCATION_FILE (diagnostic->location);
2597 tree abstract_origin = diagnostic->abstract_origin;
2598 char *new_prefix = (file && abstract_origin == NULL)
2599 ? file_name_as_prefix (file) : NULL;
2601 pp_base_set_prefix (context->printer, new_prefix);
2603 if (current_function_decl == NULL)
2604 pp_base_string (context->printer, _("At global scope:"));
2609 if (abstract_origin)
2611 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2612 while (TREE_CODE (ao) == BLOCK
2613 && BLOCK_ABSTRACT_ORIGIN (ao)
2614 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2615 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2616 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2620 fndecl = current_function_decl;
2622 pp_printf (context->printer, function_category (fndecl),
2623 cxx_printable_name_translate (fndecl, 2));
2625 while (abstract_origin)
2628 tree block = abstract_origin;
2630 locus = &BLOCK_SOURCE_LOCATION (block);
2632 block = BLOCK_SUPERCONTEXT (block);
2633 while (block && TREE_CODE (block) == BLOCK
2634 && BLOCK_ABSTRACT_ORIGIN (block))
2636 ao = BLOCK_ABSTRACT_ORIGIN (block);
2638 while (TREE_CODE (ao) == BLOCK
2639 && BLOCK_ABSTRACT_ORIGIN (ao)
2640 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2641 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2643 if (TREE_CODE (ao) == FUNCTION_DECL)
2648 else if (TREE_CODE (ao) != BLOCK)
2651 block = BLOCK_SUPERCONTEXT (block);
2654 abstract_origin = block;
2657 while (block && TREE_CODE (block) == BLOCK)
2658 block = BLOCK_SUPERCONTEXT (block);
2660 if (block && TREE_CODE (block) == FUNCTION_DECL)
2662 abstract_origin = NULL;
2666 expanded_location s = expand_location (*locus);
2667 pp_base_character (context->printer, ',');
2668 pp_base_newline (context->printer);
2671 if (flag_show_column && s.column != 0)
2672 pp_printf (context->printer,
2673 _(" inlined from %qs at %s:%d:%d"),
2674 cxx_printable_name_translate (fndecl, 2),
2675 s.file, s.line, s.column);
2677 pp_printf (context->printer,
2678 _(" inlined from %qs at %s:%d"),
2679 cxx_printable_name_translate (fndecl, 2),
2684 pp_printf (context->printer, _(" inlined from %qs"),
2685 cxx_printable_name_translate (fndecl, 2));
2688 pp_base_character (context->printer, ':');
2690 pp_base_newline (context->printer);
2692 diagnostic_set_last_function (context, diagnostic);
2693 pp_base_destroy_prefix (context->printer);
2694 context->printer->prefix = old_prefix;
2698 /* Returns a description of FUNCTION using standard terminology. The
2699 result is a format string of the form "In CATEGORY %qs". */
2701 function_category (tree fn)
2703 /* We can get called from the middle-end for diagnostics of function
2704 clones. Make sure we have language specific information before
2705 dereferencing it. */
2706 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
2707 && DECL_FUNCTION_MEMBER_P (fn))
2709 if (DECL_STATIC_FUNCTION_P (fn))
2710 return _("In static member function %qs");
2711 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2712 return _("In copy constructor %qs");
2713 else if (DECL_CONSTRUCTOR_P (fn))
2714 return _("In constructor %qs");
2715 else if (DECL_DESTRUCTOR_P (fn))
2716 return _("In destructor %qs");
2717 else if (LAMBDA_FUNCTION_P (fn))
2718 return _("In lambda function");
2720 return _("In member function %qs");
2723 return _("In function %qs");
2726 /* Report the full context of a current template instantiation,
2729 print_instantiation_full_context (diagnostic_context *context)
2731 struct tinst_level *p = current_instantiation ();
2732 location_t location = input_location;
2736 if (current_function_decl != p->decl
2737 && current_function_decl != NULL_TREE)
2738 /* We can get here during the processing of some synthesized
2739 method. Then, P->DECL will be the function that's causing
2744 if (current_function_decl == p->decl)
2745 /* Avoid redundancy with the "In function" line. */;
2747 pp_verbatim (context->printer,
2748 _("%s: In instantiation of %qs:\n"),
2749 LOCATION_FILE (location),
2750 decl_as_string_translate (p->decl,
2751 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2753 location = p->locus;
2758 print_instantiation_partial_context (context, p, location);
2761 /* Same as above but less verbose. */
2763 print_instantiation_partial_context (diagnostic_context *context,
2764 struct tinst_level *t, location_t loc)
2766 expanded_location xloc;
2768 for (; ; t = t->next)
2770 xloc = expand_location (loc);
2773 str = decl_as_string_translate (t->decl,
2774 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE);
2775 if (flag_show_column)
2776 pp_verbatim (context->printer,
2777 _("%s:%d:%d: instantiated from %qs\n"),
2778 xloc.file, xloc.line, xloc.column, str);
2780 pp_verbatim (context->printer,
2781 _("%s:%d: instantiated from %qs\n"),
2782 xloc.file, xloc.line, str);
2785 if (flag_show_column)
2786 pp_verbatim (context->printer, _("%s:%d:%d: instantiated from here"),
2787 xloc.file, xloc.line, xloc.column);
2789 pp_verbatim (context->printer, _("%s:%d: instantiated from here"),
2790 xloc.file, xloc.line);
2791 pp_base_newline (context->printer);
2794 /* Called from cp_thing to print the template context for an error. */
2796 maybe_print_instantiation_context (diagnostic_context *context)
2798 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2801 record_last_problematic_instantiation ();
2802 print_instantiation_full_context (context);
2805 /* Report the bare minimum context of a template instantiation. */
2807 print_instantiation_context (void)
2809 print_instantiation_partial_context
2810 (global_dc, current_instantiation (), input_location);
2811 diagnostic_flush_buffer (global_dc);
2814 /* Called from output_format -- during diagnostic message processing --
2815 to handle C++ specific format specifier with the following meanings:
2816 %A function argument-list.
2820 %F function declaration.
2821 %L language as used in extern "lang".
2823 %P function parameter whose position is indicated by an integer.
2824 %Q assignment operator.
2828 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2829 int precision, bool wide, bool set_locus, bool verbose)
2833 #define next_tree (t = va_arg (*text->args_ptr, tree))
2834 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
2835 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
2836 #define next_int va_arg (*text->args_ptr, int)
2838 if (precision != 0 || wide)
2841 if (text->locus == NULL)
2846 case 'A': result = args_to_string (next_tree, verbose); break;
2847 case 'C': result = code_to_string (next_tcode); break;
2850 tree temp = next_tree;
2852 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2854 temp = DECL_DEBUG_EXPR (temp);
2857 result = expr_to_string (temp);
2861 result = decl_to_string (temp, verbose);
2864 case 'E': result = expr_to_string (next_tree); break;
2865 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2866 case 'L': result = language_to_string (next_lang); break;
2867 case 'O': result = op_to_string (next_tcode); break;
2868 case 'P': result = parm_to_string (next_int); break;
2869 case 'Q': result = assop_to_string (next_tcode); break;
2870 case 'T': result = type_to_string (next_tree, verbose); break;
2871 case 'V': result = cv_to_string (next_tree, verbose); break;
2877 pp_base_string (pp, result);
2878 if (set_locus && t != NULL)
2879 *text->locus = location_of (t);
2887 /* Warn about the use of C++0x features when appropriate. */
2889 maybe_warn_cpp0x (cpp0x_warn_str str)
2891 if ((cxx_dialect == cxx98) && !in_system_header)
2892 /* We really want to suppress this warning in system headers,
2893 because libstdc++ uses variadic templates even when we aren't
2897 case CPP0X_INITIALIZER_LISTS:
2898 pedwarn (input_location, 0,
2899 "extended initializer lists "
2900 "only available with -std=c++0x or -std=gnu++0x");
2902 case CPP0X_EXPLICIT_CONVERSION:
2903 pedwarn (input_location, 0,
2904 "explicit conversion operators "
2905 "only available with -std=c++0x or -std=gnu++0x");
2907 case CPP0X_VARIADIC_TEMPLATES:
2908 pedwarn (input_location, 0,
2909 "variadic templates "
2910 "only available with -std=c++0x or -std=gnu++0x");
2912 case CPP0X_LAMBDA_EXPR:
2913 pedwarn (input_location, 0,
2914 "lambda expressions "
2915 "only available with -std=c++0x or -std=gnu++0x");
2918 pedwarn (input_location, 0,
2919 "C++0x auto only available with -std=c++0x or -std=gnu++0x");
2921 case CPP0X_SCOPED_ENUMS:
2922 pedwarn (input_location, 0,
2923 "scoped enums only available with -std=c++0x or -std=gnu++0x");
2925 case CPP0X_DEFAULTED_DELETED:
2926 pedwarn (input_location, 0,
2927 "defaulted and deleted functions "
2928 "only available with -std=c++0x or -std=gnu++0x");
2935 /* Warn about the use of variadic templates when appropriate. */
2937 maybe_warn_variadic_templates (void)
2939 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
2943 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
2944 option OPT with text GMSGID. Use this function to report
2945 diagnostics for constructs that are invalid C++98, but valid
2948 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
2950 diagnostic_info diagnostic;
2953 va_start (ap, gmsgid);
2954 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
2955 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
2956 diagnostic.option_index = opt;
2958 return report_diagnostic (&diagnostic);