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, 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);
86 static int get_non_default_template_args_count (tree, int);
87 static const char *function_category (tree);
88 static void maybe_print_instantiation_context (diagnostic_context *);
89 static void print_instantiation_full_context (diagnostic_context *);
90 static void print_instantiation_partial_context (diagnostic_context *,
93 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
94 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
95 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
97 static bool cp_printer (pretty_printer *, text_info *, const char *,
98 int, bool, bool, bool);
99 static location_t location_of (tree);
104 diagnostic_starter (global_dc) = cp_diagnostic_starter;
105 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
106 diagnostic_format_decoder (global_dc) = cp_printer;
108 pp_construct (pp_base (cxx_pp), NULL, 0);
109 pp_cxx_pretty_printer_init (cxx_pp);
112 /* Dump a scope, if deemed necessary. */
115 dump_scope (tree scope, int flags)
117 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
119 if (scope == NULL_TREE)
122 if (TREE_CODE (scope) == NAMESPACE_DECL)
124 if (scope != global_namespace)
126 dump_decl (scope, f);
127 pp_cxx_colon_colon (cxx_pp);
130 else if (AGGREGATE_TYPE_P (scope))
132 dump_type (scope, f);
133 pp_cxx_colon_colon (cxx_pp);
135 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
137 dump_function_decl (scope, f);
138 pp_cxx_colon_colon (cxx_pp);
142 /* Dump the template ARGument under control of FLAGS. */
145 dump_template_argument (tree arg, int flags)
147 if (ARGUMENT_PACK_P (arg))
148 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), flags);
149 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
150 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
153 if (TREE_CODE (arg) == TREE_LIST)
154 arg = TREE_VALUE (arg);
156 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
160 /* Count the number of template arguments ARGS whose value does not
161 match the (optional) default template parameter in PARAMS */
164 get_non_default_template_args_count (tree args, int flags)
166 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
168 if (/* We use this flag when generating debug information. We don't
169 want to expand templates at this point, for this may generate
170 new decls, which gets decl counts out of sync, which may in
171 turn cause codegen differences between compilations with and
173 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
174 || !flag_pretty_templates)
177 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
180 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
184 dump_template_argument_list (tree args, int flags)
186 int n = get_non_default_template_args_count (args, flags);
190 for (i = 0; i < n; ++i)
192 tree arg = TREE_VEC_ELT (args, i);
194 /* Only print a comma if we know there is an argument coming. In
195 the case of an empty template argument pack, no actual
196 argument will be printed. */
198 && (!ARGUMENT_PACK_P (arg)
199 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
200 pp_separate_with_comma (cxx_pp);
202 dump_template_argument (arg, flags);
207 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
210 dump_template_parameter (tree parm, int flags)
215 if (parm == error_mark_node)
218 p = TREE_VALUE (parm);
219 a = TREE_PURPOSE (parm);
221 if (TREE_CODE (p) == TYPE_DECL)
223 if (flags & TFF_DECL_SPECIFIERS)
225 pp_cxx_ws_string (cxx_pp, "class");
226 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
227 pp_cxx_ws_string (cxx_pp, "...");
229 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
231 else if (DECL_NAME (p))
232 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
234 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
237 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
239 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
241 pp_cxx_whitespace (cxx_pp);
243 pp_cxx_whitespace (cxx_pp);
244 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
245 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
247 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
251 /* Dump, under control of FLAGS, a template-parameter-list binding.
252 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
256 dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames)
264 tree p = TREE_VALUE (parms);
265 int lvl = TMPL_PARMS_DEPTH (parms);
268 tree lvl_args = NULL_TREE;
270 /* Don't crash if we had an invalid argument list. */
271 if (TMPL_ARGS_DEPTH (args) >= lvl)
272 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
274 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
276 tree arg = NULL_TREE;
278 /* Don't crash if we had an invalid argument list. */
279 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
280 arg = TREE_VEC_ELT (lvl_args, arg_idx);
283 pp_separate_with_comma (cxx_pp);
284 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
285 pp_cxx_whitespace (cxx_pp);
287 pp_cxx_whitespace (cxx_pp);
290 if (ARGUMENT_PACK_P (arg))
291 pp_cxx_left_brace (cxx_pp);
292 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
293 if (ARGUMENT_PACK_P (arg))
294 pp_cxx_right_brace (cxx_pp);
297 pp_string (cxx_pp, M_("<missing>"));
303 parms = TREE_CHAIN (parms);
306 for (i = 0; VEC_iterate (tree, typenames, i, t); ++i)
309 pp_separate_with_comma (cxx_pp);
310 dump_type (t, TFF_PLAIN_IDENTIFIER);
311 pp_cxx_whitespace (cxx_pp);
313 pp_cxx_whitespace (cxx_pp);
314 t = tsubst (t, args, tf_none, NULL_TREE);
315 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
316 pp_simple_type_specifier doesn't know about it. */
317 t = strip_typedefs (t);
318 dump_type (t, TFF_PLAIN_IDENTIFIER);
322 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
326 dump_type (tree t, int flags)
331 if (TYPE_PTRMEMFUNC_P (t))
334 switch (TREE_CODE (t))
337 if (t == init_list_type_node)
338 pp_string (cxx_pp, M_("<brace-enclosed initializer list>"));
339 else if (t == unknown_type_node)
340 pp_string (cxx_pp, M_("<unresolved overloaded function type>"));
346 /* A list of function parms. */
347 dump_parameters (t, flags);
350 case IDENTIFIER_NODE:
351 pp_cxx_tree_identifier (cxx_pp, t);
355 dump_type (BINFO_TYPE (t), flags);
361 dump_aggr_type (t, flags);
365 if (flags & TFF_CHASE_TYPEDEF)
367 dump_type (DECL_ORIGINAL_TYPE (t)
368 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
371 /* Else fall through. */
375 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
384 case FIXED_POINT_TYPE:
385 pp_type_specifier_seq (cxx_pp, t);
388 case TEMPLATE_TEMPLATE_PARM:
389 /* For parameters inside template signature. */
390 if (TYPE_IDENTIFIER (t))
391 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
393 pp_cxx_canonical_template_parameter (cxx_pp, t);
396 case BOUND_TEMPLATE_TEMPLATE_PARM:
398 tree args = TYPE_TI_ARGS (t);
399 pp_cxx_cv_qualifier_seq (cxx_pp, t);
400 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
401 pp_cxx_begin_template_argument_list (cxx_pp);
402 dump_template_argument_list (args, flags);
403 pp_cxx_end_template_argument_list (cxx_pp);
407 case TEMPLATE_TYPE_PARM:
408 pp_cxx_cv_qualifier_seq (cxx_pp, t);
409 if (TYPE_IDENTIFIER (t))
410 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
412 pp_cxx_canonical_template_parameter
413 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
416 /* This is not always necessary for pointers and such, but doing this
417 reduces code size. */
426 dump_type_prefix (t, flags);
427 dump_type_suffix (t, flags);
431 if (! (flags & TFF_CHASE_TYPEDEF)
432 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
434 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
437 pp_cxx_cv_qualifier_seq (cxx_pp, t);
438 pp_cxx_ws_string (cxx_pp,
439 TYPENAME_IS_ENUM_P (t) ? "enum"
440 : TYPENAME_IS_CLASS_P (t) ? "class"
442 dump_typename (t, flags);
445 case UNBOUND_CLASS_TEMPLATE:
446 if (! (flags & TFF_UNQUALIFIED_NAME))
448 dump_type (TYPE_CONTEXT (t), flags);
449 pp_cxx_colon_colon (cxx_pp);
451 pp_cxx_ws_string (cxx_pp, "template");
452 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
456 pp_cxx_ws_string (cxx_pp, "__typeof__");
457 pp_cxx_whitespace (cxx_pp);
458 pp_cxx_left_paren (cxx_pp);
459 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
460 pp_cxx_right_paren (cxx_pp);
463 case TYPE_PACK_EXPANSION:
464 dump_type (PACK_EXPANSION_PATTERN (t), flags);
465 pp_cxx_ws_string (cxx_pp, "...");
468 case TYPE_ARGUMENT_PACK:
469 dump_template_argument (t, flags);
473 pp_cxx_ws_string (cxx_pp, "decltype");
474 pp_cxx_whitespace (cxx_pp);
475 pp_cxx_left_paren (cxx_pp);
476 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
477 pp_cxx_right_paren (cxx_pp);
481 pp_string (cxx_pp, "std::nullptr_t");
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:
713 dump_type (t, flags);
714 pp_base (cxx_pp)->padding = pp_before;
718 pp_unsupported_tree (cxx_pp, t);
721 pp_string (cxx_pp, M_("<typeprefixerror>"));
726 /* Dump the suffix of type T, under control of FLAGS. This is the part
727 which appears after the identifier (or function parms). */
730 dump_type_suffix (tree t, int flags)
732 if (TYPE_PTRMEMFUNC_P (t))
733 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
735 switch (TREE_CODE (t))
740 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
741 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
742 pp_cxx_right_paren (cxx_pp);
743 dump_type_suffix (TREE_TYPE (t), flags);
750 if (TREE_CODE (t) == METHOD_TYPE)
751 /* Can only be reached through a pointer. */
752 pp_cxx_right_paren (cxx_pp);
753 arg = TYPE_ARG_TYPES (t);
754 if (TREE_CODE (t) == METHOD_TYPE)
755 arg = TREE_CHAIN (arg);
757 /* Function pointers don't have default args. Not in standard C++,
758 anyway; they may in g++, but we'll just pretend otherwise. */
759 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
761 if (TREE_CODE (t) == METHOD_TYPE)
762 pp_cxx_cv_qualifier_seq
763 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
765 pp_cxx_cv_qualifier_seq (cxx_pp, t);
766 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
767 dump_type_suffix (TREE_TYPE (t), flags);
772 pp_maybe_space (cxx_pp);
773 pp_cxx_left_bracket (cxx_pp);
776 tree dtype = TYPE_DOMAIN (t);
777 tree max = TYPE_MAX_VALUE (dtype);
778 if (host_integerp (max, 0))
779 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
780 else if (TREE_CODE (max) == MINUS_EXPR)
781 dump_expr (TREE_OPERAND (max, 0),
782 flags & ~TFF_EXPR_IN_PARENS);
784 dump_expr (fold_build2_loc (input_location,
785 PLUS_EXPR, dtype, max,
786 build_int_cst (dtype, 1)),
787 flags & ~TFF_EXPR_IN_PARENS);
789 pp_cxx_right_bracket (cxx_pp);
790 dump_type_suffix (TREE_TYPE (t), flags);
794 case IDENTIFIER_NODE:
799 case TEMPLATE_TYPE_PARM:
800 case TEMPLATE_TEMPLATE_PARM:
801 case BOUND_TEMPLATE_TEMPLATE_PARM:
813 case TYPE_PACK_EXPANSION:
814 case FIXED_POINT_TYPE:
819 pp_unsupported_tree (cxx_pp, t);
821 /* Don't mark it here, we should have already done in
828 dump_global_iord (tree t)
830 const char *p = NULL;
832 if (DECL_GLOBAL_CTOR_P (t))
833 p = M_("(static initializers for %s)");
834 else if (DECL_GLOBAL_DTOR_P (t))
835 p = M_("(static destructors for %s)");
839 pp_printf (pp_base (cxx_pp), p, input_filename);
843 dump_simple_decl (tree t, tree type, int flags)
845 if (flags & TFF_DECL_SPECIFIERS)
847 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
848 pp_maybe_space (cxx_pp);
850 if (! (flags & TFF_UNQUALIFIED_NAME)
851 && (!DECL_INITIAL (t)
852 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
853 dump_scope (CP_DECL_CONTEXT (t), flags);
854 flags &= ~TFF_UNQUALIFIED_NAME;
855 if ((flags & TFF_DECL_SPECIFIERS)
856 && DECL_TEMPLATE_PARM_P (t)
857 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
858 pp_string (cxx_pp, "...");
860 dump_decl (DECL_NAME (t), flags);
862 pp_string (cxx_pp, M_("<anonymous>"));
863 if (flags & TFF_DECL_SPECIFIERS)
864 dump_type_suffix (type, flags);
867 /* Dump a human readable string for the decl T under control of FLAGS. */
870 dump_decl (tree t, int flags)
875 switch (TREE_CODE (t))
878 /* Don't say 'typedef class A' */
879 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
881 if ((flags & TFF_DECL_SPECIFIERS)
882 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
884 /* Say `class T' not just `T'. */
885 pp_cxx_ws_string (cxx_pp, "class");
887 /* Emit the `...' for a parameter pack. */
888 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
889 pp_cxx_ws_string (cxx_pp, "...");
892 dump_type (TREE_TYPE (t), flags);
895 if ((flags & TFF_DECL_SPECIFIERS)
896 && !DECL_SELF_REFERENCE_P (t))
897 pp_cxx_ws_string (cxx_pp, "typedef");
898 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
899 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
904 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
906 pp_string (cxx_pp, M_("vtable for "));
907 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
908 dump_type (DECL_CONTEXT (t), flags);
911 /* Else fall through. */
914 dump_simple_decl (t, TREE_TYPE (t), flags);
918 pp_string (cxx_pp, M_("<return value> "));
919 dump_simple_decl (t, TREE_TYPE (t), flags);
923 if (flags & TFF_DECL_SPECIFIERS)
924 pp_cxx_declaration (cxx_pp, t);
927 if (! (flags & TFF_UNQUALIFIED_NAME))
928 dump_scope (CP_DECL_CONTEXT (t), flags);
929 flags &= ~TFF_UNQUALIFIED_NAME;
930 if (DECL_NAME (t) == NULL_TREE)
931 pp_string (cxx_pp, M_("<unnamed>"));
933 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
938 dump_type (TREE_OPERAND (t, 0), flags);
939 pp_string (cxx_pp, "::");
940 dump_decl (TREE_OPERAND (t, 1), flags|TFF_UNQUALIFIED_NAME);
944 dump_decl (TREE_OPERAND (t, 0), flags);
945 pp_cxx_left_bracket (cxx_pp);
946 dump_decl (TREE_OPERAND (t, 1), flags);
947 pp_cxx_right_bracket (cxx_pp);
950 /* So that we can do dump_decl on an aggr type. */
954 dump_type (t, flags);
958 /* This is a pseudo destructor call which has not been folded into
959 a PSEUDO_DTOR_EXPR yet. */
960 pp_cxx_complement (cxx_pp);
961 dump_type (TREE_OPERAND (t, 0), flags);
968 /* These special cases are duplicated here so that other functions
969 can feed identifiers to error and get them demangled properly. */
970 case IDENTIFIER_NODE:
971 if (IDENTIFIER_TYPENAME_P (t))
973 pp_cxx_ws_string (cxx_pp, "operator");
974 /* Not exactly IDENTIFIER_TYPE_VALUE. */
975 dump_type (TREE_TYPE (t), flags);
979 pp_cxx_tree_identifier (cxx_pp, t);
986 if (DECL_CLASS_SCOPE_P (t))
988 dump_type (DECL_CONTEXT (t), flags);
989 pp_cxx_colon_colon (cxx_pp);
991 else if (DECL_CONTEXT (t))
993 dump_decl (DECL_CONTEXT (t), flags);
994 pp_cxx_colon_colon (cxx_pp);
996 dump_decl (DECL_NAME (t), flags);
1000 /* If there's only one function, just treat it like an ordinary
1002 t = OVL_CURRENT (t);
1006 if (! DECL_LANG_SPECIFIC (t))
1007 pp_string (cxx_pp, M_("<built-in>"));
1008 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1009 dump_global_iord (t);
1011 dump_function_decl (t, flags);
1015 dump_template_decl (t, flags);
1018 case TEMPLATE_ID_EXPR:
1020 tree name = TREE_OPERAND (t, 0);
1022 if (is_overloaded_fn (name))
1023 name = DECL_NAME (get_first_fn (name));
1024 dump_decl (name, flags);
1025 pp_cxx_begin_template_argument_list (cxx_pp);
1026 if (TREE_OPERAND (t, 1))
1027 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
1028 pp_cxx_end_template_argument_list (cxx_pp);
1033 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1037 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1038 || (DECL_INITIAL (t) &&
1039 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1040 dump_simple_decl (t, TREE_TYPE (t), flags);
1041 else if (DECL_NAME (t))
1042 dump_decl (DECL_NAME (t), flags);
1043 else if (DECL_INITIAL (t))
1044 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1046 pp_string (cxx_pp, M_("<enumerator>"));
1050 pp_cxx_ws_string (cxx_pp, "using");
1051 dump_type (USING_DECL_SCOPE (t), flags);
1052 pp_cxx_colon_colon (cxx_pp);
1053 dump_decl (DECL_NAME (t), flags);
1057 pp_cxx_declaration (cxx_pp, t);
1061 dump_decl (BASELINK_FUNCTIONS (t), flags);
1064 case NON_DEPENDENT_EXPR:
1065 dump_expr (t, flags);
1068 case TEMPLATE_TYPE_PARM:
1069 if (flags & TFF_DECL_SPECIFIERS)
1070 pp_cxx_declaration (cxx_pp, t);
1072 pp_type_id (cxx_pp, t);
1075 case UNBOUND_CLASS_TEMPLATE:
1076 case TYPE_PACK_EXPANSION:
1078 dump_type (t, flags);
1082 pp_unsupported_tree (cxx_pp, t);
1083 /* Fall through to error. */
1086 pp_string (cxx_pp, M_("<declaration error>"));
1091 /* Dump a template declaration T under control of FLAGS. This means the
1092 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1095 dump_template_decl (tree t, int flags)
1097 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1101 if (flags & TFF_TEMPLATE_HEADER)
1103 for (parms = orig_parms = nreverse (orig_parms);
1105 parms = TREE_CHAIN (parms))
1107 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1108 int len = TREE_VEC_LENGTH (inner_parms);
1110 pp_cxx_ws_string (cxx_pp, "template");
1111 pp_cxx_begin_template_argument_list (cxx_pp);
1113 /* If we've shown the template prefix, we'd better show the
1114 parameters' and decl's type too. */
1115 flags |= TFF_DECL_SPECIFIERS;
1117 for (i = 0; i < len; i++)
1120 pp_separate_with_comma (cxx_pp);
1121 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1123 pp_cxx_end_template_argument_list (cxx_pp);
1124 pp_cxx_whitespace (cxx_pp);
1126 nreverse(orig_parms);
1128 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1130 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1131 pp_cxx_ws_string (cxx_pp, "class");
1133 /* If this is a parameter pack, print the ellipsis. */
1134 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1135 pp_cxx_ws_string (cxx_pp, "...");
1139 if (DECL_TEMPLATE_RESULT (t)
1140 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1141 dump_type (TREE_TYPE (t),
1142 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1143 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1144 else if (DECL_TEMPLATE_RESULT (t)
1145 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1146 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1149 gcc_assert (TREE_TYPE (t));
1150 switch (NEXT_CODE (t))
1154 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1157 /* This case can occur with some invalid code. */
1158 dump_type (TREE_TYPE (t),
1159 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1160 | (flags & TFF_DECL_SPECIFIERS
1161 ? TFF_CLASS_KEY_OR_ENUM : 0));
1166 /* find_typenames looks through the type of the function template T
1167 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1170 struct find_typenames_t
1172 struct pointer_set_t *p_set;
1173 VEC (tree,gc) *typenames;
1177 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1179 struct find_typenames_t *d = (struct find_typenames_t *)data;
1180 tree mv = NULL_TREE;
1182 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1183 /* Add the type of the typedef without any additional cv-quals. */
1184 mv = TREE_TYPE (TYPE_NAME (*tp));
1185 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1186 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1187 /* Add the typename without any cv-qualifiers. */
1188 mv = TYPE_MAIN_VARIANT (*tp);
1190 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1191 VEC_safe_push (tree, gc, d->typenames, mv);
1193 /* Search into class template arguments, which cp_walk_subtrees
1195 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1196 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1202 static VEC(tree,gc) *
1203 find_typenames (tree t)
1205 struct find_typenames_t ft;
1206 ft.p_set = pointer_set_create ();
1207 ft.typenames = NULL;
1208 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1209 find_typenames_r, &ft, ft.p_set);
1210 pointer_set_destroy (ft.p_set);
1211 return ft.typenames;
1214 /* Pretty print a function decl. There are several ways we want to print a
1215 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1216 As error can only apply the '#' flag once to give 0 and 1 for V, there
1217 is %D which doesn't print the throw specs, and %F which does. */
1220 dump_function_decl (tree t, int flags)
1224 tree cname = NULL_TREE;
1225 tree template_args = NULL_TREE;
1226 tree template_parms = NULL_TREE;
1227 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1228 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1230 VEC(tree,gc) *typenames = NULL;
1232 if (LAMBDA_FUNCTION_P (t))
1234 /* A lambda's signature is essentially its "type", so defer. */
1235 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t)));
1236 dump_type (DECL_CONTEXT (t), flags);
1240 flags &= ~TFF_UNQUALIFIED_NAME;
1241 if (TREE_CODE (t) == TEMPLATE_DECL)
1242 t = DECL_TEMPLATE_RESULT (t);
1244 /* Save the exceptions, in case t is a specialization and we are
1245 emitting an error about incompatible specifications. */
1246 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1248 /* Pretty print template instantiations only. */
1249 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1250 && flag_pretty_templates)
1254 template_args = DECL_TI_ARGS (t);
1255 tmpl = most_general_template (t);
1256 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1258 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1260 typenames = find_typenames (t);
1264 fntype = TREE_TYPE (t);
1265 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1267 if (DECL_CLASS_SCOPE_P (t))
1268 cname = DECL_CONTEXT (t);
1269 /* This is for partially instantiated template methods. */
1270 else if (TREE_CODE (fntype) == METHOD_TYPE)
1271 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1273 if (!(flags & TFF_DECL_SPECIFIERS))
1275 else if (DECL_STATIC_FUNCTION_P (t))
1276 pp_cxx_ws_string (cxx_pp, "static");
1277 else if (DECL_VIRTUAL_P (t))
1278 pp_cxx_ws_string (cxx_pp, "virtual");
1280 /* Print the return type? */
1282 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1283 && !DECL_DESTRUCTOR_P (t);
1285 dump_type_prefix (TREE_TYPE (fntype), flags);
1287 /* Print the function name. */
1288 if (!do_outer_scope)
1292 dump_type (cname, flags);
1293 pp_cxx_colon_colon (cxx_pp);
1296 dump_scope (CP_DECL_CONTEXT (t), flags);
1298 dump_function_name (t, flags);
1300 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1302 dump_parameters (parmtypes, flags);
1304 if (TREE_CODE (fntype) == METHOD_TYPE)
1306 pp_base (cxx_pp)->padding = pp_before;
1307 pp_cxx_cv_qualifier_seq
1308 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1311 if (flags & TFF_EXCEPTION_SPECIFICATION)
1313 pp_base (cxx_pp)->padding = pp_before;
1314 dump_exception_spec (exceptions, flags);
1318 dump_type_suffix (TREE_TYPE (fntype), flags);
1321 /* If T is a template instantiation, dump the parameter binding. */
1322 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1324 pp_cxx_whitespace (cxx_pp);
1325 pp_cxx_left_bracket (cxx_pp);
1326 pp_cxx_ws_string (cxx_pp, M_("with"));
1327 pp_cxx_whitespace (cxx_pp);
1328 dump_template_bindings (template_parms, template_args, typenames);
1329 pp_cxx_right_bracket (cxx_pp);
1333 /* Print a parameter list. If this is for a member function, the
1334 member object ptr (and any other hidden args) should have
1335 already been removed. */
1338 dump_parameters (tree parmtypes, int flags)
1341 pp_cxx_left_paren (cxx_pp);
1343 for (first = 1; parmtypes != void_list_node;
1344 parmtypes = TREE_CHAIN (parmtypes))
1347 pp_separate_with_comma (cxx_pp);
1351 pp_cxx_ws_string (cxx_pp, "...");
1355 dump_type (TREE_VALUE (parmtypes), flags);
1357 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1359 pp_cxx_whitespace (cxx_pp);
1361 pp_cxx_whitespace (cxx_pp);
1362 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1366 pp_cxx_right_paren (cxx_pp);
1369 /* Print an exception specification. T is the exception specification. */
1372 dump_exception_spec (tree t, int flags)
1376 pp_cxx_ws_string (cxx_pp, "throw");
1377 pp_cxx_whitespace (cxx_pp);
1378 pp_cxx_left_paren (cxx_pp);
1379 if (TREE_VALUE (t) != NULL_TREE)
1382 dump_type (TREE_VALUE (t), flags);
1386 pp_separate_with_comma (cxx_pp);
1388 pp_cxx_right_paren (cxx_pp);
1392 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1393 and destructors properly. */
1396 dump_function_name (tree t, int flags)
1398 tree name = DECL_NAME (t);
1400 /* We can get here with a decl that was synthesized by language-
1401 independent machinery (e.g. coverage.c) in which case it won't
1402 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1403 will crash. In this case it is safe just to print out the
1405 if (!DECL_LANG_SPECIFIC (t))
1407 pp_cxx_tree_identifier (cxx_pp, name);
1411 if (TREE_CODE (t) == TEMPLATE_DECL)
1412 t = DECL_TEMPLATE_RESULT (t);
1414 /* Don't let the user see __comp_ctor et al. */
1415 if (DECL_CONSTRUCTOR_P (t)
1416 || DECL_DESTRUCTOR_P (t))
1418 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1419 name = get_identifier ("<lambda>");
1421 name = constructor_name (DECL_CONTEXT (t));
1424 if (DECL_DESTRUCTOR_P (t))
1426 pp_cxx_complement (cxx_pp);
1427 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1429 else if (DECL_CONV_FN_P (t))
1431 /* This cannot use the hack that the operator's return
1432 type is stashed off of its name because it may be
1433 used for error reporting. In the case of conflicting
1434 declarations, both will have the same name, yet
1435 the types will be different, hence the TREE_TYPE field
1436 of the first name will be clobbered by the second. */
1437 pp_cxx_ws_string (cxx_pp, "operator");
1438 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1440 else if (name && IDENTIFIER_OPNAME_P (name))
1441 pp_cxx_tree_identifier (cxx_pp, name);
1443 dump_decl (name, flags);
1445 if (DECL_TEMPLATE_INFO (t)
1446 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1447 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1448 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1449 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1452 /* Dump the template parameters from the template info INFO under control of
1453 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1454 specialization (partial or complete). For partial specializations we show
1455 the specialized parameter values. For a primary template we show no
1459 dump_template_parms (tree info, int primary, int flags)
1461 tree args = info ? TI_ARGS (info) : NULL_TREE;
1463 if (primary && flags & TFF_TEMPLATE_NAME)
1465 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1466 pp_cxx_begin_template_argument_list (cxx_pp);
1468 /* Be careful only to print things when we have them, so as not
1469 to crash producing error messages. */
1470 if (args && !primary)
1473 len = get_non_default_template_args_count (args, flags);
1475 args = INNERMOST_TEMPLATE_ARGS (args);
1476 for (ix = 0; ix != len; ix++)
1478 tree arg = TREE_VEC_ELT (args, ix);
1480 /* Only print a comma if we know there is an argument coming. In
1481 the case of an empty template argument pack, no actual
1482 argument will be printed. */
1484 && (!ARGUMENT_PACK_P (arg)
1485 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1486 pp_separate_with_comma (cxx_pp);
1489 pp_string (cxx_pp, M_("<template parameter error>"));
1491 dump_template_argument (arg, flags);
1496 tree tpl = TI_TEMPLATE (info);
1497 tree parms = DECL_TEMPLATE_PARMS (tpl);
1500 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1501 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1503 for (ix = 0; ix != len; ix++)
1507 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1509 pp_string (cxx_pp, M_("<template parameter error>"));
1513 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1516 pp_separate_with_comma (cxx_pp);
1518 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1521 pp_cxx_end_template_argument_list (cxx_pp);
1524 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1525 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1528 dump_call_expr_args (tree t, int flags, bool skipfirst)
1531 call_expr_arg_iterator iter;
1533 pp_cxx_left_paren (cxx_pp);
1534 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1540 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1541 if (more_call_expr_args_p (&iter))
1542 pp_separate_with_comma (cxx_pp);
1545 pp_cxx_right_paren (cxx_pp);
1548 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1549 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1553 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1556 aggr_init_expr_arg_iterator iter;
1558 pp_cxx_left_paren (cxx_pp);
1559 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1565 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1566 if (more_aggr_init_expr_args_p (&iter))
1567 pp_separate_with_comma (cxx_pp);
1570 pp_cxx_right_paren (cxx_pp);
1573 /* Print out a list of initializers (subr of dump_expr). */
1576 dump_expr_list (tree l, int flags)
1580 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1583 pp_separate_with_comma (cxx_pp);
1587 /* Print out a vector of initializers (subr of dump_expr). */
1590 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1592 unsigned HOST_WIDE_INT idx;
1595 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1597 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1598 if (idx != VEC_length (constructor_elt, v) - 1)
1599 pp_separate_with_comma (cxx_pp);
1604 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1605 function. Resolve it to a close relative -- in the sense of static
1606 type -- variant being overridden. That is close to what was written in
1607 the source code. Subroutine of dump_expr. */
1610 resolve_virtual_fun_from_obj_type_ref (tree ref)
1612 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1613 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1614 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1617 fun = TREE_CHAIN (fun);
1618 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1619 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1625 /* Print out an expression E under control of FLAGS. */
1628 dump_expr (tree t, int flags)
1633 if (STATEMENT_CLASS_P (t))
1635 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1639 switch (TREE_CODE (t))
1647 case NAMESPACE_DECL:
1650 case IDENTIFIER_NODE:
1651 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1658 pp_constant (cxx_pp, t);
1662 /* While waiting for caret diagnostics, avoid printing
1663 __cxa_allocate_exception, __cxa_throw, and the like. */
1664 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1668 pp_ampersand (cxx_pp);
1669 dump_type (PTRMEM_CST_CLASS (t), flags);
1670 pp_cxx_colon_colon (cxx_pp);
1671 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1675 pp_cxx_left_paren (cxx_pp);
1676 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1677 pp_separate_with_comma (cxx_pp);
1678 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1679 pp_cxx_right_paren (cxx_pp);
1683 pp_cxx_left_paren (cxx_pp);
1684 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1685 pp_string (cxx_pp, " ? ");
1686 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1687 pp_string (cxx_pp, " : ");
1688 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1689 pp_cxx_right_paren (cxx_pp);
1693 if (TREE_HAS_CONSTRUCTOR (t))
1695 pp_cxx_ws_string (cxx_pp, "new");
1696 pp_cxx_whitespace (cxx_pp);
1697 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1700 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1703 case AGGR_INIT_EXPR:
1705 tree fn = NULL_TREE;
1707 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1708 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1710 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1712 if (DECL_CONSTRUCTOR_P (fn))
1713 dump_type (DECL_CONTEXT (fn), flags);
1718 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1720 dump_aggr_init_expr_args (t, flags, true);
1725 tree fn = CALL_EXPR_FN (t);
1726 bool skipfirst = false;
1728 if (TREE_CODE (fn) == ADDR_EXPR)
1729 fn = TREE_OPERAND (fn, 0);
1731 /* Nobody is interested in seeing the guts of vcalls. */
1732 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1733 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1735 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1737 tree ob = CALL_EXPR_ARG (t, 0);
1738 if (TREE_CODE (ob) == ADDR_EXPR)
1740 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1741 pp_cxx_dot (cxx_pp);
1743 else if (TREE_CODE (ob) != PARM_DECL
1744 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1746 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1747 pp_cxx_arrow (cxx_pp);
1751 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1752 dump_call_expr_args (t, flags, skipfirst);
1757 /* Note that this only works for G++ target exprs. If somebody
1758 builds a general TARGET_EXPR, there's no way to represent that
1759 it initializes anything other that the parameter slot for the
1760 default argument. Note we may have cleared out the first
1761 operand in expand_expr, so don't go killing ourselves. */
1762 if (TREE_OPERAND (t, 1))
1763 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1766 case POINTER_PLUS_EXPR:
1767 dump_binary_op ("+", t, flags);
1775 case TRUNC_DIV_EXPR:
1776 case TRUNC_MOD_EXPR:
1784 case TRUTH_ANDIF_EXPR:
1785 case TRUTH_ORIF_EXPR:
1792 case EXACT_DIV_EXPR:
1793 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1797 case FLOOR_DIV_EXPR:
1798 case ROUND_DIV_EXPR:
1800 dump_binary_op ("/", t, flags);
1804 case FLOOR_MOD_EXPR:
1805 case ROUND_MOD_EXPR:
1806 dump_binary_op ("%", t, flags);
1811 tree ob = TREE_OPERAND (t, 0);
1812 if (TREE_CODE (ob) == INDIRECT_REF)
1814 ob = TREE_OPERAND (ob, 0);
1815 if (TREE_CODE (ob) != PARM_DECL
1817 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1819 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1820 pp_cxx_arrow (cxx_pp);
1825 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1826 pp_cxx_dot (cxx_pp);
1828 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1833 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1834 pp_cxx_left_bracket (cxx_pp);
1835 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1836 pp_cxx_right_bracket (cxx_pp);
1839 case UNARY_PLUS_EXPR:
1840 dump_unary_op ("+", t, flags);
1844 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1845 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1846 /* An ADDR_EXPR can have reference type. In that case, we
1847 shouldn't print the `&' doing so indicates to the user
1848 that the expression has pointer type. */
1850 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1851 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1852 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1853 dump_unary_op ("&&", t, flags);
1855 dump_unary_op ("&", t, flags);
1859 if (TREE_HAS_CONSTRUCTOR (t))
1861 t = TREE_OPERAND (t, 0);
1862 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1863 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1864 dump_call_expr_args (t, flags, true);
1868 if (TREE_OPERAND (t,0) != NULL_TREE
1869 && TREE_TYPE (TREE_OPERAND (t, 0))
1870 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1871 dump_expr (TREE_OPERAND (t, 0), flags);
1873 dump_unary_op ("*", t, flags);
1879 case TRUTH_NOT_EXPR:
1880 case PREDECREMENT_EXPR:
1881 case PREINCREMENT_EXPR:
1882 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1885 case POSTDECREMENT_EXPR:
1886 case POSTINCREMENT_EXPR:
1887 pp_cxx_left_paren (cxx_pp);
1888 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1889 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1890 pp_cxx_right_paren (cxx_pp);
1893 case NON_LVALUE_EXPR:
1894 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1895 should be another level of INDIRECT_REF so that I don't have to do
1897 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1899 tree next = TREE_TYPE (TREE_TYPE (t));
1901 while (TREE_CODE (next) == POINTER_TYPE)
1902 next = TREE_TYPE (next);
1904 if (TREE_CODE (next) == FUNCTION_TYPE)
1906 if (flags & TFF_EXPR_IN_PARENS)
1907 pp_cxx_left_paren (cxx_pp);
1908 pp_cxx_star (cxx_pp);
1909 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1910 if (flags & TFF_EXPR_IN_PARENS)
1911 pp_cxx_right_paren (cxx_pp);
1914 /* Else fall through. */
1916 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1920 case VIEW_CONVERT_EXPR:
1922 tree op = TREE_OPERAND (t, 0);
1924 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1926 /* It is a cast, but we cannot tell whether it is a
1927 reinterpret or static cast. Use the C style notation. */
1928 if (flags & TFF_EXPR_IN_PARENS)
1929 pp_cxx_left_paren (cxx_pp);
1930 pp_cxx_left_paren (cxx_pp);
1931 dump_type (TREE_TYPE (t), flags);
1932 pp_cxx_right_paren (cxx_pp);
1933 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1934 if (flags & TFF_EXPR_IN_PARENS)
1935 pp_cxx_right_paren (cxx_pp);
1938 dump_expr (op, flags);
1943 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1945 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1947 if (integer_zerop (idx))
1949 /* A NULL pointer-to-member constant. */
1950 pp_cxx_left_paren (cxx_pp);
1951 pp_cxx_left_paren (cxx_pp);
1952 dump_type (TREE_TYPE (t), flags);
1953 pp_cxx_right_paren (cxx_pp);
1954 pp_character (cxx_pp, '0');
1955 pp_cxx_right_paren (cxx_pp);
1958 else if (host_integerp (idx, 0))
1961 unsigned HOST_WIDE_INT n;
1963 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1964 t = TYPE_METHOD_BASETYPE (t);
1965 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1967 n = tree_low_cst (idx, 0);
1969 /* Map vtable index back one, to allow for the null pointer to
1973 while (n > 0 && virtuals)
1976 virtuals = TREE_CHAIN (virtuals);
1980 dump_expr (BV_FN (virtuals),
1981 flags | TFF_EXPR_IN_PARENS);
1986 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1988 dump_type (TREE_TYPE (t), 0);
1989 pp_cxx_left_paren (cxx_pp);
1990 pp_cxx_right_paren (cxx_pp);
1994 pp_cxx_left_brace (cxx_pp);
1995 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1996 pp_cxx_right_brace (cxx_pp);
2003 tree ob = TREE_OPERAND (t, 0);
2004 if (is_dummy_object (ob))
2006 t = TREE_OPERAND (t, 1);
2007 if (TREE_CODE (t) == FUNCTION_DECL)
2009 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
2010 else if (BASELINK_P (t))
2011 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2012 flags | TFF_EXPR_IN_PARENS);
2014 dump_decl (t, flags);
2018 if (TREE_CODE (ob) == INDIRECT_REF)
2020 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2021 pp_cxx_arrow (cxx_pp);
2022 pp_cxx_star (cxx_pp);
2026 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2027 pp_cxx_dot (cxx_pp);
2028 pp_cxx_star (cxx_pp);
2030 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2035 case TEMPLATE_PARM_INDEX:
2036 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2040 if (TREE_OPERAND (t, 0) == NULL_TREE
2041 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2043 dump_type (TREE_TYPE (t), flags);
2044 pp_cxx_left_paren (cxx_pp);
2045 dump_expr_list (TREE_OPERAND (t, 0), flags);
2046 pp_cxx_right_paren (cxx_pp);
2050 pp_cxx_left_paren (cxx_pp);
2051 dump_type (TREE_TYPE (t), flags);
2052 pp_cxx_right_paren (cxx_pp);
2053 pp_cxx_left_paren (cxx_pp);
2054 dump_expr_list (TREE_OPERAND (t, 0), flags);
2055 pp_cxx_right_paren (cxx_pp);
2059 case STATIC_CAST_EXPR:
2060 pp_cxx_ws_string (cxx_pp, "static_cast");
2062 case REINTERPRET_CAST_EXPR:
2063 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2065 case CONST_CAST_EXPR:
2066 pp_cxx_ws_string (cxx_pp, "const_cast");
2068 case DYNAMIC_CAST_EXPR:
2069 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2071 pp_cxx_begin_template_argument_list (cxx_pp);
2072 dump_type (TREE_TYPE (t), flags);
2073 pp_cxx_end_template_argument_list (cxx_pp);
2074 pp_cxx_left_paren (cxx_pp);
2075 dump_expr (TREE_OPERAND (t, 0), flags);
2076 pp_cxx_right_paren (cxx_pp);
2080 dump_expr (TREE_OPERAND (t, 0), flags);
2081 pp_cxx_arrow (cxx_pp);
2086 if (TREE_CODE (t) == SIZEOF_EXPR)
2087 pp_cxx_ws_string (cxx_pp, "sizeof");
2090 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2091 pp_cxx_ws_string (cxx_pp, "__alignof__");
2093 pp_cxx_whitespace (cxx_pp);
2094 pp_cxx_left_paren (cxx_pp);
2095 if (TYPE_P (TREE_OPERAND (t, 0)))
2096 dump_type (TREE_OPERAND (t, 0), flags);
2098 dump_expr (TREE_OPERAND (t, 0), flags);
2099 pp_cxx_right_paren (cxx_pp);
2104 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2105 pp_cxx_whitespace (cxx_pp);
2106 dump_expr (TREE_OPERAND (t, 0), flags);
2110 pp_string (cxx_pp, M_("<unparsed>"));
2113 case TRY_CATCH_EXPR:
2114 case WITH_CLEANUP_EXPR:
2115 case CLEANUP_POINT_EXPR:
2116 dump_expr (TREE_OPERAND (t, 0), flags);
2119 case PSEUDO_DTOR_EXPR:
2120 dump_expr (TREE_OPERAND (t, 2), flags);
2121 pp_cxx_dot (cxx_pp);
2122 dump_type (TREE_OPERAND (t, 0), flags);
2123 pp_cxx_colon_colon (cxx_pp);
2124 pp_cxx_complement (cxx_pp);
2125 dump_type (TREE_OPERAND (t, 1), flags);
2128 case TEMPLATE_ID_EXPR:
2129 dump_decl (t, flags);
2135 case STATEMENT_LIST:
2136 /* We don't yet have a way of dumping statements in a
2137 human-readable format. */
2138 pp_string (cxx_pp, "({...})");
2142 pp_string (cxx_pp, "while (1) { ");
2143 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2144 pp_cxx_right_brace (cxx_pp);
2148 pp_string (cxx_pp, "if (");
2149 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2150 pp_string (cxx_pp, ") break; ");
2154 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2157 case EMPTY_CLASS_EXPR:
2158 dump_type (TREE_TYPE (t), flags);
2159 pp_cxx_left_paren (cxx_pp);
2160 pp_cxx_right_paren (cxx_pp);
2163 case NON_DEPENDENT_EXPR:
2164 dump_expr (TREE_OPERAND (t, 0), flags);
2167 case ARGUMENT_PACK_SELECT:
2168 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2180 pp_type_specifier_seq (cxx_pp, t);
2184 /* We get here when we want to print a dependent type as an
2185 id-expression, without any disambiguator decoration. */
2186 pp_id_expression (cxx_pp, t);
2189 case TEMPLATE_TYPE_PARM:
2190 case BOUND_TEMPLATE_TEMPLATE_PARM:
2191 dump_type (t, flags);
2195 pp_cxx_trait_expression (cxx_pp, t);
2199 pp_cxx_va_arg_expression (cxx_pp, t);
2203 pp_cxx_offsetof_expression (cxx_pp, t);
2207 dump_decl (t, flags);
2210 case EXPR_PACK_EXPANSION:
2217 case VEC_DELETE_EXPR:
2223 case UNORDERED_EXPR:
2233 case FIX_TRUNC_EXPR:
2235 pp_expression (cxx_pp, t);
2238 case TRUTH_AND_EXPR:
2240 case TRUTH_XOR_EXPR:
2241 if (flags & TFF_EXPR_IN_PARENS)
2242 pp_cxx_left_paren (cxx_pp);
2243 pp_expression (cxx_pp, t);
2244 if (flags & TFF_EXPR_IN_PARENS)
2245 pp_cxx_right_paren (cxx_pp);
2249 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2252 /* This list is incomplete, but should suffice for now.
2253 It is very important that `sorry' does not call
2254 `report_error_function'. That could cause an infinite loop. */
2256 pp_unsupported_tree (cxx_pp, t);
2257 /* fall through to ERROR_MARK... */
2259 pp_string (cxx_pp, M_("<expression error>"));
2265 dump_binary_op (const char *opstring, tree t, int flags)
2267 pp_cxx_left_paren (cxx_pp);
2268 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2269 pp_cxx_whitespace (cxx_pp);
2271 pp_cxx_ws_string (cxx_pp, opstring);
2273 pp_string (cxx_pp, M_("<unknown operator>"));
2274 pp_cxx_whitespace (cxx_pp);
2275 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2276 pp_cxx_right_paren (cxx_pp);
2280 dump_unary_op (const char *opstring, tree t, int flags)
2282 if (flags & TFF_EXPR_IN_PARENS)
2283 pp_cxx_left_paren (cxx_pp);
2284 pp_cxx_ws_string (cxx_pp, opstring);
2285 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2286 if (flags & TFF_EXPR_IN_PARENS)
2287 pp_cxx_right_paren (cxx_pp);
2291 reinit_cxx_pp (void)
2293 pp_clear_output_area (cxx_pp);
2294 pp_base (cxx_pp)->padding = pp_none;
2295 pp_indentation (cxx_pp) = 0;
2296 pp_needs_newline (cxx_pp) = false;
2297 cxx_pp->enclosing_scope = current_function_decl;
2301 /* Exported interface to stringifying types, exprs and decls under TFF_*
2305 type_as_string (tree typ, int flags)
2308 pp_translate_identifiers (cxx_pp) = false;
2309 dump_type (typ, flags);
2310 return pp_formatted_text (cxx_pp);
2314 type_as_string_translate (tree typ, int flags)
2317 dump_type (typ, flags);
2318 return pp_formatted_text (cxx_pp);
2322 expr_as_string (tree decl, int flags)
2325 pp_translate_identifiers (cxx_pp) = false;
2326 dump_expr (decl, flags);
2327 return pp_formatted_text (cxx_pp);
2331 decl_as_string (tree decl, int flags)
2334 pp_translate_identifiers (cxx_pp) = false;
2335 dump_decl (decl, flags);
2336 return pp_formatted_text (cxx_pp);
2340 decl_as_string_translate (tree decl, int flags)
2343 dump_decl (decl, flags);
2344 return pp_formatted_text (cxx_pp);
2347 /* Generate the three forms of printable names for cxx_printable_name. */
2350 lang_decl_name (tree decl, int v, bool translate)
2354 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2355 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2358 pp_translate_identifiers (cxx_pp) = translate;
2360 && (DECL_CLASS_SCOPE_P (decl)
2361 || (DECL_NAMESPACE_SCOPE_P (decl)
2362 && CP_DECL_CONTEXT (decl) != global_namespace)))
2364 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2365 pp_cxx_colon_colon (cxx_pp);
2368 if (TREE_CODE (decl) == FUNCTION_DECL)
2369 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2371 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2373 return pp_formatted_text (cxx_pp);
2376 /* Return the location of a tree passed to %+ formats. */
2379 location_of (tree t)
2381 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2382 t = DECL_CONTEXT (t);
2383 else if (TYPE_P (t))
2384 t = TYPE_MAIN_DECL (t);
2385 else if (TREE_CODE (t) == OVERLOAD)
2386 t = OVL_FUNCTION (t);
2388 return DECL_SOURCE_LOCATION (t);
2391 /* Now the interfaces from error et al to dump_type et al. Each takes an
2392 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2396 decl_to_string (tree decl, int verbose)
2400 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2401 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2402 flags = TFF_CLASS_KEY_OR_ENUM;
2404 flags |= TFF_DECL_SPECIFIERS;
2405 else if (TREE_CODE (decl) == FUNCTION_DECL)
2406 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2407 flags |= TFF_TEMPLATE_HEADER;
2410 dump_decl (decl, flags);
2411 return pp_formatted_text (cxx_pp);
2415 expr_to_string (tree decl)
2418 dump_expr (decl, 0);
2419 return pp_formatted_text (cxx_pp);
2423 fndecl_to_string (tree fndecl, int verbose)
2427 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2428 | TFF_TEMPLATE_HEADER;
2430 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2432 dump_decl (fndecl, flags);
2433 return pp_formatted_text (cxx_pp);
2438 code_to_string (enum tree_code c)
2440 return tree_code_name [c];
2444 language_to_string (enum languages c)
2451 case lang_cplusplus:
2463 /* Return the proper printed version of a parameter to a C++ function. */
2466 parm_to_string (int p)
2470 pp_string (cxx_pp, "'this'");
2472 pp_decimal_int (cxx_pp, p + 1);
2473 return pp_formatted_text (cxx_pp);
2477 op_to_string (enum tree_code p)
2479 tree id = operator_name_info[(int) p].identifier;
2480 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2484 type_to_string (tree typ, int verbose)
2488 flags |= TFF_CLASS_KEY_OR_ENUM;
2489 flags |= TFF_TEMPLATE_HEADER;
2492 dump_type (typ, flags);
2493 return pp_formatted_text (cxx_pp);
2497 assop_to_string (enum tree_code p)
2499 tree id = assignment_operator_name_info[(int) p].identifier;
2500 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2504 args_to_string (tree p, int verbose)
2508 flags |= TFF_CLASS_KEY_OR_ENUM;
2513 if (TYPE_P (TREE_VALUE (p)))
2514 return type_as_string_translate (p, flags);
2517 for (; p; p = TREE_CHAIN (p))
2519 if (TREE_VALUE (p) == null_node)
2520 pp_cxx_ws_string (cxx_pp, "NULL");
2522 dump_type (error_type (TREE_VALUE (p)), flags);
2524 pp_separate_with_comma (cxx_pp);
2526 return pp_formatted_text (cxx_pp);
2530 cv_to_string (tree p, int v)
2533 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2534 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2535 return pp_formatted_text (cxx_pp);
2538 /* Langhook for print_error_function. */
2540 cxx_print_error_function (diagnostic_context *context, const char *file,
2541 diagnostic_info *diagnostic)
2543 lhd_print_error_function (context, file, diagnostic);
2544 pp_base_set_prefix (context->printer, file);
2545 maybe_print_instantiation_context (context);
2549 cp_diagnostic_starter (diagnostic_context *context,
2550 diagnostic_info *diagnostic)
2552 diagnostic_report_current_module (context);
2553 cp_print_error_function (context, diagnostic);
2554 maybe_print_instantiation_context (context);
2555 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2559 cp_diagnostic_finalizer (diagnostic_context *context,
2560 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2562 pp_base_destroy_prefix (context->printer);
2565 /* Print current function onto BUFFER, in the process of reporting
2566 a diagnostic message. Called from cp_diagnostic_starter. */
2568 cp_print_error_function (diagnostic_context *context,
2569 diagnostic_info *diagnostic)
2571 if (diagnostic_last_function_changed (context, diagnostic))
2573 const char *old_prefix = context->printer->prefix;
2574 const char *file = LOCATION_FILE (diagnostic->location);
2575 tree abstract_origin = diagnostic->abstract_origin;
2576 char *new_prefix = (file && abstract_origin == NULL)
2577 ? file_name_as_prefix (file) : NULL;
2579 pp_base_set_prefix (context->printer, new_prefix);
2581 if (current_function_decl == NULL)
2582 pp_base_string (context->printer, _("At global scope:"));
2587 if (abstract_origin)
2589 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2590 while (TREE_CODE (ao) == BLOCK
2591 && BLOCK_ABSTRACT_ORIGIN (ao)
2592 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2593 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2594 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2598 fndecl = current_function_decl;
2600 pp_printf (context->printer, function_category (fndecl),
2601 cxx_printable_name_translate (fndecl, 2));
2603 while (abstract_origin)
2606 tree block = abstract_origin;
2608 locus = &BLOCK_SOURCE_LOCATION (block);
2610 block = BLOCK_SUPERCONTEXT (block);
2611 while (block && TREE_CODE (block) == BLOCK
2612 && BLOCK_ABSTRACT_ORIGIN (block))
2614 ao = BLOCK_ABSTRACT_ORIGIN (block);
2616 while (TREE_CODE (ao) == BLOCK
2617 && BLOCK_ABSTRACT_ORIGIN (ao)
2618 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2619 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2621 if (TREE_CODE (ao) == FUNCTION_DECL)
2626 else if (TREE_CODE (ao) != BLOCK)
2629 block = BLOCK_SUPERCONTEXT (block);
2632 abstract_origin = block;
2635 while (block && TREE_CODE (block) == BLOCK)
2636 block = BLOCK_SUPERCONTEXT (block);
2638 if (block && TREE_CODE (block) == FUNCTION_DECL)
2640 abstract_origin = NULL;
2644 expanded_location s = expand_location (*locus);
2645 pp_base_character (context->printer, ',');
2646 pp_base_newline (context->printer);
2649 if (flag_show_column && s.column != 0)
2650 pp_printf (context->printer,
2651 _(" inlined from %qs at %s:%d:%d"),
2652 cxx_printable_name_translate (fndecl, 2),
2653 s.file, s.line, s.column);
2655 pp_printf (context->printer,
2656 _(" inlined from %qs at %s:%d"),
2657 cxx_printable_name_translate (fndecl, 2),
2662 pp_printf (context->printer, _(" inlined from %qs"),
2663 cxx_printable_name_translate (fndecl, 2));
2666 pp_base_character (context->printer, ':');
2668 pp_base_newline (context->printer);
2670 diagnostic_set_last_function (context, diagnostic);
2671 pp_base_destroy_prefix (context->printer);
2672 context->printer->prefix = old_prefix;
2676 /* Returns a description of FUNCTION using standard terminology. The
2677 result is a format string of the form "In CATEGORY %qs". */
2679 function_category (tree fn)
2681 /* We can get called from the middle-end for diagnostics of function
2682 clones. Make sure we have language specific information before
2683 dereferencing it. */
2684 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
2685 && DECL_FUNCTION_MEMBER_P (fn))
2687 if (DECL_STATIC_FUNCTION_P (fn))
2688 return _("In static member function %qs");
2689 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2690 return _("In copy constructor %qs");
2691 else if (DECL_CONSTRUCTOR_P (fn))
2692 return _("In constructor %qs");
2693 else if (DECL_DESTRUCTOR_P (fn))
2694 return _("In destructor %qs");
2695 else if (LAMBDA_FUNCTION_P (fn))
2696 return _("In lambda function");
2698 return _("In member function %qs");
2701 return _("In function %qs");
2704 /* Report the full context of a current template instantiation,
2707 print_instantiation_full_context (diagnostic_context *context)
2709 struct tinst_level *p = current_instantiation ();
2710 location_t location = input_location;
2714 if (current_function_decl != p->decl
2715 && current_function_decl != NULL_TREE)
2716 /* We can get here during the processing of some synthesized
2717 method. Then, P->DECL will be the function that's causing
2722 if (current_function_decl == p->decl)
2723 /* Avoid redundancy with the "In function" line. */;
2725 pp_verbatim (context->printer,
2726 _("%s: In instantiation of %qs:\n"),
2727 LOCATION_FILE (location),
2728 decl_as_string_translate (p->decl,
2729 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2731 location = p->locus;
2736 print_instantiation_partial_context (context, p, location);
2739 /* Helper function of print_instantiation_partial_context() that
2740 prints a single line of instantiation context. */
2743 print_instantiation_partial_context_line (diagnostic_context *context,
2744 const struct tinst_level *t,
2745 location_t loc, bool recursive_p)
2747 expanded_location xloc;
2748 xloc = expand_location (loc);
2753 str = decl_as_string_translate (t->decl,
2754 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE);
2755 if (flag_show_column)
2756 pp_verbatim (context->printer,
2758 ? _("%s:%d:%d: recursively instantiated from %qs\n")
2759 : _("%s:%d:%d: instantiated from %qs\n"),
2760 xloc.file, xloc.line, xloc.column, str);
2762 pp_verbatim (context->printer,
2764 ? _("%s:%d: recursively instantiated from %qs\n")
2765 : _("%s:%d: recursively instantiated from %qs\n"),
2766 xloc.file, xloc.line, str);
2770 if (flag_show_column)
2771 pp_verbatim (context->printer,
2773 ? _("%s:%d:%d: recursively instantiated from here")
2774 : _("%s:%d:%d: instantiated from here"),
2775 xloc.file, xloc.line, xloc.column);
2777 pp_verbatim (context->printer,
2779 ? _("%s:%d: recursively instantiated from here")
2780 : _("%s:%d: instantiated from here"),
2781 xloc.file, xloc.line);
2785 /* Same as print_instantiation_full_context but less verbose. */
2788 print_instantiation_partial_context (diagnostic_context *context,
2789 struct tinst_level *t0, location_t loc)
2791 struct tinst_level *t;
2794 location_t prev_loc = loc;
2796 for (t = t0; t != NULL; t = t->next)
2797 if (prev_loc != t->locus)
2799 prev_loc = t->locus;
2807 int skip = n_total - 10;
2808 for (n = 0; n < 5; n++)
2810 gcc_assert (t != NULL);
2811 if (loc != t->locus)
2812 print_instantiation_partial_context_line (context, t, loc,
2813 /*recursive_p=*/false);
2817 if (t != NULL && skip > 1)
2819 expanded_location xloc;
2820 xloc = expand_location (loc);
2821 if (flag_show_column)
2822 pp_verbatim (context->printer,
2823 _("%s:%d:%d: [ skipping %d instantiation contexts ]\n"),
2824 xloc.file, xloc.line, xloc.column, skip);
2826 pp_verbatim (context->printer,
2827 _("%s:%d: [ skipping %d instantiation contexts ]\n"),
2828 xloc.file, xloc.line, skip);
2833 } while (t != NULL && --skip > 0);
2839 while (t->next != NULL && t->locus == t->next->locus)
2844 print_instantiation_partial_context_line (context, t, loc,
2849 print_instantiation_partial_context_line (context, NULL, loc,
2850 /*recursive_p=*/false);
2851 pp_base_newline (context->printer);
2854 /* Called from cp_thing to print the template context for an error. */
2856 maybe_print_instantiation_context (diagnostic_context *context)
2858 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2861 record_last_problematic_instantiation ();
2862 print_instantiation_full_context (context);
2865 /* Report the bare minimum context of a template instantiation. */
2867 print_instantiation_context (void)
2869 print_instantiation_partial_context
2870 (global_dc, current_instantiation (), input_location);
2871 diagnostic_flush_buffer (global_dc);
2874 /* Called from output_format -- during diagnostic message processing --
2875 to handle C++ specific format specifier with the following meanings:
2876 %A function argument-list.
2880 %F function declaration.
2881 %L language as used in extern "lang".
2883 %P function parameter whose position is indicated by an integer.
2884 %Q assignment operator.
2888 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2889 int precision, bool wide, bool set_locus, bool verbose)
2893 #define next_tree (t = va_arg (*text->args_ptr, tree))
2894 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
2895 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
2896 #define next_int va_arg (*text->args_ptr, int)
2898 if (precision != 0 || wide)
2901 if (text->locus == NULL)
2906 case 'A': result = args_to_string (next_tree, verbose); break;
2907 case 'C': result = code_to_string (next_tcode); break;
2910 tree temp = next_tree;
2912 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2914 temp = DECL_DEBUG_EXPR (temp);
2917 result = expr_to_string (temp);
2921 result = decl_to_string (temp, verbose);
2924 case 'E': result = expr_to_string (next_tree); break;
2925 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2926 case 'L': result = language_to_string (next_lang); break;
2927 case 'O': result = op_to_string (next_tcode); break;
2928 case 'P': result = parm_to_string (next_int); break;
2929 case 'Q': result = assop_to_string (next_tcode); break;
2930 case 'T': result = type_to_string (next_tree, verbose); break;
2931 case 'V': result = cv_to_string (next_tree, verbose); break;
2937 pp_base_string (pp, result);
2938 if (set_locus && t != NULL)
2939 *text->locus = location_of (t);
2947 /* Warn about the use of C++0x features when appropriate. */
2949 maybe_warn_cpp0x (cpp0x_warn_str str)
2951 if ((cxx_dialect == cxx98) && !in_system_header)
2952 /* We really want to suppress this warning in system headers,
2953 because libstdc++ uses variadic templates even when we aren't
2957 case CPP0X_INITIALIZER_LISTS:
2958 pedwarn (input_location, 0,
2959 "extended initializer lists "
2960 "only available with -std=c++0x or -std=gnu++0x");
2962 case CPP0X_EXPLICIT_CONVERSION:
2963 pedwarn (input_location, 0,
2964 "explicit conversion operators "
2965 "only available with -std=c++0x or -std=gnu++0x");
2967 case CPP0X_VARIADIC_TEMPLATES:
2968 pedwarn (input_location, 0,
2969 "variadic templates "
2970 "only available with -std=c++0x or -std=gnu++0x");
2972 case CPP0X_LAMBDA_EXPR:
2973 pedwarn (input_location, 0,
2974 "lambda expressions "
2975 "only available with -std=c++0x or -std=gnu++0x");
2978 pedwarn (input_location, 0,
2979 "C++0x auto only available with -std=c++0x or -std=gnu++0x");
2981 case CPP0X_SCOPED_ENUMS:
2982 pedwarn (input_location, 0,
2983 "scoped enums only available with -std=c++0x or -std=gnu++0x");
2985 case CPP0X_DEFAULTED_DELETED:
2986 pedwarn (input_location, 0,
2987 "defaulted and deleted functions "
2988 "only available with -std=c++0x or -std=gnu++0x");
2995 /* Warn about the use of variadic templates when appropriate. */
2997 maybe_warn_variadic_templates (void)
2999 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3003 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3004 option OPT with text GMSGID. Use this function to report
3005 diagnostics for constructs that are invalid C++98, but valid
3008 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3010 diagnostic_info diagnostic;
3013 va_start (ap, gmsgid);
3014 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
3015 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3016 diagnostic.option_index = opt;
3018 return report_diagnostic (&diagnostic);