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, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010 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"
29 #include "diagnostic.h"
30 #include "tree-diagnostic.h"
31 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
34 #include "tree-pretty-print.h"
35 #include "pointer-set.h"
37 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
39 /* The global buffer where we dump everything. It is there only for
40 transitional purpose. It is expected, in the near future, to be
41 completely removed. */
42 static cxx_pretty_printer scratch_pretty_printer;
43 #define cxx_pp (&scratch_pretty_printer)
45 /* Translate if being used for diagnostics, but not for dump files or
47 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
49 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
51 static const char *args_to_string (tree, int);
52 static const char *assop_to_string (enum tree_code);
53 static const char *code_to_string (enum tree_code);
54 static const char *cv_to_string (tree, int);
55 static const char *decl_to_string (tree, int);
56 static const char *expr_to_string (tree);
57 static const char *fndecl_to_string (tree, int);
58 static const char *op_to_string (enum tree_code);
59 static const char *parm_to_string (int);
60 static const char *type_to_string (tree, int);
62 static void dump_type (tree, int);
63 static void dump_typename (tree, int);
64 static void dump_simple_decl (tree, tree, int);
65 static void dump_decl (tree, int);
66 static void dump_template_decl (tree, int);
67 static void dump_function_decl (tree, int);
68 static void dump_expr (tree, int);
69 static void dump_unary_op (const char *, tree, int);
70 static void dump_binary_op (const char *, tree, int);
71 static void dump_aggr_type (tree, int);
72 static void dump_type_prefix (tree, int);
73 static void dump_type_suffix (tree, int);
74 static void dump_function_name (tree, int);
75 static void dump_call_expr_args (tree, int, bool);
76 static void dump_aggr_init_expr_args (tree, int, bool);
77 static void dump_expr_list (tree, int);
78 static void dump_global_iord (tree);
79 static void dump_parameters (tree, int);
80 static void dump_exception_spec (tree, int);
81 static void dump_template_argument (tree, int);
82 static void dump_template_argument_list (tree, int);
83 static void dump_template_parameter (tree, int);
84 static void dump_template_bindings (tree, tree, VEC(tree,gc) *);
85 static void dump_scope (tree, int);
86 static void dump_template_parms (tree, int, int);
87 static int get_non_default_template_args_count (tree, int);
88 static const char *function_category (tree);
89 static void maybe_print_instantiation_context (diagnostic_context *);
90 static void print_instantiation_full_context (diagnostic_context *);
91 static void print_instantiation_partial_context (diagnostic_context *,
94 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
95 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
96 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
98 static bool cp_printer (pretty_printer *, text_info *, const char *,
99 int, bool, bool, bool);
100 static location_t location_of (tree);
105 diagnostic_starter (global_dc) = cp_diagnostic_starter;
106 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
107 diagnostic_format_decoder (global_dc) = cp_printer;
109 pp_construct (pp_base (cxx_pp), NULL, 0);
110 pp_cxx_pretty_printer_init (cxx_pp);
113 /* Dump a scope, if deemed necessary. */
116 dump_scope (tree scope, int flags)
118 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
120 if (scope == NULL_TREE)
123 if (TREE_CODE (scope) == NAMESPACE_DECL)
125 if (scope != global_namespace)
127 dump_decl (scope, f);
128 pp_cxx_colon_colon (cxx_pp);
131 else if (AGGREGATE_TYPE_P (scope))
133 dump_type (scope, f);
134 pp_cxx_colon_colon (cxx_pp);
136 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
138 dump_function_decl (scope, f);
139 pp_cxx_colon_colon (cxx_pp);
143 /* Dump the template ARGument under control of FLAGS. */
146 dump_template_argument (tree arg, int flags)
148 if (ARGUMENT_PACK_P (arg))
149 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), flags);
150 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
151 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
154 if (TREE_CODE (arg) == TREE_LIST)
155 arg = TREE_VALUE (arg);
157 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
161 /* Count the number of template arguments ARGS whose value does not
162 match the (optional) default template parameter in PARAMS */
165 get_non_default_template_args_count (tree args, int flags)
167 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
169 if (/* We use this flag when generating debug information. We don't
170 want to expand templates at this point, for this may generate
171 new decls, which gets decl counts out of sync, which may in
172 turn cause codegen differences between compilations with and
174 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
175 || !flag_pretty_templates)
178 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
181 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
185 dump_template_argument_list (tree args, int flags)
187 int n = get_non_default_template_args_count (args, flags);
191 for (i = 0; i < n; ++i)
193 tree arg = TREE_VEC_ELT (args, i);
195 /* Only print a comma if we know there is an argument coming. In
196 the case of an empty template argument pack, no actual
197 argument will be printed. */
199 && (!ARGUMENT_PACK_P (arg)
200 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
201 pp_separate_with_comma (cxx_pp);
203 dump_template_argument (arg, flags);
208 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
211 dump_template_parameter (tree parm, int flags)
216 if (parm == error_mark_node)
219 p = TREE_VALUE (parm);
220 a = TREE_PURPOSE (parm);
222 if (TREE_CODE (p) == TYPE_DECL)
224 if (flags & TFF_DECL_SPECIFIERS)
226 pp_cxx_ws_string (cxx_pp, "class");
227 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
228 pp_cxx_ws_string (cxx_pp, "...");
230 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
232 else if (DECL_NAME (p))
233 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
235 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
238 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
240 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
242 pp_cxx_whitespace (cxx_pp);
244 pp_cxx_whitespace (cxx_pp);
245 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
246 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
248 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
252 /* Dump, under control of FLAGS, a template-parameter-list binding.
253 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
257 dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames)
265 tree p = TREE_VALUE (parms);
266 int lvl = TMPL_PARMS_DEPTH (parms);
269 tree lvl_args = NULL_TREE;
271 /* Don't crash if we had an invalid argument list. */
272 if (TMPL_ARGS_DEPTH (args) >= lvl)
273 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
275 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
277 tree arg = NULL_TREE;
279 /* Don't crash if we had an invalid argument list. */
280 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
281 arg = TREE_VEC_ELT (lvl_args, arg_idx);
284 pp_separate_with_comma (cxx_pp);
285 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
286 pp_cxx_whitespace (cxx_pp);
288 pp_cxx_whitespace (cxx_pp);
291 if (ARGUMENT_PACK_P (arg))
292 pp_cxx_left_brace (cxx_pp);
293 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
294 if (ARGUMENT_PACK_P (arg))
295 pp_cxx_right_brace (cxx_pp);
298 pp_string (cxx_pp, M_("<missing>"));
304 parms = TREE_CHAIN (parms);
307 for (i = 0; VEC_iterate (tree, typenames, i, t); ++i)
310 pp_separate_with_comma (cxx_pp);
311 dump_type (t, TFF_PLAIN_IDENTIFIER);
312 pp_cxx_whitespace (cxx_pp);
314 pp_cxx_whitespace (cxx_pp);
315 t = tsubst (t, args, tf_none, NULL_TREE);
316 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
317 pp_simple_type_specifier doesn't know about it. */
318 t = strip_typedefs (t);
319 dump_type (t, TFF_PLAIN_IDENTIFIER);
323 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
327 dump_type (tree t, int flags)
332 if (TYPE_PTRMEMFUNC_P (t))
335 switch (TREE_CODE (t))
338 if (t == init_list_type_node)
339 pp_string (cxx_pp, M_("<brace-enclosed initializer list>"));
340 else if (t == unknown_type_node)
341 pp_string (cxx_pp, M_("<unresolved overloaded function type>"));
344 pp_cxx_cv_qualifier_seq (cxx_pp, t);
345 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
350 /* A list of function parms. */
351 dump_parameters (t, flags);
354 case IDENTIFIER_NODE:
355 pp_cxx_tree_identifier (cxx_pp, t);
359 dump_type (BINFO_TYPE (t), flags);
365 dump_aggr_type (t, flags);
369 if (flags & TFF_CHASE_TYPEDEF)
371 dump_type (DECL_ORIGINAL_TYPE (t)
372 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
375 /* Else fall through. */
379 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
388 case FIXED_POINT_TYPE:
389 pp_type_specifier_seq (cxx_pp, t);
392 case TEMPLATE_TEMPLATE_PARM:
393 /* For parameters inside template signature. */
394 if (TYPE_IDENTIFIER (t))
395 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
397 pp_cxx_canonical_template_parameter (cxx_pp, t);
400 case BOUND_TEMPLATE_TEMPLATE_PARM:
402 tree args = TYPE_TI_ARGS (t);
403 pp_cxx_cv_qualifier_seq (cxx_pp, t);
404 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
405 pp_cxx_begin_template_argument_list (cxx_pp);
406 dump_template_argument_list (args, flags);
407 pp_cxx_end_template_argument_list (cxx_pp);
411 case TEMPLATE_TYPE_PARM:
412 pp_cxx_cv_qualifier_seq (cxx_pp, t);
413 if (TYPE_IDENTIFIER (t))
414 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
416 pp_cxx_canonical_template_parameter
417 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
420 /* This is not always necessary for pointers and such, but doing this
421 reduces code size. */
430 dump_type_prefix (t, flags);
431 dump_type_suffix (t, flags);
435 if (! (flags & TFF_CHASE_TYPEDEF)
436 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
438 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
441 pp_cxx_cv_qualifier_seq (cxx_pp, t);
442 pp_cxx_ws_string (cxx_pp,
443 TYPENAME_IS_ENUM_P (t) ? "enum"
444 : TYPENAME_IS_CLASS_P (t) ? "class"
446 dump_typename (t, flags);
449 case UNBOUND_CLASS_TEMPLATE:
450 if (! (flags & TFF_UNQUALIFIED_NAME))
452 dump_type (TYPE_CONTEXT (t), flags);
453 pp_cxx_colon_colon (cxx_pp);
455 pp_cxx_ws_string (cxx_pp, "template");
456 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
460 pp_cxx_ws_string (cxx_pp, "__typeof__");
461 pp_cxx_whitespace (cxx_pp);
462 pp_cxx_left_paren (cxx_pp);
463 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
464 pp_cxx_right_paren (cxx_pp);
467 case TYPE_PACK_EXPANSION:
468 dump_type (PACK_EXPANSION_PATTERN (t), flags);
469 pp_cxx_ws_string (cxx_pp, "...");
472 case TYPE_ARGUMENT_PACK:
473 dump_template_argument (t, flags);
477 pp_cxx_ws_string (cxx_pp, "decltype");
478 pp_cxx_whitespace (cxx_pp);
479 pp_cxx_left_paren (cxx_pp);
480 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
481 pp_cxx_right_paren (cxx_pp);
485 pp_unsupported_tree (cxx_pp, t);
486 /* Fall through to error. */
489 pp_string (cxx_pp, M_("<type error>"));
494 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
498 dump_typename (tree t, int flags)
500 tree ctx = TYPE_CONTEXT (t);
502 if (TREE_CODE (ctx) == TYPENAME_TYPE)
503 dump_typename (ctx, flags);
505 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
506 pp_cxx_colon_colon (cxx_pp);
507 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
510 /* Return the name of the supplied aggregate, or enumeral type. */
513 class_key_or_enum_as_string (tree t)
515 if (TREE_CODE (t) == ENUMERAL_TYPE)
517 if (SCOPED_ENUM_P (t))
522 else if (TREE_CODE (t) == UNION_TYPE)
524 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
530 /* Print out a class declaration T under the control of FLAGS,
531 in the form `class foo'. */
534 dump_aggr_type (tree t, int flags)
537 const char *variety = class_key_or_enum_as_string (t);
541 pp_cxx_cv_qualifier_seq (cxx_pp, t);
543 if (flags & TFF_CLASS_KEY_OR_ENUM)
544 pp_cxx_ws_string (cxx_pp, variety);
546 name = TYPE_NAME (t);
550 typdef = !DECL_ARTIFICIAL (name);
553 && ((flags & TFF_CHASE_TYPEDEF)
554 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
555 && DECL_TEMPLATE_INFO (name))))
556 || DECL_SELF_REFERENCE_P (name))
558 t = TYPE_MAIN_VARIANT (t);
559 name = TYPE_NAME (t);
563 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
564 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
565 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
566 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
568 if (! (flags & TFF_UNQUALIFIED_NAME))
569 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
570 flags &= ~TFF_UNQUALIFIED_NAME;
573 /* Because the template names are mangled, we have to locate
574 the most general template, and use that name. */
575 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
577 while (DECL_TEMPLATE_INFO (tpl))
578 tpl = DECL_TI_TEMPLATE (tpl);
581 name = DECL_NAME (name);
584 if (name == 0 || ANON_AGGRNAME_P (name))
586 if (flags & TFF_CLASS_KEY_OR_ENUM)
587 pp_string (cxx_pp, M_("<anonymous>"));
589 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety);
591 else if (LAMBDANAME_P (name))
593 /* A lambda's "type" is essentially its signature. */
594 pp_string (cxx_pp, M_("<lambda"));
595 if (lambda_function (t))
596 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
598 pp_character(cxx_pp, '>');
601 pp_cxx_tree_identifier (cxx_pp, name);
603 dump_template_parms (TYPE_TEMPLATE_INFO (t),
604 !CLASSTYPE_USE_TEMPLATE (t),
605 flags & ~TFF_TEMPLATE_HEADER);
608 /* Dump into the obstack the initial part of the output for a given type.
609 This is necessary when dealing with things like functions returning
612 return type of `int (* fee ())()': pointer -> function -> int. Both
613 pointer (and reference and offset) and function (and member) types must
614 deal with prefix and suffix.
616 Arrays must also do this for DECL nodes, like int a[], and for things like
620 dump_type_prefix (tree t, int flags)
622 if (TYPE_PTRMEMFUNC_P (t))
624 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
628 switch (TREE_CODE (t))
633 tree sub = TREE_TYPE (t);
635 dump_type_prefix (sub, flags);
636 if (TREE_CODE (sub) == ARRAY_TYPE
637 || TREE_CODE (sub) == FUNCTION_TYPE)
639 pp_cxx_whitespace (cxx_pp);
640 pp_cxx_left_paren (cxx_pp);
642 if (TREE_CODE (t) == POINTER_TYPE)
643 pp_character(cxx_pp, '*');
644 else if (TREE_CODE (t) == REFERENCE_TYPE)
646 if (TYPE_REF_IS_RVALUE (t))
647 pp_string (cxx_pp, "&&");
649 pp_character (cxx_pp, '&');
651 pp_base (cxx_pp)->padding = pp_before;
652 pp_cxx_cv_qualifier_seq (cxx_pp, t);
658 dump_type_prefix (TREE_TYPE (t), flags);
659 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
661 pp_maybe_space (cxx_pp);
662 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
663 pp_cxx_left_paren (cxx_pp);
664 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
665 pp_cxx_colon_colon (cxx_pp);
667 pp_cxx_star (cxx_pp);
668 pp_cxx_cv_qualifier_seq (cxx_pp, t);
669 pp_base (cxx_pp)->padding = pp_before;
672 /* This can be reached without a pointer when dealing with
673 templates, e.g. std::is_function. */
675 dump_type_prefix (TREE_TYPE (t), flags);
679 dump_type_prefix (TREE_TYPE (t), flags);
680 pp_maybe_space (cxx_pp);
681 pp_cxx_left_paren (cxx_pp);
682 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
683 pp_cxx_colon_colon (cxx_pp);
687 dump_type_prefix (TREE_TYPE (t), flags);
691 case IDENTIFIER_NODE:
696 case TEMPLATE_TYPE_PARM:
697 case TEMPLATE_TEMPLATE_PARM:
698 case BOUND_TEMPLATE_TEMPLATE_PARM:
710 case TYPE_PACK_EXPANSION:
711 case FIXED_POINT_TYPE:
712 dump_type (t, flags);
713 pp_base (cxx_pp)->padding = pp_before;
717 pp_unsupported_tree (cxx_pp, t);
720 pp_string (cxx_pp, M_("<typeprefixerror>"));
725 /* Dump the suffix of type T, under control of FLAGS. This is the part
726 which appears after the identifier (or function parms). */
729 dump_type_suffix (tree t, int flags)
731 if (TYPE_PTRMEMFUNC_P (t))
732 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
734 switch (TREE_CODE (t))
739 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
740 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
741 pp_cxx_right_paren (cxx_pp);
742 dump_type_suffix (TREE_TYPE (t), flags);
749 if (TREE_CODE (t) == METHOD_TYPE)
750 /* Can only be reached through a pointer. */
751 pp_cxx_right_paren (cxx_pp);
752 arg = TYPE_ARG_TYPES (t);
753 if (TREE_CODE (t) == METHOD_TYPE)
754 arg = TREE_CHAIN (arg);
756 /* Function pointers don't have default args. Not in standard C++,
757 anyway; they may in g++, but we'll just pretend otherwise. */
758 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
760 if (TREE_CODE (t) == METHOD_TYPE)
761 pp_cxx_cv_qualifier_seq
762 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
764 pp_cxx_cv_qualifier_seq (cxx_pp, t);
765 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
766 dump_type_suffix (TREE_TYPE (t), flags);
771 pp_maybe_space (cxx_pp);
772 pp_cxx_left_bracket (cxx_pp);
775 tree dtype = TYPE_DOMAIN (t);
776 tree max = TYPE_MAX_VALUE (dtype);
777 if (host_integerp (max, 0))
778 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
779 else if (TREE_CODE (max) == MINUS_EXPR)
780 dump_expr (TREE_OPERAND (max, 0),
781 flags & ~TFF_EXPR_IN_PARENS);
783 dump_expr (fold_build2_loc (input_location,
784 PLUS_EXPR, dtype, max,
785 build_int_cst (dtype, 1)),
786 flags & ~TFF_EXPR_IN_PARENS);
788 pp_cxx_right_bracket (cxx_pp);
789 dump_type_suffix (TREE_TYPE (t), flags);
793 case IDENTIFIER_NODE:
798 case TEMPLATE_TYPE_PARM:
799 case TEMPLATE_TEMPLATE_PARM:
800 case BOUND_TEMPLATE_TEMPLATE_PARM:
812 case TYPE_PACK_EXPANSION:
813 case FIXED_POINT_TYPE:
817 pp_unsupported_tree (cxx_pp, t);
819 /* Don't mark it here, we should have already done in
826 dump_global_iord (tree t)
828 const char *p = NULL;
830 if (DECL_GLOBAL_CTOR_P (t))
831 p = M_("(static initializers for %s)");
832 else if (DECL_GLOBAL_DTOR_P (t))
833 p = M_("(static destructors for %s)");
837 pp_printf (pp_base (cxx_pp), p, input_filename);
841 dump_simple_decl (tree t, tree type, int flags)
843 if (flags & TFF_DECL_SPECIFIERS)
845 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
846 pp_maybe_space (cxx_pp);
848 if (! (flags & TFF_UNQUALIFIED_NAME)
849 && (!DECL_INITIAL (t)
850 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
851 dump_scope (CP_DECL_CONTEXT (t), flags);
852 flags &= ~TFF_UNQUALIFIED_NAME;
853 if ((flags & TFF_DECL_SPECIFIERS)
854 && DECL_TEMPLATE_PARM_P (t)
855 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
856 pp_string (cxx_pp, "...");
858 dump_decl (DECL_NAME (t), flags);
860 pp_string (cxx_pp, M_("<anonymous>"));
861 if (flags & TFF_DECL_SPECIFIERS)
862 dump_type_suffix (type, flags);
865 /* Dump a human readable string for the decl T under control of FLAGS. */
868 dump_decl (tree t, int flags)
873 switch (TREE_CODE (t))
876 /* Don't say 'typedef class A' */
877 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
879 if ((flags & TFF_DECL_SPECIFIERS)
880 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
882 /* Say `class T' not just `T'. */
883 pp_cxx_ws_string (cxx_pp, "class");
885 /* Emit the `...' for a parameter pack. */
886 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
887 pp_cxx_ws_string (cxx_pp, "...");
890 dump_type (TREE_TYPE (t), flags);
893 if ((flags & TFF_DECL_SPECIFIERS)
894 && !DECL_SELF_REFERENCE_P (t))
895 pp_cxx_ws_string (cxx_pp, "typedef");
896 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
897 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
902 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
904 pp_string (cxx_pp, M_("vtable for "));
905 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
906 dump_type (DECL_CONTEXT (t), flags);
909 /* Else fall through. */
912 dump_simple_decl (t, TREE_TYPE (t), flags);
916 pp_string (cxx_pp, M_("<return value> "));
917 dump_simple_decl (t, TREE_TYPE (t), flags);
921 if (flags & TFF_DECL_SPECIFIERS)
922 pp_cxx_declaration (cxx_pp, t);
925 if (! (flags & TFF_UNQUALIFIED_NAME))
926 dump_scope (CP_DECL_CONTEXT (t), flags);
927 flags &= ~TFF_UNQUALIFIED_NAME;
928 if (DECL_NAME (t) == NULL_TREE)
929 pp_string (cxx_pp, M_("<unnamed>"));
931 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
936 dump_type (TREE_OPERAND (t, 0), flags);
937 pp_string (cxx_pp, "::");
938 dump_decl (TREE_OPERAND (t, 1), flags|TFF_UNQUALIFIED_NAME);
942 dump_decl (TREE_OPERAND (t, 0), flags);
943 pp_cxx_left_bracket (cxx_pp);
944 dump_decl (TREE_OPERAND (t, 1), flags);
945 pp_cxx_right_bracket (cxx_pp);
948 /* So that we can do dump_decl on an aggr type. */
952 dump_type (t, flags);
956 /* This is a pseudo destructor call which has not been folded into
957 a PSEUDO_DTOR_EXPR yet. */
958 pp_cxx_complement (cxx_pp);
959 dump_type (TREE_OPERAND (t, 0), flags);
966 /* These special cases are duplicated here so that other functions
967 can feed identifiers to error and get them demangled properly. */
968 case IDENTIFIER_NODE:
969 if (IDENTIFIER_TYPENAME_P (t))
971 pp_cxx_ws_string (cxx_pp, "operator");
972 /* Not exactly IDENTIFIER_TYPE_VALUE. */
973 dump_type (TREE_TYPE (t), flags);
977 pp_cxx_tree_identifier (cxx_pp, t);
984 if (DECL_CLASS_SCOPE_P (t))
986 dump_type (DECL_CONTEXT (t), flags);
987 pp_cxx_colon_colon (cxx_pp);
989 else if (DECL_CONTEXT (t))
991 dump_decl (DECL_CONTEXT (t), flags);
992 pp_cxx_colon_colon (cxx_pp);
994 dump_decl (DECL_NAME (t), flags);
998 /* If there's only one function, just treat it like an ordinary
1000 t = OVL_CURRENT (t);
1004 if (! DECL_LANG_SPECIFIC (t))
1005 pp_string (cxx_pp, M_("<built-in>"));
1006 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1007 dump_global_iord (t);
1009 dump_function_decl (t, flags);
1013 dump_template_decl (t, flags);
1016 case TEMPLATE_ID_EXPR:
1018 tree name = TREE_OPERAND (t, 0);
1020 if (is_overloaded_fn (name))
1021 name = DECL_NAME (get_first_fn (name));
1022 dump_decl (name, flags);
1023 pp_cxx_begin_template_argument_list (cxx_pp);
1024 if (TREE_OPERAND (t, 1))
1025 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
1026 pp_cxx_end_template_argument_list (cxx_pp);
1031 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1035 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1036 || (DECL_INITIAL (t) &&
1037 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1038 dump_simple_decl (t, TREE_TYPE (t), flags);
1039 else if (DECL_NAME (t))
1040 dump_decl (DECL_NAME (t), flags);
1041 else if (DECL_INITIAL (t))
1042 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1044 pp_string (cxx_pp, M_("<enumerator>"));
1048 pp_cxx_ws_string (cxx_pp, "using");
1049 dump_type (USING_DECL_SCOPE (t), flags);
1050 pp_cxx_colon_colon (cxx_pp);
1051 dump_decl (DECL_NAME (t), flags);
1055 pp_cxx_declaration (cxx_pp, t);
1059 dump_decl (BASELINK_FUNCTIONS (t), flags);
1062 case NON_DEPENDENT_EXPR:
1063 dump_expr (t, flags);
1066 case TEMPLATE_TYPE_PARM:
1067 if (flags & TFF_DECL_SPECIFIERS)
1068 pp_cxx_declaration (cxx_pp, t);
1070 pp_type_id (cxx_pp, t);
1073 case UNBOUND_CLASS_TEMPLATE:
1074 case TYPE_PACK_EXPANSION:
1076 dump_type (t, flags);
1080 pp_unsupported_tree (cxx_pp, t);
1081 /* Fall through to error. */
1084 pp_string (cxx_pp, M_("<declaration error>"));
1089 /* Dump a template declaration T under control of FLAGS. This means the
1090 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1093 dump_template_decl (tree t, int flags)
1095 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1099 if (flags & TFF_TEMPLATE_HEADER)
1101 for (parms = orig_parms = nreverse (orig_parms);
1103 parms = TREE_CHAIN (parms))
1105 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1106 int len = TREE_VEC_LENGTH (inner_parms);
1108 pp_cxx_ws_string (cxx_pp, "template");
1109 pp_cxx_begin_template_argument_list (cxx_pp);
1111 /* If we've shown the template prefix, we'd better show the
1112 parameters' and decl's type too. */
1113 flags |= TFF_DECL_SPECIFIERS;
1115 for (i = 0; i < len; i++)
1118 pp_separate_with_comma (cxx_pp);
1119 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1121 pp_cxx_end_template_argument_list (cxx_pp);
1122 pp_cxx_whitespace (cxx_pp);
1124 nreverse(orig_parms);
1126 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1128 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1129 pp_cxx_ws_string (cxx_pp, "class");
1131 /* If this is a parameter pack, print the ellipsis. */
1132 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1133 pp_cxx_ws_string (cxx_pp, "...");
1137 if (DECL_TEMPLATE_RESULT (t)
1138 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1139 dump_type (TREE_TYPE (t),
1140 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1141 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1142 else if (DECL_TEMPLATE_RESULT (t)
1143 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1144 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1147 gcc_assert (TREE_TYPE (t));
1148 switch (NEXT_CODE (t))
1152 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1155 /* This case can occur with some invalid code. */
1156 dump_type (TREE_TYPE (t),
1157 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1158 | (flags & TFF_DECL_SPECIFIERS
1159 ? TFF_CLASS_KEY_OR_ENUM : 0));
1164 /* find_typenames looks through the type of the function template T
1165 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1168 struct find_typenames_t
1170 struct pointer_set_t *p_set;
1171 VEC (tree,gc) *typenames;
1175 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1177 struct find_typenames_t *d = (struct find_typenames_t *)data;
1178 tree mv = NULL_TREE;
1180 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1181 /* Add the type of the typedef without any additional cv-quals. */
1182 mv = TREE_TYPE (TYPE_NAME (*tp));
1183 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1184 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1185 /* Add the typename without any cv-qualifiers. */
1186 mv = TYPE_MAIN_VARIANT (*tp);
1188 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1189 VEC_safe_push (tree, gc, d->typenames, mv);
1191 /* Search into class template arguments, which cp_walk_subtrees
1193 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1194 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1200 static VEC(tree,gc) *
1201 find_typenames (tree t)
1203 struct find_typenames_t ft;
1204 ft.p_set = pointer_set_create ();
1205 ft.typenames = NULL;
1206 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1207 find_typenames_r, &ft, ft.p_set);
1208 pointer_set_destroy (ft.p_set);
1209 return ft.typenames;
1212 /* Pretty print a function decl. There are several ways we want to print a
1213 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1214 As error can only apply the '#' flag once to give 0 and 1 for V, there
1215 is %D which doesn't print the throw specs, and %F which does. */
1218 dump_function_decl (tree t, int flags)
1222 tree cname = NULL_TREE;
1223 tree template_args = NULL_TREE;
1224 tree template_parms = NULL_TREE;
1225 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1226 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1228 VEC(tree,gc) *typenames = NULL;
1230 if (LAMBDA_FUNCTION_P (t))
1232 /* A lambda's signature is essentially its "type", so defer. */
1233 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t)));
1234 dump_type (DECL_CONTEXT (t), flags);
1238 flags &= ~TFF_UNQUALIFIED_NAME;
1239 if (TREE_CODE (t) == TEMPLATE_DECL)
1240 t = DECL_TEMPLATE_RESULT (t);
1242 /* Save the exceptions, in case t is a specialization and we are
1243 emitting an error about incompatible specifications. */
1244 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1246 /* Pretty print template instantiations only. */
1247 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1248 && flag_pretty_templates)
1252 template_args = DECL_TI_ARGS (t);
1253 tmpl = most_general_template (t);
1254 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1256 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1258 typenames = find_typenames (t);
1262 fntype = TREE_TYPE (t);
1263 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1265 if (DECL_CLASS_SCOPE_P (t))
1266 cname = DECL_CONTEXT (t);
1267 /* This is for partially instantiated template methods. */
1268 else if (TREE_CODE (fntype) == METHOD_TYPE)
1269 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1271 if (!(flags & TFF_DECL_SPECIFIERS))
1273 else if (DECL_STATIC_FUNCTION_P (t))
1274 pp_cxx_ws_string (cxx_pp, "static");
1275 else if (DECL_VIRTUAL_P (t))
1276 pp_cxx_ws_string (cxx_pp, "virtual");
1278 /* Print the return type? */
1280 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1281 && !DECL_DESTRUCTOR_P (t);
1283 dump_type_prefix (TREE_TYPE (fntype), flags);
1285 /* Print the function name. */
1286 if (!do_outer_scope)
1290 dump_type (cname, flags);
1291 pp_cxx_colon_colon (cxx_pp);
1294 dump_scope (CP_DECL_CONTEXT (t), flags);
1296 dump_function_name (t, flags);
1298 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1300 dump_parameters (parmtypes, flags);
1302 if (TREE_CODE (fntype) == METHOD_TYPE)
1304 pp_base (cxx_pp)->padding = pp_before;
1305 pp_cxx_cv_qualifier_seq
1306 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1309 if (flags & TFF_EXCEPTION_SPECIFICATION)
1311 pp_base (cxx_pp)->padding = pp_before;
1312 dump_exception_spec (exceptions, flags);
1316 dump_type_suffix (TREE_TYPE (fntype), flags);
1319 /* If T is a template instantiation, dump the parameter binding. */
1320 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1322 pp_cxx_whitespace (cxx_pp);
1323 pp_cxx_left_bracket (cxx_pp);
1324 pp_cxx_ws_string (cxx_pp, M_("with"));
1325 pp_cxx_whitespace (cxx_pp);
1326 dump_template_bindings (template_parms, template_args, typenames);
1327 pp_cxx_right_bracket (cxx_pp);
1331 /* Print a parameter list. If this is for a member function, the
1332 member object ptr (and any other hidden args) should have
1333 already been removed. */
1336 dump_parameters (tree parmtypes, int flags)
1339 pp_cxx_left_paren (cxx_pp);
1341 for (first = 1; parmtypes != void_list_node;
1342 parmtypes = TREE_CHAIN (parmtypes))
1345 pp_separate_with_comma (cxx_pp);
1349 pp_cxx_ws_string (cxx_pp, "...");
1353 dump_type (TREE_VALUE (parmtypes), flags);
1355 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1357 pp_cxx_whitespace (cxx_pp);
1359 pp_cxx_whitespace (cxx_pp);
1360 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1364 pp_cxx_right_paren (cxx_pp);
1367 /* Print an exception specification. T is the exception specification. */
1370 dump_exception_spec (tree t, int flags)
1374 pp_cxx_ws_string (cxx_pp, "throw");
1375 pp_cxx_whitespace (cxx_pp);
1376 pp_cxx_left_paren (cxx_pp);
1377 if (TREE_VALUE (t) != NULL_TREE)
1380 dump_type (TREE_VALUE (t), flags);
1384 pp_separate_with_comma (cxx_pp);
1386 pp_cxx_right_paren (cxx_pp);
1390 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1391 and destructors properly. */
1394 dump_function_name (tree t, int flags)
1396 tree name = DECL_NAME (t);
1398 /* We can get here with a decl that was synthesized by language-
1399 independent machinery (e.g. coverage.c) in which case it won't
1400 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1401 will crash. In this case it is safe just to print out the
1403 if (!DECL_LANG_SPECIFIC (t))
1405 pp_cxx_tree_identifier (cxx_pp, name);
1409 if (TREE_CODE (t) == TEMPLATE_DECL)
1410 t = DECL_TEMPLATE_RESULT (t);
1412 /* Don't let the user see __comp_ctor et al. */
1413 if (DECL_CONSTRUCTOR_P (t)
1414 || DECL_DESTRUCTOR_P (t))
1416 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1417 name = get_identifier ("<lambda>");
1419 name = constructor_name (DECL_CONTEXT (t));
1422 if (DECL_DESTRUCTOR_P (t))
1424 pp_cxx_complement (cxx_pp);
1425 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1427 else if (DECL_CONV_FN_P (t))
1429 /* This cannot use the hack that the operator's return
1430 type is stashed off of its name because it may be
1431 used for error reporting. In the case of conflicting
1432 declarations, both will have the same name, yet
1433 the types will be different, hence the TREE_TYPE field
1434 of the first name will be clobbered by the second. */
1435 pp_cxx_ws_string (cxx_pp, "operator");
1436 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1438 else if (name && IDENTIFIER_OPNAME_P (name))
1439 pp_cxx_tree_identifier (cxx_pp, name);
1441 dump_decl (name, flags);
1443 if (DECL_TEMPLATE_INFO (t)
1444 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1445 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1446 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1447 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1450 /* Dump the template parameters from the template info INFO under control of
1451 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1452 specialization (partial or complete). For partial specializations we show
1453 the specialized parameter values. For a primary template we show no
1457 dump_template_parms (tree info, int primary, int flags)
1459 tree args = info ? TI_ARGS (info) : NULL_TREE;
1461 if (primary && flags & TFF_TEMPLATE_NAME)
1463 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1464 pp_cxx_begin_template_argument_list (cxx_pp);
1466 /* Be careful only to print things when we have them, so as not
1467 to crash producing error messages. */
1468 if (args && !primary)
1471 len = get_non_default_template_args_count (args, flags);
1473 args = INNERMOST_TEMPLATE_ARGS (args);
1474 for (ix = 0; ix != len; ix++)
1476 tree arg = TREE_VEC_ELT (args, ix);
1478 /* Only print a comma if we know there is an argument coming. In
1479 the case of an empty template argument pack, no actual
1480 argument will be printed. */
1482 && (!ARGUMENT_PACK_P (arg)
1483 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1484 pp_separate_with_comma (cxx_pp);
1487 pp_string (cxx_pp, M_("<template parameter error>"));
1489 dump_template_argument (arg, flags);
1494 tree tpl = TI_TEMPLATE (info);
1495 tree parms = DECL_TEMPLATE_PARMS (tpl);
1498 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1499 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1501 for (ix = 0; ix != len; ix++)
1505 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1507 pp_string (cxx_pp, M_("<template parameter error>"));
1511 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1514 pp_separate_with_comma (cxx_pp);
1516 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1519 pp_cxx_end_template_argument_list (cxx_pp);
1522 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1523 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1526 dump_call_expr_args (tree t, int flags, bool skipfirst)
1529 call_expr_arg_iterator iter;
1531 pp_cxx_left_paren (cxx_pp);
1532 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1538 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1539 if (more_call_expr_args_p (&iter))
1540 pp_separate_with_comma (cxx_pp);
1543 pp_cxx_right_paren (cxx_pp);
1546 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1547 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1551 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1554 aggr_init_expr_arg_iterator iter;
1556 pp_cxx_left_paren (cxx_pp);
1557 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1563 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1564 if (more_aggr_init_expr_args_p (&iter))
1565 pp_separate_with_comma (cxx_pp);
1568 pp_cxx_right_paren (cxx_pp);
1571 /* Print out a list of initializers (subr of dump_expr). */
1574 dump_expr_list (tree l, int flags)
1578 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1581 pp_separate_with_comma (cxx_pp);
1585 /* Print out a vector of initializers (subr of dump_expr). */
1588 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1590 unsigned HOST_WIDE_INT idx;
1593 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1595 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1596 if (idx != VEC_length (constructor_elt, v) - 1)
1597 pp_separate_with_comma (cxx_pp);
1602 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1603 function. Resolve it to a close relative -- in the sense of static
1604 type -- variant being overridden. That is close to what was written in
1605 the source code. Subroutine of dump_expr. */
1608 resolve_virtual_fun_from_obj_type_ref (tree ref)
1610 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1611 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1612 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1615 fun = TREE_CHAIN (fun);
1616 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1617 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1623 /* Print out an expression E under control of FLAGS. */
1626 dump_expr (tree t, int flags)
1631 if (STATEMENT_CLASS_P (t))
1633 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1637 switch (TREE_CODE (t))
1645 case NAMESPACE_DECL:
1648 case IDENTIFIER_NODE:
1649 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1656 pp_constant (cxx_pp, t);
1660 /* While waiting for caret diagnostics, avoid printing
1661 __cxa_allocate_exception, __cxa_throw, and the like. */
1662 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1666 pp_ampersand (cxx_pp);
1667 dump_type (PTRMEM_CST_CLASS (t), flags);
1668 pp_cxx_colon_colon (cxx_pp);
1669 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1673 pp_cxx_left_paren (cxx_pp);
1674 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1675 pp_separate_with_comma (cxx_pp);
1676 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1677 pp_cxx_right_paren (cxx_pp);
1681 pp_cxx_left_paren (cxx_pp);
1682 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1683 pp_string (cxx_pp, " ? ");
1684 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1685 pp_string (cxx_pp, " : ");
1686 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1687 pp_cxx_right_paren (cxx_pp);
1691 if (TREE_HAS_CONSTRUCTOR (t))
1693 pp_cxx_ws_string (cxx_pp, "new");
1694 pp_cxx_whitespace (cxx_pp);
1695 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1698 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1701 case AGGR_INIT_EXPR:
1703 tree fn = NULL_TREE;
1705 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1706 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1708 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1710 if (DECL_CONSTRUCTOR_P (fn))
1711 dump_type (DECL_CONTEXT (fn), flags);
1716 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1718 dump_aggr_init_expr_args (t, flags, true);
1723 tree fn = CALL_EXPR_FN (t);
1724 bool skipfirst = false;
1726 if (TREE_CODE (fn) == ADDR_EXPR)
1727 fn = TREE_OPERAND (fn, 0);
1729 /* Nobody is interested in seeing the guts of vcalls. */
1730 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1731 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1733 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1735 tree ob = CALL_EXPR_ARG (t, 0);
1736 if (TREE_CODE (ob) == ADDR_EXPR)
1738 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1739 pp_cxx_dot (cxx_pp);
1741 else if (TREE_CODE (ob) != PARM_DECL
1742 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1744 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1745 pp_cxx_arrow (cxx_pp);
1749 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1750 dump_call_expr_args (t, flags, skipfirst);
1755 /* Note that this only works for G++ target exprs. If somebody
1756 builds a general TARGET_EXPR, there's no way to represent that
1757 it initializes anything other that the parameter slot for the
1758 default argument. Note we may have cleared out the first
1759 operand in expand_expr, so don't go killing ourselves. */
1760 if (TREE_OPERAND (t, 1))
1761 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1764 case POINTER_PLUS_EXPR:
1765 dump_binary_op ("+", t, flags);
1773 case TRUNC_DIV_EXPR:
1774 case TRUNC_MOD_EXPR:
1782 case TRUTH_ANDIF_EXPR:
1783 case TRUTH_ORIF_EXPR:
1790 case EXACT_DIV_EXPR:
1791 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1795 case FLOOR_DIV_EXPR:
1796 case ROUND_DIV_EXPR:
1798 dump_binary_op ("/", t, flags);
1802 case FLOOR_MOD_EXPR:
1803 case ROUND_MOD_EXPR:
1804 dump_binary_op ("%", t, flags);
1809 tree ob = TREE_OPERAND (t, 0);
1810 if (TREE_CODE (ob) == INDIRECT_REF)
1812 ob = TREE_OPERAND (ob, 0);
1813 if (TREE_CODE (ob) != PARM_DECL
1815 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1817 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1818 pp_cxx_arrow (cxx_pp);
1823 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1824 pp_cxx_dot (cxx_pp);
1826 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1831 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1832 pp_cxx_left_bracket (cxx_pp);
1833 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1834 pp_cxx_right_bracket (cxx_pp);
1837 case UNARY_PLUS_EXPR:
1838 dump_unary_op ("+", t, flags);
1842 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1843 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1844 /* An ADDR_EXPR can have reference type. In that case, we
1845 shouldn't print the `&' doing so indicates to the user
1846 that the expression has pointer type. */
1848 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1849 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1850 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1851 dump_unary_op ("&&", t, flags);
1853 dump_unary_op ("&", t, flags);
1857 if (TREE_HAS_CONSTRUCTOR (t))
1859 t = TREE_OPERAND (t, 0);
1860 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1861 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1862 dump_call_expr_args (t, flags, true);
1866 if (TREE_OPERAND (t,0) != NULL_TREE
1867 && TREE_TYPE (TREE_OPERAND (t, 0))
1868 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1869 dump_expr (TREE_OPERAND (t, 0), flags);
1871 dump_unary_op ("*", t, flags);
1877 case TRUTH_NOT_EXPR:
1878 case PREDECREMENT_EXPR:
1879 case PREINCREMENT_EXPR:
1880 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1883 case POSTDECREMENT_EXPR:
1884 case POSTINCREMENT_EXPR:
1885 pp_cxx_left_paren (cxx_pp);
1886 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1887 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1888 pp_cxx_right_paren (cxx_pp);
1891 case NON_LVALUE_EXPR:
1892 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1893 should be another level of INDIRECT_REF so that I don't have to do
1895 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1897 tree next = TREE_TYPE (TREE_TYPE (t));
1899 while (TREE_CODE (next) == POINTER_TYPE)
1900 next = TREE_TYPE (next);
1902 if (TREE_CODE (next) == FUNCTION_TYPE)
1904 if (flags & TFF_EXPR_IN_PARENS)
1905 pp_cxx_left_paren (cxx_pp);
1906 pp_cxx_star (cxx_pp);
1907 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1908 if (flags & TFF_EXPR_IN_PARENS)
1909 pp_cxx_right_paren (cxx_pp);
1912 /* Else fall through. */
1914 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1918 case VIEW_CONVERT_EXPR:
1920 tree op = TREE_OPERAND (t, 0);
1922 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1924 /* It is a cast, but we cannot tell whether it is a
1925 reinterpret or static cast. Use the C style notation. */
1926 if (flags & TFF_EXPR_IN_PARENS)
1927 pp_cxx_left_paren (cxx_pp);
1928 pp_cxx_left_paren (cxx_pp);
1929 dump_type (TREE_TYPE (t), flags);
1930 pp_cxx_right_paren (cxx_pp);
1931 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1932 if (flags & TFF_EXPR_IN_PARENS)
1933 pp_cxx_right_paren (cxx_pp);
1936 dump_expr (op, flags);
1941 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1943 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1945 if (integer_zerop (idx))
1947 /* A NULL pointer-to-member constant. */
1948 pp_cxx_left_paren (cxx_pp);
1949 pp_cxx_left_paren (cxx_pp);
1950 dump_type (TREE_TYPE (t), flags);
1951 pp_cxx_right_paren (cxx_pp);
1952 pp_character (cxx_pp, '0');
1953 pp_cxx_right_paren (cxx_pp);
1956 else if (host_integerp (idx, 0))
1959 unsigned HOST_WIDE_INT n;
1961 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1962 t = TYPE_METHOD_BASETYPE (t);
1963 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1965 n = tree_low_cst (idx, 0);
1967 /* Map vtable index back one, to allow for the null pointer to
1971 while (n > 0 && virtuals)
1974 virtuals = TREE_CHAIN (virtuals);
1978 dump_expr (BV_FN (virtuals),
1979 flags | TFF_EXPR_IN_PARENS);
1984 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1986 dump_type (TREE_TYPE (t), 0);
1987 pp_cxx_left_paren (cxx_pp);
1988 pp_cxx_right_paren (cxx_pp);
1992 pp_cxx_left_brace (cxx_pp);
1993 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1994 pp_cxx_right_brace (cxx_pp);
2001 tree ob = TREE_OPERAND (t, 0);
2002 if (is_dummy_object (ob))
2004 t = TREE_OPERAND (t, 1);
2005 if (TREE_CODE (t) == FUNCTION_DECL)
2007 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
2008 else if (BASELINK_P (t))
2009 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2010 flags | TFF_EXPR_IN_PARENS);
2012 dump_decl (t, flags);
2016 if (TREE_CODE (ob) == INDIRECT_REF)
2018 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2019 pp_cxx_arrow (cxx_pp);
2020 pp_cxx_star (cxx_pp);
2024 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2025 pp_cxx_dot (cxx_pp);
2026 pp_cxx_star (cxx_pp);
2028 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2033 case TEMPLATE_PARM_INDEX:
2034 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2038 if (TREE_OPERAND (t, 0) == NULL_TREE
2039 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2041 dump_type (TREE_TYPE (t), flags);
2042 pp_cxx_left_paren (cxx_pp);
2043 dump_expr_list (TREE_OPERAND (t, 0), flags);
2044 pp_cxx_right_paren (cxx_pp);
2048 pp_cxx_left_paren (cxx_pp);
2049 dump_type (TREE_TYPE (t), flags);
2050 pp_cxx_right_paren (cxx_pp);
2051 pp_cxx_left_paren (cxx_pp);
2052 dump_expr_list (TREE_OPERAND (t, 0), flags);
2053 pp_cxx_right_paren (cxx_pp);
2057 case STATIC_CAST_EXPR:
2058 pp_cxx_ws_string (cxx_pp, "static_cast");
2060 case REINTERPRET_CAST_EXPR:
2061 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2063 case CONST_CAST_EXPR:
2064 pp_cxx_ws_string (cxx_pp, "const_cast");
2066 case DYNAMIC_CAST_EXPR:
2067 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2069 pp_cxx_begin_template_argument_list (cxx_pp);
2070 dump_type (TREE_TYPE (t), flags);
2071 pp_cxx_end_template_argument_list (cxx_pp);
2072 pp_cxx_left_paren (cxx_pp);
2073 dump_expr (TREE_OPERAND (t, 0), flags);
2074 pp_cxx_right_paren (cxx_pp);
2078 dump_expr (TREE_OPERAND (t, 0), flags);
2079 pp_cxx_arrow (cxx_pp);
2084 if (TREE_CODE (t) == SIZEOF_EXPR)
2085 pp_cxx_ws_string (cxx_pp, "sizeof");
2088 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2089 pp_cxx_ws_string (cxx_pp, "__alignof__");
2091 pp_cxx_whitespace (cxx_pp);
2092 pp_cxx_left_paren (cxx_pp);
2093 if (TYPE_P (TREE_OPERAND (t, 0)))
2094 dump_type (TREE_OPERAND (t, 0), flags);
2096 dump_expr (TREE_OPERAND (t, 0), flags);
2097 pp_cxx_right_paren (cxx_pp);
2102 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2103 pp_cxx_whitespace (cxx_pp);
2104 dump_expr (TREE_OPERAND (t, 0), flags);
2108 pp_string (cxx_pp, M_("<unparsed>"));
2111 case TRY_CATCH_EXPR:
2112 case WITH_CLEANUP_EXPR:
2113 case CLEANUP_POINT_EXPR:
2114 dump_expr (TREE_OPERAND (t, 0), flags);
2117 case PSEUDO_DTOR_EXPR:
2118 dump_expr (TREE_OPERAND (t, 2), flags);
2119 pp_cxx_dot (cxx_pp);
2120 dump_type (TREE_OPERAND (t, 0), flags);
2121 pp_cxx_colon_colon (cxx_pp);
2122 pp_cxx_complement (cxx_pp);
2123 dump_type (TREE_OPERAND (t, 1), flags);
2126 case TEMPLATE_ID_EXPR:
2127 dump_decl (t, flags);
2133 case STATEMENT_LIST:
2134 /* We don't yet have a way of dumping statements in a
2135 human-readable format. */
2136 pp_string (cxx_pp, "({...})");
2140 pp_string (cxx_pp, "while (1) { ");
2141 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2142 pp_cxx_right_brace (cxx_pp);
2146 pp_string (cxx_pp, "if (");
2147 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2148 pp_string (cxx_pp, ") break; ");
2152 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2155 case EMPTY_CLASS_EXPR:
2156 dump_type (TREE_TYPE (t), flags);
2157 pp_cxx_left_paren (cxx_pp);
2158 pp_cxx_right_paren (cxx_pp);
2161 case NON_DEPENDENT_EXPR:
2162 dump_expr (TREE_OPERAND (t, 0), flags);
2165 case ARGUMENT_PACK_SELECT:
2166 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2178 pp_type_specifier_seq (cxx_pp, t);
2182 /* We get here when we want to print a dependent type as an
2183 id-expression, without any disambiguator decoration. */
2184 pp_id_expression (cxx_pp, t);
2187 case TEMPLATE_TYPE_PARM:
2188 case BOUND_TEMPLATE_TEMPLATE_PARM:
2189 dump_type (t, flags);
2193 pp_cxx_trait_expression (cxx_pp, t);
2197 pp_cxx_va_arg_expression (cxx_pp, t);
2201 pp_cxx_offsetof_expression (cxx_pp, t);
2205 dump_decl (t, flags);
2208 case EXPR_PACK_EXPANSION:
2215 case VEC_DELETE_EXPR:
2221 case UNORDERED_EXPR:
2231 case FIX_TRUNC_EXPR:
2233 pp_expression (cxx_pp, t);
2236 case TRUTH_AND_EXPR:
2238 case TRUTH_XOR_EXPR:
2239 if (flags & TFF_EXPR_IN_PARENS)
2240 pp_cxx_left_paren (cxx_pp);
2241 pp_expression (cxx_pp, t);
2242 if (flags & TFF_EXPR_IN_PARENS)
2243 pp_cxx_right_paren (cxx_pp);
2247 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2250 /* This list is incomplete, but should suffice for now.
2251 It is very important that `sorry' does not call
2252 `report_error_function'. That could cause an infinite loop. */
2254 pp_unsupported_tree (cxx_pp, t);
2255 /* fall through to ERROR_MARK... */
2257 pp_string (cxx_pp, M_("<expression error>"));
2263 dump_binary_op (const char *opstring, tree t, int flags)
2265 pp_cxx_left_paren (cxx_pp);
2266 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2267 pp_cxx_whitespace (cxx_pp);
2269 pp_cxx_ws_string (cxx_pp, opstring);
2271 pp_string (cxx_pp, M_("<unknown operator>"));
2272 pp_cxx_whitespace (cxx_pp);
2273 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2274 pp_cxx_right_paren (cxx_pp);
2278 dump_unary_op (const char *opstring, tree t, int flags)
2280 if (flags & TFF_EXPR_IN_PARENS)
2281 pp_cxx_left_paren (cxx_pp);
2282 pp_cxx_ws_string (cxx_pp, opstring);
2283 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2284 if (flags & TFF_EXPR_IN_PARENS)
2285 pp_cxx_right_paren (cxx_pp);
2289 reinit_cxx_pp (void)
2291 pp_clear_output_area (cxx_pp);
2292 pp_base (cxx_pp)->padding = pp_none;
2293 pp_indentation (cxx_pp) = 0;
2294 pp_needs_newline (cxx_pp) = false;
2295 cxx_pp->enclosing_scope = current_function_decl;
2299 /* Exported interface to stringifying types, exprs and decls under TFF_*
2303 type_as_string (tree typ, int flags)
2306 pp_translate_identifiers (cxx_pp) = false;
2307 dump_type (typ, flags);
2308 return pp_formatted_text (cxx_pp);
2312 type_as_string_translate (tree typ, int flags)
2315 dump_type (typ, flags);
2316 return pp_formatted_text (cxx_pp);
2320 expr_as_string (tree decl, int flags)
2323 pp_translate_identifiers (cxx_pp) = false;
2324 dump_expr (decl, flags);
2325 return pp_formatted_text (cxx_pp);
2329 decl_as_string (tree decl, int flags)
2332 pp_translate_identifiers (cxx_pp) = false;
2333 dump_decl (decl, flags);
2334 return pp_formatted_text (cxx_pp);
2338 decl_as_string_translate (tree decl, int flags)
2341 dump_decl (decl, flags);
2342 return pp_formatted_text (cxx_pp);
2345 /* Generate the three forms of printable names for cxx_printable_name. */
2348 lang_decl_name (tree decl, int v, bool translate)
2352 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2353 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2356 pp_translate_identifiers (cxx_pp) = translate;
2358 && (DECL_CLASS_SCOPE_P (decl)
2359 || (DECL_NAMESPACE_SCOPE_P (decl)
2360 && CP_DECL_CONTEXT (decl) != global_namespace)))
2362 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2363 pp_cxx_colon_colon (cxx_pp);
2366 if (TREE_CODE (decl) == FUNCTION_DECL)
2367 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2369 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2371 return pp_formatted_text (cxx_pp);
2374 /* Return the location of a tree passed to %+ formats. */
2377 location_of (tree t)
2379 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2380 t = DECL_CONTEXT (t);
2381 else if (TYPE_P (t))
2382 t = TYPE_MAIN_DECL (t);
2383 else if (TREE_CODE (t) == OVERLOAD)
2384 t = OVL_FUNCTION (t);
2386 return DECL_SOURCE_LOCATION (t);
2389 /* Now the interfaces from error et al to dump_type et al. Each takes an
2390 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2394 decl_to_string (tree decl, int verbose)
2398 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2399 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2400 flags = TFF_CLASS_KEY_OR_ENUM;
2402 flags |= TFF_DECL_SPECIFIERS;
2403 else if (TREE_CODE (decl) == FUNCTION_DECL)
2404 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2405 flags |= TFF_TEMPLATE_HEADER;
2408 dump_decl (decl, flags);
2409 return pp_formatted_text (cxx_pp);
2413 expr_to_string (tree decl)
2416 dump_expr (decl, 0);
2417 return pp_formatted_text (cxx_pp);
2421 fndecl_to_string (tree fndecl, int verbose)
2425 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2426 | TFF_TEMPLATE_HEADER;
2428 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2430 dump_decl (fndecl, flags);
2431 return pp_formatted_text (cxx_pp);
2436 code_to_string (enum tree_code c)
2438 return tree_code_name [c];
2442 language_to_string (enum languages c)
2449 case lang_cplusplus:
2461 /* Return the proper printed version of a parameter to a C++ function. */
2464 parm_to_string (int p)
2468 pp_string (cxx_pp, "'this'");
2470 pp_decimal_int (cxx_pp, p + 1);
2471 return pp_formatted_text (cxx_pp);
2475 op_to_string (enum tree_code p)
2477 tree id = operator_name_info[(int) p].identifier;
2478 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2482 type_to_string (tree typ, int verbose)
2486 flags |= TFF_CLASS_KEY_OR_ENUM;
2487 flags |= TFF_TEMPLATE_HEADER;
2490 dump_type (typ, flags);
2491 return pp_formatted_text (cxx_pp);
2495 assop_to_string (enum tree_code p)
2497 tree id = assignment_operator_name_info[(int) p].identifier;
2498 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2502 args_to_string (tree p, int verbose)
2506 flags |= TFF_CLASS_KEY_OR_ENUM;
2511 if (TYPE_P (TREE_VALUE (p)))
2512 return type_as_string_translate (p, flags);
2515 for (; p; p = TREE_CHAIN (p))
2517 if (TREE_VALUE (p) == null_node)
2518 pp_cxx_ws_string (cxx_pp, "NULL");
2520 dump_type (error_type (TREE_VALUE (p)), flags);
2522 pp_separate_with_comma (cxx_pp);
2524 return pp_formatted_text (cxx_pp);
2528 cv_to_string (tree p, int v)
2531 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2532 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2533 return pp_formatted_text (cxx_pp);
2536 /* Langhook for print_error_function. */
2538 cxx_print_error_function (diagnostic_context *context, const char *file,
2539 diagnostic_info *diagnostic)
2541 lhd_print_error_function (context, file, diagnostic);
2542 pp_base_set_prefix (context->printer, file);
2543 maybe_print_instantiation_context (context);
2547 cp_diagnostic_starter (diagnostic_context *context,
2548 diagnostic_info *diagnostic)
2550 diagnostic_report_current_module (context);
2551 cp_print_error_function (context, diagnostic);
2552 maybe_print_instantiation_context (context);
2553 pp_base_set_prefix (context->printer, diagnostic_build_prefix (context,
2558 cp_diagnostic_finalizer (diagnostic_context *context,
2559 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2561 pp_base_destroy_prefix (context->printer);
2564 /* Print current function onto BUFFER, in the process of reporting
2565 a diagnostic message. Called from cp_diagnostic_starter. */
2567 cp_print_error_function (diagnostic_context *context,
2568 diagnostic_info *diagnostic)
2570 if (diagnostic_last_function_changed (context, diagnostic))
2572 const char *old_prefix = context->printer->prefix;
2573 const char *file = LOCATION_FILE (diagnostic->location);
2574 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
2575 char *new_prefix = (file && abstract_origin == NULL)
2576 ? file_name_as_prefix (file) : NULL;
2578 pp_base_set_prefix (context->printer, new_prefix);
2580 if (current_function_decl == NULL)
2581 pp_base_string (context->printer, _("At global scope:"));
2586 if (abstract_origin)
2588 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2589 while (TREE_CODE (ao) == BLOCK
2590 && BLOCK_ABSTRACT_ORIGIN (ao)
2591 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2592 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2593 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2597 fndecl = current_function_decl;
2599 pp_printf (context->printer, function_category (fndecl),
2600 cxx_printable_name_translate (fndecl, 2));
2602 while (abstract_origin)
2605 tree block = abstract_origin;
2607 locus = &BLOCK_SOURCE_LOCATION (block);
2609 block = BLOCK_SUPERCONTEXT (block);
2610 while (block && TREE_CODE (block) == BLOCK
2611 && BLOCK_ABSTRACT_ORIGIN (block))
2613 ao = BLOCK_ABSTRACT_ORIGIN (block);
2615 while (TREE_CODE (ao) == BLOCK
2616 && BLOCK_ABSTRACT_ORIGIN (ao)
2617 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2618 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2620 if (TREE_CODE (ao) == FUNCTION_DECL)
2625 else if (TREE_CODE (ao) != BLOCK)
2628 block = BLOCK_SUPERCONTEXT (block);
2631 abstract_origin = block;
2634 while (block && TREE_CODE (block) == BLOCK)
2635 block = BLOCK_SUPERCONTEXT (block);
2637 if (block && TREE_CODE (block) == FUNCTION_DECL)
2639 abstract_origin = NULL;
2643 expanded_location s = expand_location (*locus);
2644 pp_base_character (context->printer, ',');
2645 pp_base_newline (context->printer);
2648 if (context->show_column && s.column != 0)
2649 pp_printf (context->printer,
2650 _(" inlined from %qs at %s:%d:%d"),
2651 cxx_printable_name_translate (fndecl, 2),
2652 s.file, s.line, s.column);
2654 pp_printf (context->printer,
2655 _(" inlined from %qs at %s:%d"),
2656 cxx_printable_name_translate (fndecl, 2),
2661 pp_printf (context->printer, _(" inlined from %qs"),
2662 cxx_printable_name_translate (fndecl, 2));
2665 pp_base_character (context->printer, ':');
2667 pp_base_newline (context->printer);
2669 diagnostic_set_last_function (context, diagnostic);
2670 pp_base_destroy_prefix (context->printer);
2671 context->printer->prefix = old_prefix;
2675 /* Returns a description of FUNCTION using standard terminology. The
2676 result is a format string of the form "In CATEGORY %qs". */
2678 function_category (tree fn)
2680 /* We can get called from the middle-end for diagnostics of function
2681 clones. Make sure we have language specific information before
2682 dereferencing it. */
2683 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
2684 && DECL_FUNCTION_MEMBER_P (fn))
2686 if (DECL_STATIC_FUNCTION_P (fn))
2687 return _("In static member function %qs");
2688 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2689 return _("In copy constructor %qs");
2690 else if (DECL_CONSTRUCTOR_P (fn))
2691 return _("In constructor %qs");
2692 else if (DECL_DESTRUCTOR_P (fn))
2693 return _("In destructor %qs");
2694 else if (LAMBDA_FUNCTION_P (fn))
2695 return _("In lambda function");
2697 return _("In member function %qs");
2700 return _("In function %qs");
2703 /* Report the full context of a current template instantiation,
2706 print_instantiation_full_context (diagnostic_context *context)
2708 struct tinst_level *p = current_instantiation ();
2709 location_t location = input_location;
2713 if (current_function_decl != p->decl
2714 && current_function_decl != NULL_TREE)
2715 /* We can get here during the processing of some synthesized
2716 method. Then, P->DECL will be the function that's causing
2721 if (current_function_decl == p->decl)
2722 /* Avoid redundancy with the "In function" line. */;
2724 pp_verbatim (context->printer,
2725 _("%s: In instantiation of %qs:\n"),
2726 LOCATION_FILE (location),
2727 decl_as_string_translate (p->decl,
2728 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2730 location = p->locus;
2735 print_instantiation_partial_context (context, p, location);
2738 /* Helper function of print_instantiation_partial_context() that
2739 prints a single line of instantiation context. */
2742 print_instantiation_partial_context_line (diagnostic_context *context,
2743 const struct tinst_level *t,
2744 location_t loc, bool recursive_p)
2746 expanded_location xloc;
2747 xloc = expand_location (loc);
2752 str = decl_as_string_translate (t->decl,
2753 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE);
2754 if (context->show_column)
2755 pp_verbatim (context->printer,
2757 ? _("%s:%d:%d: recursively instantiated from %qs\n")
2758 : _("%s:%d:%d: instantiated from %qs\n"),
2759 xloc.file, xloc.line, xloc.column, str);
2761 pp_verbatim (context->printer,
2763 ? _("%s:%d: recursively instantiated from %qs\n")
2764 : _("%s:%d: recursively instantiated from %qs\n"),
2765 xloc.file, xloc.line, str);
2769 if (context->show_column)
2770 pp_verbatim (context->printer,
2772 ? _("%s:%d:%d: recursively instantiated from here")
2773 : _("%s:%d:%d: instantiated from here"),
2774 xloc.file, xloc.line, xloc.column);
2776 pp_verbatim (context->printer,
2778 ? _("%s:%d: recursively instantiated from here")
2779 : _("%s:%d: instantiated from here"),
2780 xloc.file, xloc.line);
2784 /* Same as print_instantiation_full_context but less verbose. */
2787 print_instantiation_partial_context (diagnostic_context *context,
2788 struct tinst_level *t0, location_t loc)
2790 struct tinst_level *t;
2793 location_t prev_loc = loc;
2795 for (t = t0; t != NULL; t = t->next)
2796 if (prev_loc != t->locus)
2798 prev_loc = t->locus;
2806 int skip = n_total - 10;
2807 for (n = 0; n < 5; n++)
2809 gcc_assert (t != NULL);
2810 if (loc != t->locus)
2811 print_instantiation_partial_context_line (context, t, loc,
2812 /*recursive_p=*/false);
2816 if (t != NULL && skip > 1)
2818 expanded_location xloc;
2819 xloc = expand_location (loc);
2820 if (context->show_column)
2821 pp_verbatim (context->printer,
2822 _("%s:%d:%d: [ skipping %d instantiation contexts ]\n"),
2823 xloc.file, xloc.line, xloc.column, skip);
2825 pp_verbatim (context->printer,
2826 _("%s:%d: [ skipping %d instantiation contexts ]\n"),
2827 xloc.file, xloc.line, skip);
2832 } while (t != NULL && --skip > 0);
2838 while (t->next != NULL && t->locus == t->next->locus)
2843 print_instantiation_partial_context_line (context, t, loc,
2848 print_instantiation_partial_context_line (context, NULL, loc,
2849 /*recursive_p=*/false);
2850 pp_base_newline (context->printer);
2853 /* Called from cp_thing to print the template context for an error. */
2855 maybe_print_instantiation_context (diagnostic_context *context)
2857 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2860 record_last_problematic_instantiation ();
2861 print_instantiation_full_context (context);
2864 /* Report the bare minimum context of a template instantiation. */
2866 print_instantiation_context (void)
2868 print_instantiation_partial_context
2869 (global_dc, current_instantiation (), input_location);
2870 diagnostic_flush_buffer (global_dc);
2873 /* Called from output_format -- during diagnostic message processing --
2874 to handle C++ specific format specifier with the following meanings:
2875 %A function argument-list.
2879 %F function declaration.
2880 %L language as used in extern "lang".
2882 %P function parameter whose position is indicated by an integer.
2883 %Q assignment operator.
2887 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2888 int precision, bool wide, bool set_locus, bool verbose)
2892 #define next_tree (t = va_arg (*text->args_ptr, tree))
2893 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
2894 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
2895 #define next_int va_arg (*text->args_ptr, int)
2897 if (precision != 0 || wide)
2900 if (text->locus == NULL)
2905 case 'A': result = args_to_string (next_tree, verbose); break;
2906 case 'C': result = code_to_string (next_tcode); break;
2909 tree temp = next_tree;
2911 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2913 temp = DECL_DEBUG_EXPR (temp);
2916 result = expr_to_string (temp);
2920 result = decl_to_string (temp, verbose);
2923 case 'E': result = expr_to_string (next_tree); break;
2924 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2925 case 'L': result = language_to_string (next_lang); break;
2926 case 'O': result = op_to_string (next_tcode); break;
2927 case 'P': result = parm_to_string (next_int); break;
2928 case 'Q': result = assop_to_string (next_tcode); break;
2929 case 'T': result = type_to_string (next_tree, verbose); break;
2930 case 'V': result = cv_to_string (next_tree, verbose); break;
2933 percent_K_format (text);
2940 pp_base_string (pp, result);
2941 if (set_locus && t != NULL)
2942 *text->locus = location_of (t);
2950 /* Warn about the use of C++0x features when appropriate. */
2952 maybe_warn_cpp0x (cpp0x_warn_str str)
2954 if ((cxx_dialect == cxx98) && !in_system_header)
2955 /* We really want to suppress this warning in system headers,
2956 because libstdc++ uses variadic templates even when we aren't
2960 case CPP0X_INITIALIZER_LISTS:
2961 pedwarn (input_location, 0,
2962 "extended initializer lists "
2963 "only available with -std=c++0x or -std=gnu++0x");
2965 case CPP0X_EXPLICIT_CONVERSION:
2966 pedwarn (input_location, 0,
2967 "explicit conversion operators "
2968 "only available with -std=c++0x or -std=gnu++0x");
2970 case CPP0X_VARIADIC_TEMPLATES:
2971 pedwarn (input_location, 0,
2972 "variadic templates "
2973 "only available with -std=c++0x or -std=gnu++0x");
2975 case CPP0X_LAMBDA_EXPR:
2976 pedwarn (input_location, 0,
2977 "lambda expressions "
2978 "only available with -std=c++0x or -std=gnu++0x");
2981 pedwarn (input_location, 0,
2982 "C++0x auto only available with -std=c++0x or -std=gnu++0x");
2984 case CPP0X_SCOPED_ENUMS:
2985 pedwarn (input_location, 0,
2986 "scoped enums only available with -std=c++0x or -std=gnu++0x");
2988 case CPP0X_DEFAULTED_DELETED:
2989 pedwarn (input_location, 0,
2990 "defaulted and deleted functions "
2991 "only available with -std=c++0x or -std=gnu++0x");
2998 /* Warn about the use of variadic templates when appropriate. */
3000 maybe_warn_variadic_templates (void)
3002 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3006 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3007 option OPT with text GMSGID. Use this function to report
3008 diagnostics for constructs that are invalid C++98, but valid
3011 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3013 diagnostic_info diagnostic;
3016 va_start (ap, gmsgid);
3017 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
3018 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3019 diagnostic.option_index = opt;
3021 return report_diagnostic (&diagnostic);