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, ',')
40 /* The global buffer where we dump everything. It is there only for
41 transitional purpose. It is expected, in the near future, to be
42 completely removed. */
43 static cxx_pretty_printer scratch_pretty_printer;
44 #define cxx_pp (&scratch_pretty_printer)
46 /* Translate if being used for diagnostics, but not for dump files or
48 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
50 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
52 static const char *args_to_string (tree, int);
53 static const char *assop_to_string (enum tree_code);
54 static const char *code_to_string (enum tree_code);
55 static const char *cv_to_string (tree, int);
56 static const char *decl_to_string (tree, int);
57 static const char *expr_to_string (tree);
58 static const char *fndecl_to_string (tree, int);
59 static const char *op_to_string (enum tree_code);
60 static const char *parm_to_string (int);
61 static const char *type_to_string (tree, int);
63 static void dump_type (tree, int);
64 static void dump_typename (tree, int);
65 static void dump_simple_decl (tree, tree, int);
66 static void dump_decl (tree, int);
67 static void dump_template_decl (tree, int);
68 static void dump_function_decl (tree, int);
69 static void dump_expr (tree, int);
70 static void dump_unary_op (const char *, tree, int);
71 static void dump_binary_op (const char *, tree, int);
72 static void dump_aggr_type (tree, int);
73 static void dump_type_prefix (tree, int);
74 static void dump_type_suffix (tree, int);
75 static void dump_function_name (tree, int);
76 static void dump_call_expr_args (tree, int, bool);
77 static void dump_aggr_init_expr_args (tree, int, bool);
78 static void dump_expr_list (tree, int);
79 static void dump_global_iord (tree);
80 static void dump_parameters (tree, int);
81 static void dump_exception_spec (tree, int);
82 static void dump_template_argument (tree, int);
83 static void dump_template_argument_list (tree, int);
84 static void dump_template_parameter (tree, int);
85 static void dump_template_bindings (tree, tree, VEC(tree,gc) *);
86 static void dump_scope (tree, int);
87 static void dump_template_parms (tree, int, int);
88 static int get_non_default_template_args_count (tree, int);
89 static const char *function_category (tree);
90 static void maybe_print_constexpr_context (diagnostic_context *);
91 static void maybe_print_instantiation_context (diagnostic_context *);
92 static void print_instantiation_full_context (diagnostic_context *);
93 static void print_instantiation_partial_context (diagnostic_context *,
96 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
97 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
98 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
100 static bool cp_printer (pretty_printer *, text_info *, const char *,
101 int, bool, bool, bool);
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 = 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), 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 get_non_default_template_args_count (tree args, int flags)
168 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
170 if (/* We use this flag when generating debug information. We don't
171 want to expand templates at this point, for this may generate
172 new decls, which gets decl counts out of sync, which may in
173 turn cause codegen differences between compilations with and
175 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
176 || !flag_pretty_templates)
179 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
182 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
186 dump_template_argument_list (tree args, int flags)
188 int n = get_non_default_template_args_count (args, flags);
192 for (i = 0; i < n; ++i)
194 tree arg = TREE_VEC_ELT (args, i);
196 /* Only print a comma if we know there is an argument coming. In
197 the case of an empty template argument pack, no actual
198 argument will be printed. */
200 && (!ARGUMENT_PACK_P (arg)
201 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
202 pp_separate_with_comma (cxx_pp);
204 dump_template_argument (arg, flags);
209 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
212 dump_template_parameter (tree parm, int flags)
217 if (parm == error_mark_node)
220 p = TREE_VALUE (parm);
221 a = TREE_PURPOSE (parm);
223 if (TREE_CODE (p) == TYPE_DECL)
225 if (flags & TFF_DECL_SPECIFIERS)
227 pp_cxx_ws_string (cxx_pp, "class");
228 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
229 pp_cxx_ws_string (cxx_pp, "...");
231 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
233 else if (DECL_NAME (p))
234 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
236 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
239 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
241 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
243 pp_cxx_whitespace (cxx_pp);
245 pp_cxx_whitespace (cxx_pp);
246 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
247 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
249 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
253 /* Dump, under control of FLAGS, a template-parameter-list binding.
254 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
258 dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames)
266 tree p = TREE_VALUE (parms);
267 int lvl = TMPL_PARMS_DEPTH (parms);
270 tree lvl_args = NULL_TREE;
272 /* Don't crash if we had an invalid argument list. */
273 if (TMPL_ARGS_DEPTH (args) >= lvl)
274 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
276 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
278 tree arg = NULL_TREE;
280 /* Don't crash if we had an invalid argument list. */
281 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
282 arg = TREE_VEC_ELT (lvl_args, arg_idx);
285 pp_separate_with_comma (cxx_pp);
286 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
287 pp_cxx_whitespace (cxx_pp);
289 pp_cxx_whitespace (cxx_pp);
292 if (ARGUMENT_PACK_P (arg))
293 pp_cxx_left_brace (cxx_pp);
294 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
295 if (ARGUMENT_PACK_P (arg))
296 pp_cxx_right_brace (cxx_pp);
299 pp_string (cxx_pp, M_("<missing>"));
305 parms = TREE_CHAIN (parms);
308 FOR_EACH_VEC_ELT (tree, typenames, i, t)
310 bool dependent = uses_template_parms (args);
312 pp_separate_with_comma (cxx_pp);
313 dump_type (t, TFF_PLAIN_IDENTIFIER);
314 pp_cxx_whitespace (cxx_pp);
316 pp_cxx_whitespace (cxx_pp);
317 push_deferring_access_checks (dk_no_check);
319 ++processing_template_decl;
320 t = tsubst (t, args, tf_none, NULL_TREE);
322 --processing_template_decl;
323 pop_deferring_access_checks ();
324 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
325 pp_simple_type_specifier doesn't know about it. */
326 t = strip_typedefs (t);
327 dump_type (t, TFF_PLAIN_IDENTIFIER);
331 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
335 dump_type (tree t, int flags)
340 /* Don't print e.g. "struct mytypedef". */
341 if (TYPE_P (t) && typedef_variant_p (t))
343 tree decl = TYPE_NAME (t);
344 if ((flags & TFF_CHASE_TYPEDEF)
345 || DECL_SELF_REFERENCE_P (decl)
346 || (!flag_pretty_templates
347 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)))
348 t = strip_typedefs (t);
349 else if (same_type_p (t, TREE_TYPE (decl)))
353 pp_cxx_cv_qualifier_seq (cxx_pp, t);
354 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
359 if (TYPE_PTRMEMFUNC_P (t))
362 switch (TREE_CODE (t))
365 if (t == init_list_type_node)
366 pp_string (cxx_pp, M_("<brace-enclosed initializer list>"));
367 else if (t == unknown_type_node)
368 pp_string (cxx_pp, M_("<unresolved overloaded function type>"));
371 pp_cxx_cv_qualifier_seq (cxx_pp, t);
372 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
377 /* A list of function parms. */
378 dump_parameters (t, flags);
381 case IDENTIFIER_NODE:
382 pp_cxx_tree_identifier (cxx_pp, t);
386 dump_type (BINFO_TYPE (t), flags);
392 dump_aggr_type (t, flags);
396 if (flags & TFF_CHASE_TYPEDEF)
398 dump_type (DECL_ORIGINAL_TYPE (t)
399 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
402 /* Else fall through. */
406 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
415 case FIXED_POINT_TYPE:
416 pp_type_specifier_seq (cxx_pp, t);
419 case TEMPLATE_TEMPLATE_PARM:
420 /* For parameters inside template signature. */
421 if (TYPE_IDENTIFIER (t))
422 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
424 pp_cxx_canonical_template_parameter (cxx_pp, t);
427 case BOUND_TEMPLATE_TEMPLATE_PARM:
429 tree args = TYPE_TI_ARGS (t);
430 pp_cxx_cv_qualifier_seq (cxx_pp, t);
431 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
432 pp_cxx_begin_template_argument_list (cxx_pp);
433 dump_template_argument_list (args, flags);
434 pp_cxx_end_template_argument_list (cxx_pp);
438 case TEMPLATE_TYPE_PARM:
439 pp_cxx_cv_qualifier_seq (cxx_pp, t);
440 if (TYPE_IDENTIFIER (t))
441 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
443 pp_cxx_canonical_template_parameter
444 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
447 /* This is not always necessary for pointers and such, but doing this
448 reduces code size. */
457 dump_type_prefix (t, flags);
458 dump_type_suffix (t, flags);
462 if (! (flags & TFF_CHASE_TYPEDEF)
463 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
465 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
468 pp_cxx_cv_qualifier_seq (cxx_pp, t);
469 pp_cxx_ws_string (cxx_pp,
470 TYPENAME_IS_ENUM_P (t) ? "enum"
471 : TYPENAME_IS_CLASS_P (t) ? "class"
473 dump_typename (t, flags);
476 case UNBOUND_CLASS_TEMPLATE:
477 if (! (flags & TFF_UNQUALIFIED_NAME))
479 dump_type (TYPE_CONTEXT (t), flags);
480 pp_cxx_colon_colon (cxx_pp);
482 pp_cxx_ws_string (cxx_pp, "template");
483 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
487 pp_cxx_ws_string (cxx_pp, "__typeof__");
488 pp_cxx_whitespace (cxx_pp);
489 pp_cxx_left_paren (cxx_pp);
490 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
491 pp_cxx_right_paren (cxx_pp);
494 case UNDERLYING_TYPE:
495 pp_cxx_ws_string (cxx_pp, "__underlying_type");
496 pp_cxx_whitespace (cxx_pp);
497 pp_cxx_left_paren (cxx_pp);
498 dump_expr (UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
499 pp_cxx_right_paren (cxx_pp);
502 case TYPE_PACK_EXPANSION:
503 dump_type (PACK_EXPANSION_PATTERN (t), flags);
504 pp_cxx_ws_string (cxx_pp, "...");
507 case TYPE_ARGUMENT_PACK:
508 dump_template_argument (t, flags);
512 pp_cxx_ws_string (cxx_pp, "decltype");
513 pp_cxx_whitespace (cxx_pp);
514 pp_cxx_left_paren (cxx_pp);
515 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
516 pp_cxx_right_paren (cxx_pp);
520 pp_string (cxx_pp, "std::nullptr_t");
524 pp_unsupported_tree (cxx_pp, t);
525 /* Fall through to error. */
528 pp_string (cxx_pp, M_("<type error>"));
533 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
537 dump_typename (tree t, int flags)
539 tree ctx = TYPE_CONTEXT (t);
541 if (TREE_CODE (ctx) == TYPENAME_TYPE)
542 dump_typename (ctx, flags);
544 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
545 pp_cxx_colon_colon (cxx_pp);
546 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
549 /* Return the name of the supplied aggregate, or enumeral type. */
552 class_key_or_enum_as_string (tree t)
554 if (TREE_CODE (t) == ENUMERAL_TYPE)
556 if (SCOPED_ENUM_P (t))
561 else if (TREE_CODE (t) == UNION_TYPE)
563 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
569 /* Print out a class declaration T under the control of FLAGS,
570 in the form `class foo'. */
573 dump_aggr_type (tree t, int flags)
576 const char *variety = class_key_or_enum_as_string (t);
580 pp_cxx_cv_qualifier_seq (cxx_pp, t);
582 if (flags & TFF_CLASS_KEY_OR_ENUM)
583 pp_cxx_ws_string (cxx_pp, variety);
585 name = TYPE_NAME (t);
589 typdef = !DECL_ARTIFICIAL (name);
592 && ((flags & TFF_CHASE_TYPEDEF)
593 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
594 && DECL_TEMPLATE_INFO (name))))
595 || DECL_SELF_REFERENCE_P (name))
597 t = TYPE_MAIN_VARIANT (t);
598 name = TYPE_NAME (t);
602 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
603 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
604 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
605 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
607 if (! (flags & TFF_UNQUALIFIED_NAME))
608 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
609 flags &= ~TFF_UNQUALIFIED_NAME;
612 /* Because the template names are mangled, we have to locate
613 the most general template, and use that name. */
614 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
616 while (DECL_TEMPLATE_INFO (tpl))
617 tpl = DECL_TI_TEMPLATE (tpl);
620 name = DECL_NAME (name);
623 if (name == 0 || ANON_AGGRNAME_P (name))
625 if (flags & TFF_CLASS_KEY_OR_ENUM)
626 pp_string (cxx_pp, M_("<anonymous>"));
628 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety);
630 else if (LAMBDANAME_P (name))
632 /* A lambda's "type" is essentially its signature. */
633 pp_string (cxx_pp, M_("<lambda"));
634 if (lambda_function (t))
635 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
637 pp_character(cxx_pp, '>');
640 pp_cxx_tree_identifier (cxx_pp, name);
642 dump_template_parms (TYPE_TEMPLATE_INFO (t),
643 !CLASSTYPE_USE_TEMPLATE (t),
644 flags & ~TFF_TEMPLATE_HEADER);
647 /* Dump into the obstack the initial part of the output for a given type.
648 This is necessary when dealing with things like functions returning
651 return type of `int (* fee ())()': pointer -> function -> int. Both
652 pointer (and reference and offset) and function (and member) types must
653 deal with prefix and suffix.
655 Arrays must also do this for DECL nodes, like int a[], and for things like
659 dump_type_prefix (tree t, int flags)
661 if (TYPE_PTRMEMFUNC_P (t))
663 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
667 switch (TREE_CODE (t))
672 tree sub = TREE_TYPE (t);
674 dump_type_prefix (sub, flags);
675 if (TREE_CODE (sub) == ARRAY_TYPE
676 || TREE_CODE (sub) == FUNCTION_TYPE)
678 pp_cxx_whitespace (cxx_pp);
679 pp_cxx_left_paren (cxx_pp);
680 pp_c_attributes_display (pp_c_base (cxx_pp),
681 TYPE_ATTRIBUTES (sub));
683 if (TREE_CODE (t) == POINTER_TYPE)
684 pp_character(cxx_pp, '*');
685 else if (TREE_CODE (t) == REFERENCE_TYPE)
687 if (TYPE_REF_IS_RVALUE (t))
688 pp_string (cxx_pp, "&&");
690 pp_character (cxx_pp, '&');
692 pp_base (cxx_pp)->padding = pp_before;
693 pp_cxx_cv_qualifier_seq (cxx_pp, t);
699 dump_type_prefix (TREE_TYPE (t), flags);
700 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
702 pp_maybe_space (cxx_pp);
703 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
704 pp_cxx_left_paren (cxx_pp);
705 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
706 pp_cxx_colon_colon (cxx_pp);
708 pp_cxx_star (cxx_pp);
709 pp_cxx_cv_qualifier_seq (cxx_pp, t);
710 pp_base (cxx_pp)->padding = pp_before;
713 /* This can be reached without a pointer when dealing with
714 templates, e.g. std::is_function. */
716 dump_type_prefix (TREE_TYPE (t), flags);
720 dump_type_prefix (TREE_TYPE (t), flags);
721 pp_maybe_space (cxx_pp);
722 pp_cxx_left_paren (cxx_pp);
723 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
724 pp_cxx_colon_colon (cxx_pp);
728 dump_type_prefix (TREE_TYPE (t), flags);
732 case IDENTIFIER_NODE:
737 case TEMPLATE_TYPE_PARM:
738 case TEMPLATE_TEMPLATE_PARM:
739 case BOUND_TEMPLATE_TEMPLATE_PARM:
750 case UNDERLYING_TYPE:
752 case TYPE_PACK_EXPANSION:
753 case FIXED_POINT_TYPE:
755 dump_type (t, flags);
756 pp_base (cxx_pp)->padding = pp_before;
760 pp_unsupported_tree (cxx_pp, t);
763 pp_string (cxx_pp, M_("<typeprefixerror>"));
768 /* Dump the suffix of type T, under control of FLAGS. This is the part
769 which appears after the identifier (or function parms). */
772 dump_type_suffix (tree t, int flags)
774 if (TYPE_PTRMEMFUNC_P (t))
775 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
777 switch (TREE_CODE (t))
782 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
783 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
784 pp_cxx_right_paren (cxx_pp);
785 dump_type_suffix (TREE_TYPE (t), flags);
792 if (TREE_CODE (t) == METHOD_TYPE)
793 /* Can only be reached through a pointer. */
794 pp_cxx_right_paren (cxx_pp);
795 arg = TYPE_ARG_TYPES (t);
796 if (TREE_CODE (t) == METHOD_TYPE)
797 arg = TREE_CHAIN (arg);
799 /* Function pointers don't have default args. Not in standard C++,
800 anyway; they may in g++, but we'll just pretend otherwise. */
801 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
803 if (TREE_CODE (t) == METHOD_TYPE)
804 pp_cxx_cv_qualifier_seq (cxx_pp, class_of_this_parm (t));
806 pp_cxx_cv_qualifier_seq (cxx_pp, t);
807 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
808 dump_type_suffix (TREE_TYPE (t), flags);
813 pp_maybe_space (cxx_pp);
814 pp_cxx_left_bracket (cxx_pp);
817 tree dtype = TYPE_DOMAIN (t);
818 tree max = TYPE_MAX_VALUE (dtype);
819 if (host_integerp (max, 0))
820 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
821 else if (TREE_CODE (max) == MINUS_EXPR)
822 dump_expr (TREE_OPERAND (max, 0),
823 flags & ~TFF_EXPR_IN_PARENS);
825 dump_expr (fold_build2_loc (input_location,
826 PLUS_EXPR, dtype, max,
827 build_int_cst (dtype, 1)),
828 flags & ~TFF_EXPR_IN_PARENS);
830 pp_cxx_right_bracket (cxx_pp);
831 dump_type_suffix (TREE_TYPE (t), flags);
835 case IDENTIFIER_NODE:
840 case TEMPLATE_TYPE_PARM:
841 case TEMPLATE_TEMPLATE_PARM:
842 case BOUND_TEMPLATE_TEMPLATE_PARM:
853 case UNDERLYING_TYPE:
855 case TYPE_PACK_EXPANSION:
856 case FIXED_POINT_TYPE:
861 pp_unsupported_tree (cxx_pp, t);
863 /* Don't mark it here, we should have already done in
870 dump_global_iord (tree t)
872 const char *p = NULL;
874 if (DECL_GLOBAL_CTOR_P (t))
875 p = M_("(static initializers for %s)");
876 else if (DECL_GLOBAL_DTOR_P (t))
877 p = M_("(static destructors for %s)");
881 pp_printf (pp_base (cxx_pp), p, input_filename);
885 dump_simple_decl (tree t, tree type, int flags)
887 if (flags & TFF_DECL_SPECIFIERS)
889 if (TREE_CODE (t) == VAR_DECL
890 && DECL_DECLARED_CONSTEXPR_P (t))
891 pp_cxx_ws_string (cxx_pp, "constexpr");
892 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
893 pp_maybe_space (cxx_pp);
895 if (! (flags & TFF_UNQUALIFIED_NAME)
896 && TREE_CODE (t) != PARM_DECL
897 && (!DECL_INITIAL (t)
898 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
899 dump_scope (CP_DECL_CONTEXT (t), flags);
900 flags &= ~TFF_UNQUALIFIED_NAME;
901 if ((flags & TFF_DECL_SPECIFIERS)
902 && DECL_TEMPLATE_PARM_P (t)
903 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
904 pp_string (cxx_pp, "...");
906 dump_decl (DECL_NAME (t), flags);
908 pp_string (cxx_pp, M_("<anonymous>"));
909 if (flags & TFF_DECL_SPECIFIERS)
910 dump_type_suffix (type, flags);
913 /* Dump a human readable string for the decl T under control of FLAGS. */
916 dump_decl (tree t, int flags)
921 /* If doing Objective-C++, give Objective-C a chance to demangle
922 Objective-C method names. */
923 if (c_dialect_objc ())
925 const char *demangled = objc_maybe_printable_name (t, flags);
928 pp_string (cxx_pp, demangled);
933 switch (TREE_CODE (t))
936 /* Don't say 'typedef class A' */
937 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
939 if ((flags & TFF_DECL_SPECIFIERS)
940 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
942 /* Say `class T' not just `T'. */
943 pp_cxx_ws_string (cxx_pp, "class");
945 /* Emit the `...' for a parameter pack. */
946 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
947 pp_cxx_ws_string (cxx_pp, "...");
950 dump_type (TREE_TYPE (t), flags);
953 if ((flags & TFF_DECL_SPECIFIERS)
954 && !DECL_SELF_REFERENCE_P (t))
955 pp_cxx_ws_string (cxx_pp, "typedef");
956 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
957 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
962 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
964 pp_string (cxx_pp, M_("vtable for "));
965 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
966 dump_type (DECL_CONTEXT (t), flags);
969 /* Else fall through. */
972 dump_simple_decl (t, TREE_TYPE (t), flags);
976 pp_string (cxx_pp, M_("<return value> "));
977 dump_simple_decl (t, TREE_TYPE (t), flags);
981 if (flags & TFF_DECL_SPECIFIERS)
982 pp_cxx_declaration (cxx_pp, t);
985 if (! (flags & TFF_UNQUALIFIED_NAME))
986 dump_scope (CP_DECL_CONTEXT (t), flags);
987 flags &= ~TFF_UNQUALIFIED_NAME;
988 if (DECL_NAME (t) == NULL_TREE)
989 pp_cxx_ws_string (cxx_pp, M_("{anonymous}"));
991 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
996 dump_type (TREE_OPERAND (t, 0), flags);
997 pp_string (cxx_pp, "::");
998 dump_decl (TREE_OPERAND (t, 1), flags|TFF_UNQUALIFIED_NAME);
1002 dump_decl (TREE_OPERAND (t, 0), flags);
1003 pp_cxx_left_bracket (cxx_pp);
1004 dump_decl (TREE_OPERAND (t, 1), flags);
1005 pp_cxx_right_bracket (cxx_pp);
1008 /* So that we can do dump_decl on an aggr type. */
1012 dump_type (t, flags);
1016 /* This is a pseudo destructor call which has not been folded into
1017 a PSEUDO_DTOR_EXPR yet. */
1018 pp_cxx_complement (cxx_pp);
1019 dump_type (TREE_OPERAND (t, 0), flags);
1026 /* These special cases are duplicated here so that other functions
1027 can feed identifiers to error and get them demangled properly. */
1028 case IDENTIFIER_NODE:
1029 if (IDENTIFIER_TYPENAME_P (t))
1031 pp_cxx_ws_string (cxx_pp, "operator");
1032 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1033 dump_type (TREE_TYPE (t), flags);
1037 pp_cxx_tree_identifier (cxx_pp, t);
1043 t = OVL_CURRENT (t);
1044 if (DECL_CLASS_SCOPE_P (t))
1046 dump_type (DECL_CONTEXT (t), flags);
1047 pp_cxx_colon_colon (cxx_pp);
1049 else if (!DECL_FILE_SCOPE_P (t))
1051 dump_decl (DECL_CONTEXT (t), flags);
1052 pp_cxx_colon_colon (cxx_pp);
1054 dump_decl (DECL_NAME (t), flags);
1058 /* If there's only one function, just treat it like an ordinary
1060 t = OVL_CURRENT (t);
1064 if (! DECL_LANG_SPECIFIC (t))
1065 pp_string (cxx_pp, M_("<built-in>"));
1066 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1067 dump_global_iord (t);
1069 dump_function_decl (t, flags);
1073 dump_template_decl (t, flags);
1076 case TEMPLATE_ID_EXPR:
1078 tree name = TREE_OPERAND (t, 0);
1080 if (is_overloaded_fn (name))
1081 name = DECL_NAME (get_first_fn (name));
1082 dump_decl (name, flags);
1083 pp_cxx_begin_template_argument_list (cxx_pp);
1084 if (TREE_OPERAND (t, 1))
1085 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
1086 pp_cxx_end_template_argument_list (cxx_pp);
1091 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1095 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1096 || (DECL_INITIAL (t) &&
1097 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1098 dump_simple_decl (t, TREE_TYPE (t), flags);
1099 else if (DECL_NAME (t))
1100 dump_decl (DECL_NAME (t), flags);
1101 else if (DECL_INITIAL (t))
1102 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1104 pp_string (cxx_pp, M_("<enumerator>"));
1108 pp_cxx_ws_string (cxx_pp, "using");
1109 dump_type (USING_DECL_SCOPE (t), flags);
1110 pp_cxx_colon_colon (cxx_pp);
1111 dump_decl (DECL_NAME (t), flags);
1115 pp_cxx_declaration (cxx_pp, t);
1119 dump_decl (BASELINK_FUNCTIONS (t), flags);
1122 case NON_DEPENDENT_EXPR:
1123 dump_expr (t, flags);
1126 case TEMPLATE_TYPE_PARM:
1127 if (flags & TFF_DECL_SPECIFIERS)
1128 pp_cxx_declaration (cxx_pp, t);
1130 pp_type_id (cxx_pp, t);
1133 case UNBOUND_CLASS_TEMPLATE:
1134 case TYPE_PACK_EXPANSION:
1136 dump_type (t, flags);
1140 pp_unsupported_tree (cxx_pp, t);
1141 /* Fall through to error. */
1144 pp_string (cxx_pp, M_("<declaration error>"));
1149 /* Dump a template declaration T under control of FLAGS. This means the
1150 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1153 dump_template_decl (tree t, int flags)
1155 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1159 if (flags & TFF_TEMPLATE_HEADER)
1161 for (parms = orig_parms = nreverse (orig_parms);
1163 parms = TREE_CHAIN (parms))
1165 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1166 int len = TREE_VEC_LENGTH (inner_parms);
1168 pp_cxx_ws_string (cxx_pp, "template");
1169 pp_cxx_begin_template_argument_list (cxx_pp);
1171 /* If we've shown the template prefix, we'd better show the
1172 parameters' and decl's type too. */
1173 flags |= TFF_DECL_SPECIFIERS;
1175 for (i = 0; i < len; i++)
1178 pp_separate_with_comma (cxx_pp);
1179 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1181 pp_cxx_end_template_argument_list (cxx_pp);
1182 pp_cxx_whitespace (cxx_pp);
1184 nreverse(orig_parms);
1186 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1188 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1189 pp_cxx_ws_string (cxx_pp, "class");
1191 /* If this is a parameter pack, print the ellipsis. */
1192 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1193 pp_cxx_ws_string (cxx_pp, "...");
1197 if (DECL_TEMPLATE_RESULT (t)
1198 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1199 dump_type (TREE_TYPE (t),
1200 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1201 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1202 else if (DECL_TEMPLATE_RESULT (t)
1203 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1204 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1207 gcc_assert (TREE_TYPE (t));
1208 switch (NEXT_CODE (t))
1212 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1215 /* This case can occur with some invalid code. */
1216 dump_type (TREE_TYPE (t),
1217 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1218 | (flags & TFF_DECL_SPECIFIERS
1219 ? TFF_CLASS_KEY_OR_ENUM : 0));
1224 /* find_typenames looks through the type of the function template T
1225 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1228 struct find_typenames_t
1230 struct pointer_set_t *p_set;
1231 VEC (tree,gc) *typenames;
1235 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1237 struct find_typenames_t *d = (struct find_typenames_t *)data;
1238 tree mv = NULL_TREE;
1240 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1241 /* Add the type of the typedef without any additional cv-quals. */
1242 mv = TREE_TYPE (TYPE_NAME (*tp));
1243 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1244 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1245 /* Add the typename without any cv-qualifiers. */
1246 mv = TYPE_MAIN_VARIANT (*tp);
1248 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1249 VEC_safe_push (tree, gc, d->typenames, mv);
1251 /* Search into class template arguments, which cp_walk_subtrees
1253 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1254 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1260 static VEC(tree,gc) *
1261 find_typenames (tree t)
1263 struct find_typenames_t ft;
1264 ft.p_set = pointer_set_create ();
1265 ft.typenames = NULL;
1266 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1267 find_typenames_r, &ft, ft.p_set);
1268 pointer_set_destroy (ft.p_set);
1269 return ft.typenames;
1272 /* Pretty print a function decl. There are several ways we want to print a
1273 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1274 As error can only apply the '#' flag once to give 0 and 1 for V, there
1275 is %D which doesn't print the throw specs, and %F which does. */
1278 dump_function_decl (tree t, int flags)
1282 tree cname = NULL_TREE;
1283 tree template_args = NULL_TREE;
1284 tree template_parms = NULL_TREE;
1285 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1286 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1288 VEC(tree,gc) *typenames = NULL;
1290 if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1292 /* A lambda's signature is essentially its "type", so defer. */
1293 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t)));
1294 dump_type (DECL_CONTEXT (t), flags);
1298 flags &= ~TFF_UNQUALIFIED_NAME;
1299 if (TREE_CODE (t) == TEMPLATE_DECL)
1300 t = DECL_TEMPLATE_RESULT (t);
1302 /* Save the exceptions, in case t is a specialization and we are
1303 emitting an error about incompatible specifications. */
1304 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1306 /* Pretty print template instantiations only. */
1307 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1308 && flag_pretty_templates)
1312 template_args = DECL_TI_ARGS (t);
1313 tmpl = most_general_template (t);
1314 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1316 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1318 typenames = find_typenames (t);
1322 fntype = TREE_TYPE (t);
1323 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1325 if (DECL_CLASS_SCOPE_P (t))
1326 cname = DECL_CONTEXT (t);
1327 /* This is for partially instantiated template methods. */
1328 else if (TREE_CODE (fntype) == METHOD_TYPE)
1329 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1331 if (flags & TFF_DECL_SPECIFIERS)
1333 if (DECL_STATIC_FUNCTION_P (t))
1334 pp_cxx_ws_string (cxx_pp, "static");
1335 else if (DECL_VIRTUAL_P (t))
1336 pp_cxx_ws_string (cxx_pp, "virtual");
1338 if (DECL_DECLARED_CONSTEXPR_P (STRIP_TEMPLATE (t)))
1339 pp_cxx_ws_string (cxx_pp, "constexpr");
1342 /* Print the return type? */
1344 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1345 && !DECL_DESTRUCTOR_P (t);
1347 dump_type_prefix (TREE_TYPE (fntype), flags);
1349 /* Print the function name. */
1350 if (!do_outer_scope)
1354 dump_type (cname, flags);
1355 pp_cxx_colon_colon (cxx_pp);
1358 dump_scope (CP_DECL_CONTEXT (t), flags);
1360 dump_function_name (t, flags);
1362 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1364 dump_parameters (parmtypes, flags);
1366 if (TREE_CODE (fntype) == METHOD_TYPE)
1368 pp_base (cxx_pp)->padding = pp_before;
1369 pp_cxx_cv_qualifier_seq (cxx_pp, class_of_this_parm (fntype));
1372 if (flags & TFF_EXCEPTION_SPECIFICATION)
1374 pp_base (cxx_pp)->padding = pp_before;
1375 dump_exception_spec (exceptions, flags);
1379 dump_type_suffix (TREE_TYPE (fntype), flags);
1382 /* If T is a template instantiation, dump the parameter binding. */
1383 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1385 pp_cxx_whitespace (cxx_pp);
1386 pp_cxx_left_bracket (cxx_pp);
1387 pp_cxx_ws_string (cxx_pp, M_("with"));
1388 pp_cxx_whitespace (cxx_pp);
1389 dump_template_bindings (template_parms, template_args, typenames);
1390 pp_cxx_right_bracket (cxx_pp);
1394 /* Print a parameter list. If this is for a member function, the
1395 member object ptr (and any other hidden args) should have
1396 already been removed. */
1399 dump_parameters (tree parmtypes, int flags)
1402 flags &= ~TFF_SCOPE;
1403 pp_cxx_left_paren (cxx_pp);
1405 for (first = 1; parmtypes != void_list_node;
1406 parmtypes = TREE_CHAIN (parmtypes))
1409 pp_separate_with_comma (cxx_pp);
1413 pp_cxx_ws_string (cxx_pp, "...");
1417 dump_type (TREE_VALUE (parmtypes), flags);
1419 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1421 pp_cxx_whitespace (cxx_pp);
1423 pp_cxx_whitespace (cxx_pp);
1424 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1428 pp_cxx_right_paren (cxx_pp);
1431 /* Print an exception specification. T is the exception specification. */
1434 dump_exception_spec (tree t, int flags)
1436 if (t && TREE_PURPOSE (t))
1438 pp_cxx_ws_string (cxx_pp, "noexcept");
1439 pp_cxx_whitespace (cxx_pp);
1440 pp_cxx_left_paren (cxx_pp);
1441 if (DEFERRED_NOEXCEPT_SPEC_P (t))
1442 pp_cxx_ws_string (cxx_pp, "<uninstantiated>");
1444 dump_expr (TREE_PURPOSE (t), flags);
1445 pp_cxx_right_paren (cxx_pp);
1449 pp_cxx_ws_string (cxx_pp, "throw");
1450 pp_cxx_whitespace (cxx_pp);
1451 pp_cxx_left_paren (cxx_pp);
1452 if (TREE_VALUE (t) != NULL_TREE)
1455 dump_type (TREE_VALUE (t), flags);
1459 pp_separate_with_comma (cxx_pp);
1461 pp_cxx_right_paren (cxx_pp);
1465 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1466 and destructors properly. */
1469 dump_function_name (tree t, int flags)
1471 tree name = DECL_NAME (t);
1473 /* We can get here with a decl that was synthesized by language-
1474 independent machinery (e.g. coverage.c) in which case it won't
1475 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1476 will crash. In this case it is safe just to print out the
1478 if (!DECL_LANG_SPECIFIC (t))
1480 pp_cxx_tree_identifier (cxx_pp, name);
1484 if (TREE_CODE (t) == TEMPLATE_DECL)
1485 t = DECL_TEMPLATE_RESULT (t);
1487 /* Don't let the user see __comp_ctor et al. */
1488 if (DECL_CONSTRUCTOR_P (t)
1489 || DECL_DESTRUCTOR_P (t))
1491 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1492 name = get_identifier ("<lambda>");
1494 name = constructor_name (DECL_CONTEXT (t));
1497 if (DECL_DESTRUCTOR_P (t))
1499 pp_cxx_complement (cxx_pp);
1500 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1502 else if (DECL_CONV_FN_P (t))
1504 /* This cannot use the hack that the operator's return
1505 type is stashed off of its name because it may be
1506 used for error reporting. In the case of conflicting
1507 declarations, both will have the same name, yet
1508 the types will be different, hence the TREE_TYPE field
1509 of the first name will be clobbered by the second. */
1510 pp_cxx_ws_string (cxx_pp, "operator");
1511 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1513 else if (name && IDENTIFIER_OPNAME_P (name))
1514 pp_cxx_tree_identifier (cxx_pp, name);
1516 dump_decl (name, flags);
1518 if (DECL_TEMPLATE_INFO (t)
1519 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1520 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1521 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1522 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1525 /* Dump the template parameters from the template info INFO under control of
1526 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1527 specialization (partial or complete). For partial specializations we show
1528 the specialized parameter values. For a primary template we show no
1532 dump_template_parms (tree info, int primary, int flags)
1534 tree args = info ? TI_ARGS (info) : NULL_TREE;
1536 if (primary && flags & TFF_TEMPLATE_NAME)
1538 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1539 pp_cxx_begin_template_argument_list (cxx_pp);
1541 /* Be careful only to print things when we have them, so as not
1542 to crash producing error messages. */
1543 if (args && !primary)
1546 len = get_non_default_template_args_count (args, flags);
1548 args = INNERMOST_TEMPLATE_ARGS (args);
1549 for (ix = 0; ix != len; ix++)
1551 tree arg = TREE_VEC_ELT (args, ix);
1553 /* Only print a comma if we know there is an argument coming. In
1554 the case of an empty template argument pack, no actual
1555 argument will be printed. */
1557 && (!ARGUMENT_PACK_P (arg)
1558 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1559 pp_separate_with_comma (cxx_pp);
1562 pp_string (cxx_pp, M_("<template parameter error>"));
1564 dump_template_argument (arg, flags);
1569 tree tpl = TI_TEMPLATE (info);
1570 tree parms = DECL_TEMPLATE_PARMS (tpl);
1573 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1574 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1576 for (ix = 0; ix != len; ix++)
1580 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1582 pp_string (cxx_pp, M_("<template parameter error>"));
1586 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1589 pp_separate_with_comma (cxx_pp);
1591 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1594 pp_cxx_end_template_argument_list (cxx_pp);
1597 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1598 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1601 dump_call_expr_args (tree t, int flags, bool skipfirst)
1604 call_expr_arg_iterator iter;
1606 pp_cxx_left_paren (cxx_pp);
1607 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1613 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1614 if (more_call_expr_args_p (&iter))
1615 pp_separate_with_comma (cxx_pp);
1618 pp_cxx_right_paren (cxx_pp);
1621 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1622 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1626 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1629 aggr_init_expr_arg_iterator iter;
1631 pp_cxx_left_paren (cxx_pp);
1632 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1638 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1639 if (more_aggr_init_expr_args_p (&iter))
1640 pp_separate_with_comma (cxx_pp);
1643 pp_cxx_right_paren (cxx_pp);
1646 /* Print out a list of initializers (subr of dump_expr). */
1649 dump_expr_list (tree l, int flags)
1653 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1656 pp_separate_with_comma (cxx_pp);
1660 /* Print out a vector of initializers (subr of dump_expr). */
1663 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1665 unsigned HOST_WIDE_INT idx;
1668 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1670 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1671 if (idx != VEC_length (constructor_elt, v) - 1)
1672 pp_separate_with_comma (cxx_pp);
1677 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1678 function. Resolve it to a close relative -- in the sense of static
1679 type -- variant being overridden. That is close to what was written in
1680 the source code. Subroutine of dump_expr. */
1683 resolve_virtual_fun_from_obj_type_ref (tree ref)
1685 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1686 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1687 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1690 fun = TREE_CHAIN (fun);
1691 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1692 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1698 /* Print out an expression E under control of FLAGS. */
1701 dump_expr (tree t, int flags)
1706 if (STATEMENT_CLASS_P (t))
1708 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1712 switch (TREE_CODE (t))
1720 case NAMESPACE_DECL:
1724 case IDENTIFIER_NODE:
1725 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1732 pp_constant (cxx_pp, t);
1736 /* While waiting for caret diagnostics, avoid printing
1737 __cxa_allocate_exception, __cxa_throw, and the like. */
1738 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1742 pp_ampersand (cxx_pp);
1743 dump_type (PTRMEM_CST_CLASS (t), flags);
1744 pp_cxx_colon_colon (cxx_pp);
1745 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1749 pp_cxx_left_paren (cxx_pp);
1750 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1751 pp_separate_with_comma (cxx_pp);
1752 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1753 pp_cxx_right_paren (cxx_pp);
1757 pp_cxx_left_paren (cxx_pp);
1758 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1759 pp_string (cxx_pp, " ? ");
1760 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1761 pp_string (cxx_pp, " : ");
1762 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1763 pp_cxx_right_paren (cxx_pp);
1767 if (TREE_HAS_CONSTRUCTOR (t))
1769 pp_cxx_ws_string (cxx_pp, "new");
1770 pp_cxx_whitespace (cxx_pp);
1771 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1774 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1777 case AGGR_INIT_EXPR:
1779 tree fn = NULL_TREE;
1781 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1782 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1784 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1786 if (DECL_CONSTRUCTOR_P (fn))
1787 dump_type (DECL_CONTEXT (fn), flags);
1792 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1794 dump_aggr_init_expr_args (t, flags, true);
1799 tree fn = CALL_EXPR_FN (t);
1800 bool skipfirst = false;
1802 if (TREE_CODE (fn) == ADDR_EXPR)
1803 fn = TREE_OPERAND (fn, 0);
1805 /* Nobody is interested in seeing the guts of vcalls. */
1806 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1807 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1809 if (TREE_TYPE (fn) != NULL_TREE
1810 && NEXT_CODE (fn) == METHOD_TYPE
1811 && call_expr_nargs (t))
1813 tree ob = CALL_EXPR_ARG (t, 0);
1814 if (TREE_CODE (ob) == ADDR_EXPR)
1816 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1817 pp_cxx_dot (cxx_pp);
1819 else if (TREE_CODE (ob) != PARM_DECL
1820 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1822 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1823 pp_cxx_arrow (cxx_pp);
1827 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1828 dump_call_expr_args (t, flags, skipfirst);
1833 /* Note that this only works for G++ target exprs. If somebody
1834 builds a general TARGET_EXPR, there's no way to represent that
1835 it initializes anything other that the parameter slot for the
1836 default argument. Note we may have cleared out the first
1837 operand in expand_expr, so don't go killing ourselves. */
1838 if (TREE_OPERAND (t, 1))
1839 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1842 case POINTER_PLUS_EXPR:
1843 dump_binary_op ("+", t, flags);
1851 case TRUNC_DIV_EXPR:
1852 case TRUNC_MOD_EXPR:
1860 case TRUTH_ANDIF_EXPR:
1861 case TRUTH_ORIF_EXPR:
1868 case EXACT_DIV_EXPR:
1869 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1873 case FLOOR_DIV_EXPR:
1874 case ROUND_DIV_EXPR:
1876 dump_binary_op ("/", t, flags);
1880 case FLOOR_MOD_EXPR:
1881 case ROUND_MOD_EXPR:
1882 dump_binary_op ("%", t, flags);
1887 tree ob = TREE_OPERAND (t, 0);
1888 if (TREE_CODE (ob) == INDIRECT_REF)
1890 ob = TREE_OPERAND (ob, 0);
1891 if (TREE_CODE (ob) != PARM_DECL
1893 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1895 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1896 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
1897 pp_cxx_dot (cxx_pp);
1899 pp_cxx_arrow (cxx_pp);
1904 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1905 pp_cxx_dot (cxx_pp);
1907 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1912 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1913 pp_cxx_left_bracket (cxx_pp);
1914 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1915 pp_cxx_right_bracket (cxx_pp);
1918 case UNARY_PLUS_EXPR:
1919 dump_unary_op ("+", t, flags);
1923 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1924 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1925 /* An ADDR_EXPR can have reference type. In that case, we
1926 shouldn't print the `&' doing so indicates to the user
1927 that the expression has pointer type. */
1929 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1930 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1931 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1932 dump_unary_op ("&&", t, flags);
1934 dump_unary_op ("&", t, flags);
1938 if (TREE_HAS_CONSTRUCTOR (t))
1940 t = TREE_OPERAND (t, 0);
1941 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1942 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1943 dump_call_expr_args (t, flags, true);
1947 if (TREE_OPERAND (t,0) != NULL_TREE
1948 && TREE_TYPE (TREE_OPERAND (t, 0))
1949 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1950 dump_expr (TREE_OPERAND (t, 0), flags);
1952 dump_unary_op ("*", t, flags);
1957 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
1958 && integer_zerop (TREE_OPERAND (t, 1)))
1959 dump_expr (TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
1962 pp_cxx_star (cxx_pp);
1963 if (!integer_zerop (TREE_OPERAND (t, 1)))
1965 pp_cxx_left_paren (cxx_pp);
1966 if (!integer_onep (TYPE_SIZE_UNIT
1967 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
1969 pp_cxx_left_paren (cxx_pp);
1970 dump_type (ptr_type_node, flags);
1971 pp_cxx_right_paren (cxx_pp);
1974 dump_expr (TREE_OPERAND (t, 0), flags);
1975 if (!integer_zerop (TREE_OPERAND (t, 1)))
1977 pp_cxx_ws_string (cxx_pp, "+");
1978 dump_expr (fold_convert (ssizetype, TREE_OPERAND (t, 1)), flags);
1979 pp_cxx_right_paren (cxx_pp);
1986 case TRUTH_NOT_EXPR:
1987 case PREDECREMENT_EXPR:
1988 case PREINCREMENT_EXPR:
1989 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1992 case POSTDECREMENT_EXPR:
1993 case POSTINCREMENT_EXPR:
1994 pp_cxx_left_paren (cxx_pp);
1995 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1996 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1997 pp_cxx_right_paren (cxx_pp);
2000 case NON_LVALUE_EXPR:
2001 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2002 should be another level of INDIRECT_REF so that I don't have to do
2004 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2006 tree next = TREE_TYPE (TREE_TYPE (t));
2008 while (TREE_CODE (next) == POINTER_TYPE)
2009 next = TREE_TYPE (next);
2011 if (TREE_CODE (next) == FUNCTION_TYPE)
2013 if (flags & TFF_EXPR_IN_PARENS)
2014 pp_cxx_left_paren (cxx_pp);
2015 pp_cxx_star (cxx_pp);
2016 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2017 if (flags & TFF_EXPR_IN_PARENS)
2018 pp_cxx_right_paren (cxx_pp);
2021 /* Else fall through. */
2023 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2027 case VIEW_CONVERT_EXPR:
2029 tree op = TREE_OPERAND (t, 0);
2030 tree ttype = TREE_TYPE (t);
2031 tree optype = TREE_TYPE (op);
2033 if (TREE_CODE (ttype) != TREE_CODE (optype)
2034 && POINTER_TYPE_P (ttype)
2035 && POINTER_TYPE_P (optype)
2036 && same_type_p (TREE_TYPE (optype),
2039 if (TREE_CODE (ttype) == REFERENCE_TYPE)
2040 dump_unary_op ("*", t, flags);
2042 dump_unary_op ("&", t, flags);
2044 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2046 /* It is a cast, but we cannot tell whether it is a
2047 reinterpret or static cast. Use the C style notation. */
2048 if (flags & TFF_EXPR_IN_PARENS)
2049 pp_cxx_left_paren (cxx_pp);
2050 pp_cxx_left_paren (cxx_pp);
2051 dump_type (TREE_TYPE (t), flags);
2052 pp_cxx_right_paren (cxx_pp);
2053 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
2054 if (flags & TFF_EXPR_IN_PARENS)
2055 pp_cxx_right_paren (cxx_pp);
2058 dump_expr (op, flags);
2063 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2065 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2067 if (integer_zerop (idx))
2069 /* A NULL pointer-to-member constant. */
2070 pp_cxx_left_paren (cxx_pp);
2071 pp_cxx_left_paren (cxx_pp);
2072 dump_type (TREE_TYPE (t), flags);
2073 pp_cxx_right_paren (cxx_pp);
2074 pp_character (cxx_pp, '0');
2075 pp_cxx_right_paren (cxx_pp);
2078 else if (host_integerp (idx, 0))
2081 unsigned HOST_WIDE_INT n;
2083 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2084 t = TYPE_METHOD_BASETYPE (t);
2085 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2087 n = tree_low_cst (idx, 0);
2089 /* Map vtable index back one, to allow for the null pointer to
2093 while (n > 0 && virtuals)
2096 virtuals = TREE_CHAIN (virtuals);
2100 dump_expr (BV_FN (virtuals),
2101 flags | TFF_EXPR_IN_PARENS);
2106 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2108 dump_type (TREE_TYPE (t), 0);
2109 pp_cxx_left_paren (cxx_pp);
2110 pp_cxx_right_paren (cxx_pp);
2114 pp_cxx_left_brace (cxx_pp);
2115 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
2116 pp_cxx_right_brace (cxx_pp);
2123 tree ob = TREE_OPERAND (t, 0);
2124 if (is_dummy_object (ob))
2126 t = TREE_OPERAND (t, 1);
2127 if (TREE_CODE (t) == FUNCTION_DECL)
2129 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
2130 else if (BASELINK_P (t))
2131 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2132 flags | TFF_EXPR_IN_PARENS);
2134 dump_decl (t, flags);
2138 if (TREE_CODE (ob) == INDIRECT_REF)
2140 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2141 pp_cxx_arrow (cxx_pp);
2142 pp_cxx_star (cxx_pp);
2146 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2147 pp_cxx_dot (cxx_pp);
2148 pp_cxx_star (cxx_pp);
2150 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2155 case TEMPLATE_PARM_INDEX:
2156 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2160 if (TREE_OPERAND (t, 0) == NULL_TREE
2161 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2163 dump_type (TREE_TYPE (t), flags);
2164 pp_cxx_left_paren (cxx_pp);
2165 dump_expr_list (TREE_OPERAND (t, 0), flags);
2166 pp_cxx_right_paren (cxx_pp);
2170 pp_cxx_left_paren (cxx_pp);
2171 dump_type (TREE_TYPE (t), flags);
2172 pp_cxx_right_paren (cxx_pp);
2173 pp_cxx_left_paren (cxx_pp);
2174 dump_expr_list (TREE_OPERAND (t, 0), flags);
2175 pp_cxx_right_paren (cxx_pp);
2179 case STATIC_CAST_EXPR:
2180 pp_cxx_ws_string (cxx_pp, "static_cast");
2182 case REINTERPRET_CAST_EXPR:
2183 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2185 case CONST_CAST_EXPR:
2186 pp_cxx_ws_string (cxx_pp, "const_cast");
2188 case DYNAMIC_CAST_EXPR:
2189 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2191 pp_cxx_begin_template_argument_list (cxx_pp);
2192 dump_type (TREE_TYPE (t), flags);
2193 pp_cxx_end_template_argument_list (cxx_pp);
2194 pp_cxx_left_paren (cxx_pp);
2195 dump_expr (TREE_OPERAND (t, 0), flags);
2196 pp_cxx_right_paren (cxx_pp);
2200 dump_expr (TREE_OPERAND (t, 0), flags);
2201 pp_cxx_arrow (cxx_pp);
2206 if (TREE_CODE (t) == SIZEOF_EXPR)
2207 pp_cxx_ws_string (cxx_pp, "sizeof");
2210 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2211 pp_cxx_ws_string (cxx_pp, "__alignof__");
2213 pp_cxx_whitespace (cxx_pp);
2214 pp_cxx_left_paren (cxx_pp);
2215 if (TYPE_P (TREE_OPERAND (t, 0)))
2216 dump_type (TREE_OPERAND (t, 0), flags);
2218 dump_expr (TREE_OPERAND (t, 0), flags);
2219 pp_cxx_right_paren (cxx_pp);
2222 case AT_ENCODE_EXPR:
2223 pp_cxx_ws_string (cxx_pp, "@encode");
2224 pp_cxx_whitespace (cxx_pp);
2225 pp_cxx_left_paren (cxx_pp);
2226 dump_type (TREE_OPERAND (t, 0), flags);
2227 pp_cxx_right_paren (cxx_pp);
2231 pp_cxx_ws_string (cxx_pp, "noexcept");
2232 pp_cxx_whitespace (cxx_pp);
2233 pp_cxx_left_paren (cxx_pp);
2234 dump_expr (TREE_OPERAND (t, 0), flags);
2235 pp_cxx_right_paren (cxx_pp);
2240 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2241 pp_cxx_whitespace (cxx_pp);
2242 dump_expr (TREE_OPERAND (t, 0), flags);
2246 pp_string (cxx_pp, M_("<unparsed>"));
2249 case TRY_CATCH_EXPR:
2250 case WITH_CLEANUP_EXPR:
2251 case CLEANUP_POINT_EXPR:
2252 dump_expr (TREE_OPERAND (t, 0), flags);
2255 case PSEUDO_DTOR_EXPR:
2256 dump_expr (TREE_OPERAND (t, 2), flags);
2257 pp_cxx_dot (cxx_pp);
2258 dump_type (TREE_OPERAND (t, 0), flags);
2259 pp_cxx_colon_colon (cxx_pp);
2260 pp_cxx_complement (cxx_pp);
2261 dump_type (TREE_OPERAND (t, 1), flags);
2264 case TEMPLATE_ID_EXPR:
2265 dump_decl (t, flags);
2271 case STATEMENT_LIST:
2272 /* We don't yet have a way of dumping statements in a
2273 human-readable format. */
2274 pp_string (cxx_pp, "({...})");
2278 pp_string (cxx_pp, "while (1) { ");
2279 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2280 pp_cxx_right_brace (cxx_pp);
2284 pp_string (cxx_pp, "if (");
2285 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2286 pp_string (cxx_pp, ") break; ");
2290 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2293 case EMPTY_CLASS_EXPR:
2294 dump_type (TREE_TYPE (t), flags);
2295 pp_cxx_left_paren (cxx_pp);
2296 pp_cxx_right_paren (cxx_pp);
2299 case NON_DEPENDENT_EXPR:
2300 dump_expr (TREE_OPERAND (t, 0), flags);
2303 case ARGUMENT_PACK_SELECT:
2304 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2316 pp_type_specifier_seq (cxx_pp, t);
2320 /* We get here when we want to print a dependent type as an
2321 id-expression, without any disambiguator decoration. */
2322 pp_id_expression (cxx_pp, t);
2325 case TEMPLATE_TYPE_PARM:
2326 case BOUND_TEMPLATE_TEMPLATE_PARM:
2327 dump_type (t, flags);
2331 pp_cxx_trait_expression (cxx_pp, t);
2335 pp_cxx_va_arg_expression (cxx_pp, t);
2339 pp_cxx_offsetof_expression (cxx_pp, t);
2343 dump_decl (t, flags);
2346 case EXPR_PACK_EXPANSION:
2353 case VEC_DELETE_EXPR:
2359 case UNORDERED_EXPR:
2369 case FIX_TRUNC_EXPR:
2371 pp_expression (cxx_pp, t);
2374 case TRUTH_AND_EXPR:
2376 case TRUTH_XOR_EXPR:
2377 if (flags & TFF_EXPR_IN_PARENS)
2378 pp_cxx_left_paren (cxx_pp);
2379 pp_expression (cxx_pp, t);
2380 if (flags & TFF_EXPR_IN_PARENS)
2381 pp_cxx_right_paren (cxx_pp);
2385 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2388 /* This list is incomplete, but should suffice for now.
2389 It is very important that `sorry' does not call
2390 `report_error_function'. That could cause an infinite loop. */
2392 pp_unsupported_tree (cxx_pp, t);
2393 /* fall through to ERROR_MARK... */
2395 pp_string (cxx_pp, M_("<expression error>"));
2401 dump_binary_op (const char *opstring, tree t, int flags)
2403 pp_cxx_left_paren (cxx_pp);
2404 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2405 pp_cxx_whitespace (cxx_pp);
2407 pp_cxx_ws_string (cxx_pp, opstring);
2409 pp_string (cxx_pp, M_("<unknown operator>"));
2410 pp_cxx_whitespace (cxx_pp);
2411 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2412 pp_cxx_right_paren (cxx_pp);
2416 dump_unary_op (const char *opstring, tree t, int flags)
2418 if (flags & TFF_EXPR_IN_PARENS)
2419 pp_cxx_left_paren (cxx_pp);
2420 pp_cxx_ws_string (cxx_pp, opstring);
2421 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2422 if (flags & TFF_EXPR_IN_PARENS)
2423 pp_cxx_right_paren (cxx_pp);
2427 reinit_cxx_pp (void)
2429 pp_clear_output_area (cxx_pp);
2430 pp_base (cxx_pp)->padding = pp_none;
2431 pp_indentation (cxx_pp) = 0;
2432 pp_needs_newline (cxx_pp) = false;
2433 cxx_pp->enclosing_scope = current_function_decl;
2437 /* Exported interface to stringifying types, exprs and decls under TFF_*
2441 type_as_string (tree typ, int flags)
2444 pp_translate_identifiers (cxx_pp) = false;
2445 dump_type (typ, flags);
2446 return pp_formatted_text (cxx_pp);
2450 type_as_string_translate (tree typ, int flags)
2453 dump_type (typ, flags);
2454 return pp_formatted_text (cxx_pp);
2458 expr_as_string (tree decl, int flags)
2461 pp_translate_identifiers (cxx_pp) = false;
2462 dump_expr (decl, flags);
2463 return pp_formatted_text (cxx_pp);
2467 decl_as_string (tree decl, int flags)
2470 pp_translate_identifiers (cxx_pp) = false;
2471 dump_decl (decl, flags);
2472 return pp_formatted_text (cxx_pp);
2476 decl_as_string_translate (tree decl, int flags)
2479 dump_decl (decl, flags);
2480 return pp_formatted_text (cxx_pp);
2483 /* Generate the three forms of printable names for cxx_printable_name. */
2486 lang_decl_name (tree decl, int v, bool translate)
2490 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2491 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2494 pp_translate_identifiers (cxx_pp) = translate;
2496 && (DECL_CLASS_SCOPE_P (decl)
2497 || (DECL_NAMESPACE_SCOPE_P (decl)
2498 && CP_DECL_CONTEXT (decl) != global_namespace)))
2500 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2501 pp_cxx_colon_colon (cxx_pp);
2504 if (TREE_CODE (decl) == FUNCTION_DECL)
2505 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2507 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2509 return pp_formatted_text (cxx_pp);
2512 /* Return the location of a tree passed to %+ formats. */
2515 location_of (tree t)
2517 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2518 t = DECL_CONTEXT (t);
2519 else if (TYPE_P (t))
2521 t = TYPE_MAIN_DECL (t);
2523 return input_location;
2525 else if (TREE_CODE (t) == OVERLOAD)
2526 t = OVL_FUNCTION (t);
2529 return DECL_SOURCE_LOCATION (t);
2530 return EXPR_LOC_OR_HERE (t);
2533 /* Now the interfaces from error et al to dump_type et al. Each takes an
2534 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2538 decl_to_string (tree decl, int verbose)
2542 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2543 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2544 flags = TFF_CLASS_KEY_OR_ENUM;
2546 flags |= TFF_DECL_SPECIFIERS;
2547 else if (TREE_CODE (decl) == FUNCTION_DECL)
2548 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2549 flags |= TFF_TEMPLATE_HEADER;
2552 dump_decl (decl, flags);
2553 return pp_formatted_text (cxx_pp);
2557 expr_to_string (tree decl)
2560 dump_expr (decl, 0);
2561 return pp_formatted_text (cxx_pp);
2565 fndecl_to_string (tree fndecl, int verbose)
2569 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2570 | TFF_TEMPLATE_HEADER;
2572 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2574 dump_decl (fndecl, flags);
2575 return pp_formatted_text (cxx_pp);
2580 code_to_string (enum tree_code c)
2582 return tree_code_name [c];
2586 language_to_string (enum languages c)
2593 case lang_cplusplus:
2605 /* Return the proper printed version of a parameter to a C++ function. */
2608 parm_to_string (int p)
2612 pp_string (cxx_pp, "'this'");
2614 pp_decimal_int (cxx_pp, p + 1);
2615 return pp_formatted_text (cxx_pp);
2619 op_to_string (enum tree_code p)
2621 tree id = operator_name_info[(int) p].identifier;
2622 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2626 type_to_string (tree typ, int verbose)
2630 flags |= TFF_CLASS_KEY_OR_ENUM;
2631 flags |= TFF_TEMPLATE_HEADER;
2634 dump_type (typ, flags);
2635 if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
2636 && !uses_template_parms (typ))
2638 tree aka = strip_typedefs (typ);
2639 pp_string (cxx_pp, " {aka");
2640 pp_cxx_whitespace (cxx_pp);
2641 dump_type (aka, flags);
2642 pp_character (cxx_pp, '}');
2644 return pp_formatted_text (cxx_pp);
2648 assop_to_string (enum tree_code p)
2650 tree id = assignment_operator_name_info[(int) p].identifier;
2651 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2655 args_to_string (tree p, int verbose)
2659 flags |= TFF_CLASS_KEY_OR_ENUM;
2664 if (TYPE_P (TREE_VALUE (p)))
2665 return type_as_string_translate (p, flags);
2668 for (; p; p = TREE_CHAIN (p))
2670 if (TREE_VALUE (p) == null_node)
2671 pp_cxx_ws_string (cxx_pp, "NULL");
2673 dump_type (error_type (TREE_VALUE (p)), flags);
2675 pp_separate_with_comma (cxx_pp);
2677 return pp_formatted_text (cxx_pp);
2680 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
2681 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
2685 subst_to_string (tree p)
2687 tree decl = TREE_PURPOSE (p);
2688 tree targs = TREE_VALUE (p);
2689 tree tparms = DECL_TEMPLATE_PARMS (decl);
2690 int flags = TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER;
2696 dump_template_decl (TREE_PURPOSE (p), flags);
2697 pp_cxx_whitespace (cxx_pp);
2698 pp_cxx_left_bracket (cxx_pp);
2699 pp_cxx_ws_string (cxx_pp, M_("with"));
2700 pp_cxx_whitespace (cxx_pp);
2701 dump_template_bindings (tparms, targs, NULL);
2702 pp_cxx_right_bracket (cxx_pp);
2703 return pp_formatted_text (cxx_pp);
2707 cv_to_string (tree p, int v)
2710 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2711 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2712 return pp_formatted_text (cxx_pp);
2715 /* Langhook for print_error_function. */
2717 cxx_print_error_function (diagnostic_context *context, const char *file,
2718 diagnostic_info *diagnostic)
2720 lhd_print_error_function (context, file, diagnostic);
2721 pp_base_set_prefix (context->printer, file);
2722 maybe_print_instantiation_context (context);
2726 cp_diagnostic_starter (diagnostic_context *context,
2727 diagnostic_info *diagnostic)
2729 diagnostic_report_current_module (context);
2730 cp_print_error_function (context, diagnostic);
2731 maybe_print_instantiation_context (context);
2732 maybe_print_constexpr_context (context);
2733 pp_base_set_prefix (context->printer, diagnostic_build_prefix (context,
2738 cp_diagnostic_finalizer (diagnostic_context *context,
2739 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2741 pp_base_destroy_prefix (context->printer);
2744 /* Print current function onto BUFFER, in the process of reporting
2745 a diagnostic message. Called from cp_diagnostic_starter. */
2747 cp_print_error_function (diagnostic_context *context,
2748 diagnostic_info *diagnostic)
2750 if (diagnostic_last_function_changed (context, diagnostic))
2752 const char *old_prefix = context->printer->prefix;
2753 const char *file = LOCATION_FILE (diagnostic->location);
2754 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
2755 char *new_prefix = (file && abstract_origin == NULL)
2756 ? file_name_as_prefix (file) : NULL;
2758 pp_base_set_prefix (context->printer, new_prefix);
2760 if (current_function_decl == NULL)
2761 pp_base_string (context->printer, _("At global scope:"));
2766 if (abstract_origin)
2768 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2769 while (TREE_CODE (ao) == BLOCK
2770 && BLOCK_ABSTRACT_ORIGIN (ao)
2771 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2772 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2773 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2777 fndecl = current_function_decl;
2779 pp_printf (context->printer, function_category (fndecl),
2780 cxx_printable_name_translate (fndecl, 2));
2782 while (abstract_origin)
2785 tree block = abstract_origin;
2787 locus = &BLOCK_SOURCE_LOCATION (block);
2789 block = BLOCK_SUPERCONTEXT (block);
2790 while (block && TREE_CODE (block) == BLOCK
2791 && BLOCK_ABSTRACT_ORIGIN (block))
2793 ao = BLOCK_ABSTRACT_ORIGIN (block);
2795 while (TREE_CODE (ao) == BLOCK
2796 && BLOCK_ABSTRACT_ORIGIN (ao)
2797 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2798 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2800 if (TREE_CODE (ao) == FUNCTION_DECL)
2805 else if (TREE_CODE (ao) != BLOCK)
2808 block = BLOCK_SUPERCONTEXT (block);
2811 abstract_origin = block;
2814 while (block && TREE_CODE (block) == BLOCK)
2815 block = BLOCK_SUPERCONTEXT (block);
2817 if (block && TREE_CODE (block) == FUNCTION_DECL)
2819 abstract_origin = NULL;
2823 expanded_location s = expand_location (*locus);
2824 pp_base_character (context->printer, ',');
2825 pp_base_newline (context->printer);
2828 if (context->show_column && s.column != 0)
2829 pp_printf (context->printer,
2830 _(" inlined from %qs at %s:%d:%d"),
2831 cxx_printable_name_translate (fndecl, 2),
2832 s.file, s.line, s.column);
2834 pp_printf (context->printer,
2835 _(" inlined from %qs at %s:%d"),
2836 cxx_printable_name_translate (fndecl, 2),
2841 pp_printf (context->printer, _(" inlined from %qs"),
2842 cxx_printable_name_translate (fndecl, 2));
2845 pp_base_character (context->printer, ':');
2847 pp_base_newline (context->printer);
2849 diagnostic_set_last_function (context, diagnostic);
2850 pp_base_destroy_prefix (context->printer);
2851 context->printer->prefix = old_prefix;
2855 /* Returns a description of FUNCTION using standard terminology. The
2856 result is a format string of the form "In CATEGORY %qs". */
2858 function_category (tree fn)
2860 /* We can get called from the middle-end for diagnostics of function
2861 clones. Make sure we have language specific information before
2862 dereferencing it. */
2863 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
2864 && DECL_FUNCTION_MEMBER_P (fn))
2866 if (DECL_STATIC_FUNCTION_P (fn))
2867 return _("In static member function %qs");
2868 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2869 return _("In copy constructor %qs");
2870 else if (DECL_CONSTRUCTOR_P (fn))
2871 return _("In constructor %qs");
2872 else if (DECL_DESTRUCTOR_P (fn))
2873 return _("In destructor %qs");
2874 else if (LAMBDA_FUNCTION_P (fn))
2875 return _("In lambda function");
2877 return _("In member function %qs");
2880 return _("In function %qs");
2883 /* Report the full context of a current template instantiation,
2886 print_instantiation_full_context (diagnostic_context *context)
2888 struct tinst_level *p = current_instantiation ();
2889 location_t location = input_location;
2893 if (current_function_decl != p->decl
2894 && current_function_decl != NULL_TREE)
2895 /* We can get here during the processing of some synthesized
2896 method. Then, P->DECL will be the function that's causing
2901 if (current_function_decl == p->decl)
2902 /* Avoid redundancy with the "In function" line. */;
2904 pp_verbatim (context->printer,
2905 _("%s: In instantiation of %qs:\n"),
2906 LOCATION_FILE (location),
2907 decl_as_string_translate (p->decl,
2908 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2910 location = p->locus;
2915 print_instantiation_partial_context (context, p, location);
2918 /* Helper function of print_instantiation_partial_context() that
2919 prints a single line of instantiation context. */
2922 print_instantiation_partial_context_line (diagnostic_context *context,
2923 const struct tinst_level *t,
2924 location_t loc, bool recursive_p)
2926 expanded_location xloc;
2927 xloc = expand_location (loc);
2929 if (context->show_column)
2930 pp_verbatim (context->printer, _("%s:%d:%d: "),
2931 xloc.file, xloc.line, xloc.column);
2933 pp_verbatim (context->printer, _("%s:%d: "),
2934 xloc.file, xloc.line);
2938 if (TREE_CODE (t->decl) == TREE_LIST)
2939 pp_verbatim (context->printer,
2941 ? _("recursively required by substitution of %qS\n")
2942 : _("required by substitution of %qS\n"),
2945 pp_verbatim (context->printer,
2947 ? _("recursively required from %q#D\n")
2948 : _("required from %q#D\n"),
2953 pp_verbatim (context->printer,
2955 ? _("recursively required from here")
2956 : _("required from here"));
2960 /* Same as print_instantiation_full_context but less verbose. */
2963 print_instantiation_partial_context (diagnostic_context *context,
2964 struct tinst_level *t0, location_t loc)
2966 struct tinst_level *t;
2969 location_t prev_loc = loc;
2971 for (t = t0; t != NULL; t = t->next)
2972 if (prev_loc != t->locus)
2974 prev_loc = t->locus;
2982 int skip = n_total - 10;
2983 for (n = 0; n < 5; n++)
2985 gcc_assert (t != NULL);
2986 if (loc != t->locus)
2987 print_instantiation_partial_context_line (context, t, loc,
2988 /*recursive_p=*/false);
2992 if (t != NULL && skip > 1)
2994 expanded_location xloc;
2995 xloc = expand_location (loc);
2996 if (context->show_column)
2997 pp_verbatim (context->printer,
2998 _("%s:%d:%d: [ skipping %d instantiation contexts ]\n"),
2999 xloc.file, xloc.line, xloc.column, skip);
3001 pp_verbatim (context->printer,
3002 _("%s:%d: [ skipping %d instantiation contexts ]\n"),
3003 xloc.file, xloc.line, skip);
3008 } while (t != NULL && --skip > 0);
3014 while (t->next != NULL && t->locus == t->next->locus)
3019 print_instantiation_partial_context_line (context, t, loc,
3024 print_instantiation_partial_context_line (context, NULL, loc,
3025 /*recursive_p=*/false);
3026 pp_base_newline (context->printer);
3029 /* Called from cp_thing to print the template context for an error. */
3031 maybe_print_instantiation_context (diagnostic_context *context)
3033 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3036 record_last_problematic_instantiation ();
3037 print_instantiation_full_context (context);
3040 /* Report the bare minimum context of a template instantiation. */
3042 print_instantiation_context (void)
3044 print_instantiation_partial_context
3045 (global_dc, current_instantiation (), input_location);
3046 diagnostic_flush_buffer (global_dc);
3049 /* Report what constexpr call(s) we're trying to expand, if any. */
3052 maybe_print_constexpr_context (diagnostic_context *context)
3054 VEC(tree,heap) *call_stack = cx_error_context ();
3058 FOR_EACH_VEC_ELT (tree, call_stack, ix, t)
3060 expanded_location xloc = expand_location (EXPR_LOCATION (t));
3061 const char *s = expr_as_string (t, 0);
3062 if (context->show_column)
3063 pp_verbatim (context->printer,
3064 _("%s:%d:%d: in constexpr expansion of %qs"),
3065 xloc.file, xloc.line, xloc.column, s);
3067 pp_verbatim (context->printer,
3068 _("%s:%d: in constexpr expansion of %qs"),
3069 xloc.file, xloc.line, s);
3070 pp_base_newline (context->printer);
3074 /* Called from output_format -- during diagnostic message processing --
3075 to handle C++ specific format specifier with the following meanings:
3076 %A function argument-list.
3080 %F function declaration.
3081 %L language as used in extern "lang".
3083 %P function parameter whose position is indicated by an integer.
3084 %Q assignment operator.
3088 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
3089 int precision, bool wide, bool set_locus, bool verbose)
3093 #define next_tree (t = va_arg (*text->args_ptr, tree))
3094 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3095 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3096 #define next_int va_arg (*text->args_ptr, int)
3098 if (precision != 0 || wide)
3101 if (text->locus == NULL)
3106 case 'A': result = args_to_string (next_tree, verbose); break;
3107 case 'C': result = code_to_string (next_tcode); break;
3110 tree temp = next_tree;
3112 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
3114 temp = DECL_DEBUG_EXPR (temp);
3117 result = expr_to_string (temp);
3121 result = decl_to_string (temp, verbose);
3124 case 'E': result = expr_to_string (next_tree); break;
3125 case 'F': result = fndecl_to_string (next_tree, verbose); break;
3126 case 'L': result = language_to_string (next_lang); break;
3127 case 'O': result = op_to_string (next_tcode); break;
3128 case 'P': result = parm_to_string (next_int); break;
3129 case 'Q': result = assop_to_string (next_tcode); break;
3130 case 'S': result = subst_to_string (next_tree); break;
3131 case 'T': result = type_to_string (next_tree, verbose); break;
3132 case 'V': result = cv_to_string (next_tree, verbose); break;
3135 percent_K_format (text);
3142 pp_base_string (pp, result);
3143 if (set_locus && t != NULL)
3144 *text->locus = location_of (t);
3152 /* Warn about the use of C++0x features when appropriate. */
3154 maybe_warn_cpp0x (cpp0x_warn_str str)
3156 if ((cxx_dialect == cxx98) && !in_system_header)
3157 /* We really want to suppress this warning in system headers,
3158 because libstdc++ uses variadic templates even when we aren't
3162 case CPP0X_INITIALIZER_LISTS:
3163 pedwarn (input_location, 0,
3164 "extended initializer lists "
3165 "only available with -std=c++0x or -std=gnu++0x");
3167 case CPP0X_EXPLICIT_CONVERSION:
3168 pedwarn (input_location, 0,
3169 "explicit conversion operators "
3170 "only available with -std=c++0x or -std=gnu++0x");
3172 case CPP0X_VARIADIC_TEMPLATES:
3173 pedwarn (input_location, 0,
3174 "variadic templates "
3175 "only available with -std=c++0x or -std=gnu++0x");
3177 case CPP0X_LAMBDA_EXPR:
3178 pedwarn (input_location, 0,
3179 "lambda expressions "
3180 "only available with -std=c++0x or -std=gnu++0x");
3183 pedwarn (input_location, 0,
3184 "C++0x auto only available with -std=c++0x or -std=gnu++0x");
3186 case CPP0X_SCOPED_ENUMS:
3187 pedwarn (input_location, 0,
3188 "scoped enums only available with -std=c++0x or -std=gnu++0x");
3190 case CPP0X_DEFAULTED_DELETED:
3191 pedwarn (input_location, 0,
3192 "defaulted and deleted functions "
3193 "only available with -std=c++0x or -std=gnu++0x");
3195 case CPP0X_INLINE_NAMESPACES:
3196 pedwarn (input_location, OPT_pedantic,
3197 "inline namespaces "
3198 "only available with -std=c++0x or -std=gnu++0x");
3205 /* Warn about the use of variadic templates when appropriate. */
3207 maybe_warn_variadic_templates (void)
3209 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3213 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3214 option OPT with text GMSGID. Use this function to report
3215 diagnostics for constructs that are invalid C++98, but valid
3218 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3220 diagnostic_info diagnostic;
3223 va_start (ap, gmsgid);
3224 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
3225 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3226 diagnostic.option_index = opt;
3228 return report_diagnostic (&diagnostic);
3231 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3232 we found when we tried to do the lookup. LOCATION is the location of
3233 the NAME identifier. */
3236 qualified_name_lookup_error (tree scope, tree name,
3237 tree decl, location_t location)
3239 if (scope == error_mark_node)
3240 ; /* We already complained. */
3241 else if (TYPE_P (scope))
3243 if (!COMPLETE_TYPE_P (scope))
3244 error_at (location, "incomplete type %qT used in nested name specifier",
3246 else if (TREE_CODE (decl) == TREE_LIST)
3248 error_at (location, "reference to %<%T::%D%> is ambiguous",
3250 print_candidates (decl);
3253 error_at (location, "%qD is not a member of %qT", name, scope);
3255 else if (scope != global_namespace)
3257 error_at (location, "%qD is not a member of %qD", name, scope);
3258 suggest_alternatives_for (location, name);
3262 error_at (location, "%<::%D%> has not been declared", name);
3263 suggest_alternatives_for (location, name);