1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "diagnostic.h"
31 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
34 #include "pointer-set.h"
36 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
38 /* The global buffer where we dump everything. It is there only for
39 transitional purpose. It is expected, in the near future, to be
40 completely removed. */
41 static cxx_pretty_printer scratch_pretty_printer;
42 #define cxx_pp (&scratch_pretty_printer)
44 /* Translate if being used for diagnostics, but not for dump files or
46 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
48 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
50 static const char *args_to_string (tree, int);
51 static const char *assop_to_string (enum tree_code);
52 static const char *code_to_string (enum tree_code);
53 static const char *cv_to_string (tree, int);
54 static const char *decl_to_string (tree, int);
55 static const char *expr_to_string (tree);
56 static const char *fndecl_to_string (tree, int);
57 static const char *op_to_string (enum tree_code);
58 static const char *parm_to_string (int);
59 static const char *type_to_string (tree, int);
61 static void dump_type (tree, int);
62 static void dump_typename (tree, int);
63 static void dump_simple_decl (tree, tree, int);
64 static void dump_decl (tree, int);
65 static void dump_template_decl (tree, int);
66 static void dump_function_decl (tree, int);
67 static void dump_expr (tree, int);
68 static void dump_unary_op (const char *, tree, int);
69 static void dump_binary_op (const char *, tree, int);
70 static void dump_aggr_type (tree, int);
71 static void dump_type_prefix (tree, int);
72 static void dump_type_suffix (tree, int);
73 static void dump_function_name (tree, int);
74 static void dump_call_expr_args (tree, int, bool);
75 static void dump_aggr_init_expr_args (tree, int, bool);
76 static void dump_expr_list (tree, int);
77 static void dump_global_iord (tree);
78 static void dump_parameters (tree, int);
79 static void dump_exception_spec (tree, int);
80 static void dump_template_argument (tree, int);
81 static void dump_template_argument_list (tree, tree, int);
82 static void dump_template_parameter (tree, int);
83 static void dump_template_bindings (tree, tree, VEC(tree,gc) *);
84 static void dump_scope (tree, int);
85 static void dump_template_parms (tree, int, int);
87 static int count_non_default_template_args (tree, tree, int);
89 static const char *function_category (tree);
90 static void maybe_print_instantiation_context (diagnostic_context *);
91 static void print_instantiation_full_context (diagnostic_context *);
92 static void print_instantiation_partial_context (diagnostic_context *,
95 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
96 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
97 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
99 static bool cp_printer (pretty_printer *, text_info *, const char *,
100 int, bool, bool, bool);
101 static location_t location_of (tree);
106 diagnostic_starter (global_dc) = cp_diagnostic_starter;
107 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
108 diagnostic_format_decoder (global_dc) = cp_printer;
110 pp_construct (pp_base (cxx_pp), NULL, 0);
111 pp_cxx_pretty_printer_init (cxx_pp);
114 /* Dump a scope, if deemed necessary. */
117 dump_scope (tree scope, int flags)
119 int f = ~TFF_RETURN_TYPE & (flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF));
121 if (scope == NULL_TREE)
124 if (TREE_CODE (scope) == NAMESPACE_DECL)
126 if (scope != global_namespace)
128 dump_decl (scope, f);
129 pp_cxx_colon_colon (cxx_pp);
132 else if (AGGREGATE_TYPE_P (scope))
134 dump_type (scope, f);
135 pp_cxx_colon_colon (cxx_pp);
137 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
139 dump_function_decl (scope, f);
140 pp_cxx_colon_colon (cxx_pp);
144 /* Dump the template ARGument under control of FLAGS. */
147 dump_template_argument (tree arg, int flags)
149 if (ARGUMENT_PACK_P (arg))
150 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg), NULL_TREE, flags);
151 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
152 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
155 if (TREE_CODE (arg) == TREE_LIST)
156 arg = TREE_VALUE (arg);
158 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
162 /* Count the number of template arguments ARGS whose value does not
163 match the (optional) default template parameter in PARAMS */
166 count_non_default_template_args (tree args, tree params, int flags)
168 tree inner_args = INNERMOST_TEMPLATE_ARGS (args);
169 int n = TREE_VEC_LENGTH (inner_args);
172 if (params == NULL_TREE
173 /* We use this flag when generating debug information. We don't
174 want to expand templates at this point, for this may generate
175 new decls, which gets decl counts out of sync, which may in
176 turn cause codegen differences between compilations with and
178 || (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
179 || !flag_pretty_templates)
182 for (last = n - 1; last >= 0; --last)
184 tree param = TREE_VEC_ELT (params, last);
185 tree def = TREE_PURPOSE (param);
189 if (uses_template_parms (def))
191 ++processing_template_decl;
192 /* This speculative substitution must not cause any classes to be
193 instantiated that otherwise wouldn't be. */
194 def = tsubst_copy_and_build (def, args, tf_no_class_instantiations,
195 NULL_TREE, false, true);
196 --processing_template_decl;
198 if (!cp_tree_equal (TREE_VEC_ELT (inner_args, last), def))
205 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
209 dump_template_argument_list (tree args, tree parms, int flags)
211 int n = count_non_default_template_args (args, parms, flags);
215 for (i = 0; i < n; ++i)
217 tree arg = TREE_VEC_ELT (args, i);
219 /* Only print a comma if we know there is an argument coming. In
220 the case of an empty template argument pack, no actual
221 argument will be printed. */
223 && (!ARGUMENT_PACK_P (arg)
224 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
225 pp_separate_with_comma (cxx_pp);
227 dump_template_argument (arg, flags);
232 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
235 dump_template_parameter (tree parm, int flags)
240 if (parm == error_mark_node)
243 p = TREE_VALUE (parm);
244 a = TREE_PURPOSE (parm);
246 if (TREE_CODE (p) == TYPE_DECL)
248 if (flags & TFF_DECL_SPECIFIERS)
250 pp_cxx_ws_string (cxx_pp, "class");
251 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
252 pp_cxx_ws_string (cxx_pp, "...");
254 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
256 else if (DECL_NAME (p))
257 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
259 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
262 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
264 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
266 pp_cxx_whitespace (cxx_pp);
268 pp_cxx_whitespace (cxx_pp);
269 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
270 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
272 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
276 /* Dump, under control of FLAGS, a template-parameter-list binding.
277 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
281 dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames)
289 tree p = TREE_VALUE (parms);
290 int lvl = TMPL_PARMS_DEPTH (parms);
293 tree lvl_args = NULL_TREE;
295 /* Don't crash if we had an invalid argument list. */
296 if (TMPL_ARGS_DEPTH (args) >= lvl)
297 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
299 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
301 tree arg = NULL_TREE;
303 /* Don't crash if we had an invalid argument list. */
304 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
305 arg = TREE_VEC_ELT (lvl_args, arg_idx);
308 pp_separate_with_comma (cxx_pp);
309 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
310 pp_cxx_whitespace (cxx_pp);
312 pp_cxx_whitespace (cxx_pp);
314 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
316 pp_string (cxx_pp, M_("<missing>"));
322 parms = TREE_CHAIN (parms);
325 for (i = 0; VEC_iterate (tree, typenames, i, t); ++i)
328 pp_separate_with_comma (cxx_pp);
329 dump_type (t, TFF_PLAIN_IDENTIFIER);
330 pp_cxx_whitespace (cxx_pp);
332 pp_cxx_whitespace (cxx_pp);
333 t = tsubst (t, args, tf_none, NULL_TREE);
334 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
335 pp_simple_type_specifier doesn't know about it. */
336 t = strip_typedefs (t);
337 dump_type (t, TFF_PLAIN_IDENTIFIER);
341 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
345 dump_type (tree t, int flags)
350 if (TYPE_PTRMEMFUNC_P (t))
353 switch (TREE_CODE (t))
356 if (t == init_list_type_node)
357 pp_string (cxx_pp, M_("<brace-enclosed initializer list>"));
359 pp_string (cxx_pp, M_("<unresolved overloaded function type>"));
363 /* A list of function parms. */
364 dump_parameters (t, flags);
367 case IDENTIFIER_NODE:
368 pp_cxx_tree_identifier (cxx_pp, t);
372 dump_type (BINFO_TYPE (t), flags);
378 dump_aggr_type (t, flags);
382 if (flags & TFF_CHASE_TYPEDEF)
384 dump_type (DECL_ORIGINAL_TYPE (t)
385 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
388 /* Else fall through. */
392 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
401 case FIXED_POINT_TYPE:
402 pp_type_specifier_seq (cxx_pp, t);
405 case TEMPLATE_TEMPLATE_PARM:
406 /* For parameters inside template signature. */
407 if (TYPE_IDENTIFIER (t))
408 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
410 pp_cxx_canonical_template_parameter (cxx_pp, t);
413 case BOUND_TEMPLATE_TEMPLATE_PARM:
415 tree args = TYPE_TI_ARGS (t);
416 pp_cxx_cv_qualifier_seq (cxx_pp, t);
417 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
418 pp_cxx_begin_template_argument_list (cxx_pp);
419 dump_template_argument_list (args, NULL_TREE, flags);
420 pp_cxx_end_template_argument_list (cxx_pp);
424 case TEMPLATE_TYPE_PARM:
425 pp_cxx_cv_qualifier_seq (cxx_pp, t);
426 if (TYPE_IDENTIFIER (t))
427 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
429 pp_cxx_canonical_template_parameter
430 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
433 /* This is not always necessary for pointers and such, but doing this
434 reduces code size. */
443 dump_type_prefix (t, flags);
444 dump_type_suffix (t, flags);
448 if (! (flags & TFF_CHASE_TYPEDEF)
449 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
451 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
454 pp_cxx_cv_qualifier_seq (cxx_pp, t);
455 pp_cxx_ws_string (cxx_pp,
456 TYPENAME_IS_ENUM_P (t) ? "enum"
457 : TYPENAME_IS_CLASS_P (t) ? "class"
459 dump_typename (t, flags);
462 case UNBOUND_CLASS_TEMPLATE:
463 dump_type (TYPE_CONTEXT (t), flags);
464 pp_cxx_colon_colon (cxx_pp);
465 pp_cxx_ws_string (cxx_pp, "template");
466 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
470 pp_cxx_ws_string (cxx_pp, "__typeof__");
471 pp_cxx_whitespace (cxx_pp);
472 pp_cxx_left_paren (cxx_pp);
473 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
474 pp_cxx_right_paren (cxx_pp);
477 case TYPE_PACK_EXPANSION:
478 dump_type (PACK_EXPANSION_PATTERN (t), flags);
479 pp_cxx_ws_string (cxx_pp, "...");
482 case TYPE_ARGUMENT_PACK:
483 dump_template_argument (t, flags);
487 pp_cxx_ws_string (cxx_pp, "decltype");
488 pp_cxx_whitespace (cxx_pp);
489 pp_cxx_left_paren (cxx_pp);
490 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
491 pp_cxx_right_paren (cxx_pp);
495 pp_unsupported_tree (cxx_pp, t);
496 /* Fall through to error. */
499 pp_string (cxx_pp, M_("<type error>"));
504 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
508 dump_typename (tree t, int flags)
510 tree ctx = TYPE_CONTEXT (t);
512 if (TREE_CODE (ctx) == TYPENAME_TYPE)
513 dump_typename (ctx, flags);
515 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
516 pp_cxx_colon_colon (cxx_pp);
517 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
520 /* Return the name of the supplied aggregate, or enumeral type. */
523 class_key_or_enum_as_string (tree t)
525 if (TREE_CODE (t) == ENUMERAL_TYPE)
527 if (SCOPED_ENUM_P (t))
532 else if (TREE_CODE (t) == UNION_TYPE)
534 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
540 /* Print out a class declaration T under the control of FLAGS,
541 in the form `class foo'. */
544 dump_aggr_type (tree t, int flags)
547 const char *variety = class_key_or_enum_as_string (t);
551 pp_cxx_cv_qualifier_seq (cxx_pp, t);
553 if (flags & TFF_CLASS_KEY_OR_ENUM)
554 pp_cxx_ws_string (cxx_pp, variety);
556 name = TYPE_NAME (t);
560 typdef = !DECL_ARTIFICIAL (name);
563 && ((flags & TFF_CHASE_TYPEDEF)
564 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
565 && DECL_TEMPLATE_INFO (name))))
567 t = TYPE_MAIN_VARIANT (t);
568 name = TYPE_NAME (t);
572 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
573 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
574 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
575 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
577 if (! (flags & TFF_UNQUALIFIED_NAME))
578 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
579 flags &= ~TFF_UNQUALIFIED_NAME;
582 /* Because the template names are mangled, we have to locate
583 the most general template, and use that name. */
584 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
586 while (DECL_TEMPLATE_INFO (tpl))
587 tpl = DECL_TI_TEMPLATE (tpl);
590 name = DECL_NAME (name);
593 if (name == 0 || ANON_AGGRNAME_P (name))
595 if (flags & TFF_CLASS_KEY_OR_ENUM)
596 pp_string (cxx_pp, M_("<anonymous>"));
598 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety);
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 pp_cxx_ws_string (cxx_pp, "typedef");
895 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
896 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
901 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
903 pp_string (cxx_pp, M_("vtable for "));
904 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
905 dump_type (DECL_CONTEXT (t), flags);
908 /* Else fall through. */
911 dump_simple_decl (t, TREE_TYPE (t), flags);
915 pp_string (cxx_pp, M_("<return value> "));
916 dump_simple_decl (t, TREE_TYPE (t), flags);
920 if (flags & TFF_DECL_SPECIFIERS)
921 pp_cxx_declaration (cxx_pp, t);
924 if (! (flags & TFF_UNQUALIFIED_NAME))
925 dump_scope (CP_DECL_CONTEXT (t), flags);
926 flags &= ~TFF_UNQUALIFIED_NAME;
927 if (DECL_NAME (t) == NULL_TREE)
928 pp_string (cxx_pp, M_("<unnamed>"));
930 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
935 pp_expression (cxx_pp, t);
939 dump_decl (TREE_OPERAND (t, 0), flags);
940 pp_cxx_left_bracket (cxx_pp);
941 dump_decl (TREE_OPERAND (t, 1), flags);
942 pp_cxx_right_bracket (cxx_pp);
945 /* So that we can do dump_decl on an aggr type. */
949 dump_type (t, flags);
953 /* This is a pseudo destructor call which has not been folded into
954 a PSEUDO_DTOR_EXPR yet. */
955 pp_cxx_complement (cxx_pp);
956 dump_type (TREE_OPERAND (t, 0), flags);
963 /* These special cases are duplicated here so that other functions
964 can feed identifiers to error and get them demangled properly. */
965 case IDENTIFIER_NODE:
966 if (IDENTIFIER_TYPENAME_P (t))
968 pp_cxx_ws_string (cxx_pp, "operator");
969 /* Not exactly IDENTIFIER_TYPE_VALUE. */
970 dump_type (TREE_TYPE (t), flags);
974 pp_cxx_tree_identifier (cxx_pp, t);
981 if (DECL_CLASS_SCOPE_P (t))
983 dump_type (DECL_CONTEXT (t), flags);
984 pp_cxx_colon_colon (cxx_pp);
986 else if (DECL_CONTEXT (t))
988 dump_decl (DECL_CONTEXT (t), flags);
989 pp_cxx_colon_colon (cxx_pp);
991 dump_decl (DECL_NAME (t), flags);
995 /* If there's only one function, just treat it like an ordinary
1001 if (! DECL_LANG_SPECIFIC (t))
1002 pp_string (cxx_pp, M_("<built-in>"));
1003 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1004 dump_global_iord (t);
1006 dump_function_decl (t, flags);
1010 dump_template_decl (t, flags);
1013 case TEMPLATE_ID_EXPR:
1015 tree name = TREE_OPERAND (t, 0);
1017 if (is_overloaded_fn (name))
1018 name = DECL_NAME (get_first_fn (name));
1019 dump_decl (name, flags);
1020 pp_cxx_begin_template_argument_list (cxx_pp);
1021 if (TREE_OPERAND (t, 1))
1022 dump_template_argument_list (TREE_OPERAND (t, 1), NULL_TREE, flags);
1023 pp_cxx_end_template_argument_list (cxx_pp);
1028 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1032 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1033 || (DECL_INITIAL (t) &&
1034 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1035 dump_simple_decl (t, TREE_TYPE (t), flags);
1036 else if (DECL_NAME (t))
1037 dump_decl (DECL_NAME (t), flags);
1038 else if (DECL_INITIAL (t))
1039 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1041 pp_string (cxx_pp, M_("<enumerator>"));
1045 pp_cxx_ws_string (cxx_pp, "using");
1046 dump_type (USING_DECL_SCOPE (t), flags);
1047 pp_cxx_colon_colon (cxx_pp);
1048 dump_decl (DECL_NAME (t), flags);
1052 pp_cxx_declaration (cxx_pp, t);
1056 dump_decl (BASELINK_FUNCTIONS (t), flags);
1059 case NON_DEPENDENT_EXPR:
1060 dump_expr (t, flags);
1063 case TEMPLATE_TYPE_PARM:
1064 if (flags & TFF_DECL_SPECIFIERS)
1065 pp_cxx_declaration (cxx_pp, t);
1067 pp_type_id (cxx_pp, t);
1070 case UNBOUND_CLASS_TEMPLATE:
1071 case TYPE_PACK_EXPANSION:
1073 dump_type (t, flags);
1077 pp_unsupported_tree (cxx_pp, t);
1078 /* Fall through to error. */
1081 pp_string (cxx_pp, M_("<declaration error>"));
1086 /* Dump a template declaration T under control of FLAGS. This means the
1087 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1090 dump_template_decl (tree t, int flags)
1092 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1096 if (flags & TFF_TEMPLATE_HEADER)
1098 for (parms = orig_parms = nreverse (orig_parms);
1100 parms = TREE_CHAIN (parms))
1102 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1103 int len = TREE_VEC_LENGTH (inner_parms);
1105 pp_cxx_ws_string (cxx_pp, "template");
1106 pp_cxx_begin_template_argument_list (cxx_pp);
1108 /* If we've shown the template prefix, we'd better show the
1109 parameters' and decl's type too. */
1110 flags |= TFF_DECL_SPECIFIERS;
1112 for (i = 0; i < len; i++)
1115 pp_separate_with_comma (cxx_pp);
1116 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1118 pp_cxx_end_template_argument_list (cxx_pp);
1119 pp_cxx_whitespace (cxx_pp);
1121 nreverse(orig_parms);
1123 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1125 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1126 pp_cxx_ws_string (cxx_pp, "class");
1128 /* If this is a parameter pack, print the ellipsis. */
1129 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1130 pp_cxx_ws_string (cxx_pp, "...");
1134 if (DECL_TEMPLATE_RESULT (t)
1135 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1136 dump_type (TREE_TYPE (t),
1137 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1138 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1139 else if (DECL_TEMPLATE_RESULT (t)
1140 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1141 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1144 gcc_assert (TREE_TYPE (t));
1145 switch (NEXT_CODE (t))
1149 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1152 /* This case can occur with some invalid code. */
1153 dump_type (TREE_TYPE (t),
1154 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1155 | (flags & TFF_DECL_SPECIFIERS
1156 ? TFF_CLASS_KEY_OR_ENUM : 0));
1161 /* find_typenames looks through the type of the function template T
1162 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1165 struct find_typenames_t
1167 struct pointer_set_t *p_set;
1168 VEC (tree,gc) *typenames;
1172 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1174 struct find_typenames_t *d = (struct find_typenames_t *)data;
1175 tree mv = NULL_TREE;
1177 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1178 /* Add the type of the typedef without any additional cv-quals. */
1179 mv = TREE_TYPE (TYPE_NAME (*tp));
1180 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1181 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1182 /* Add the typename without any cv-qualifiers. */
1183 mv = TYPE_MAIN_VARIANT (*tp);
1185 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1186 VEC_safe_push (tree, gc, d->typenames, mv);
1188 /* Search into class template arguments, which cp_walk_subtrees
1190 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1191 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1197 static VEC(tree,gc) *
1198 find_typenames (tree t)
1200 struct find_typenames_t ft;
1201 ft.p_set = pointer_set_create ();
1202 ft.typenames = NULL;
1203 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1204 find_typenames_r, &ft, ft.p_set);
1205 pointer_set_destroy (ft.p_set);
1206 return ft.typenames;
1209 /* Pretty print a function decl. There are several ways we want to print a
1210 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1211 As error can only apply the '#' flag once to give 0 and 1 for V, there
1212 is %D which doesn't print the throw specs, and %F which does. */
1215 dump_function_decl (tree t, int flags)
1219 tree cname = NULL_TREE;
1220 tree template_args = NULL_TREE;
1221 tree template_parms = NULL_TREE;
1222 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1223 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1225 VEC(tree,gc) *typenames = NULL;
1227 flags &= ~TFF_UNQUALIFIED_NAME;
1228 if (TREE_CODE (t) == TEMPLATE_DECL)
1229 t = DECL_TEMPLATE_RESULT (t);
1231 /* Save the exceptions, in case t is a specialization and we are
1232 emitting an error about incompatible specifications. */
1233 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1235 /* Pretty print template instantiations only. */
1236 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1237 && flag_pretty_templates)
1241 template_args = DECL_TI_ARGS (t);
1242 tmpl = most_general_template (t);
1243 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1245 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1247 typenames = find_typenames (t);
1251 fntype = TREE_TYPE (t);
1252 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1254 if (DECL_CLASS_SCOPE_P (t))
1255 cname = DECL_CONTEXT (t);
1256 /* This is for partially instantiated template methods. */
1257 else if (TREE_CODE (fntype) == METHOD_TYPE)
1258 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1260 if (!(flags & TFF_DECL_SPECIFIERS))
1262 else if (DECL_STATIC_FUNCTION_P (t))
1263 pp_cxx_ws_string (cxx_pp, "static");
1264 else if (DECL_VIRTUAL_P (t))
1265 pp_cxx_ws_string (cxx_pp, "virtual");
1267 /* Print the return type? */
1269 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1270 && !DECL_DESTRUCTOR_P (t);
1272 dump_type_prefix (TREE_TYPE (fntype), flags);
1274 /* Print the function name. */
1275 if (!do_outer_scope)
1279 dump_type (cname, flags);
1280 pp_cxx_colon_colon (cxx_pp);
1283 dump_scope (CP_DECL_CONTEXT (t), flags);
1285 dump_function_name (t, flags);
1287 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1289 dump_parameters (parmtypes, flags);
1291 if (TREE_CODE (fntype) == METHOD_TYPE)
1293 pp_base (cxx_pp)->padding = pp_before;
1294 pp_cxx_cv_qualifier_seq
1295 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1298 if (flags & TFF_EXCEPTION_SPECIFICATION)
1300 pp_base (cxx_pp)->padding = pp_before;
1301 dump_exception_spec (exceptions, flags);
1305 dump_type_suffix (TREE_TYPE (fntype), flags);
1308 /* If T is a template instantiation, dump the parameter binding. */
1309 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1311 pp_cxx_whitespace (cxx_pp);
1312 pp_cxx_left_bracket (cxx_pp);
1313 pp_cxx_ws_string (cxx_pp, M_("with"));
1314 pp_cxx_whitespace (cxx_pp);
1315 dump_template_bindings (template_parms, template_args, typenames);
1316 pp_cxx_right_bracket (cxx_pp);
1320 /* Print a parameter list. If this is for a member function, the
1321 member object ptr (and any other hidden args) should have
1322 already been removed. */
1325 dump_parameters (tree parmtypes, int flags)
1328 pp_cxx_left_paren (cxx_pp);
1330 for (first = 1; parmtypes != void_list_node;
1331 parmtypes = TREE_CHAIN (parmtypes))
1334 pp_separate_with_comma (cxx_pp);
1338 pp_cxx_ws_string (cxx_pp, "...");
1342 dump_type (TREE_VALUE (parmtypes), flags);
1344 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1346 pp_cxx_whitespace (cxx_pp);
1348 pp_cxx_whitespace (cxx_pp);
1349 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1353 pp_cxx_right_paren (cxx_pp);
1356 /* Print an exception specification. T is the exception specification. */
1359 dump_exception_spec (tree t, int flags)
1363 pp_cxx_ws_string (cxx_pp, "throw");
1364 pp_cxx_whitespace (cxx_pp);
1365 pp_cxx_left_paren (cxx_pp);
1366 if (TREE_VALUE (t) != NULL_TREE)
1369 dump_type (TREE_VALUE (t), flags);
1373 pp_separate_with_comma (cxx_pp);
1375 pp_cxx_right_paren (cxx_pp);
1379 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1380 and destructors properly. */
1383 dump_function_name (tree t, int flags)
1385 tree name = DECL_NAME (t);
1387 /* We can get here with a decl that was synthesized by language-
1388 independent machinery (e.g. coverage.c) in which case it won't
1389 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1390 will crash. In this case it is safe just to print out the
1392 if (!DECL_LANG_SPECIFIC (t))
1394 pp_cxx_tree_identifier (cxx_pp, name);
1398 if (TREE_CODE (t) == TEMPLATE_DECL)
1399 t = DECL_TEMPLATE_RESULT (t);
1401 /* Don't let the user see __comp_ctor et al. */
1402 if (DECL_CONSTRUCTOR_P (t)
1403 || DECL_DESTRUCTOR_P (t))
1404 name = constructor_name (DECL_CONTEXT (t));
1406 if (DECL_DESTRUCTOR_P (t))
1408 pp_cxx_complement (cxx_pp);
1409 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1411 else if (DECL_CONV_FN_P (t))
1413 /* This cannot use the hack that the operator's return
1414 type is stashed off of its name because it may be
1415 used for error reporting. In the case of conflicting
1416 declarations, both will have the same name, yet
1417 the types will be different, hence the TREE_TYPE field
1418 of the first name will be clobbered by the second. */
1419 pp_cxx_ws_string (cxx_pp, "operator");
1420 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1422 else if (name && IDENTIFIER_OPNAME_P (name))
1423 pp_cxx_tree_identifier (cxx_pp, name);
1425 dump_decl (name, flags);
1427 if (DECL_TEMPLATE_INFO (t)
1428 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1429 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1430 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1431 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1434 /* Dump the template parameters from the template info INFO under control of
1435 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1436 specialization (partial or complete). For partial specializations we show
1437 the specialized parameter values. For a primary template we show no
1441 dump_template_parms (tree info, int primary, int flags)
1443 tree args = info ? TI_ARGS (info) : NULL_TREE;
1445 if (primary && flags & TFF_TEMPLATE_NAME)
1447 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1448 pp_cxx_begin_template_argument_list (cxx_pp);
1450 /* Be careful only to print things when we have them, so as not
1451 to crash producing error messages. */
1452 if (args && !primary)
1455 /* We don't know the parms for a friend template specialization. */
1456 tree params = (TREE_CODE (TI_TEMPLATE (info)) == TEMPLATE_DECL
1457 ? DECL_INNERMOST_TEMPLATE_PARMS (TI_TEMPLATE (info))
1460 len = count_non_default_template_args (args, params, flags);
1462 args = INNERMOST_TEMPLATE_ARGS (args);
1463 for (ix = 0; ix != len; ix++)
1465 tree arg = TREE_VEC_ELT (args, ix);
1467 /* Only print a comma if we know there is an argument coming. In
1468 the case of an empty template argument pack, no actual
1469 argument will be printed. */
1471 && (!ARGUMENT_PACK_P (arg)
1472 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1473 pp_separate_with_comma (cxx_pp);
1476 pp_string (cxx_pp, M_("<template parameter error>"));
1478 dump_template_argument (arg, flags);
1483 tree tpl = TI_TEMPLATE (info);
1484 tree parms = DECL_TEMPLATE_PARMS (tpl);
1487 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1488 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1490 for (ix = 0; ix != len; ix++)
1494 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1496 pp_string (cxx_pp, M_("<template parameter error>"));
1500 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1503 pp_separate_with_comma (cxx_pp);
1505 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1508 pp_cxx_end_template_argument_list (cxx_pp);
1511 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1512 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1515 dump_call_expr_args (tree t, int flags, bool skipfirst)
1518 call_expr_arg_iterator iter;
1520 pp_cxx_left_paren (cxx_pp);
1521 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1527 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1528 if (more_call_expr_args_p (&iter))
1529 pp_separate_with_comma (cxx_pp);
1532 pp_cxx_right_paren (cxx_pp);
1535 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1536 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1540 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1543 aggr_init_expr_arg_iterator iter;
1545 pp_cxx_left_paren (cxx_pp);
1546 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1552 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1553 if (more_aggr_init_expr_args_p (&iter))
1554 pp_separate_with_comma (cxx_pp);
1557 pp_cxx_right_paren (cxx_pp);
1560 /* Print out a list of initializers (subr of dump_expr). */
1563 dump_expr_list (tree l, int flags)
1567 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1570 pp_separate_with_comma (cxx_pp);
1574 /* Print out a vector of initializers (subr of dump_expr). */
1577 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1579 unsigned HOST_WIDE_INT idx;
1582 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1584 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1585 if (idx != VEC_length (constructor_elt, v) - 1)
1586 pp_separate_with_comma (cxx_pp);
1591 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1592 function. Resolve it to a close relative -- in the sense of static
1593 type -- variant being overridden. That is close to what was written in
1594 the source code. Subroutine of dump_expr. */
1597 resolve_virtual_fun_from_obj_type_ref (tree ref)
1599 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1600 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1601 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1604 fun = TREE_CHAIN (fun);
1605 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1606 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1612 /* Print out an expression E under control of FLAGS. */
1615 dump_expr (tree t, int flags)
1620 if (STATEMENT_CLASS_P (t))
1622 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1626 switch (TREE_CODE (t))
1634 case NAMESPACE_DECL:
1637 case IDENTIFIER_NODE:
1638 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1645 pp_constant (cxx_pp, t);
1649 /* While waiting for caret diagnostics, avoid printing
1650 __cxa_allocate_exception, __cxa_throw, and the like. */
1651 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1655 pp_ampersand (cxx_pp);
1656 dump_type (PTRMEM_CST_CLASS (t), flags);
1657 pp_cxx_colon_colon (cxx_pp);
1658 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1662 pp_cxx_left_paren (cxx_pp);
1663 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1664 pp_separate_with_comma (cxx_pp);
1665 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1666 pp_cxx_right_paren (cxx_pp);
1670 pp_cxx_left_paren (cxx_pp);
1671 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1672 pp_string (cxx_pp, " ? ");
1673 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1674 pp_string (cxx_pp, " : ");
1675 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1676 pp_cxx_right_paren (cxx_pp);
1680 if (TREE_HAS_CONSTRUCTOR (t))
1682 pp_cxx_ws_string (cxx_pp, "new");
1683 pp_cxx_whitespace (cxx_pp);
1684 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1687 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1690 case AGGR_INIT_EXPR:
1692 tree fn = NULL_TREE;
1694 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1695 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1697 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1699 if (DECL_CONSTRUCTOR_P (fn))
1700 dump_type (DECL_CONTEXT (fn), flags);
1705 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1707 dump_aggr_init_expr_args (t, flags, true);
1712 tree fn = CALL_EXPR_FN (t);
1713 bool skipfirst = false;
1715 if (TREE_CODE (fn) == ADDR_EXPR)
1716 fn = TREE_OPERAND (fn, 0);
1718 /* Nobody is interested in seeing the guts of vcalls. */
1719 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1720 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1722 if (TREE_TYPE (fn) != NULL_TREE && NEXT_CODE (fn) == METHOD_TYPE)
1724 tree ob = CALL_EXPR_ARG (t, 0);
1725 if (TREE_CODE (ob) == ADDR_EXPR)
1727 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1728 pp_cxx_dot (cxx_pp);
1730 else if (TREE_CODE (ob) != PARM_DECL
1731 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1733 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1734 pp_cxx_arrow (cxx_pp);
1738 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1739 dump_call_expr_args (t, flags, skipfirst);
1744 /* Note that this only works for G++ target exprs. If somebody
1745 builds a general TARGET_EXPR, there's no way to represent that
1746 it initializes anything other that the parameter slot for the
1747 default argument. Note we may have cleared out the first
1748 operand in expand_expr, so don't go killing ourselves. */
1749 if (TREE_OPERAND (t, 1))
1750 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1753 case POINTER_PLUS_EXPR:
1754 dump_binary_op ("+", t, flags);
1762 case TRUNC_DIV_EXPR:
1763 case TRUNC_MOD_EXPR:
1771 case TRUTH_ANDIF_EXPR:
1772 case TRUTH_ORIF_EXPR:
1779 case EXACT_DIV_EXPR:
1780 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1784 case FLOOR_DIV_EXPR:
1785 case ROUND_DIV_EXPR:
1787 dump_binary_op ("/", t, flags);
1791 case FLOOR_MOD_EXPR:
1792 case ROUND_MOD_EXPR:
1793 dump_binary_op ("%", t, flags);
1798 tree ob = TREE_OPERAND (t, 0);
1799 if (TREE_CODE (ob) == INDIRECT_REF)
1801 ob = TREE_OPERAND (ob, 0);
1802 if (TREE_CODE (ob) != PARM_DECL
1804 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1806 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1807 pp_cxx_arrow (cxx_pp);
1812 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1813 pp_cxx_dot (cxx_pp);
1815 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1820 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1821 pp_cxx_left_bracket (cxx_pp);
1822 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1823 pp_cxx_right_bracket (cxx_pp);
1826 case UNARY_PLUS_EXPR:
1827 dump_unary_op ("+", t, flags);
1831 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1832 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1833 /* An ADDR_EXPR can have reference type. In that case, we
1834 shouldn't print the `&' doing so indicates to the user
1835 that the expression has pointer type. */
1837 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1838 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1839 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1840 dump_unary_op ("&&", t, flags);
1842 dump_unary_op ("&", t, flags);
1846 if (TREE_HAS_CONSTRUCTOR (t))
1848 t = TREE_OPERAND (t, 0);
1849 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1850 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1851 dump_call_expr_args (t, flags, true);
1855 if (TREE_OPERAND (t,0) != NULL_TREE
1856 && TREE_TYPE (TREE_OPERAND (t, 0))
1857 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1858 dump_expr (TREE_OPERAND (t, 0), flags);
1860 dump_unary_op ("*", t, flags);
1866 case TRUTH_NOT_EXPR:
1867 case PREDECREMENT_EXPR:
1868 case PREINCREMENT_EXPR:
1869 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1872 case POSTDECREMENT_EXPR:
1873 case POSTINCREMENT_EXPR:
1874 pp_cxx_left_paren (cxx_pp);
1875 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1876 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1877 pp_cxx_right_paren (cxx_pp);
1880 case NON_LVALUE_EXPR:
1881 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1882 should be another level of INDIRECT_REF so that I don't have to do
1884 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1886 tree next = TREE_TYPE (TREE_TYPE (t));
1888 while (TREE_CODE (next) == POINTER_TYPE)
1889 next = TREE_TYPE (next);
1891 if (TREE_CODE (next) == FUNCTION_TYPE)
1893 if (flags & TFF_EXPR_IN_PARENS)
1894 pp_cxx_left_paren (cxx_pp);
1895 pp_cxx_star (cxx_pp);
1896 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1897 if (flags & TFF_EXPR_IN_PARENS)
1898 pp_cxx_right_paren (cxx_pp);
1901 /* Else fall through. */
1903 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1907 case VIEW_CONVERT_EXPR:
1909 tree op = TREE_OPERAND (t, 0);
1911 if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1913 /* It is a cast, but we cannot tell whether it is a
1914 reinterpret or static cast. Use the C style notation. */
1915 if (flags & TFF_EXPR_IN_PARENS)
1916 pp_cxx_left_paren (cxx_pp);
1917 pp_cxx_left_paren (cxx_pp);
1918 dump_type (TREE_TYPE (t), flags);
1919 pp_cxx_right_paren (cxx_pp);
1920 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1921 if (flags & TFF_EXPR_IN_PARENS)
1922 pp_cxx_right_paren (cxx_pp);
1925 dump_expr (op, flags);
1930 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1932 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1934 if (integer_zerop (idx))
1936 /* A NULL pointer-to-member constant. */
1937 pp_cxx_left_paren (cxx_pp);
1938 pp_cxx_left_paren (cxx_pp);
1939 dump_type (TREE_TYPE (t), flags);
1940 pp_cxx_right_paren (cxx_pp);
1941 pp_character (cxx_pp, '0');
1942 pp_cxx_right_paren (cxx_pp);
1945 else if (host_integerp (idx, 0))
1948 unsigned HOST_WIDE_INT n;
1950 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1951 t = TYPE_METHOD_BASETYPE (t);
1952 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1954 n = tree_low_cst (idx, 0);
1956 /* Map vtable index back one, to allow for the null pointer to
1960 while (n > 0 && virtuals)
1963 virtuals = TREE_CHAIN (virtuals);
1967 dump_expr (BV_FN (virtuals),
1968 flags | TFF_EXPR_IN_PARENS);
1973 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1975 dump_type (TREE_TYPE (t), 0);
1976 pp_cxx_left_paren (cxx_pp);
1977 pp_cxx_right_paren (cxx_pp);
1981 pp_cxx_left_brace (cxx_pp);
1982 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1983 pp_cxx_right_brace (cxx_pp);
1990 tree ob = TREE_OPERAND (t, 0);
1991 if (is_dummy_object (ob))
1993 t = TREE_OPERAND (t, 1);
1994 if (TREE_CODE (t) == FUNCTION_DECL)
1996 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1997 else if (BASELINK_P (t))
1998 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1999 flags | TFF_EXPR_IN_PARENS);
2001 dump_decl (t, flags);
2005 if (TREE_CODE (ob) == INDIRECT_REF)
2007 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2008 pp_cxx_arrow (cxx_pp);
2009 pp_cxx_star (cxx_pp);
2013 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2014 pp_cxx_dot (cxx_pp);
2015 pp_cxx_star (cxx_pp);
2017 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2022 case TEMPLATE_PARM_INDEX:
2023 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2027 if (TREE_OPERAND (t, 0) == NULL_TREE
2028 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2030 dump_type (TREE_TYPE (t), flags);
2031 pp_cxx_left_paren (cxx_pp);
2032 dump_expr_list (TREE_OPERAND (t, 0), flags);
2033 pp_cxx_right_paren (cxx_pp);
2037 pp_cxx_left_paren (cxx_pp);
2038 dump_type (TREE_TYPE (t), flags);
2039 pp_cxx_right_paren (cxx_pp);
2040 pp_cxx_left_paren (cxx_pp);
2041 dump_expr_list (TREE_OPERAND (t, 0), flags);
2042 pp_cxx_right_paren (cxx_pp);
2046 case STATIC_CAST_EXPR:
2047 pp_cxx_ws_string (cxx_pp, "static_cast");
2049 case REINTERPRET_CAST_EXPR:
2050 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2052 case CONST_CAST_EXPR:
2053 pp_cxx_ws_string (cxx_pp, "const_cast");
2055 case DYNAMIC_CAST_EXPR:
2056 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2058 pp_cxx_begin_template_argument_list (cxx_pp);
2059 dump_type (TREE_TYPE (t), flags);
2060 pp_cxx_end_template_argument_list (cxx_pp);
2061 pp_cxx_left_paren (cxx_pp);
2062 dump_expr (TREE_OPERAND (t, 0), flags);
2063 pp_cxx_right_paren (cxx_pp);
2067 dump_expr (TREE_OPERAND (t, 0), flags);
2068 pp_cxx_arrow (cxx_pp);
2073 if (TREE_CODE (t) == SIZEOF_EXPR)
2074 pp_cxx_ws_string (cxx_pp, "sizeof");
2077 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2078 pp_cxx_ws_string (cxx_pp, "__alignof__");
2080 pp_cxx_whitespace (cxx_pp);
2081 pp_cxx_left_paren (cxx_pp);
2082 if (TYPE_P (TREE_OPERAND (t, 0)))
2083 dump_type (TREE_OPERAND (t, 0), flags);
2085 dump_expr (TREE_OPERAND (t, 0), flags);
2086 pp_cxx_right_paren (cxx_pp);
2091 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2092 pp_cxx_whitespace (cxx_pp);
2093 dump_expr (TREE_OPERAND (t, 0), flags);
2097 pp_string (cxx_pp, M_("<unparsed>"));
2100 case TRY_CATCH_EXPR:
2101 case WITH_CLEANUP_EXPR:
2102 case CLEANUP_POINT_EXPR:
2103 dump_expr (TREE_OPERAND (t, 0), flags);
2106 case PSEUDO_DTOR_EXPR:
2107 dump_expr (TREE_OPERAND (t, 2), flags);
2108 pp_cxx_dot (cxx_pp);
2109 dump_type (TREE_OPERAND (t, 0), flags);
2110 pp_cxx_colon_colon (cxx_pp);
2111 pp_cxx_complement (cxx_pp);
2112 dump_type (TREE_OPERAND (t, 1), flags);
2115 case TEMPLATE_ID_EXPR:
2116 dump_decl (t, flags);
2122 case STATEMENT_LIST:
2123 /* We don't yet have a way of dumping statements in a
2124 human-readable format. */
2125 pp_string (cxx_pp, "({...})");
2129 pp_string (cxx_pp, "while (1) { ");
2130 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2131 pp_cxx_right_brace (cxx_pp);
2135 pp_string (cxx_pp, "if (");
2136 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2137 pp_string (cxx_pp, ") break; ");
2141 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2144 case EMPTY_CLASS_EXPR:
2145 dump_type (TREE_TYPE (t), flags);
2146 pp_cxx_left_paren (cxx_pp);
2147 pp_cxx_right_paren (cxx_pp);
2150 case NON_DEPENDENT_EXPR:
2151 dump_expr (TREE_OPERAND (t, 0), flags);
2154 case ARGUMENT_PACK_SELECT:
2155 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2167 pp_type_specifier_seq (cxx_pp, t);
2171 /* We get here when we want to print a dependent type as an
2172 id-expression, without any disambiguator decoration. */
2173 pp_id_expression (cxx_pp, t);
2176 case TEMPLATE_TYPE_PARM:
2177 case BOUND_TEMPLATE_TEMPLATE_PARM:
2178 dump_type (t, flags);
2182 pp_cxx_trait_expression (cxx_pp, t);
2186 pp_cxx_va_arg_expression (cxx_pp, t);
2190 pp_cxx_offsetof_expression (cxx_pp, t);
2194 case EXPR_PACK_EXPANSION:
2201 case VEC_DELETE_EXPR:
2207 case UNORDERED_EXPR:
2217 case FIX_TRUNC_EXPR:
2219 pp_expression (cxx_pp, t);
2222 case TRUTH_AND_EXPR:
2224 case TRUTH_XOR_EXPR:
2225 if (flags & TFF_EXPR_IN_PARENS)
2226 pp_cxx_left_paren (cxx_pp);
2227 pp_expression (cxx_pp, t);
2228 if (flags & TFF_EXPR_IN_PARENS)
2229 pp_cxx_right_paren (cxx_pp);
2233 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2236 /* This list is incomplete, but should suffice for now.
2237 It is very important that `sorry' does not call
2238 `report_error_function'. That could cause an infinite loop. */
2240 pp_unsupported_tree (cxx_pp, t);
2241 /* fall through to ERROR_MARK... */
2243 pp_string (cxx_pp, M_("<expression error>"));
2249 dump_binary_op (const char *opstring, tree t, int flags)
2251 pp_cxx_left_paren (cxx_pp);
2252 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2253 pp_cxx_whitespace (cxx_pp);
2255 pp_cxx_ws_string (cxx_pp, opstring);
2257 pp_string (cxx_pp, M_("<unknown operator>"));
2258 pp_cxx_whitespace (cxx_pp);
2259 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2260 pp_cxx_right_paren (cxx_pp);
2264 dump_unary_op (const char *opstring, tree t, int flags)
2266 if (flags & TFF_EXPR_IN_PARENS)
2267 pp_cxx_left_paren (cxx_pp);
2268 pp_cxx_ws_string (cxx_pp, opstring);
2269 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2270 if (flags & TFF_EXPR_IN_PARENS)
2271 pp_cxx_right_paren (cxx_pp);
2275 reinit_cxx_pp (void)
2277 pp_clear_output_area (cxx_pp);
2278 pp_base (cxx_pp)->padding = pp_none;
2279 pp_indentation (cxx_pp) = 0;
2280 pp_needs_newline (cxx_pp) = false;
2281 cxx_pp->enclosing_scope = current_function_decl;
2285 /* Exported interface to stringifying types, exprs and decls under TFF_*
2289 type_as_string (tree typ, int flags)
2292 pp_translate_identifiers (cxx_pp) = false;
2293 dump_type (typ, flags);
2294 return pp_formatted_text (cxx_pp);
2298 type_as_string_translate (tree typ, int flags)
2301 dump_type (typ, flags);
2302 return pp_formatted_text (cxx_pp);
2306 expr_as_string (tree decl, int flags)
2309 pp_translate_identifiers (cxx_pp) = false;
2310 dump_expr (decl, flags);
2311 return pp_formatted_text (cxx_pp);
2315 decl_as_string (tree decl, int flags)
2318 pp_translate_identifiers (cxx_pp) = false;
2319 dump_decl (decl, flags);
2320 return pp_formatted_text (cxx_pp);
2324 decl_as_string_translate (tree decl, int flags)
2327 dump_decl (decl, flags);
2328 return pp_formatted_text (cxx_pp);
2331 /* Generate the three forms of printable names for cxx_printable_name. */
2334 lang_decl_name (tree decl, int v, bool translate)
2338 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2339 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2342 pp_translate_identifiers (cxx_pp) = translate;
2344 && (DECL_CLASS_SCOPE_P (decl)
2345 || (DECL_NAMESPACE_SCOPE_P (decl)
2346 && CP_DECL_CONTEXT (decl) != global_namespace)))
2348 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2349 pp_cxx_colon_colon (cxx_pp);
2352 if (TREE_CODE (decl) == FUNCTION_DECL)
2353 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2355 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2357 return pp_formatted_text (cxx_pp);
2360 /* Return the location of a tree passed to %+ formats. */
2363 location_of (tree t)
2365 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2366 t = DECL_CONTEXT (t);
2367 else if (TYPE_P (t))
2368 t = TYPE_MAIN_DECL (t);
2369 else if (TREE_CODE (t) == OVERLOAD)
2370 t = OVL_FUNCTION (t);
2372 return DECL_SOURCE_LOCATION (t);
2375 /* Now the interfaces from error et al to dump_type et al. Each takes an
2376 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2380 decl_to_string (tree decl, int verbose)
2384 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2385 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2386 flags = TFF_CLASS_KEY_OR_ENUM;
2388 flags |= TFF_DECL_SPECIFIERS;
2389 else if (TREE_CODE (decl) == FUNCTION_DECL)
2390 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2391 flags |= TFF_TEMPLATE_HEADER;
2394 dump_decl (decl, flags);
2395 return pp_formatted_text (cxx_pp);
2399 expr_to_string (tree decl)
2402 dump_expr (decl, 0);
2403 return pp_formatted_text (cxx_pp);
2407 fndecl_to_string (tree fndecl, int verbose)
2411 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2412 | TFF_TEMPLATE_HEADER;
2414 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2416 dump_decl (fndecl, flags);
2417 return pp_formatted_text (cxx_pp);
2422 code_to_string (enum tree_code c)
2424 return tree_code_name [c];
2428 language_to_string (enum languages c)
2435 case lang_cplusplus:
2447 /* Return the proper printed version of a parameter to a C++ function. */
2450 parm_to_string (int p)
2454 pp_string (cxx_pp, "'this'");
2456 pp_decimal_int (cxx_pp, p + 1);
2457 return pp_formatted_text (cxx_pp);
2461 op_to_string (enum tree_code p)
2463 tree id = operator_name_info[(int) p].identifier;
2464 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2468 type_to_string (tree typ, int verbose)
2472 flags |= TFF_CLASS_KEY_OR_ENUM;
2473 flags |= TFF_TEMPLATE_HEADER;
2476 dump_type (typ, flags);
2477 return pp_formatted_text (cxx_pp);
2481 assop_to_string (enum tree_code p)
2483 tree id = assignment_operator_name_info[(int) p].identifier;
2484 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2488 args_to_string (tree p, int verbose)
2492 flags |= TFF_CLASS_KEY_OR_ENUM;
2497 if (TYPE_P (TREE_VALUE (p)))
2498 return type_as_string_translate (p, flags);
2501 for (; p; p = TREE_CHAIN (p))
2503 if (TREE_VALUE (p) == null_node)
2504 pp_cxx_ws_string (cxx_pp, "NULL");
2506 dump_type (error_type (TREE_VALUE (p)), flags);
2508 pp_separate_with_comma (cxx_pp);
2510 return pp_formatted_text (cxx_pp);
2514 cv_to_string (tree p, int v)
2517 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2518 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2519 return pp_formatted_text (cxx_pp);
2522 /* Langhook for print_error_function. */
2524 cxx_print_error_function (diagnostic_context *context, const char *file,
2525 diagnostic_info *diagnostic)
2527 lhd_print_error_function (context, file, diagnostic);
2528 pp_base_set_prefix (context->printer, file);
2529 maybe_print_instantiation_context (context);
2533 cp_diagnostic_starter (diagnostic_context *context,
2534 diagnostic_info *diagnostic)
2536 diagnostic_report_current_module (context);
2537 cp_print_error_function (context, diagnostic);
2538 maybe_print_instantiation_context (context);
2539 pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2543 cp_diagnostic_finalizer (diagnostic_context *context,
2544 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2546 pp_base_destroy_prefix (context->printer);
2549 /* Print current function onto BUFFER, in the process of reporting
2550 a diagnostic message. Called from cp_diagnostic_starter. */
2552 cp_print_error_function (diagnostic_context *context,
2553 diagnostic_info *diagnostic)
2555 if (diagnostic_last_function_changed (context, diagnostic))
2557 const char *old_prefix = context->printer->prefix;
2558 const char *file = LOCATION_FILE (diagnostic->location);
2559 tree abstract_origin = diagnostic->abstract_origin;
2560 char *new_prefix = (file && abstract_origin == NULL)
2561 ? file_name_as_prefix (file) : NULL;
2563 pp_base_set_prefix (context->printer, new_prefix);
2565 if (current_function_decl == NULL)
2566 pp_base_string (context->printer, _("At global scope:"));
2571 if (abstract_origin)
2573 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2574 while (TREE_CODE (ao) == BLOCK
2575 && BLOCK_ABSTRACT_ORIGIN (ao)
2576 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2577 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2578 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2582 fndecl = current_function_decl;
2584 pp_printf (context->printer, function_category (fndecl),
2585 cxx_printable_name_translate (fndecl, 2));
2587 while (abstract_origin)
2590 tree block = abstract_origin;
2592 locus = &BLOCK_SOURCE_LOCATION (block);
2594 block = BLOCK_SUPERCONTEXT (block);
2595 while (block && TREE_CODE (block) == BLOCK
2596 && BLOCK_ABSTRACT_ORIGIN (block))
2598 ao = BLOCK_ABSTRACT_ORIGIN (block);
2600 while (TREE_CODE (ao) == BLOCK
2601 && BLOCK_ABSTRACT_ORIGIN (ao)
2602 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2603 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2605 if (TREE_CODE (ao) == FUNCTION_DECL)
2610 else if (TREE_CODE (ao) != BLOCK)
2613 block = BLOCK_SUPERCONTEXT (block);
2616 abstract_origin = block;
2619 while (block && TREE_CODE (block) == BLOCK)
2620 block = BLOCK_SUPERCONTEXT (block);
2622 if (block && TREE_CODE (block) == FUNCTION_DECL)
2624 abstract_origin = NULL;
2628 expanded_location s = expand_location (*locus);
2629 pp_base_character (context->printer, ',');
2630 pp_base_newline (context->printer);
2633 if (flag_show_column && s.column != 0)
2634 pp_printf (context->printer,
2635 _(" inlined from %qs at %s:%d:%d"),
2636 cxx_printable_name_translate (fndecl, 2),
2637 s.file, s.line, s.column);
2639 pp_printf (context->printer,
2640 _(" inlined from %qs at %s:%d"),
2641 cxx_printable_name_translate (fndecl, 2),
2646 pp_printf (context->printer, _(" inlined from %qs"),
2647 cxx_printable_name_translate (fndecl, 2));
2650 pp_base_character (context->printer, ':');
2652 pp_base_newline (context->printer);
2654 diagnostic_set_last_function (context, diagnostic);
2655 pp_base_destroy_prefix (context->printer);
2656 context->printer->prefix = old_prefix;
2660 /* Returns a description of FUNCTION using standard terminology. The
2661 result is a format string of the form "In CATEGORY %qs". */
2663 function_category (tree fn)
2665 /* We can get called from the middle-end for diagnostics of function
2666 clones. Make sure we have language specific information before
2667 dereferencing it. */
2668 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
2669 && DECL_FUNCTION_MEMBER_P (fn))
2671 if (DECL_STATIC_FUNCTION_P (fn))
2672 return _("In static member function %qs");
2673 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2674 return _("In copy constructor %qs");
2675 else if (DECL_CONSTRUCTOR_P (fn))
2676 return _("In constructor %qs");
2677 else if (DECL_DESTRUCTOR_P (fn))
2678 return _("In destructor %qs");
2680 return _("In member function %qs");
2683 return _("In function %qs");
2686 /* Report the full context of a current template instantiation,
2689 print_instantiation_full_context (diagnostic_context *context)
2691 struct tinst_level *p = current_instantiation ();
2692 location_t location = input_location;
2696 if (current_function_decl != p->decl
2697 && current_function_decl != NULL_TREE)
2698 /* We can get here during the processing of some synthesized
2699 method. Then, P->DECL will be the function that's causing
2704 if (current_function_decl == p->decl)
2705 /* Avoid redundancy with the "In function" line. */;
2707 pp_verbatim (context->printer,
2708 _("%s: In instantiation of %qs:\n"),
2709 LOCATION_FILE (location),
2710 decl_as_string_translate (p->decl,
2711 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2713 location = p->locus;
2718 print_instantiation_partial_context (context, p, location);
2721 /* Same as above but less verbose. */
2723 print_instantiation_partial_context (diagnostic_context *context,
2724 struct tinst_level *t, location_t loc)
2726 expanded_location xloc;
2728 for (; ; t = t->next)
2730 xloc = expand_location (loc);
2733 str = decl_as_string_translate (t->decl,
2734 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE);
2735 if (flag_show_column)
2736 pp_verbatim (context->printer,
2737 _("%s:%d:%d: instantiated from %qs\n"),
2738 xloc.file, xloc.line, xloc.column, str);
2740 pp_verbatim (context->printer,
2741 _("%s:%d: instantiated from %qs\n"),
2742 xloc.file, xloc.line, str);
2745 if (flag_show_column)
2746 pp_verbatim (context->printer, _("%s:%d:%d: instantiated from here"),
2747 xloc.file, xloc.line, xloc.column);
2749 pp_verbatim (context->printer, _("%s:%d: instantiated from here"),
2750 xloc.file, xloc.line);
2751 pp_base_newline (context->printer);
2754 /* Called from cp_thing to print the template context for an error. */
2756 maybe_print_instantiation_context (diagnostic_context *context)
2758 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2761 record_last_problematic_instantiation ();
2762 print_instantiation_full_context (context);
2765 /* Report the bare minimum context of a template instantiation. */
2767 print_instantiation_context (void)
2769 print_instantiation_partial_context
2770 (global_dc, current_instantiation (), input_location);
2771 diagnostic_flush_buffer (global_dc);
2774 /* Called from output_format -- during diagnostic message processing --
2775 to handle C++ specific format specifier with the following meanings:
2776 %A function argument-list.
2780 %F function declaration.
2781 %L language as used in extern "lang".
2783 %P function parameter whose position is indicated by an integer.
2784 %Q assignment operator.
2788 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2789 int precision, bool wide, bool set_locus, bool verbose)
2793 #define next_tree (t = va_arg (*text->args_ptr, tree))
2794 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
2795 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
2796 #define next_int va_arg (*text->args_ptr, int)
2798 if (precision != 0 || wide)
2801 if (text->locus == NULL)
2806 case 'A': result = args_to_string (next_tree, verbose); break;
2807 case 'C': result = code_to_string (next_tcode); break;
2810 tree temp = next_tree;
2812 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2814 temp = DECL_DEBUG_EXPR (temp);
2817 result = expr_to_string (temp);
2821 result = decl_to_string (temp, verbose);
2824 case 'E': result = expr_to_string (next_tree); break;
2825 case 'F': result = fndecl_to_string (next_tree, verbose); break;
2826 case 'L': result = language_to_string (next_lang); break;
2827 case 'O': result = op_to_string (next_tcode); break;
2828 case 'P': result = parm_to_string (next_int); break;
2829 case 'Q': result = assop_to_string (next_tcode); break;
2830 case 'T': result = type_to_string (next_tree, verbose); break;
2831 case 'V': result = cv_to_string (next_tree, verbose); break;
2837 pp_base_string (pp, result);
2838 if (set_locus && t != NULL)
2839 *text->locus = location_of (t);
2847 /* Warn about the use of C++0x features when appropriate. */
2849 maybe_warn_cpp0x (const char* str)
2851 if ((cxx_dialect == cxx98) && !in_system_header)
2852 /* We really want to suppress this warning in system headers,
2853 because libstdc++ uses variadic templates even when we aren't
2855 pedwarn (input_location, 0, "%s only available with -std=c++0x or -std=gnu++0x", str);
2858 /* Warn about the use of variadic templates when appropriate. */
2860 maybe_warn_variadic_templates (void)
2862 maybe_warn_cpp0x ("variadic templates");
2866 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
2867 option OPT with text GMSGID. Use this function to report
2868 diagnostics for constructs that are invalid C++98, but valid
2871 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
2873 diagnostic_info diagnostic;
2876 va_start (ap, gmsgid);
2877 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
2878 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
2879 diagnostic.option_index = opt;
2881 return report_diagnostic (&diagnostic);