1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "diagnostic.h"
30 #include "tree-diagnostic.h"
31 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
34 #include "tree-pretty-print.h"
35 #include "pointer-set.h"
36 #include "c-family/c-objc.h"
38 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
39 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
41 /* The global buffer where we dump everything. It is there only for
42 transitional purpose. It is expected, in the near future, to be
43 completely removed. */
44 static cxx_pretty_printer scratch_pretty_printer;
45 #define cxx_pp (&scratch_pretty_printer)
47 /* Translate if being used for diagnostics, but not for dump files or
49 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
51 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
53 static const char *args_to_string (tree, int);
54 static const char *assop_to_string (enum tree_code);
55 static const char *code_to_string (enum tree_code);
56 static const char *cv_to_string (tree, int);
57 static const char *decl_to_string (tree, int);
58 static const char *expr_to_string (tree);
59 static const char *fndecl_to_string (tree, int);
60 static const char *op_to_string (enum tree_code);
61 static const char *parm_to_string (int);
62 static const char *type_to_string (tree, int);
64 static void dump_type (tree, int);
65 static void dump_typename (tree, int);
66 static void dump_simple_decl (tree, tree, int);
67 static void dump_decl (tree, int);
68 static void dump_template_decl (tree, int);
69 static void dump_function_decl (tree, int);
70 static void dump_expr (tree, int);
71 static void dump_unary_op (const char *, tree, int);
72 static void dump_binary_op (const char *, tree, int);
73 static void dump_aggr_type (tree, int);
74 static void dump_type_prefix (tree, int);
75 static void dump_type_suffix (tree, int);
76 static void dump_function_name (tree, int);
77 static void dump_call_expr_args (tree, int, bool);
78 static void dump_aggr_init_expr_args (tree, int, bool);
79 static void dump_expr_list (tree, int);
80 static void dump_global_iord (tree);
81 static void dump_parameters (tree, int);
82 static void dump_exception_spec (tree, int);
83 static void dump_template_argument (tree, int);
84 static void dump_template_argument_list (tree, int);
85 static void dump_template_parameter (tree, int);
86 static void dump_template_bindings (tree, tree, VEC(tree,gc) *);
87 static void dump_scope (tree, int);
88 static void dump_template_parms (tree, int, int);
89 static int get_non_default_template_args_count (tree, int);
90 static const char *function_category (tree);
91 static void maybe_print_constexpr_context (diagnostic_context *);
92 static void maybe_print_instantiation_context (diagnostic_context *);
93 static void print_instantiation_full_context (diagnostic_context *);
94 static void print_instantiation_partial_context (diagnostic_context *,
97 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
98 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
99 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
101 static bool cp_printer (pretty_printer *, text_info *, const char *,
102 int, bool, bool, bool);
107 diagnostic_starter (global_dc) = cp_diagnostic_starter;
108 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
109 diagnostic_format_decoder (global_dc) = cp_printer;
111 pp_construct (pp_base (cxx_pp), NULL, 0);
112 pp_cxx_pretty_printer_init (cxx_pp);
115 /* Dump a scope, if deemed necessary. */
118 dump_scope (tree scope, int flags)
120 int f = flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF);
122 if (scope == NULL_TREE)
125 if (TREE_CODE (scope) == NAMESPACE_DECL)
127 if (scope != global_namespace)
129 dump_decl (scope, f);
130 pp_cxx_colon_colon (cxx_pp);
133 else if (AGGREGATE_TYPE_P (scope))
135 dump_type (scope, f);
136 pp_cxx_colon_colon (cxx_pp);
138 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
140 dump_function_decl (scope, f);
141 pp_cxx_colon_colon (cxx_pp);
145 /* Dump the template ARGument under control of FLAGS. */
148 dump_template_argument (tree arg, int flags)
150 if (ARGUMENT_PACK_P (arg))
151 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg),
152 /* No default args in argument packs. */
153 flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
154 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
155 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
158 if (TREE_CODE (arg) == TREE_LIST)
159 arg = TREE_VALUE (arg);
161 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
165 /* Count the number of template arguments ARGS whose value does not
166 match the (optional) default template parameter in PARAMS */
169 get_non_default_template_args_count (tree args, int flags)
171 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
173 if (/* 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 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
185 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
189 dump_template_argument_list (tree args, int flags)
191 int n = get_non_default_template_args_count (args, flags);
195 for (i = 0; i < n; ++i)
197 tree arg = TREE_VEC_ELT (args, i);
199 /* Only print a comma if we know there is an argument coming. In
200 the case of an empty template argument pack, no actual
201 argument will be printed. */
203 && (!ARGUMENT_PACK_P (arg)
204 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
205 pp_separate_with_comma (cxx_pp);
207 dump_template_argument (arg, flags);
212 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
215 dump_template_parameter (tree parm, int flags)
220 if (parm == error_mark_node)
223 p = TREE_VALUE (parm);
224 a = TREE_PURPOSE (parm);
226 if (TREE_CODE (p) == TYPE_DECL)
228 if (flags & TFF_DECL_SPECIFIERS)
230 pp_cxx_ws_string (cxx_pp, "class");
231 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
232 pp_cxx_ws_string (cxx_pp, "...");
234 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
236 else if (DECL_NAME (p))
237 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
239 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
242 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
244 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
246 pp_cxx_whitespace (cxx_pp);
248 pp_cxx_whitespace (cxx_pp);
249 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
250 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
252 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
256 /* Dump, under control of FLAGS, a template-parameter-list binding.
257 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
261 dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames)
263 bool need_semicolon = false;
269 tree p = TREE_VALUE (parms);
270 int lvl = TMPL_PARMS_DEPTH (parms);
273 tree lvl_args = NULL_TREE;
275 /* Don't crash if we had an invalid argument list. */
276 if (TMPL_ARGS_DEPTH (args) >= lvl)
277 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
279 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
281 tree arg = NULL_TREE;
283 /* Don't crash if we had an invalid argument list. */
284 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
285 arg = TREE_VEC_ELT (lvl_args, arg_idx);
288 pp_separate_with_semicolon (cxx_pp);
289 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
290 pp_cxx_whitespace (cxx_pp);
292 pp_cxx_whitespace (cxx_pp);
295 if (ARGUMENT_PACK_P (arg))
296 pp_cxx_left_brace (cxx_pp);
297 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
298 if (ARGUMENT_PACK_P (arg))
299 pp_cxx_right_brace (cxx_pp);
302 pp_string (cxx_pp, M_("<missing>"));
305 need_semicolon = true;
308 parms = TREE_CHAIN (parms);
311 /* Don't bother with typenames for a partial instantiation. */
312 if (VEC_empty (tree, typenames) || uses_template_parms (args))
315 FOR_EACH_VEC_ELT (tree, typenames, i, t)
318 pp_separate_with_semicolon (cxx_pp);
319 dump_type (t, TFF_PLAIN_IDENTIFIER);
320 pp_cxx_whitespace (cxx_pp);
322 pp_cxx_whitespace (cxx_pp);
323 push_deferring_access_checks (dk_no_check);
324 t = tsubst (t, args, tf_none, NULL_TREE);
325 pop_deferring_access_checks ();
326 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
327 pp_simple_type_specifier doesn't know about it. */
328 t = strip_typedefs (t);
329 dump_type (t, TFF_PLAIN_IDENTIFIER);
333 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
337 dump_type (tree t, int flags)
342 /* Don't print e.g. "struct mytypedef". */
343 if (TYPE_P (t) && typedef_variant_p (t))
345 tree decl = TYPE_NAME (t);
346 if ((flags & TFF_CHASE_TYPEDEF)
347 || DECL_SELF_REFERENCE_P (decl)
348 || (!flag_pretty_templates
349 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)))
350 t = strip_typedefs (t);
351 else if (same_type_p (t, TREE_TYPE (decl)))
355 pp_cxx_cv_qualifier_seq (cxx_pp, t);
356 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
361 if (TYPE_PTRMEMFUNC_P (t))
364 switch (TREE_CODE (t))
367 if (t == init_list_type_node)
368 pp_string (cxx_pp, M_("<brace-enclosed initializer list>"));
369 else if (t == unknown_type_node)
370 pp_string (cxx_pp, M_("<unresolved overloaded function type>"));
373 pp_cxx_cv_qualifier_seq (cxx_pp, t);
374 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
379 /* A list of function parms. */
380 dump_parameters (t, flags);
383 case IDENTIFIER_NODE:
384 pp_cxx_tree_identifier (cxx_pp, t);
388 dump_type (BINFO_TYPE (t), flags);
394 dump_aggr_type (t, flags);
398 if (flags & TFF_CHASE_TYPEDEF)
400 dump_type (DECL_ORIGINAL_TYPE (t)
401 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
404 /* Else fall through. */
408 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
417 case FIXED_POINT_TYPE:
418 pp_type_specifier_seq (cxx_pp, t);
421 case TEMPLATE_TEMPLATE_PARM:
422 /* For parameters inside template signature. */
423 if (TYPE_IDENTIFIER (t))
424 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
426 pp_cxx_canonical_template_parameter (cxx_pp, t);
429 case BOUND_TEMPLATE_TEMPLATE_PARM:
431 tree args = TYPE_TI_ARGS (t);
432 pp_cxx_cv_qualifier_seq (cxx_pp, t);
433 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
434 pp_cxx_begin_template_argument_list (cxx_pp);
435 dump_template_argument_list (args, flags);
436 pp_cxx_end_template_argument_list (cxx_pp);
440 case TEMPLATE_TYPE_PARM:
441 pp_cxx_cv_qualifier_seq (cxx_pp, t);
442 if (TYPE_IDENTIFIER (t))
443 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
445 pp_cxx_canonical_template_parameter
446 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
449 /* This is not always necessary for pointers and such, but doing this
450 reduces code size. */
459 dump_type_prefix (t, flags);
460 dump_type_suffix (t, flags);
464 if (! (flags & TFF_CHASE_TYPEDEF)
465 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
467 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
470 pp_cxx_cv_qualifier_seq (cxx_pp, t);
471 pp_cxx_ws_string (cxx_pp,
472 TYPENAME_IS_ENUM_P (t) ? "enum"
473 : TYPENAME_IS_CLASS_P (t) ? "class"
475 dump_typename (t, flags);
478 case UNBOUND_CLASS_TEMPLATE:
479 if (! (flags & TFF_UNQUALIFIED_NAME))
481 dump_type (TYPE_CONTEXT (t), flags);
482 pp_cxx_colon_colon (cxx_pp);
484 pp_cxx_ws_string (cxx_pp, "template");
485 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
489 pp_cxx_ws_string (cxx_pp, "__typeof__");
490 pp_cxx_whitespace (cxx_pp);
491 pp_cxx_left_paren (cxx_pp);
492 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
493 pp_cxx_right_paren (cxx_pp);
496 case UNDERLYING_TYPE:
497 pp_cxx_ws_string (cxx_pp, "__underlying_type");
498 pp_cxx_whitespace (cxx_pp);
499 pp_cxx_left_paren (cxx_pp);
500 dump_expr (UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
501 pp_cxx_right_paren (cxx_pp);
504 case TYPE_PACK_EXPANSION:
505 dump_type (PACK_EXPANSION_PATTERN (t), flags);
506 pp_cxx_ws_string (cxx_pp, "...");
509 case TYPE_ARGUMENT_PACK:
510 dump_template_argument (t, flags);
514 pp_cxx_ws_string (cxx_pp, "decltype");
515 pp_cxx_whitespace (cxx_pp);
516 pp_cxx_left_paren (cxx_pp);
517 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
518 pp_cxx_right_paren (cxx_pp);
522 pp_string (cxx_pp, "std::nullptr_t");
526 pp_unsupported_tree (cxx_pp, t);
527 /* Fall through to error. */
530 pp_string (cxx_pp, M_("<type error>"));
535 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
539 dump_typename (tree t, int flags)
541 tree ctx = TYPE_CONTEXT (t);
543 if (TREE_CODE (ctx) == TYPENAME_TYPE)
544 dump_typename (ctx, flags);
546 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
547 pp_cxx_colon_colon (cxx_pp);
548 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
551 /* Return the name of the supplied aggregate, or enumeral type. */
554 class_key_or_enum_as_string (tree t)
556 if (TREE_CODE (t) == ENUMERAL_TYPE)
558 if (SCOPED_ENUM_P (t))
563 else if (TREE_CODE (t) == UNION_TYPE)
565 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
571 /* Print out a class declaration T under the control of FLAGS,
572 in the form `class foo'. */
575 dump_aggr_type (tree t, int flags)
578 const char *variety = class_key_or_enum_as_string (t);
582 pp_cxx_cv_qualifier_seq (cxx_pp, t);
584 if (flags & TFF_CLASS_KEY_OR_ENUM)
585 pp_cxx_ws_string (cxx_pp, variety);
587 name = TYPE_NAME (t);
591 typdef = !DECL_ARTIFICIAL (name);
594 && ((flags & TFF_CHASE_TYPEDEF)
595 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
596 && DECL_TEMPLATE_INFO (name))))
597 || DECL_SELF_REFERENCE_P (name))
599 t = TYPE_MAIN_VARIANT (t);
600 name = TYPE_NAME (t);
604 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
605 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
606 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
607 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
609 if (! (flags & TFF_UNQUALIFIED_NAME))
610 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
611 flags &= ~TFF_UNQUALIFIED_NAME;
614 /* Because the template names are mangled, we have to locate
615 the most general template, and use that name. */
616 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
618 while (DECL_TEMPLATE_INFO (tpl))
619 tpl = DECL_TI_TEMPLATE (tpl);
622 name = DECL_NAME (name);
625 if (name == 0 || ANON_AGGRNAME_P (name))
627 if (flags & TFF_CLASS_KEY_OR_ENUM)
628 pp_string (cxx_pp, M_("<anonymous>"));
630 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety);
632 else if (LAMBDANAME_P (name))
634 /* A lambda's "type" is essentially its signature. */
635 pp_string (cxx_pp, M_("<lambda"));
636 if (lambda_function (t))
637 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
639 pp_character(cxx_pp, '>');
642 pp_cxx_tree_identifier (cxx_pp, name);
644 dump_template_parms (TYPE_TEMPLATE_INFO (t),
645 !CLASSTYPE_USE_TEMPLATE (t),
646 flags & ~TFF_TEMPLATE_HEADER);
649 /* Dump into the obstack the initial part of the output for a given type.
650 This is necessary when dealing with things like functions returning
653 return type of `int (* fee ())()': pointer -> function -> int. Both
654 pointer (and reference and offset) and function (and member) types must
655 deal with prefix and suffix.
657 Arrays must also do this for DECL nodes, like int a[], and for things like
661 dump_type_prefix (tree t, int flags)
663 if (TYPE_PTRMEMFUNC_P (t))
665 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
669 switch (TREE_CODE (t))
674 tree sub = TREE_TYPE (t);
676 dump_type_prefix (sub, flags);
677 if (TREE_CODE (sub) == ARRAY_TYPE
678 || TREE_CODE (sub) == FUNCTION_TYPE)
680 pp_cxx_whitespace (cxx_pp);
681 pp_cxx_left_paren (cxx_pp);
682 pp_c_attributes_display (pp_c_base (cxx_pp),
683 TYPE_ATTRIBUTES (sub));
685 if (TREE_CODE (t) == POINTER_TYPE)
686 pp_character(cxx_pp, '*');
687 else if (TREE_CODE (t) == REFERENCE_TYPE)
689 if (TYPE_REF_IS_RVALUE (t))
690 pp_string (cxx_pp, "&&");
692 pp_character (cxx_pp, '&');
694 pp_base (cxx_pp)->padding = pp_before;
695 pp_cxx_cv_qualifier_seq (cxx_pp, t);
701 dump_type_prefix (TREE_TYPE (t), flags);
702 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
704 pp_maybe_space (cxx_pp);
705 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
706 pp_cxx_left_paren (cxx_pp);
707 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
708 pp_cxx_colon_colon (cxx_pp);
710 pp_cxx_star (cxx_pp);
711 pp_cxx_cv_qualifier_seq (cxx_pp, t);
712 pp_base (cxx_pp)->padding = pp_before;
715 /* This can be reached without a pointer when dealing with
716 templates, e.g. std::is_function. */
718 dump_type_prefix (TREE_TYPE (t), flags);
722 dump_type_prefix (TREE_TYPE (t), flags);
723 pp_maybe_space (cxx_pp);
724 pp_cxx_left_paren (cxx_pp);
725 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
726 pp_cxx_colon_colon (cxx_pp);
730 dump_type_prefix (TREE_TYPE (t), flags);
734 case IDENTIFIER_NODE:
739 case TEMPLATE_TYPE_PARM:
740 case TEMPLATE_TEMPLATE_PARM:
741 case BOUND_TEMPLATE_TEMPLATE_PARM:
752 case UNDERLYING_TYPE:
754 case TYPE_PACK_EXPANSION:
755 case FIXED_POINT_TYPE:
757 dump_type (t, flags);
758 pp_base (cxx_pp)->padding = pp_before;
762 pp_unsupported_tree (cxx_pp, t);
765 pp_string (cxx_pp, M_("<typeprefixerror>"));
770 /* Dump the suffix of type T, under control of FLAGS. This is the part
771 which appears after the identifier (or function parms). */
774 dump_type_suffix (tree t, int flags)
776 if (TYPE_PTRMEMFUNC_P (t))
777 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
779 switch (TREE_CODE (t))
784 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
785 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
786 pp_cxx_right_paren (cxx_pp);
787 dump_type_suffix (TREE_TYPE (t), flags);
794 if (TREE_CODE (t) == METHOD_TYPE)
795 /* Can only be reached through a pointer. */
796 pp_cxx_right_paren (cxx_pp);
797 arg = TYPE_ARG_TYPES (t);
798 if (TREE_CODE (t) == METHOD_TYPE)
799 arg = TREE_CHAIN (arg);
801 /* Function pointers don't have default args. Not in standard C++,
802 anyway; they may in g++, but we'll just pretend otherwise. */
803 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
805 if (TREE_CODE (t) == METHOD_TYPE)
806 pp_cxx_cv_qualifier_seq (cxx_pp, class_of_this_parm (t));
808 pp_cxx_cv_qualifier_seq (cxx_pp, t);
809 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
810 dump_type_suffix (TREE_TYPE (t), flags);
815 pp_maybe_space (cxx_pp);
816 pp_cxx_left_bracket (cxx_pp);
819 tree dtype = TYPE_DOMAIN (t);
820 tree max = TYPE_MAX_VALUE (dtype);
821 if (host_integerp (max, 0))
822 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
823 else if (TREE_CODE (max) == MINUS_EXPR)
824 dump_expr (TREE_OPERAND (max, 0),
825 flags & ~TFF_EXPR_IN_PARENS);
827 dump_expr (fold_build2_loc (input_location,
828 PLUS_EXPR, dtype, max,
829 build_int_cst (dtype, 1)),
830 flags & ~TFF_EXPR_IN_PARENS);
832 pp_cxx_right_bracket (cxx_pp);
833 dump_type_suffix (TREE_TYPE (t), flags);
837 case IDENTIFIER_NODE:
842 case TEMPLATE_TYPE_PARM:
843 case TEMPLATE_TEMPLATE_PARM:
844 case BOUND_TEMPLATE_TEMPLATE_PARM:
855 case UNDERLYING_TYPE:
857 case TYPE_PACK_EXPANSION:
858 case FIXED_POINT_TYPE:
863 pp_unsupported_tree (cxx_pp, t);
865 /* Don't mark it here, we should have already done in
872 dump_global_iord (tree t)
874 const char *p = NULL;
876 if (DECL_GLOBAL_CTOR_P (t))
877 p = M_("(static initializers for %s)");
878 else if (DECL_GLOBAL_DTOR_P (t))
879 p = M_("(static destructors for %s)");
883 pp_printf (pp_base (cxx_pp), p, input_filename);
887 dump_simple_decl (tree t, tree type, int flags)
889 if (flags & TFF_DECL_SPECIFIERS)
891 if (TREE_CODE (t) == VAR_DECL
892 && DECL_DECLARED_CONSTEXPR_P (t))
893 pp_cxx_ws_string (cxx_pp, "constexpr");
894 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
895 pp_maybe_space (cxx_pp);
897 if (! (flags & TFF_UNQUALIFIED_NAME)
898 && TREE_CODE (t) != PARM_DECL
899 && (!DECL_INITIAL (t)
900 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
901 dump_scope (CP_DECL_CONTEXT (t), flags);
902 flags &= ~TFF_UNQUALIFIED_NAME;
903 if ((flags & TFF_DECL_SPECIFIERS)
904 && DECL_TEMPLATE_PARM_P (t)
905 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
906 pp_string (cxx_pp, "...");
908 dump_decl (DECL_NAME (t), flags);
910 pp_string (cxx_pp, M_("<anonymous>"));
911 if (flags & TFF_DECL_SPECIFIERS)
912 dump_type_suffix (type, flags);
915 /* Dump a human readable string for the decl T under control of FLAGS. */
918 dump_decl (tree t, int flags)
923 /* If doing Objective-C++, give Objective-C a chance to demangle
924 Objective-C method names. */
925 if (c_dialect_objc ())
927 const char *demangled = objc_maybe_printable_name (t, flags);
930 pp_string (cxx_pp, demangled);
935 switch (TREE_CODE (t))
938 /* Don't say 'typedef class A' */
939 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
941 if ((flags & TFF_DECL_SPECIFIERS)
942 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
944 /* Say `class T' not just `T'. */
945 pp_cxx_ws_string (cxx_pp, "class");
947 /* Emit the `...' for a parameter pack. */
948 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
949 pp_cxx_ws_string (cxx_pp, "...");
952 dump_type (TREE_TYPE (t), flags);
955 if ((flags & TFF_DECL_SPECIFIERS)
956 && !DECL_SELF_REFERENCE_P (t))
957 pp_cxx_ws_string (cxx_pp, "typedef");
958 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
959 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
964 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
966 pp_string (cxx_pp, M_("vtable for "));
967 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
968 dump_type (DECL_CONTEXT (t), flags);
971 /* Else fall through. */
974 dump_simple_decl (t, TREE_TYPE (t), flags);
978 pp_string (cxx_pp, M_("<return value> "));
979 dump_simple_decl (t, TREE_TYPE (t), flags);
983 if (flags & TFF_DECL_SPECIFIERS)
984 pp_cxx_declaration (cxx_pp, t);
987 if (! (flags & TFF_UNQUALIFIED_NAME))
988 dump_scope (CP_DECL_CONTEXT (t), flags);
989 flags &= ~TFF_UNQUALIFIED_NAME;
990 if (DECL_NAME (t) == NULL_TREE)
991 pp_cxx_ws_string (cxx_pp, M_("{anonymous}"));
993 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
998 dump_type (TREE_OPERAND (t, 0), flags);
999 pp_string (cxx_pp, "::");
1000 dump_decl (TREE_OPERAND (t, 1), flags|TFF_UNQUALIFIED_NAME);
1004 dump_decl (TREE_OPERAND (t, 0), flags);
1005 pp_cxx_left_bracket (cxx_pp);
1006 dump_decl (TREE_OPERAND (t, 1), flags);
1007 pp_cxx_right_bracket (cxx_pp);
1010 /* So that we can do dump_decl on an aggr type. */
1014 dump_type (t, flags);
1018 /* This is a pseudo destructor call which has not been folded into
1019 a PSEUDO_DTOR_EXPR yet. */
1020 pp_cxx_complement (cxx_pp);
1021 dump_type (TREE_OPERAND (t, 0), flags);
1028 /* These special cases are duplicated here so that other functions
1029 can feed identifiers to error and get them demangled properly. */
1030 case IDENTIFIER_NODE:
1031 if (IDENTIFIER_TYPENAME_P (t))
1033 pp_cxx_ws_string (cxx_pp, "operator");
1034 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1035 dump_type (TREE_TYPE (t), flags);
1039 pp_cxx_tree_identifier (cxx_pp, t);
1045 t = OVL_CURRENT (t);
1046 if (DECL_CLASS_SCOPE_P (t))
1048 dump_type (DECL_CONTEXT (t), flags);
1049 pp_cxx_colon_colon (cxx_pp);
1051 else if (!DECL_FILE_SCOPE_P (t))
1053 dump_decl (DECL_CONTEXT (t), flags);
1054 pp_cxx_colon_colon (cxx_pp);
1056 dump_decl (DECL_NAME (t), flags);
1060 /* If there's only one function, just treat it like an ordinary
1062 t = OVL_CURRENT (t);
1066 if (! DECL_LANG_SPECIFIC (t))
1067 pp_string (cxx_pp, M_("<built-in>"));
1068 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1069 dump_global_iord (t);
1071 dump_function_decl (t, flags);
1075 dump_template_decl (t, flags);
1078 case TEMPLATE_ID_EXPR:
1080 tree name = TREE_OPERAND (t, 0);
1082 if (is_overloaded_fn (name))
1083 name = DECL_NAME (get_first_fn (name));
1084 dump_decl (name, flags);
1085 pp_cxx_begin_template_argument_list (cxx_pp);
1086 if (TREE_OPERAND (t, 1))
1087 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
1088 pp_cxx_end_template_argument_list (cxx_pp);
1093 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1097 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1098 || (DECL_INITIAL (t) &&
1099 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1100 dump_simple_decl (t, TREE_TYPE (t), flags);
1101 else if (DECL_NAME (t))
1102 dump_decl (DECL_NAME (t), flags);
1103 else if (DECL_INITIAL (t))
1104 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1106 pp_string (cxx_pp, M_("<enumerator>"));
1110 pp_cxx_ws_string (cxx_pp, "using");
1111 dump_type (USING_DECL_SCOPE (t), flags);
1112 pp_cxx_colon_colon (cxx_pp);
1113 dump_decl (DECL_NAME (t), flags);
1117 pp_cxx_declaration (cxx_pp, t);
1121 dump_decl (BASELINK_FUNCTIONS (t), flags);
1124 case NON_DEPENDENT_EXPR:
1125 dump_expr (t, flags);
1128 case TEMPLATE_TYPE_PARM:
1129 if (flags & TFF_DECL_SPECIFIERS)
1130 pp_cxx_declaration (cxx_pp, t);
1132 pp_type_id (cxx_pp, t);
1135 case UNBOUND_CLASS_TEMPLATE:
1136 case TYPE_PACK_EXPANSION:
1138 dump_type (t, flags);
1142 pp_unsupported_tree (cxx_pp, t);
1143 /* Fall through to error. */
1146 pp_string (cxx_pp, M_("<declaration error>"));
1151 /* Dump a template declaration T under control of FLAGS. This means the
1152 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1155 dump_template_decl (tree t, int flags)
1157 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1161 if (flags & TFF_TEMPLATE_HEADER)
1163 for (parms = orig_parms = nreverse (orig_parms);
1165 parms = TREE_CHAIN (parms))
1167 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1168 int len = TREE_VEC_LENGTH (inner_parms);
1170 pp_cxx_ws_string (cxx_pp, "template");
1171 pp_cxx_begin_template_argument_list (cxx_pp);
1173 /* If we've shown the template prefix, we'd better show the
1174 parameters' and decl's type too. */
1175 flags |= TFF_DECL_SPECIFIERS;
1177 for (i = 0; i < len; i++)
1180 pp_separate_with_comma (cxx_pp);
1181 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1183 pp_cxx_end_template_argument_list (cxx_pp);
1184 pp_cxx_whitespace (cxx_pp);
1186 nreverse(orig_parms);
1188 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1190 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1191 pp_cxx_ws_string (cxx_pp, "class");
1193 /* If this is a parameter pack, print the ellipsis. */
1194 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1195 pp_cxx_ws_string (cxx_pp, "...");
1199 if (DECL_TEMPLATE_RESULT (t)
1200 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1201 dump_type (TREE_TYPE (t),
1202 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1203 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1204 else if (DECL_TEMPLATE_RESULT (t)
1205 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1206 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1209 gcc_assert (TREE_TYPE (t));
1210 switch (NEXT_CODE (t))
1214 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1217 /* This case can occur with some invalid code. */
1218 dump_type (TREE_TYPE (t),
1219 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1220 | (flags & TFF_DECL_SPECIFIERS
1221 ? TFF_CLASS_KEY_OR_ENUM : 0));
1226 /* find_typenames looks through the type of the function template T
1227 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1230 struct find_typenames_t
1232 struct pointer_set_t *p_set;
1233 VEC (tree,gc) *typenames;
1237 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1239 struct find_typenames_t *d = (struct find_typenames_t *)data;
1240 tree mv = NULL_TREE;
1242 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1243 /* Add the type of the typedef without any additional cv-quals. */
1244 mv = TREE_TYPE (TYPE_NAME (*tp));
1245 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1246 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1247 /* Add the typename without any cv-qualifiers. */
1248 mv = TYPE_MAIN_VARIANT (*tp);
1250 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1251 VEC_safe_push (tree, gc, d->typenames, mv);
1253 /* Search into class template arguments, which cp_walk_subtrees
1255 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1256 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1262 static VEC(tree,gc) *
1263 find_typenames (tree t)
1265 struct find_typenames_t ft;
1266 ft.p_set = pointer_set_create ();
1267 ft.typenames = NULL;
1268 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1269 find_typenames_r, &ft, ft.p_set);
1270 pointer_set_destroy (ft.p_set);
1271 return ft.typenames;
1274 /* Pretty print a function decl. There are several ways we want to print a
1275 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1276 As error can only apply the '#' flag once to give 0 and 1 for V, there
1277 is %D which doesn't print the throw specs, and %F which does. */
1280 dump_function_decl (tree t, int flags)
1284 tree cname = NULL_TREE;
1285 tree template_args = NULL_TREE;
1286 tree template_parms = NULL_TREE;
1287 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1288 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1290 VEC(tree,gc) *typenames = NULL;
1292 if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1294 /* A lambda's signature is essentially its "type", so defer. */
1295 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t)));
1296 dump_type (DECL_CONTEXT (t), flags);
1300 flags &= ~TFF_UNQUALIFIED_NAME;
1301 if (TREE_CODE (t) == TEMPLATE_DECL)
1302 t = DECL_TEMPLATE_RESULT (t);
1304 /* Save the exceptions, in case t is a specialization and we are
1305 emitting an error about incompatible specifications. */
1306 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1308 /* Pretty print template instantiations only. */
1309 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1310 && flag_pretty_templates)
1314 template_args = DECL_TI_ARGS (t);
1315 tmpl = most_general_template (t);
1316 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1318 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1320 typenames = find_typenames (t);
1324 fntype = TREE_TYPE (t);
1325 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1327 if (DECL_CLASS_SCOPE_P (t))
1328 cname = DECL_CONTEXT (t);
1329 /* This is for partially instantiated template methods. */
1330 else if (TREE_CODE (fntype) == METHOD_TYPE)
1331 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1333 if (flags & TFF_DECL_SPECIFIERS)
1335 if (DECL_STATIC_FUNCTION_P (t))
1336 pp_cxx_ws_string (cxx_pp, "static");
1337 else if (DECL_VIRTUAL_P (t))
1338 pp_cxx_ws_string (cxx_pp, "virtual");
1340 if (DECL_DECLARED_CONSTEXPR_P (STRIP_TEMPLATE (t)))
1341 pp_cxx_ws_string (cxx_pp, "constexpr");
1344 /* Print the return type? */
1346 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1347 && !DECL_DESTRUCTOR_P (t);
1349 dump_type_prefix (TREE_TYPE (fntype), flags);
1351 /* Print the function name. */
1352 if (!do_outer_scope)
1356 dump_type (cname, flags);
1357 pp_cxx_colon_colon (cxx_pp);
1360 dump_scope (CP_DECL_CONTEXT (t), flags);
1362 dump_function_name (t, flags);
1364 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1366 dump_parameters (parmtypes, flags);
1368 if (TREE_CODE (fntype) == METHOD_TYPE)
1370 pp_base (cxx_pp)->padding = pp_before;
1371 pp_cxx_cv_qualifier_seq (cxx_pp, class_of_this_parm (fntype));
1374 if (flags & TFF_EXCEPTION_SPECIFICATION)
1376 pp_base (cxx_pp)->padding = pp_before;
1377 dump_exception_spec (exceptions, flags);
1381 dump_type_suffix (TREE_TYPE (fntype), flags);
1383 /* If T is a template instantiation, dump the parameter binding. */
1384 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1386 pp_cxx_whitespace (cxx_pp);
1387 pp_cxx_left_bracket (cxx_pp);
1388 pp_cxx_ws_string (cxx_pp, M_("with"));
1389 pp_cxx_whitespace (cxx_pp);
1390 dump_template_bindings (template_parms, template_args, typenames);
1391 pp_cxx_right_bracket (cxx_pp);
1394 else if (template_args)
1396 bool need_comma = false;
1398 pp_cxx_begin_template_argument_list (cxx_pp);
1399 template_args = INNERMOST_TEMPLATE_ARGS (template_args);
1400 for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
1402 tree arg = TREE_VEC_ELT (template_args, i);
1404 pp_separate_with_comma (cxx_pp);
1405 if (ARGUMENT_PACK_P (arg))
1406 pp_cxx_left_brace (cxx_pp);
1407 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
1408 if (ARGUMENT_PACK_P (arg))
1409 pp_cxx_right_brace (cxx_pp);
1412 pp_cxx_end_template_argument_list (cxx_pp);
1416 /* Print a parameter list. If this is for a member function, the
1417 member object ptr (and any other hidden args) should have
1418 already been removed. */
1421 dump_parameters (tree parmtypes, int flags)
1424 flags &= ~TFF_SCOPE;
1425 pp_cxx_left_paren (cxx_pp);
1427 for (first = 1; parmtypes != void_list_node;
1428 parmtypes = TREE_CHAIN (parmtypes))
1431 pp_separate_with_comma (cxx_pp);
1435 pp_cxx_ws_string (cxx_pp, "...");
1439 dump_type (TREE_VALUE (parmtypes), flags);
1441 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1443 pp_cxx_whitespace (cxx_pp);
1445 pp_cxx_whitespace (cxx_pp);
1446 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1450 pp_cxx_right_paren (cxx_pp);
1453 /* Print an exception specification. T is the exception specification. */
1456 dump_exception_spec (tree t, int flags)
1458 if (t && TREE_PURPOSE (t))
1460 pp_cxx_ws_string (cxx_pp, "noexcept");
1461 pp_cxx_whitespace (cxx_pp);
1462 pp_cxx_left_paren (cxx_pp);
1463 if (DEFERRED_NOEXCEPT_SPEC_P (t))
1464 pp_cxx_ws_string (cxx_pp, "<uninstantiated>");
1466 dump_expr (TREE_PURPOSE (t), flags);
1467 pp_cxx_right_paren (cxx_pp);
1471 pp_cxx_ws_string (cxx_pp, "throw");
1472 pp_cxx_whitespace (cxx_pp);
1473 pp_cxx_left_paren (cxx_pp);
1474 if (TREE_VALUE (t) != NULL_TREE)
1477 dump_type (TREE_VALUE (t), flags);
1481 pp_separate_with_comma (cxx_pp);
1483 pp_cxx_right_paren (cxx_pp);
1487 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1488 and destructors properly. */
1491 dump_function_name (tree t, int flags)
1493 tree name = DECL_NAME (t);
1495 /* We can get here with a decl that was synthesized by language-
1496 independent machinery (e.g. coverage.c) in which case it won't
1497 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1498 will crash. In this case it is safe just to print out the
1500 if (!DECL_LANG_SPECIFIC (t))
1502 pp_cxx_tree_identifier (cxx_pp, name);
1506 if (TREE_CODE (t) == TEMPLATE_DECL)
1507 t = DECL_TEMPLATE_RESULT (t);
1509 /* Don't let the user see __comp_ctor et al. */
1510 if (DECL_CONSTRUCTOR_P (t)
1511 || DECL_DESTRUCTOR_P (t))
1513 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1514 name = get_identifier ("<lambda>");
1516 name = constructor_name (DECL_CONTEXT (t));
1519 if (DECL_DESTRUCTOR_P (t))
1521 pp_cxx_complement (cxx_pp);
1522 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1524 else if (DECL_CONV_FN_P (t))
1526 /* This cannot use the hack that the operator's return
1527 type is stashed off of its name because it may be
1528 used for error reporting. In the case of conflicting
1529 declarations, both will have the same name, yet
1530 the types will be different, hence the TREE_TYPE field
1531 of the first name will be clobbered by the second. */
1532 pp_cxx_ws_string (cxx_pp, "operator");
1533 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1535 else if (name && IDENTIFIER_OPNAME_P (name))
1536 pp_cxx_tree_identifier (cxx_pp, name);
1538 dump_decl (name, flags);
1540 if (DECL_TEMPLATE_INFO (t)
1541 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1542 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1543 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1544 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1547 /* Dump the template parameters from the template info INFO under control of
1548 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1549 specialization (partial or complete). For partial specializations we show
1550 the specialized parameter values. For a primary template we show no
1554 dump_template_parms (tree info, int primary, int flags)
1556 tree args = info ? TI_ARGS (info) : NULL_TREE;
1558 if (primary && flags & TFF_TEMPLATE_NAME)
1560 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1561 pp_cxx_begin_template_argument_list (cxx_pp);
1563 /* Be careful only to print things when we have them, so as not
1564 to crash producing error messages. */
1565 if (args && !primary)
1568 len = get_non_default_template_args_count (args, flags);
1570 args = INNERMOST_TEMPLATE_ARGS (args);
1571 for (ix = 0; ix != len; ix++)
1573 tree arg = TREE_VEC_ELT (args, ix);
1575 /* Only print a comma if we know there is an argument coming. In
1576 the case of an empty template argument pack, no actual
1577 argument will be printed. */
1579 && (!ARGUMENT_PACK_P (arg)
1580 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1581 pp_separate_with_comma (cxx_pp);
1584 pp_string (cxx_pp, M_("<template parameter error>"));
1586 dump_template_argument (arg, flags);
1591 tree tpl = TI_TEMPLATE (info);
1592 tree parms = DECL_TEMPLATE_PARMS (tpl);
1595 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1596 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1598 for (ix = 0; ix != len; ix++)
1602 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1604 pp_string (cxx_pp, M_("<template parameter error>"));
1608 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1611 pp_separate_with_comma (cxx_pp);
1613 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1616 pp_cxx_end_template_argument_list (cxx_pp);
1619 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1620 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1623 dump_call_expr_args (tree t, int flags, bool skipfirst)
1626 call_expr_arg_iterator iter;
1628 pp_cxx_left_paren (cxx_pp);
1629 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1635 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1636 if (more_call_expr_args_p (&iter))
1637 pp_separate_with_comma (cxx_pp);
1640 pp_cxx_right_paren (cxx_pp);
1643 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1644 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1648 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1651 aggr_init_expr_arg_iterator iter;
1653 pp_cxx_left_paren (cxx_pp);
1654 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1660 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1661 if (more_aggr_init_expr_args_p (&iter))
1662 pp_separate_with_comma (cxx_pp);
1665 pp_cxx_right_paren (cxx_pp);
1668 /* Print out a list of initializers (subr of dump_expr). */
1671 dump_expr_list (tree l, int flags)
1675 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1678 pp_separate_with_comma (cxx_pp);
1682 /* Print out a vector of initializers (subr of dump_expr). */
1685 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1687 unsigned HOST_WIDE_INT idx;
1690 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1692 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1693 if (idx != VEC_length (constructor_elt, v) - 1)
1694 pp_separate_with_comma (cxx_pp);
1699 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1700 function. Resolve it to a close relative -- in the sense of static
1701 type -- variant being overridden. That is close to what was written in
1702 the source code. Subroutine of dump_expr. */
1705 resolve_virtual_fun_from_obj_type_ref (tree ref)
1707 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1708 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1709 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1712 fun = TREE_CHAIN (fun);
1713 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1714 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1720 /* Print out an expression E under control of FLAGS. */
1723 dump_expr (tree t, int flags)
1728 if (STATEMENT_CLASS_P (t))
1730 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1734 switch (TREE_CODE (t))
1742 case NAMESPACE_DECL:
1746 case IDENTIFIER_NODE:
1747 dump_decl (t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
1748 |TFF_TEMPLATE_HEADER))
1749 | TFF_NO_FUNCTION_ARGUMENTS));
1756 pp_constant (cxx_pp, t);
1760 /* While waiting for caret diagnostics, avoid printing
1761 __cxa_allocate_exception, __cxa_throw, and the like. */
1762 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1766 pp_ampersand (cxx_pp);
1767 dump_type (PTRMEM_CST_CLASS (t), flags);
1768 pp_cxx_colon_colon (cxx_pp);
1769 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1773 pp_cxx_left_paren (cxx_pp);
1774 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1775 pp_separate_with_comma (cxx_pp);
1776 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1777 pp_cxx_right_paren (cxx_pp);
1781 pp_cxx_left_paren (cxx_pp);
1782 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1783 pp_string (cxx_pp, " ? ");
1784 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1785 pp_string (cxx_pp, " : ");
1786 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1787 pp_cxx_right_paren (cxx_pp);
1791 if (TREE_HAS_CONSTRUCTOR (t))
1793 pp_cxx_ws_string (cxx_pp, "new");
1794 pp_cxx_whitespace (cxx_pp);
1795 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1798 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1801 case AGGR_INIT_EXPR:
1803 tree fn = NULL_TREE;
1805 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1806 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1808 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1810 if (DECL_CONSTRUCTOR_P (fn))
1811 dump_type (DECL_CONTEXT (fn), flags);
1816 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1818 dump_aggr_init_expr_args (t, flags, true);
1823 tree fn = CALL_EXPR_FN (t);
1824 bool skipfirst = false;
1826 if (TREE_CODE (fn) == ADDR_EXPR)
1827 fn = TREE_OPERAND (fn, 0);
1829 /* Nobody is interested in seeing the guts of vcalls. */
1830 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1831 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1833 if (TREE_TYPE (fn) != NULL_TREE
1834 && NEXT_CODE (fn) == METHOD_TYPE
1835 && call_expr_nargs (t))
1837 tree ob = CALL_EXPR_ARG (t, 0);
1838 if (TREE_CODE (ob) == ADDR_EXPR)
1840 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1841 pp_cxx_dot (cxx_pp);
1843 else if (TREE_CODE (ob) != PARM_DECL
1844 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1846 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1847 pp_cxx_arrow (cxx_pp);
1851 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1852 dump_call_expr_args (t, flags, skipfirst);
1857 /* Note that this only works for G++ target exprs. If somebody
1858 builds a general TARGET_EXPR, there's no way to represent that
1859 it initializes anything other that the parameter slot for the
1860 default argument. Note we may have cleared out the first
1861 operand in expand_expr, so don't go killing ourselves. */
1862 if (TREE_OPERAND (t, 1))
1863 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1866 case POINTER_PLUS_EXPR:
1867 dump_binary_op ("+", t, flags);
1872 dump_binary_op (assignment_operator_name_info[(int)NOP_EXPR].name,
1879 case TRUNC_DIV_EXPR:
1880 case TRUNC_MOD_EXPR:
1888 case TRUTH_ANDIF_EXPR:
1889 case TRUTH_ORIF_EXPR:
1896 case EXACT_DIV_EXPR:
1897 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1901 case FLOOR_DIV_EXPR:
1902 case ROUND_DIV_EXPR:
1904 dump_binary_op ("/", t, flags);
1908 case FLOOR_MOD_EXPR:
1909 case ROUND_MOD_EXPR:
1910 dump_binary_op ("%", t, flags);
1915 tree ob = TREE_OPERAND (t, 0);
1916 if (TREE_CODE (ob) == INDIRECT_REF)
1918 ob = TREE_OPERAND (ob, 0);
1919 if (TREE_CODE (ob) != PARM_DECL
1921 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1923 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1924 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
1925 pp_cxx_dot (cxx_pp);
1927 pp_cxx_arrow (cxx_pp);
1932 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1933 pp_cxx_dot (cxx_pp);
1935 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1940 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1941 pp_cxx_left_bracket (cxx_pp);
1942 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1943 pp_cxx_right_bracket (cxx_pp);
1946 case UNARY_PLUS_EXPR:
1947 dump_unary_op ("+", t, flags);
1951 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1952 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1953 /* An ADDR_EXPR can have reference type. In that case, we
1954 shouldn't print the `&' doing so indicates to the user
1955 that the expression has pointer type. */
1957 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1958 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1959 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1960 dump_unary_op ("&&", t, flags);
1962 dump_unary_op ("&", t, flags);
1966 if (TREE_HAS_CONSTRUCTOR (t))
1968 t = TREE_OPERAND (t, 0);
1969 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1970 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1971 dump_call_expr_args (t, flags, true);
1975 if (TREE_OPERAND (t,0) != NULL_TREE
1976 && TREE_TYPE (TREE_OPERAND (t, 0))
1977 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1978 dump_expr (TREE_OPERAND (t, 0), flags);
1980 dump_unary_op ("*", t, flags);
1985 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
1986 && integer_zerop (TREE_OPERAND (t, 1)))
1987 dump_expr (TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
1990 pp_cxx_star (cxx_pp);
1991 if (!integer_zerop (TREE_OPERAND (t, 1)))
1993 pp_cxx_left_paren (cxx_pp);
1994 if (!integer_onep (TYPE_SIZE_UNIT
1995 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
1997 pp_cxx_left_paren (cxx_pp);
1998 dump_type (ptr_type_node, flags);
1999 pp_cxx_right_paren (cxx_pp);
2002 dump_expr (TREE_OPERAND (t, 0), flags);
2003 if (!integer_zerop (TREE_OPERAND (t, 1)))
2005 pp_cxx_ws_string (cxx_pp, "+");
2006 dump_expr (fold_convert (ssizetype, TREE_OPERAND (t, 1)), flags);
2007 pp_cxx_right_paren (cxx_pp);
2014 case TRUTH_NOT_EXPR:
2015 case PREDECREMENT_EXPR:
2016 case PREINCREMENT_EXPR:
2017 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
2020 case POSTDECREMENT_EXPR:
2021 case POSTINCREMENT_EXPR:
2022 pp_cxx_left_paren (cxx_pp);
2023 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2024 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
2025 pp_cxx_right_paren (cxx_pp);
2028 case NON_LVALUE_EXPR:
2029 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2030 should be another level of INDIRECT_REF so that I don't have to do
2032 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2034 tree next = TREE_TYPE (TREE_TYPE (t));
2036 while (TREE_CODE (next) == POINTER_TYPE)
2037 next = TREE_TYPE (next);
2039 if (TREE_CODE (next) == FUNCTION_TYPE)
2041 if (flags & TFF_EXPR_IN_PARENS)
2042 pp_cxx_left_paren (cxx_pp);
2043 pp_cxx_star (cxx_pp);
2044 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2045 if (flags & TFF_EXPR_IN_PARENS)
2046 pp_cxx_right_paren (cxx_pp);
2049 /* Else fall through. */
2051 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2055 case IMPLICIT_CONV_EXPR:
2056 case VIEW_CONVERT_EXPR:
2058 tree op = TREE_OPERAND (t, 0);
2059 tree ttype = TREE_TYPE (t);
2060 tree optype = TREE_TYPE (op);
2062 if (TREE_CODE (ttype) != TREE_CODE (optype)
2063 && POINTER_TYPE_P (ttype)
2064 && POINTER_TYPE_P (optype)
2065 && same_type_p (TREE_TYPE (optype),
2068 if (TREE_CODE (ttype) == REFERENCE_TYPE)
2069 dump_unary_op ("*", t, flags);
2071 dump_unary_op ("&", t, flags);
2073 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2075 /* It is a cast, but we cannot tell whether it is a
2076 reinterpret or static cast. Use the C style notation. */
2077 if (flags & TFF_EXPR_IN_PARENS)
2078 pp_cxx_left_paren (cxx_pp);
2079 pp_cxx_left_paren (cxx_pp);
2080 dump_type (TREE_TYPE (t), flags);
2081 pp_cxx_right_paren (cxx_pp);
2082 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
2083 if (flags & TFF_EXPR_IN_PARENS)
2084 pp_cxx_right_paren (cxx_pp);
2087 dump_expr (op, flags);
2092 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2094 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2096 if (integer_zerop (idx))
2098 /* A NULL pointer-to-member constant. */
2099 pp_cxx_left_paren (cxx_pp);
2100 pp_cxx_left_paren (cxx_pp);
2101 dump_type (TREE_TYPE (t), flags);
2102 pp_cxx_right_paren (cxx_pp);
2103 pp_character (cxx_pp, '0');
2104 pp_cxx_right_paren (cxx_pp);
2107 else if (host_integerp (idx, 0))
2110 unsigned HOST_WIDE_INT n;
2112 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2113 t = TYPE_METHOD_BASETYPE (t);
2114 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2116 n = tree_low_cst (idx, 0);
2118 /* Map vtable index back one, to allow for the null pointer to
2122 while (n > 0 && virtuals)
2125 virtuals = TREE_CHAIN (virtuals);
2129 dump_expr (BV_FN (virtuals),
2130 flags | TFF_EXPR_IN_PARENS);
2135 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2137 dump_type (TREE_TYPE (t), 0);
2138 pp_cxx_left_paren (cxx_pp);
2139 pp_cxx_right_paren (cxx_pp);
2143 pp_cxx_left_brace (cxx_pp);
2144 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
2145 pp_cxx_right_brace (cxx_pp);
2152 tree ob = TREE_OPERAND (t, 0);
2153 if (is_dummy_object (ob))
2155 t = TREE_OPERAND (t, 1);
2156 if (TREE_CODE (t) == FUNCTION_DECL)
2158 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
2159 else if (BASELINK_P (t))
2160 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2161 flags | TFF_EXPR_IN_PARENS);
2163 dump_decl (t, flags);
2167 if (TREE_CODE (ob) == INDIRECT_REF)
2169 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2170 pp_cxx_arrow (cxx_pp);
2171 pp_cxx_star (cxx_pp);
2175 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2176 pp_cxx_dot (cxx_pp);
2177 pp_cxx_star (cxx_pp);
2179 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2184 case TEMPLATE_PARM_INDEX:
2185 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2189 if (TREE_OPERAND (t, 0) == NULL_TREE
2190 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2192 dump_type (TREE_TYPE (t), flags);
2193 pp_cxx_left_paren (cxx_pp);
2194 dump_expr_list (TREE_OPERAND (t, 0), flags);
2195 pp_cxx_right_paren (cxx_pp);
2199 pp_cxx_left_paren (cxx_pp);
2200 dump_type (TREE_TYPE (t), flags);
2201 pp_cxx_right_paren (cxx_pp);
2202 pp_cxx_left_paren (cxx_pp);
2203 dump_expr_list (TREE_OPERAND (t, 0), flags);
2204 pp_cxx_right_paren (cxx_pp);
2208 case STATIC_CAST_EXPR:
2209 pp_cxx_ws_string (cxx_pp, "static_cast");
2211 case REINTERPRET_CAST_EXPR:
2212 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2214 case CONST_CAST_EXPR:
2215 pp_cxx_ws_string (cxx_pp, "const_cast");
2217 case DYNAMIC_CAST_EXPR:
2218 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2220 pp_cxx_begin_template_argument_list (cxx_pp);
2221 dump_type (TREE_TYPE (t), flags);
2222 pp_cxx_end_template_argument_list (cxx_pp);
2223 pp_cxx_left_paren (cxx_pp);
2224 dump_expr (TREE_OPERAND (t, 0), flags);
2225 pp_cxx_right_paren (cxx_pp);
2229 dump_expr (TREE_OPERAND (t, 0), flags);
2230 pp_cxx_arrow (cxx_pp);
2235 if (TREE_CODE (t) == SIZEOF_EXPR)
2236 pp_cxx_ws_string (cxx_pp, "sizeof");
2239 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2240 pp_cxx_ws_string (cxx_pp, "__alignof__");
2242 pp_cxx_whitespace (cxx_pp);
2243 pp_cxx_left_paren (cxx_pp);
2244 if (TYPE_P (TREE_OPERAND (t, 0)))
2245 dump_type (TREE_OPERAND (t, 0), flags);
2247 dump_expr (TREE_OPERAND (t, 0), flags);
2248 pp_cxx_right_paren (cxx_pp);
2251 case AT_ENCODE_EXPR:
2252 pp_cxx_ws_string (cxx_pp, "@encode");
2253 pp_cxx_whitespace (cxx_pp);
2254 pp_cxx_left_paren (cxx_pp);
2255 dump_type (TREE_OPERAND (t, 0), flags);
2256 pp_cxx_right_paren (cxx_pp);
2260 pp_cxx_ws_string (cxx_pp, "noexcept");
2261 pp_cxx_whitespace (cxx_pp);
2262 pp_cxx_left_paren (cxx_pp);
2263 dump_expr (TREE_OPERAND (t, 0), flags);
2264 pp_cxx_right_paren (cxx_pp);
2269 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2270 pp_cxx_whitespace (cxx_pp);
2271 dump_expr (TREE_OPERAND (t, 0), flags);
2275 pp_string (cxx_pp, M_("<unparsed>"));
2278 case TRY_CATCH_EXPR:
2279 case WITH_CLEANUP_EXPR:
2280 case CLEANUP_POINT_EXPR:
2281 dump_expr (TREE_OPERAND (t, 0), flags);
2284 case PSEUDO_DTOR_EXPR:
2285 dump_expr (TREE_OPERAND (t, 2), flags);
2286 pp_cxx_dot (cxx_pp);
2287 dump_type (TREE_OPERAND (t, 0), flags);
2288 pp_cxx_colon_colon (cxx_pp);
2289 pp_cxx_complement (cxx_pp);
2290 dump_type (TREE_OPERAND (t, 1), flags);
2293 case TEMPLATE_ID_EXPR:
2294 dump_decl (t, flags);
2300 case STATEMENT_LIST:
2301 /* We don't yet have a way of dumping statements in a
2302 human-readable format. */
2303 pp_string (cxx_pp, "({...})");
2307 pp_string (cxx_pp, "while (1) { ");
2308 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2309 pp_cxx_right_brace (cxx_pp);
2313 pp_string (cxx_pp, "if (");
2314 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2315 pp_string (cxx_pp, ") break; ");
2319 dump_expr (BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
2322 case EMPTY_CLASS_EXPR:
2323 dump_type (TREE_TYPE (t), flags);
2324 pp_cxx_left_paren (cxx_pp);
2325 pp_cxx_right_paren (cxx_pp);
2328 case NON_DEPENDENT_EXPR:
2329 dump_expr (TREE_OPERAND (t, 0), flags);
2332 case ARGUMENT_PACK_SELECT:
2333 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2345 pp_type_specifier_seq (cxx_pp, t);
2349 /* We get here when we want to print a dependent type as an
2350 id-expression, without any disambiguator decoration. */
2351 pp_id_expression (cxx_pp, t);
2354 case TEMPLATE_TYPE_PARM:
2355 case BOUND_TEMPLATE_TEMPLATE_PARM:
2356 dump_type (t, flags);
2360 pp_cxx_trait_expression (cxx_pp, t);
2364 pp_cxx_va_arg_expression (cxx_pp, t);
2368 pp_cxx_offsetof_expression (cxx_pp, t);
2372 dump_decl (t, flags);
2375 case EXPR_PACK_EXPANSION:
2382 case VEC_DELETE_EXPR:
2388 case UNORDERED_EXPR:
2398 case FIX_TRUNC_EXPR:
2400 pp_expression (cxx_pp, t);
2403 case TRUTH_AND_EXPR:
2405 case TRUTH_XOR_EXPR:
2406 if (flags & TFF_EXPR_IN_PARENS)
2407 pp_cxx_left_paren (cxx_pp);
2408 pp_expression (cxx_pp, t);
2409 if (flags & TFF_EXPR_IN_PARENS)
2410 pp_cxx_right_paren (cxx_pp);
2414 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2417 /* This list is incomplete, but should suffice for now.
2418 It is very important that `sorry' does not call
2419 `report_error_function'. That could cause an infinite loop. */
2421 pp_unsupported_tree (cxx_pp, t);
2422 /* fall through to ERROR_MARK... */
2424 pp_string (cxx_pp, M_("<expression error>"));
2430 dump_binary_op (const char *opstring, tree t, int flags)
2432 pp_cxx_left_paren (cxx_pp);
2433 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2434 pp_cxx_whitespace (cxx_pp);
2436 pp_cxx_ws_string (cxx_pp, opstring);
2438 pp_string (cxx_pp, M_("<unknown operator>"));
2439 pp_cxx_whitespace (cxx_pp);
2440 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2441 pp_cxx_right_paren (cxx_pp);
2445 dump_unary_op (const char *opstring, tree t, int flags)
2447 if (flags & TFF_EXPR_IN_PARENS)
2448 pp_cxx_left_paren (cxx_pp);
2449 pp_cxx_ws_string (cxx_pp, opstring);
2450 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2451 if (flags & TFF_EXPR_IN_PARENS)
2452 pp_cxx_right_paren (cxx_pp);
2456 reinit_cxx_pp (void)
2458 pp_clear_output_area (cxx_pp);
2459 pp_base (cxx_pp)->padding = pp_none;
2460 pp_indentation (cxx_pp) = 0;
2461 pp_needs_newline (cxx_pp) = false;
2462 cxx_pp->enclosing_scope = current_function_decl;
2466 /* Exported interface to stringifying types, exprs and decls under TFF_*
2470 type_as_string (tree typ, int flags)
2473 pp_translate_identifiers (cxx_pp) = false;
2474 dump_type (typ, flags);
2475 return pp_formatted_text (cxx_pp);
2479 type_as_string_translate (tree typ, int flags)
2482 dump_type (typ, flags);
2483 return pp_formatted_text (cxx_pp);
2487 expr_as_string (tree decl, int flags)
2490 pp_translate_identifiers (cxx_pp) = false;
2491 dump_expr (decl, flags);
2492 return pp_formatted_text (cxx_pp);
2496 decl_as_string (tree decl, int flags)
2499 pp_translate_identifiers (cxx_pp) = false;
2500 dump_decl (decl, flags);
2501 return pp_formatted_text (cxx_pp);
2505 decl_as_string_translate (tree decl, int flags)
2508 dump_decl (decl, flags);
2509 return pp_formatted_text (cxx_pp);
2512 /* Generate the three forms of printable names for cxx_printable_name. */
2515 lang_decl_name (tree decl, int v, bool translate)
2519 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2520 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2523 pp_translate_identifiers (cxx_pp) = translate;
2525 && (DECL_CLASS_SCOPE_P (decl)
2526 || (DECL_NAMESPACE_SCOPE_P (decl)
2527 && CP_DECL_CONTEXT (decl) != global_namespace)))
2529 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2530 pp_cxx_colon_colon (cxx_pp);
2533 if (TREE_CODE (decl) == FUNCTION_DECL)
2534 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2536 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2538 return pp_formatted_text (cxx_pp);
2541 /* Return the location of a tree passed to %+ formats. */
2544 location_of (tree t)
2546 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2547 t = DECL_CONTEXT (t);
2548 else if (TYPE_P (t))
2550 t = TYPE_MAIN_DECL (t);
2552 return input_location;
2554 else if (TREE_CODE (t) == OVERLOAD)
2555 t = OVL_FUNCTION (t);
2558 return DECL_SOURCE_LOCATION (t);
2559 return EXPR_LOC_OR_HERE (t);
2562 /* Now the interfaces from error et al to dump_type et al. Each takes an
2563 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2567 decl_to_string (tree decl, int verbose)
2571 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2572 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2573 flags = TFF_CLASS_KEY_OR_ENUM;
2575 flags |= TFF_DECL_SPECIFIERS;
2576 else if (TREE_CODE (decl) == FUNCTION_DECL)
2577 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2578 flags |= TFF_TEMPLATE_HEADER;
2581 dump_decl (decl, flags);
2582 return pp_formatted_text (cxx_pp);
2586 expr_to_string (tree decl)
2589 dump_expr (decl, 0);
2590 return pp_formatted_text (cxx_pp);
2594 fndecl_to_string (tree fndecl, int verbose)
2598 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2599 | TFF_TEMPLATE_HEADER;
2601 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2603 dump_decl (fndecl, flags);
2604 return pp_formatted_text (cxx_pp);
2609 code_to_string (enum tree_code c)
2611 return tree_code_name [c];
2615 language_to_string (enum languages c)
2622 case lang_cplusplus:
2634 /* Return the proper printed version of a parameter to a C++ function. */
2637 parm_to_string (int p)
2641 pp_string (cxx_pp, "'this'");
2643 pp_decimal_int (cxx_pp, p + 1);
2644 return pp_formatted_text (cxx_pp);
2648 op_to_string (enum tree_code p)
2650 tree id = operator_name_info[(int) p].identifier;
2651 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2655 type_to_string (tree typ, int verbose)
2659 flags |= TFF_CLASS_KEY_OR_ENUM;
2660 flags |= TFF_TEMPLATE_HEADER;
2663 dump_type (typ, flags);
2664 /* If we're printing a type that involves typedefs, also print the
2665 stripped version. But sometimes the stripped version looks
2666 exactly the same, so we don't want it after all. To avoid printing
2667 it in that case, we play ugly obstack games. */
2668 if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
2669 && !uses_template_parms (typ))
2671 int aka_start; char *p;
2672 struct obstack *ob = pp_base (cxx_pp)->buffer->obstack;
2673 /* Remember the end of the initial dump. */
2674 int len = obstack_object_size (ob);
2675 tree aka = strip_typedefs (typ);
2676 pp_string (cxx_pp, " {aka");
2677 pp_cxx_whitespace (cxx_pp);
2678 /* And remember the start of the aka dump. */
2679 aka_start = obstack_object_size (ob);
2680 dump_type (aka, flags);
2681 pp_character (cxx_pp, '}');
2682 p = (char*)obstack_base (ob);
2683 /* If they are identical, cut off the aka with a NUL. */
2684 if (memcmp (p, p+aka_start, len) == 0)
2687 return pp_formatted_text (cxx_pp);
2691 assop_to_string (enum tree_code p)
2693 tree id = assignment_operator_name_info[(int) p].identifier;
2694 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2698 args_to_string (tree p, int verbose)
2702 flags |= TFF_CLASS_KEY_OR_ENUM;
2707 if (TYPE_P (TREE_VALUE (p)))
2708 return type_as_string_translate (p, flags);
2711 for (; p; p = TREE_CHAIN (p))
2713 if (TREE_VALUE (p) == null_node)
2714 pp_cxx_ws_string (cxx_pp, "NULL");
2716 dump_type (error_type (TREE_VALUE (p)), flags);
2718 pp_separate_with_comma (cxx_pp);
2720 return pp_formatted_text (cxx_pp);
2723 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
2724 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
2728 subst_to_string (tree p)
2730 tree decl = TREE_PURPOSE (p);
2731 tree targs = TREE_VALUE (p);
2732 tree tparms = DECL_TEMPLATE_PARMS (decl);
2733 int flags = TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER;
2739 dump_template_decl (TREE_PURPOSE (p), flags);
2740 pp_cxx_whitespace (cxx_pp);
2741 pp_cxx_left_bracket (cxx_pp);
2742 pp_cxx_ws_string (cxx_pp, M_("with"));
2743 pp_cxx_whitespace (cxx_pp);
2744 dump_template_bindings (tparms, targs, NULL);
2745 pp_cxx_right_bracket (cxx_pp);
2746 return pp_formatted_text (cxx_pp);
2750 cv_to_string (tree p, int v)
2753 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2754 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2755 return pp_formatted_text (cxx_pp);
2758 /* Langhook for print_error_function. */
2760 cxx_print_error_function (diagnostic_context *context, const char *file,
2761 diagnostic_info *diagnostic)
2763 lhd_print_error_function (context, file, diagnostic);
2764 pp_base_set_prefix (context->printer, file);
2765 maybe_print_instantiation_context (context);
2769 cp_diagnostic_starter (diagnostic_context *context,
2770 diagnostic_info *diagnostic)
2772 diagnostic_report_current_module (context);
2773 cp_print_error_function (context, diagnostic);
2774 maybe_print_instantiation_context (context);
2775 maybe_print_constexpr_context (context);
2776 pp_base_set_prefix (context->printer, diagnostic_build_prefix (context,
2781 cp_diagnostic_finalizer (diagnostic_context *context,
2782 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2784 pp_base_destroy_prefix (context->printer);
2787 /* Print current function onto BUFFER, in the process of reporting
2788 a diagnostic message. Called from cp_diagnostic_starter. */
2790 cp_print_error_function (diagnostic_context *context,
2791 diagnostic_info *diagnostic)
2793 /* If we are in an instantiation context, current_function_decl is likely
2794 to be wrong, so just rely on print_instantiation_full_context. */
2795 if (current_instantiation ())
2797 if (diagnostic_last_function_changed (context, diagnostic))
2799 const char *old_prefix = context->printer->prefix;
2800 const char *file = LOCATION_FILE (diagnostic->location);
2801 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
2802 char *new_prefix = (file && abstract_origin == NULL)
2803 ? file_name_as_prefix (file) : NULL;
2805 pp_base_set_prefix (context->printer, new_prefix);
2807 if (current_function_decl == NULL)
2808 pp_base_string (context->printer, _("At global scope:"));
2813 if (abstract_origin)
2815 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2816 while (TREE_CODE (ao) == BLOCK
2817 && BLOCK_ABSTRACT_ORIGIN (ao)
2818 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2819 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2820 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2824 fndecl = current_function_decl;
2826 pp_printf (context->printer, function_category (fndecl),
2827 cxx_printable_name_translate (fndecl, 2));
2829 while (abstract_origin)
2832 tree block = abstract_origin;
2834 locus = &BLOCK_SOURCE_LOCATION (block);
2836 block = BLOCK_SUPERCONTEXT (block);
2837 while (block && TREE_CODE (block) == BLOCK
2838 && BLOCK_ABSTRACT_ORIGIN (block))
2840 ao = BLOCK_ABSTRACT_ORIGIN (block);
2842 while (TREE_CODE (ao) == BLOCK
2843 && BLOCK_ABSTRACT_ORIGIN (ao)
2844 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2845 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2847 if (TREE_CODE (ao) == FUNCTION_DECL)
2852 else if (TREE_CODE (ao) != BLOCK)
2855 block = BLOCK_SUPERCONTEXT (block);
2858 abstract_origin = block;
2861 while (block && TREE_CODE (block) == BLOCK)
2862 block = BLOCK_SUPERCONTEXT (block);
2864 if (block && TREE_CODE (block) == FUNCTION_DECL)
2866 abstract_origin = NULL;
2870 expanded_location s = expand_location (*locus);
2871 pp_base_character (context->printer, ',');
2872 pp_base_newline (context->printer);
2875 if (context->show_column && s.column != 0)
2876 pp_printf (context->printer,
2877 _(" inlined from %qs at %s:%d:%d"),
2878 cxx_printable_name_translate (fndecl, 2),
2879 s.file, s.line, s.column);
2881 pp_printf (context->printer,
2882 _(" inlined from %qs at %s:%d"),
2883 cxx_printable_name_translate (fndecl, 2),
2888 pp_printf (context->printer, _(" inlined from %qs"),
2889 cxx_printable_name_translate (fndecl, 2));
2892 pp_base_character (context->printer, ':');
2894 pp_base_newline (context->printer);
2896 diagnostic_set_last_function (context, diagnostic);
2897 pp_base_destroy_prefix (context->printer);
2898 context->printer->prefix = old_prefix;
2902 /* Returns a description of FUNCTION using standard terminology. The
2903 result is a format string of the form "In CATEGORY %qs". */
2905 function_category (tree fn)
2907 /* We can get called from the middle-end for diagnostics of function
2908 clones. Make sure we have language specific information before
2909 dereferencing it. */
2910 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
2911 && DECL_FUNCTION_MEMBER_P (fn))
2913 if (DECL_STATIC_FUNCTION_P (fn))
2914 return _("In static member function %qs");
2915 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2916 return _("In copy constructor %qs");
2917 else if (DECL_CONSTRUCTOR_P (fn))
2918 return _("In constructor %qs");
2919 else if (DECL_DESTRUCTOR_P (fn))
2920 return _("In destructor %qs");
2921 else if (LAMBDA_FUNCTION_P (fn))
2922 return _("In lambda function");
2924 return _("In member function %qs");
2927 return _("In function %qs");
2930 /* Report the full context of a current template instantiation,
2933 print_instantiation_full_context (diagnostic_context *context)
2935 struct tinst_level *p = current_instantiation ();
2936 location_t location = input_location;
2940 pp_verbatim (context->printer,
2941 TREE_CODE (p->decl) == TREE_LIST
2942 ? _("%s: In substitution of %qS:\n")
2943 : _("%s: In instantiation of %q#D:\n"),
2944 LOCATION_FILE (location),
2947 location = p->locus;
2951 print_instantiation_partial_context (context, p, location);
2954 /* Helper function of print_instantiation_partial_context() that
2955 prints a single line of instantiation context. */
2958 print_instantiation_partial_context_line (diagnostic_context *context,
2959 const struct tinst_level *t,
2960 location_t loc, bool recursive_p)
2962 expanded_location xloc;
2963 xloc = expand_location (loc);
2965 if (context->show_column)
2966 pp_verbatim (context->printer, _("%s:%d:%d: "),
2967 xloc.file, xloc.line, xloc.column);
2969 pp_verbatim (context->printer, _("%s:%d: "),
2970 xloc.file, xloc.line);
2974 if (TREE_CODE (t->decl) == TREE_LIST)
2975 pp_verbatim (context->printer,
2977 ? _("recursively required by substitution of %qS\n")
2978 : _("required by substitution of %qS\n"),
2981 pp_verbatim (context->printer,
2983 ? _("recursively required from %q#D\n")
2984 : _("required from %q#D\n"),
2989 pp_verbatim (context->printer,
2991 ? _("recursively required from here")
2992 : _("required from here"));
2996 /* Same as print_instantiation_full_context but less verbose. */
2999 print_instantiation_partial_context (diagnostic_context *context,
3000 struct tinst_level *t0, location_t loc)
3002 struct tinst_level *t;
3005 location_t prev_loc = loc;
3007 for (t = t0; t != NULL; t = t->next)
3008 if (prev_loc != t->locus)
3010 prev_loc = t->locus;
3018 int skip = n_total - 10;
3019 for (n = 0; n < 5; n++)
3021 gcc_assert (t != NULL);
3022 if (loc != t->locus)
3023 print_instantiation_partial_context_line (context, t, loc,
3024 /*recursive_p=*/false);
3028 if (t != NULL && skip > 1)
3030 expanded_location xloc;
3031 xloc = expand_location (loc);
3032 if (context->show_column)
3033 pp_verbatim (context->printer,
3034 _("%s:%d:%d: [ skipping %d instantiation contexts ]\n"),
3035 xloc.file, xloc.line, xloc.column, skip);
3037 pp_verbatim (context->printer,
3038 _("%s:%d: [ skipping %d instantiation contexts ]\n"),
3039 xloc.file, xloc.line, skip);
3044 } while (t != NULL && --skip > 0);
3050 while (t->next != NULL && t->locus == t->next->locus)
3055 print_instantiation_partial_context_line (context, t, loc,
3060 print_instantiation_partial_context_line (context, NULL, loc,
3061 /*recursive_p=*/false);
3062 pp_base_newline (context->printer);
3065 /* Called from cp_thing to print the template context for an error. */
3067 maybe_print_instantiation_context (diagnostic_context *context)
3069 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3072 record_last_problematic_instantiation ();
3073 print_instantiation_full_context (context);
3076 /* Report the bare minimum context of a template instantiation. */
3078 print_instantiation_context (void)
3080 print_instantiation_partial_context
3081 (global_dc, current_instantiation (), input_location);
3082 diagnostic_flush_buffer (global_dc);
3085 /* Report what constexpr call(s) we're trying to expand, if any. */
3088 maybe_print_constexpr_context (diagnostic_context *context)
3090 VEC(tree,heap) *call_stack = cx_error_context ();
3094 FOR_EACH_VEC_ELT (tree, call_stack, ix, t)
3096 expanded_location xloc = expand_location (EXPR_LOCATION (t));
3097 const char *s = expr_as_string (t, 0);
3098 if (context->show_column)
3099 pp_verbatim (context->printer,
3100 _("%s:%d:%d: in constexpr expansion of %qs"),
3101 xloc.file, xloc.line, xloc.column, s);
3103 pp_verbatim (context->printer,
3104 _("%s:%d: in constexpr expansion of %qs"),
3105 xloc.file, xloc.line, s);
3106 pp_base_newline (context->printer);
3110 /* Called from output_format -- during diagnostic message processing --
3111 to handle C++ specific format specifier with the following meanings:
3112 %A function argument-list.
3116 %F function declaration.
3117 %L language as used in extern "lang".
3119 %P function parameter whose position is indicated by an integer.
3120 %Q assignment operator.
3124 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
3125 int precision, bool wide, bool set_locus, bool verbose)
3129 #define next_tree (t = va_arg (*text->args_ptr, tree))
3130 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3131 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3132 #define next_int va_arg (*text->args_ptr, int)
3134 if (precision != 0 || wide)
3137 if (text->locus == NULL)
3142 case 'A': result = args_to_string (next_tree, verbose); break;
3143 case 'C': result = code_to_string (next_tcode); break;
3146 tree temp = next_tree;
3148 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
3150 temp = DECL_DEBUG_EXPR (temp);
3153 result = expr_to_string (temp);
3157 result = decl_to_string (temp, verbose);
3160 case 'E': result = expr_to_string (next_tree); break;
3161 case 'F': result = fndecl_to_string (next_tree, verbose); break;
3162 case 'L': result = language_to_string (next_lang); break;
3163 case 'O': result = op_to_string (next_tcode); break;
3164 case 'P': result = parm_to_string (next_int); break;
3165 case 'Q': result = assop_to_string (next_tcode); break;
3166 case 'S': result = subst_to_string (next_tree); break;
3167 case 'T': result = type_to_string (next_tree, verbose); break;
3168 case 'V': result = cv_to_string (next_tree, verbose); break;
3171 percent_K_format (text);
3178 pp_base_string (pp, result);
3179 if (set_locus && t != NULL)
3180 *text->locus = location_of (t);
3188 /* Warn about the use of C++0x features when appropriate. */
3190 maybe_warn_cpp0x (cpp0x_warn_str str)
3192 if ((cxx_dialect == cxx98) && !in_system_header)
3193 /* We really want to suppress this warning in system headers,
3194 because libstdc++ uses variadic templates even when we aren't
3198 case CPP0X_INITIALIZER_LISTS:
3199 pedwarn (input_location, 0,
3200 "extended initializer lists "
3201 "only available with -std=c++0x or -std=gnu++0x");
3203 case CPP0X_EXPLICIT_CONVERSION:
3204 pedwarn (input_location, 0,
3205 "explicit conversion operators "
3206 "only available with -std=c++0x or -std=gnu++0x");
3208 case CPP0X_VARIADIC_TEMPLATES:
3209 pedwarn (input_location, 0,
3210 "variadic templates "
3211 "only available with -std=c++0x or -std=gnu++0x");
3213 case CPP0X_LAMBDA_EXPR:
3214 pedwarn (input_location, 0,
3215 "lambda expressions "
3216 "only available with -std=c++0x or -std=gnu++0x");
3219 pedwarn (input_location, 0,
3220 "C++0x auto only available with -std=c++0x or -std=gnu++0x");
3222 case CPP0X_SCOPED_ENUMS:
3223 pedwarn (input_location, 0,
3224 "scoped enums only available with -std=c++0x or -std=gnu++0x");
3226 case CPP0X_DEFAULTED_DELETED:
3227 pedwarn (input_location, 0,
3228 "defaulted and deleted functions "
3229 "only available with -std=c++0x or -std=gnu++0x");
3231 case CPP0X_INLINE_NAMESPACES:
3232 pedwarn (input_location, OPT_pedantic,
3233 "inline namespaces "
3234 "only available with -std=c++0x or -std=gnu++0x");
3236 case CPP0X_OVERRIDE_CONTROLS:
3237 pedwarn (input_location, 0,
3238 "override controls (override/final) "
3239 "only available with -std=c++0x or -std=gnu++0x");
3242 pedwarn (input_location, 0,
3243 "non-static data member initializers "
3244 "only available with -std=c++0x or -std=gnu++0x");
3251 /* Warn about the use of variadic templates when appropriate. */
3253 maybe_warn_variadic_templates (void)
3255 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3259 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3260 option OPT with text GMSGID. Use this function to report
3261 diagnostics for constructs that are invalid C++98, but valid
3264 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3266 diagnostic_info diagnostic;
3269 va_start (ap, gmsgid);
3270 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
3271 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3272 diagnostic.option_index = opt;
3274 return report_diagnostic (&diagnostic);
3277 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3278 we found when we tried to do the lookup. LOCATION is the location of
3279 the NAME identifier. */
3282 qualified_name_lookup_error (tree scope, tree name,
3283 tree decl, location_t location)
3285 if (scope == error_mark_node)
3286 ; /* We already complained. */
3287 else if (TYPE_P (scope))
3289 if (!COMPLETE_TYPE_P (scope))
3290 error_at (location, "incomplete type %qT used in nested name specifier",
3292 else if (TREE_CODE (decl) == TREE_LIST)
3294 error_at (location, "reference to %<%T::%D%> is ambiguous",
3296 print_candidates (decl);
3299 error_at (location, "%qD is not a member of %qT", name, scope);
3301 else if (scope != global_namespace)
3303 error_at (location, "%qD is not a member of %qD", name, scope);
3304 suggest_alternatives_for (location, name);
3308 error_at (location, "%<::%D%> has not been declared", name);
3309 suggest_alternatives_for (location, name);