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)
311 pp_separate_with_comma (cxx_pp);
312 dump_type (t, TFF_PLAIN_IDENTIFIER);
313 pp_cxx_whitespace (cxx_pp);
315 pp_cxx_whitespace (cxx_pp);
316 t = tsubst (t, args, tf_none, NULL_TREE);
317 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
318 pp_simple_type_specifier doesn't know about it. */
319 t = strip_typedefs (t);
320 dump_type (t, TFF_PLAIN_IDENTIFIER);
324 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
328 dump_type (tree t, int flags)
333 /* Don't print e.g. "struct mytypedef". */
334 if (TYPE_P (t) && typedef_variant_p (t))
336 tree decl = TYPE_NAME (t);
337 if ((flags & TFF_CHASE_TYPEDEF)
338 || DECL_SELF_REFERENCE_P (decl)
339 || (!flag_pretty_templates
340 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)))
341 t = strip_typedefs (t);
342 else if (same_type_p (t, TREE_TYPE (decl)))
346 pp_cxx_cv_qualifier_seq (cxx_pp, t);
347 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
352 if (TYPE_PTRMEMFUNC_P (t))
355 switch (TREE_CODE (t))
358 if (t == init_list_type_node)
359 pp_string (cxx_pp, M_("<brace-enclosed initializer list>"));
360 else if (t == unknown_type_node)
361 pp_string (cxx_pp, M_("<unresolved overloaded function type>"));
364 pp_cxx_cv_qualifier_seq (cxx_pp, t);
365 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
370 /* A list of function parms. */
371 dump_parameters (t, flags);
374 case IDENTIFIER_NODE:
375 pp_cxx_tree_identifier (cxx_pp, t);
379 dump_type (BINFO_TYPE (t), flags);
385 dump_aggr_type (t, flags);
389 if (flags & TFF_CHASE_TYPEDEF)
391 dump_type (DECL_ORIGINAL_TYPE (t)
392 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
395 /* Else fall through. */
399 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
408 case FIXED_POINT_TYPE:
409 pp_type_specifier_seq (cxx_pp, t);
412 case TEMPLATE_TEMPLATE_PARM:
413 /* For parameters inside template signature. */
414 if (TYPE_IDENTIFIER (t))
415 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
417 pp_cxx_canonical_template_parameter (cxx_pp, t);
420 case BOUND_TEMPLATE_TEMPLATE_PARM:
422 tree args = TYPE_TI_ARGS (t);
423 pp_cxx_cv_qualifier_seq (cxx_pp, t);
424 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
425 pp_cxx_begin_template_argument_list (cxx_pp);
426 dump_template_argument_list (args, flags);
427 pp_cxx_end_template_argument_list (cxx_pp);
431 case TEMPLATE_TYPE_PARM:
432 pp_cxx_cv_qualifier_seq (cxx_pp, t);
433 if (TYPE_IDENTIFIER (t))
434 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
436 pp_cxx_canonical_template_parameter
437 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
440 /* This is not always necessary for pointers and such, but doing this
441 reduces code size. */
450 dump_type_prefix (t, flags);
451 dump_type_suffix (t, flags);
455 if (! (flags & TFF_CHASE_TYPEDEF)
456 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
458 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
461 pp_cxx_cv_qualifier_seq (cxx_pp, t);
462 pp_cxx_ws_string (cxx_pp,
463 TYPENAME_IS_ENUM_P (t) ? "enum"
464 : TYPENAME_IS_CLASS_P (t) ? "class"
466 dump_typename (t, flags);
469 case UNBOUND_CLASS_TEMPLATE:
470 if (! (flags & TFF_UNQUALIFIED_NAME))
472 dump_type (TYPE_CONTEXT (t), flags);
473 pp_cxx_colon_colon (cxx_pp);
475 pp_cxx_ws_string (cxx_pp, "template");
476 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
480 pp_cxx_ws_string (cxx_pp, "__typeof__");
481 pp_cxx_whitespace (cxx_pp);
482 pp_cxx_left_paren (cxx_pp);
483 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
484 pp_cxx_right_paren (cxx_pp);
487 case UNDERLYING_TYPE:
488 pp_cxx_ws_string (cxx_pp, "__underlying_type");
489 pp_cxx_whitespace (cxx_pp);
490 pp_cxx_left_paren (cxx_pp);
491 dump_expr (UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
492 pp_cxx_right_paren (cxx_pp);
495 case TYPE_PACK_EXPANSION:
496 dump_type (PACK_EXPANSION_PATTERN (t), flags);
497 pp_cxx_ws_string (cxx_pp, "...");
500 case TYPE_ARGUMENT_PACK:
501 dump_template_argument (t, flags);
505 pp_cxx_ws_string (cxx_pp, "decltype");
506 pp_cxx_whitespace (cxx_pp);
507 pp_cxx_left_paren (cxx_pp);
508 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
509 pp_cxx_right_paren (cxx_pp);
513 pp_string (cxx_pp, "std::nullptr_t");
517 pp_unsupported_tree (cxx_pp, t);
518 /* Fall through to error. */
521 pp_string (cxx_pp, M_("<type error>"));
526 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
530 dump_typename (tree t, int flags)
532 tree ctx = TYPE_CONTEXT (t);
534 if (TREE_CODE (ctx) == TYPENAME_TYPE)
535 dump_typename (ctx, flags);
537 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
538 pp_cxx_colon_colon (cxx_pp);
539 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
542 /* Return the name of the supplied aggregate, or enumeral type. */
545 class_key_or_enum_as_string (tree t)
547 if (TREE_CODE (t) == ENUMERAL_TYPE)
549 if (SCOPED_ENUM_P (t))
554 else if (TREE_CODE (t) == UNION_TYPE)
556 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
562 /* Print out a class declaration T under the control of FLAGS,
563 in the form `class foo'. */
566 dump_aggr_type (tree t, int flags)
569 const char *variety = class_key_or_enum_as_string (t);
573 pp_cxx_cv_qualifier_seq (cxx_pp, t);
575 if (flags & TFF_CLASS_KEY_OR_ENUM)
576 pp_cxx_ws_string (cxx_pp, variety);
578 name = TYPE_NAME (t);
582 typdef = !DECL_ARTIFICIAL (name);
585 && ((flags & TFF_CHASE_TYPEDEF)
586 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
587 && DECL_TEMPLATE_INFO (name))))
588 || DECL_SELF_REFERENCE_P (name))
590 t = TYPE_MAIN_VARIANT (t);
591 name = TYPE_NAME (t);
595 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
596 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
597 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
598 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
600 if (! (flags & TFF_UNQUALIFIED_NAME))
601 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
602 flags &= ~TFF_UNQUALIFIED_NAME;
605 /* Because the template names are mangled, we have to locate
606 the most general template, and use that name. */
607 tree tpl = CLASSTYPE_TI_TEMPLATE (t);
609 while (DECL_TEMPLATE_INFO (tpl))
610 tpl = DECL_TI_TEMPLATE (tpl);
613 name = DECL_NAME (name);
616 if (name == 0 || ANON_AGGRNAME_P (name))
618 if (flags & TFF_CLASS_KEY_OR_ENUM)
619 pp_string (cxx_pp, M_("<anonymous>"));
621 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety);
623 else if (LAMBDANAME_P (name))
625 /* A lambda's "type" is essentially its signature. */
626 pp_string (cxx_pp, M_("<lambda"));
627 if (lambda_function (t))
628 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
630 pp_character(cxx_pp, '>');
633 pp_cxx_tree_identifier (cxx_pp, name);
635 dump_template_parms (TYPE_TEMPLATE_INFO (t),
636 !CLASSTYPE_USE_TEMPLATE (t),
637 flags & ~TFF_TEMPLATE_HEADER);
640 /* Dump into the obstack the initial part of the output for a given type.
641 This is necessary when dealing with things like functions returning
644 return type of `int (* fee ())()': pointer -> function -> int. Both
645 pointer (and reference and offset) and function (and member) types must
646 deal with prefix and suffix.
648 Arrays must also do this for DECL nodes, like int a[], and for things like
652 dump_type_prefix (tree t, int flags)
654 if (TYPE_PTRMEMFUNC_P (t))
656 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
660 switch (TREE_CODE (t))
665 tree sub = TREE_TYPE (t);
667 dump_type_prefix (sub, flags);
668 if (TREE_CODE (sub) == ARRAY_TYPE
669 || TREE_CODE (sub) == FUNCTION_TYPE)
671 pp_cxx_whitespace (cxx_pp);
672 pp_cxx_left_paren (cxx_pp);
673 pp_c_attributes_display (pp_c_base (cxx_pp),
674 TYPE_ATTRIBUTES (sub));
676 if (TREE_CODE (t) == POINTER_TYPE)
677 pp_character(cxx_pp, '*');
678 else if (TREE_CODE (t) == REFERENCE_TYPE)
680 if (TYPE_REF_IS_RVALUE (t))
681 pp_string (cxx_pp, "&&");
683 pp_character (cxx_pp, '&');
685 pp_base (cxx_pp)->padding = pp_before;
686 pp_cxx_cv_qualifier_seq (cxx_pp, t);
692 dump_type_prefix (TREE_TYPE (t), flags);
693 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
695 pp_maybe_space (cxx_pp);
696 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
697 pp_cxx_left_paren (cxx_pp);
698 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
699 pp_cxx_colon_colon (cxx_pp);
701 pp_cxx_star (cxx_pp);
702 pp_cxx_cv_qualifier_seq (cxx_pp, t);
703 pp_base (cxx_pp)->padding = pp_before;
706 /* This can be reached without a pointer when dealing with
707 templates, e.g. std::is_function. */
709 dump_type_prefix (TREE_TYPE (t), flags);
713 dump_type_prefix (TREE_TYPE (t), flags);
714 pp_maybe_space (cxx_pp);
715 pp_cxx_left_paren (cxx_pp);
716 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
717 pp_cxx_colon_colon (cxx_pp);
721 dump_type_prefix (TREE_TYPE (t), flags);
725 case IDENTIFIER_NODE:
730 case TEMPLATE_TYPE_PARM:
731 case TEMPLATE_TEMPLATE_PARM:
732 case BOUND_TEMPLATE_TEMPLATE_PARM:
743 case UNDERLYING_TYPE:
745 case TYPE_PACK_EXPANSION:
746 case FIXED_POINT_TYPE:
748 dump_type (t, flags);
749 pp_base (cxx_pp)->padding = pp_before;
753 pp_unsupported_tree (cxx_pp, t);
756 pp_string (cxx_pp, M_("<typeprefixerror>"));
761 /* Dump the suffix of type T, under control of FLAGS. This is the part
762 which appears after the identifier (or function parms). */
765 dump_type_suffix (tree t, int flags)
767 if (TYPE_PTRMEMFUNC_P (t))
768 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
770 switch (TREE_CODE (t))
775 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
776 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
777 pp_cxx_right_paren (cxx_pp);
778 dump_type_suffix (TREE_TYPE (t), flags);
785 if (TREE_CODE (t) == METHOD_TYPE)
786 /* Can only be reached through a pointer. */
787 pp_cxx_right_paren (cxx_pp);
788 arg = TYPE_ARG_TYPES (t);
789 if (TREE_CODE (t) == METHOD_TYPE)
790 arg = TREE_CHAIN (arg);
792 /* Function pointers don't have default args. Not in standard C++,
793 anyway; they may in g++, but we'll just pretend otherwise. */
794 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
796 if (TREE_CODE (t) == METHOD_TYPE)
797 pp_cxx_cv_qualifier_seq
798 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
800 pp_cxx_cv_qualifier_seq (cxx_pp, t);
801 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
802 dump_type_suffix (TREE_TYPE (t), flags);
807 pp_maybe_space (cxx_pp);
808 pp_cxx_left_bracket (cxx_pp);
811 tree dtype = TYPE_DOMAIN (t);
812 tree max = TYPE_MAX_VALUE (dtype);
813 if (host_integerp (max, 0))
814 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
815 else if (TREE_CODE (max) == MINUS_EXPR)
816 dump_expr (TREE_OPERAND (max, 0),
817 flags & ~TFF_EXPR_IN_PARENS);
819 dump_expr (fold_build2_loc (input_location,
820 PLUS_EXPR, dtype, max,
821 build_int_cst (dtype, 1)),
822 flags & ~TFF_EXPR_IN_PARENS);
824 pp_cxx_right_bracket (cxx_pp);
825 dump_type_suffix (TREE_TYPE (t), flags);
829 case IDENTIFIER_NODE:
834 case TEMPLATE_TYPE_PARM:
835 case TEMPLATE_TEMPLATE_PARM:
836 case BOUND_TEMPLATE_TEMPLATE_PARM:
847 case UNDERLYING_TYPE:
849 case TYPE_PACK_EXPANSION:
850 case FIXED_POINT_TYPE:
855 pp_unsupported_tree (cxx_pp, t);
857 /* Don't mark it here, we should have already done in
864 dump_global_iord (tree t)
866 const char *p = NULL;
868 if (DECL_GLOBAL_CTOR_P (t))
869 p = M_("(static initializers for %s)");
870 else if (DECL_GLOBAL_DTOR_P (t))
871 p = M_("(static destructors for %s)");
875 pp_printf (pp_base (cxx_pp), p, input_filename);
879 dump_simple_decl (tree t, tree type, int flags)
881 if (flags & TFF_DECL_SPECIFIERS)
883 if (TREE_CODE (t) == VAR_DECL
884 && DECL_DECLARED_CONSTEXPR_P (t))
885 pp_cxx_ws_string (cxx_pp, "constexpr");
886 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
887 pp_maybe_space (cxx_pp);
889 if (! (flags & TFF_UNQUALIFIED_NAME)
890 && TREE_CODE (t) != PARM_DECL
891 && (!DECL_INITIAL (t)
892 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
893 dump_scope (CP_DECL_CONTEXT (t), flags);
894 flags &= ~TFF_UNQUALIFIED_NAME;
895 if ((flags & TFF_DECL_SPECIFIERS)
896 && DECL_TEMPLATE_PARM_P (t)
897 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
898 pp_string (cxx_pp, "...");
900 dump_decl (DECL_NAME (t), flags);
902 pp_string (cxx_pp, M_("<anonymous>"));
903 if (flags & TFF_DECL_SPECIFIERS)
904 dump_type_suffix (type, flags);
907 /* Dump a human readable string for the decl T under control of FLAGS. */
910 dump_decl (tree t, int flags)
915 /* If doing Objective-C++, give Objective-C a chance to demangle
916 Objective-C method names. */
917 if (c_dialect_objc ())
919 const char *demangled = objc_maybe_printable_name (t, flags);
922 pp_string (cxx_pp, demangled);
927 switch (TREE_CODE (t))
930 /* Don't say 'typedef class A' */
931 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
933 if ((flags & TFF_DECL_SPECIFIERS)
934 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
936 /* Say `class T' not just `T'. */
937 pp_cxx_ws_string (cxx_pp, "class");
939 /* Emit the `...' for a parameter pack. */
940 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
941 pp_cxx_ws_string (cxx_pp, "...");
944 dump_type (TREE_TYPE (t), flags);
947 if ((flags & TFF_DECL_SPECIFIERS)
948 && !DECL_SELF_REFERENCE_P (t))
949 pp_cxx_ws_string (cxx_pp, "typedef");
950 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
951 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
956 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
958 pp_string (cxx_pp, M_("vtable for "));
959 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
960 dump_type (DECL_CONTEXT (t), flags);
963 /* Else fall through. */
966 dump_simple_decl (t, TREE_TYPE (t), flags);
970 pp_string (cxx_pp, M_("<return value> "));
971 dump_simple_decl (t, TREE_TYPE (t), flags);
975 if (flags & TFF_DECL_SPECIFIERS)
976 pp_cxx_declaration (cxx_pp, t);
979 if (! (flags & TFF_UNQUALIFIED_NAME))
980 dump_scope (CP_DECL_CONTEXT (t), flags);
981 flags &= ~TFF_UNQUALIFIED_NAME;
982 if (DECL_NAME (t) == NULL_TREE)
983 pp_cxx_ws_string (cxx_pp, M_("{anonymous}"));
985 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
990 dump_type (TREE_OPERAND (t, 0), flags);
991 pp_string (cxx_pp, "::");
992 dump_decl (TREE_OPERAND (t, 1), flags|TFF_UNQUALIFIED_NAME);
996 dump_decl (TREE_OPERAND (t, 0), flags);
997 pp_cxx_left_bracket (cxx_pp);
998 dump_decl (TREE_OPERAND (t, 1), flags);
999 pp_cxx_right_bracket (cxx_pp);
1002 /* So that we can do dump_decl on an aggr type. */
1006 dump_type (t, flags);
1010 /* This is a pseudo destructor call which has not been folded into
1011 a PSEUDO_DTOR_EXPR yet. */
1012 pp_cxx_complement (cxx_pp);
1013 dump_type (TREE_OPERAND (t, 0), flags);
1020 /* These special cases are duplicated here so that other functions
1021 can feed identifiers to error and get them demangled properly. */
1022 case IDENTIFIER_NODE:
1023 if (IDENTIFIER_TYPENAME_P (t))
1025 pp_cxx_ws_string (cxx_pp, "operator");
1026 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1027 dump_type (TREE_TYPE (t), flags);
1031 pp_cxx_tree_identifier (cxx_pp, t);
1037 t = OVL_CURRENT (t);
1038 if (DECL_CLASS_SCOPE_P (t))
1040 dump_type (DECL_CONTEXT (t), flags);
1041 pp_cxx_colon_colon (cxx_pp);
1043 else if (!DECL_FILE_SCOPE_P (t))
1045 dump_decl (DECL_CONTEXT (t), flags);
1046 pp_cxx_colon_colon (cxx_pp);
1048 dump_decl (DECL_NAME (t), flags);
1052 /* If there's only one function, just treat it like an ordinary
1054 t = OVL_CURRENT (t);
1058 if (! DECL_LANG_SPECIFIC (t))
1059 pp_string (cxx_pp, M_("<built-in>"));
1060 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1061 dump_global_iord (t);
1063 dump_function_decl (t, flags);
1067 dump_template_decl (t, flags);
1070 case TEMPLATE_ID_EXPR:
1072 tree name = TREE_OPERAND (t, 0);
1074 if (is_overloaded_fn (name))
1075 name = DECL_NAME (get_first_fn (name));
1076 dump_decl (name, flags);
1077 pp_cxx_begin_template_argument_list (cxx_pp);
1078 if (TREE_OPERAND (t, 1))
1079 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
1080 pp_cxx_end_template_argument_list (cxx_pp);
1085 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1089 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1090 || (DECL_INITIAL (t) &&
1091 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1092 dump_simple_decl (t, TREE_TYPE (t), flags);
1093 else if (DECL_NAME (t))
1094 dump_decl (DECL_NAME (t), flags);
1095 else if (DECL_INITIAL (t))
1096 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1098 pp_string (cxx_pp, M_("<enumerator>"));
1102 pp_cxx_ws_string (cxx_pp, "using");
1103 dump_type (USING_DECL_SCOPE (t), flags);
1104 pp_cxx_colon_colon (cxx_pp);
1105 dump_decl (DECL_NAME (t), flags);
1109 pp_cxx_declaration (cxx_pp, t);
1113 dump_decl (BASELINK_FUNCTIONS (t), flags);
1116 case NON_DEPENDENT_EXPR:
1117 dump_expr (t, flags);
1120 case TEMPLATE_TYPE_PARM:
1121 if (flags & TFF_DECL_SPECIFIERS)
1122 pp_cxx_declaration (cxx_pp, t);
1124 pp_type_id (cxx_pp, t);
1127 case UNBOUND_CLASS_TEMPLATE:
1128 case TYPE_PACK_EXPANSION:
1130 dump_type (t, flags);
1134 pp_unsupported_tree (cxx_pp, t);
1135 /* Fall through to error. */
1138 pp_string (cxx_pp, M_("<declaration error>"));
1143 /* Dump a template declaration T under control of FLAGS. This means the
1144 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1147 dump_template_decl (tree t, int flags)
1149 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1153 if (flags & TFF_TEMPLATE_HEADER)
1155 for (parms = orig_parms = nreverse (orig_parms);
1157 parms = TREE_CHAIN (parms))
1159 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1160 int len = TREE_VEC_LENGTH (inner_parms);
1162 pp_cxx_ws_string (cxx_pp, "template");
1163 pp_cxx_begin_template_argument_list (cxx_pp);
1165 /* If we've shown the template prefix, we'd better show the
1166 parameters' and decl's type too. */
1167 flags |= TFF_DECL_SPECIFIERS;
1169 for (i = 0; i < len; i++)
1172 pp_separate_with_comma (cxx_pp);
1173 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1175 pp_cxx_end_template_argument_list (cxx_pp);
1176 pp_cxx_whitespace (cxx_pp);
1178 nreverse(orig_parms);
1180 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1182 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1183 pp_cxx_ws_string (cxx_pp, "class");
1185 /* If this is a parameter pack, print the ellipsis. */
1186 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1187 pp_cxx_ws_string (cxx_pp, "...");
1191 if (DECL_TEMPLATE_RESULT (t)
1192 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
1193 dump_type (TREE_TYPE (t),
1194 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1195 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1196 else if (DECL_TEMPLATE_RESULT (t)
1197 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL)
1198 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1201 gcc_assert (TREE_TYPE (t));
1202 switch (NEXT_CODE (t))
1206 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1209 /* This case can occur with some invalid code. */
1210 dump_type (TREE_TYPE (t),
1211 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1212 | (flags & TFF_DECL_SPECIFIERS
1213 ? TFF_CLASS_KEY_OR_ENUM : 0));
1218 /* find_typenames looks through the type of the function template T
1219 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1222 struct find_typenames_t
1224 struct pointer_set_t *p_set;
1225 VEC (tree,gc) *typenames;
1229 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1231 struct find_typenames_t *d = (struct find_typenames_t *)data;
1232 tree mv = NULL_TREE;
1234 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1235 /* Add the type of the typedef without any additional cv-quals. */
1236 mv = TREE_TYPE (TYPE_NAME (*tp));
1237 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1238 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1239 /* Add the typename without any cv-qualifiers. */
1240 mv = TYPE_MAIN_VARIANT (*tp);
1242 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1243 VEC_safe_push (tree, gc, d->typenames, mv);
1245 /* Search into class template arguments, which cp_walk_subtrees
1247 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1248 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1254 static VEC(tree,gc) *
1255 find_typenames (tree t)
1257 struct find_typenames_t ft;
1258 ft.p_set = pointer_set_create ();
1259 ft.typenames = NULL;
1260 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1261 find_typenames_r, &ft, ft.p_set);
1262 pointer_set_destroy (ft.p_set);
1263 return ft.typenames;
1266 /* Pretty print a function decl. There are several ways we want to print a
1267 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1268 As error can only apply the '#' flag once to give 0 and 1 for V, there
1269 is %D which doesn't print the throw specs, and %F which does. */
1272 dump_function_decl (tree t, int flags)
1276 tree cname = NULL_TREE;
1277 tree template_args = NULL_TREE;
1278 tree template_parms = NULL_TREE;
1279 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1280 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1282 VEC(tree,gc) *typenames = NULL;
1284 if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1286 /* A lambda's signature is essentially its "type", so defer. */
1287 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t)));
1288 dump_type (DECL_CONTEXT (t), flags);
1292 flags &= ~TFF_UNQUALIFIED_NAME;
1293 if (TREE_CODE (t) == TEMPLATE_DECL)
1294 t = DECL_TEMPLATE_RESULT (t);
1296 /* Save the exceptions, in case t is a specialization and we are
1297 emitting an error about incompatible specifications. */
1298 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1300 /* Pretty print template instantiations only. */
1301 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1302 && flag_pretty_templates)
1306 template_args = DECL_TI_ARGS (t);
1307 tmpl = most_general_template (t);
1308 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1310 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1312 typenames = find_typenames (t);
1316 fntype = TREE_TYPE (t);
1317 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1319 if (DECL_CLASS_SCOPE_P (t))
1320 cname = DECL_CONTEXT (t);
1321 /* This is for partially instantiated template methods. */
1322 else if (TREE_CODE (fntype) == METHOD_TYPE)
1323 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1325 if (flags & TFF_DECL_SPECIFIERS)
1327 if (DECL_STATIC_FUNCTION_P (t))
1328 pp_cxx_ws_string (cxx_pp, "static");
1329 else if (DECL_VIRTUAL_P (t))
1330 pp_cxx_ws_string (cxx_pp, "virtual");
1332 if (DECL_DECLARED_CONSTEXPR_P (STRIP_TEMPLATE (t)))
1333 pp_cxx_ws_string (cxx_pp, "constexpr");
1336 /* Print the return type? */
1338 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1339 && !DECL_DESTRUCTOR_P (t);
1341 dump_type_prefix (TREE_TYPE (fntype), flags);
1343 /* Print the function name. */
1344 if (!do_outer_scope)
1348 dump_type (cname, flags);
1349 pp_cxx_colon_colon (cxx_pp);
1352 dump_scope (CP_DECL_CONTEXT (t), flags);
1354 dump_function_name (t, flags);
1356 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1358 dump_parameters (parmtypes, flags);
1360 if (TREE_CODE (fntype) == METHOD_TYPE)
1362 pp_base (cxx_pp)->padding = pp_before;
1363 pp_cxx_cv_qualifier_seq
1364 (cxx_pp, TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1367 if (flags & TFF_EXCEPTION_SPECIFICATION)
1369 pp_base (cxx_pp)->padding = pp_before;
1370 dump_exception_spec (exceptions, flags);
1374 dump_type_suffix (TREE_TYPE (fntype), flags);
1377 /* If T is a template instantiation, dump the parameter binding. */
1378 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1380 pp_cxx_whitespace (cxx_pp);
1381 pp_cxx_left_bracket (cxx_pp);
1382 pp_cxx_ws_string (cxx_pp, M_("with"));
1383 pp_cxx_whitespace (cxx_pp);
1384 dump_template_bindings (template_parms, template_args, typenames);
1385 pp_cxx_right_bracket (cxx_pp);
1389 /* Print a parameter list. If this is for a member function, the
1390 member object ptr (and any other hidden args) should have
1391 already been removed. */
1394 dump_parameters (tree parmtypes, int flags)
1397 flags &= ~TFF_SCOPE;
1398 pp_cxx_left_paren (cxx_pp);
1400 for (first = 1; parmtypes != void_list_node;
1401 parmtypes = TREE_CHAIN (parmtypes))
1404 pp_separate_with_comma (cxx_pp);
1408 pp_cxx_ws_string (cxx_pp, "...");
1412 dump_type (TREE_VALUE (parmtypes), flags);
1414 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1416 pp_cxx_whitespace (cxx_pp);
1418 pp_cxx_whitespace (cxx_pp);
1419 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1423 pp_cxx_right_paren (cxx_pp);
1426 /* Print an exception specification. T is the exception specification. */
1429 dump_exception_spec (tree t, int flags)
1431 if (t && TREE_PURPOSE (t))
1433 pp_cxx_ws_string (cxx_pp, "noexcept");
1434 pp_cxx_whitespace (cxx_pp);
1435 pp_cxx_left_paren (cxx_pp);
1436 dump_expr (TREE_PURPOSE (t), flags);
1437 pp_cxx_right_paren (cxx_pp);
1441 pp_cxx_ws_string (cxx_pp, "throw");
1442 pp_cxx_whitespace (cxx_pp);
1443 pp_cxx_left_paren (cxx_pp);
1444 if (TREE_VALUE (t) != NULL_TREE)
1447 dump_type (TREE_VALUE (t), flags);
1451 pp_separate_with_comma (cxx_pp);
1453 pp_cxx_right_paren (cxx_pp);
1457 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1458 and destructors properly. */
1461 dump_function_name (tree t, int flags)
1463 tree name = DECL_NAME (t);
1465 /* We can get here with a decl that was synthesized by language-
1466 independent machinery (e.g. coverage.c) in which case it won't
1467 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1468 will crash. In this case it is safe just to print out the
1470 if (!DECL_LANG_SPECIFIC (t))
1472 pp_cxx_tree_identifier (cxx_pp, name);
1476 if (TREE_CODE (t) == TEMPLATE_DECL)
1477 t = DECL_TEMPLATE_RESULT (t);
1479 /* Don't let the user see __comp_ctor et al. */
1480 if (DECL_CONSTRUCTOR_P (t)
1481 || DECL_DESTRUCTOR_P (t))
1483 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1484 name = get_identifier ("<lambda>");
1486 name = constructor_name (DECL_CONTEXT (t));
1489 if (DECL_DESTRUCTOR_P (t))
1491 pp_cxx_complement (cxx_pp);
1492 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1494 else if (DECL_CONV_FN_P (t))
1496 /* This cannot use the hack that the operator's return
1497 type is stashed off of its name because it may be
1498 used for error reporting. In the case of conflicting
1499 declarations, both will have the same name, yet
1500 the types will be different, hence the TREE_TYPE field
1501 of the first name will be clobbered by the second. */
1502 pp_cxx_ws_string (cxx_pp, "operator");
1503 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1505 else if (name && IDENTIFIER_OPNAME_P (name))
1506 pp_cxx_tree_identifier (cxx_pp, name);
1508 dump_decl (name, flags);
1510 if (DECL_TEMPLATE_INFO (t)
1511 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1512 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1513 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1514 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1517 /* Dump the template parameters from the template info INFO under control of
1518 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1519 specialization (partial or complete). For partial specializations we show
1520 the specialized parameter values. For a primary template we show no
1524 dump_template_parms (tree info, int primary, int flags)
1526 tree args = info ? TI_ARGS (info) : NULL_TREE;
1528 if (primary && flags & TFF_TEMPLATE_NAME)
1530 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1531 pp_cxx_begin_template_argument_list (cxx_pp);
1533 /* Be careful only to print things when we have them, so as not
1534 to crash producing error messages. */
1535 if (args && !primary)
1538 len = get_non_default_template_args_count (args, flags);
1540 args = INNERMOST_TEMPLATE_ARGS (args);
1541 for (ix = 0; ix != len; ix++)
1543 tree arg = TREE_VEC_ELT (args, ix);
1545 /* Only print a comma if we know there is an argument coming. In
1546 the case of an empty template argument pack, no actual
1547 argument will be printed. */
1549 && (!ARGUMENT_PACK_P (arg)
1550 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1551 pp_separate_with_comma (cxx_pp);
1554 pp_string (cxx_pp, M_("<template parameter error>"));
1556 dump_template_argument (arg, flags);
1561 tree tpl = TI_TEMPLATE (info);
1562 tree parms = DECL_TEMPLATE_PARMS (tpl);
1565 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1566 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1568 for (ix = 0; ix != len; ix++)
1572 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1574 pp_string (cxx_pp, M_("<template parameter error>"));
1578 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1581 pp_separate_with_comma (cxx_pp);
1583 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1586 pp_cxx_end_template_argument_list (cxx_pp);
1589 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1590 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1593 dump_call_expr_args (tree t, int flags, bool skipfirst)
1596 call_expr_arg_iterator iter;
1598 pp_cxx_left_paren (cxx_pp);
1599 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1605 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1606 if (more_call_expr_args_p (&iter))
1607 pp_separate_with_comma (cxx_pp);
1610 pp_cxx_right_paren (cxx_pp);
1613 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1614 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1618 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1621 aggr_init_expr_arg_iterator iter;
1623 pp_cxx_left_paren (cxx_pp);
1624 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1630 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1631 if (more_aggr_init_expr_args_p (&iter))
1632 pp_separate_with_comma (cxx_pp);
1635 pp_cxx_right_paren (cxx_pp);
1638 /* Print out a list of initializers (subr of dump_expr). */
1641 dump_expr_list (tree l, int flags)
1645 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1648 pp_separate_with_comma (cxx_pp);
1652 /* Print out a vector of initializers (subr of dump_expr). */
1655 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1657 unsigned HOST_WIDE_INT idx;
1660 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1662 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1663 if (idx != VEC_length (constructor_elt, v) - 1)
1664 pp_separate_with_comma (cxx_pp);
1669 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1670 function. Resolve it to a close relative -- in the sense of static
1671 type -- variant being overridden. That is close to what was written in
1672 the source code. Subroutine of dump_expr. */
1675 resolve_virtual_fun_from_obj_type_ref (tree ref)
1677 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1678 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1679 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1682 fun = TREE_CHAIN (fun);
1683 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1684 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1690 /* Print out an expression E under control of FLAGS. */
1693 dump_expr (tree t, int flags)
1698 if (STATEMENT_CLASS_P (t))
1700 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1704 switch (TREE_CODE (t))
1712 case NAMESPACE_DECL:
1716 case IDENTIFIER_NODE:
1717 dump_decl (t, (flags & ~TFF_DECL_SPECIFIERS) | TFF_NO_FUNCTION_ARGUMENTS);
1724 pp_constant (cxx_pp, t);
1728 /* While waiting for caret diagnostics, avoid printing
1729 __cxa_allocate_exception, __cxa_throw, and the like. */
1730 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1734 pp_ampersand (cxx_pp);
1735 dump_type (PTRMEM_CST_CLASS (t), flags);
1736 pp_cxx_colon_colon (cxx_pp);
1737 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1741 pp_cxx_left_paren (cxx_pp);
1742 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1743 pp_separate_with_comma (cxx_pp);
1744 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1745 pp_cxx_right_paren (cxx_pp);
1749 pp_cxx_left_paren (cxx_pp);
1750 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1751 pp_string (cxx_pp, " ? ");
1752 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1753 pp_string (cxx_pp, " : ");
1754 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1755 pp_cxx_right_paren (cxx_pp);
1759 if (TREE_HAS_CONSTRUCTOR (t))
1761 pp_cxx_ws_string (cxx_pp, "new");
1762 pp_cxx_whitespace (cxx_pp);
1763 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1766 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1769 case AGGR_INIT_EXPR:
1771 tree fn = NULL_TREE;
1773 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1774 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1776 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1778 if (DECL_CONSTRUCTOR_P (fn))
1779 dump_type (DECL_CONTEXT (fn), flags);
1784 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1786 dump_aggr_init_expr_args (t, flags, true);
1791 tree fn = CALL_EXPR_FN (t);
1792 bool skipfirst = false;
1794 if (TREE_CODE (fn) == ADDR_EXPR)
1795 fn = TREE_OPERAND (fn, 0);
1797 /* Nobody is interested in seeing the guts of vcalls. */
1798 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1799 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1801 if (TREE_TYPE (fn) != NULL_TREE
1802 && NEXT_CODE (fn) == METHOD_TYPE
1803 && call_expr_nargs (t))
1805 tree ob = CALL_EXPR_ARG (t, 0);
1806 if (TREE_CODE (ob) == ADDR_EXPR)
1808 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1809 pp_cxx_dot (cxx_pp);
1811 else if (TREE_CODE (ob) != PARM_DECL
1812 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1814 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1815 pp_cxx_arrow (cxx_pp);
1819 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1820 dump_call_expr_args (t, flags, skipfirst);
1825 /* Note that this only works for G++ target exprs. If somebody
1826 builds a general TARGET_EXPR, there's no way to represent that
1827 it initializes anything other that the parameter slot for the
1828 default argument. Note we may have cleared out the first
1829 operand in expand_expr, so don't go killing ourselves. */
1830 if (TREE_OPERAND (t, 1))
1831 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1834 case POINTER_PLUS_EXPR:
1835 dump_binary_op ("+", t, flags);
1843 case TRUNC_DIV_EXPR:
1844 case TRUNC_MOD_EXPR:
1852 case TRUTH_ANDIF_EXPR:
1853 case TRUTH_ORIF_EXPR:
1860 case EXACT_DIV_EXPR:
1861 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1865 case FLOOR_DIV_EXPR:
1866 case ROUND_DIV_EXPR:
1868 dump_binary_op ("/", t, flags);
1872 case FLOOR_MOD_EXPR:
1873 case ROUND_MOD_EXPR:
1874 dump_binary_op ("%", t, flags);
1879 tree ob = TREE_OPERAND (t, 0);
1880 if (TREE_CODE (ob) == INDIRECT_REF)
1882 ob = TREE_OPERAND (ob, 0);
1883 if (TREE_CODE (ob) != PARM_DECL
1885 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1887 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1888 pp_cxx_arrow (cxx_pp);
1893 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1894 pp_cxx_dot (cxx_pp);
1896 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1901 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1902 pp_cxx_left_bracket (cxx_pp);
1903 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1904 pp_cxx_right_bracket (cxx_pp);
1907 case UNARY_PLUS_EXPR:
1908 dump_unary_op ("+", t, flags);
1912 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1913 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
1914 /* An ADDR_EXPR can have reference type. In that case, we
1915 shouldn't print the `&' doing so indicates to the user
1916 that the expression has pointer type. */
1918 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
1919 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1920 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
1921 dump_unary_op ("&&", t, flags);
1923 dump_unary_op ("&", t, flags);
1927 if (TREE_HAS_CONSTRUCTOR (t))
1929 t = TREE_OPERAND (t, 0);
1930 gcc_assert (TREE_CODE (t) == CALL_EXPR);
1931 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
1932 dump_call_expr_args (t, flags, true);
1936 if (TREE_OPERAND (t,0) != NULL_TREE
1937 && TREE_TYPE (TREE_OPERAND (t, 0))
1938 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
1939 dump_expr (TREE_OPERAND (t, 0), flags);
1941 dump_unary_op ("*", t, flags);
1946 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
1947 && integer_zerop (TREE_OPERAND (t, 1)))
1948 dump_expr (TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
1951 pp_cxx_star (cxx_pp);
1952 if (!integer_zerop (TREE_OPERAND (t, 1)))
1954 pp_cxx_left_paren (cxx_pp);
1955 if (!integer_onep (TYPE_SIZE_UNIT
1956 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
1958 pp_cxx_left_paren (cxx_pp);
1959 dump_type (ptr_type_node, flags);
1960 pp_cxx_right_paren (cxx_pp);
1963 dump_expr (TREE_OPERAND (t, 0), flags);
1964 if (!integer_zerop (TREE_OPERAND (t, 1)))
1966 pp_cxx_ws_string (cxx_pp, "+");
1967 dump_expr (fold_convert (ssizetype, TREE_OPERAND (t, 1)), flags);
1968 pp_cxx_right_paren (cxx_pp);
1975 case TRUTH_NOT_EXPR:
1976 case PREDECREMENT_EXPR:
1977 case PREINCREMENT_EXPR:
1978 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
1981 case POSTDECREMENT_EXPR:
1982 case POSTINCREMENT_EXPR:
1983 pp_cxx_left_paren (cxx_pp);
1984 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1985 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
1986 pp_cxx_right_paren (cxx_pp);
1989 case NON_LVALUE_EXPR:
1990 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
1991 should be another level of INDIRECT_REF so that I don't have to do
1993 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
1995 tree next = TREE_TYPE (TREE_TYPE (t));
1997 while (TREE_CODE (next) == POINTER_TYPE)
1998 next = TREE_TYPE (next);
2000 if (TREE_CODE (next) == FUNCTION_TYPE)
2002 if (flags & TFF_EXPR_IN_PARENS)
2003 pp_cxx_left_paren (cxx_pp);
2004 pp_cxx_star (cxx_pp);
2005 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2006 if (flags & TFF_EXPR_IN_PARENS)
2007 pp_cxx_right_paren (cxx_pp);
2010 /* Else fall through. */
2012 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2016 case VIEW_CONVERT_EXPR:
2018 tree op = TREE_OPERAND (t, 0);
2019 tree ttype = TREE_TYPE (t);
2020 tree optype = TREE_TYPE (op);
2022 if (TREE_CODE (ttype) != TREE_CODE (optype)
2023 && POINTER_TYPE_P (ttype)
2024 && POINTER_TYPE_P (optype)
2025 && same_type_p (TREE_TYPE (optype),
2028 if (TREE_CODE (ttype) == REFERENCE_TYPE)
2029 dump_unary_op ("*", t, flags);
2031 dump_unary_op ("&", t, flags);
2033 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2035 /* It is a cast, but we cannot tell whether it is a
2036 reinterpret or static cast. Use the C style notation. */
2037 if (flags & TFF_EXPR_IN_PARENS)
2038 pp_cxx_left_paren (cxx_pp);
2039 pp_cxx_left_paren (cxx_pp);
2040 dump_type (TREE_TYPE (t), flags);
2041 pp_cxx_right_paren (cxx_pp);
2042 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
2043 if (flags & TFF_EXPR_IN_PARENS)
2044 pp_cxx_right_paren (cxx_pp);
2047 dump_expr (op, flags);
2052 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2054 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2056 if (integer_zerop (idx))
2058 /* A NULL pointer-to-member constant. */
2059 pp_cxx_left_paren (cxx_pp);
2060 pp_cxx_left_paren (cxx_pp);
2061 dump_type (TREE_TYPE (t), flags);
2062 pp_cxx_right_paren (cxx_pp);
2063 pp_character (cxx_pp, '0');
2064 pp_cxx_right_paren (cxx_pp);
2067 else if (host_integerp (idx, 0))
2070 unsigned HOST_WIDE_INT n;
2072 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2073 t = TYPE_METHOD_BASETYPE (t);
2074 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2076 n = tree_low_cst (idx, 0);
2078 /* Map vtable index back one, to allow for the null pointer to
2082 while (n > 0 && virtuals)
2085 virtuals = TREE_CHAIN (virtuals);
2089 dump_expr (BV_FN (virtuals),
2090 flags | TFF_EXPR_IN_PARENS);
2095 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2097 dump_type (TREE_TYPE (t), 0);
2098 pp_cxx_left_paren (cxx_pp);
2099 pp_cxx_right_paren (cxx_pp);
2103 pp_cxx_left_brace (cxx_pp);
2104 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
2105 pp_cxx_right_brace (cxx_pp);
2112 tree ob = TREE_OPERAND (t, 0);
2113 if (is_dummy_object (ob))
2115 t = TREE_OPERAND (t, 1);
2116 if (TREE_CODE (t) == FUNCTION_DECL)
2118 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
2119 else if (BASELINK_P (t))
2120 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2121 flags | TFF_EXPR_IN_PARENS);
2123 dump_decl (t, flags);
2127 if (TREE_CODE (ob) == INDIRECT_REF)
2129 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2130 pp_cxx_arrow (cxx_pp);
2131 pp_cxx_star (cxx_pp);
2135 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2136 pp_cxx_dot (cxx_pp);
2137 pp_cxx_star (cxx_pp);
2139 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2144 case TEMPLATE_PARM_INDEX:
2145 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2149 if (TREE_OPERAND (t, 0) == NULL_TREE
2150 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2152 dump_type (TREE_TYPE (t), flags);
2153 pp_cxx_left_paren (cxx_pp);
2154 dump_expr_list (TREE_OPERAND (t, 0), flags);
2155 pp_cxx_right_paren (cxx_pp);
2159 pp_cxx_left_paren (cxx_pp);
2160 dump_type (TREE_TYPE (t), flags);
2161 pp_cxx_right_paren (cxx_pp);
2162 pp_cxx_left_paren (cxx_pp);
2163 dump_expr_list (TREE_OPERAND (t, 0), flags);
2164 pp_cxx_right_paren (cxx_pp);
2168 case STATIC_CAST_EXPR:
2169 pp_cxx_ws_string (cxx_pp, "static_cast");
2171 case REINTERPRET_CAST_EXPR:
2172 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2174 case CONST_CAST_EXPR:
2175 pp_cxx_ws_string (cxx_pp, "const_cast");
2177 case DYNAMIC_CAST_EXPR:
2178 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2180 pp_cxx_begin_template_argument_list (cxx_pp);
2181 dump_type (TREE_TYPE (t), flags);
2182 pp_cxx_end_template_argument_list (cxx_pp);
2183 pp_cxx_left_paren (cxx_pp);
2184 dump_expr (TREE_OPERAND (t, 0), flags);
2185 pp_cxx_right_paren (cxx_pp);
2189 dump_expr (TREE_OPERAND (t, 0), flags);
2190 pp_cxx_arrow (cxx_pp);
2195 if (TREE_CODE (t) == SIZEOF_EXPR)
2196 pp_cxx_ws_string (cxx_pp, "sizeof");
2199 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2200 pp_cxx_ws_string (cxx_pp, "__alignof__");
2202 pp_cxx_whitespace (cxx_pp);
2203 pp_cxx_left_paren (cxx_pp);
2204 if (TYPE_P (TREE_OPERAND (t, 0)))
2205 dump_type (TREE_OPERAND (t, 0), flags);
2207 dump_expr (TREE_OPERAND (t, 0), flags);
2208 pp_cxx_right_paren (cxx_pp);
2211 case AT_ENCODE_EXPR:
2212 pp_cxx_ws_string (cxx_pp, "@encode");
2213 pp_cxx_whitespace (cxx_pp);
2214 pp_cxx_left_paren (cxx_pp);
2215 dump_type (TREE_OPERAND (t, 0), flags);
2216 pp_cxx_right_paren (cxx_pp);
2220 pp_cxx_ws_string (cxx_pp, "noexcept");
2221 pp_cxx_whitespace (cxx_pp);
2222 pp_cxx_left_paren (cxx_pp);
2223 dump_expr (TREE_OPERAND (t, 0), flags);
2224 pp_cxx_right_paren (cxx_pp);
2229 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2230 pp_cxx_whitespace (cxx_pp);
2231 dump_expr (TREE_OPERAND (t, 0), flags);
2235 pp_string (cxx_pp, M_("<unparsed>"));
2238 case TRY_CATCH_EXPR:
2239 case WITH_CLEANUP_EXPR:
2240 case CLEANUP_POINT_EXPR:
2241 dump_expr (TREE_OPERAND (t, 0), flags);
2244 case PSEUDO_DTOR_EXPR:
2245 dump_expr (TREE_OPERAND (t, 2), flags);
2246 pp_cxx_dot (cxx_pp);
2247 dump_type (TREE_OPERAND (t, 0), flags);
2248 pp_cxx_colon_colon (cxx_pp);
2249 pp_cxx_complement (cxx_pp);
2250 dump_type (TREE_OPERAND (t, 1), flags);
2253 case TEMPLATE_ID_EXPR:
2254 dump_decl (t, flags);
2260 case STATEMENT_LIST:
2261 /* We don't yet have a way of dumping statements in a
2262 human-readable format. */
2263 pp_string (cxx_pp, "({...})");
2267 pp_string (cxx_pp, "while (1) { ");
2268 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2269 pp_cxx_right_brace (cxx_pp);
2273 pp_string (cxx_pp, "if (");
2274 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2275 pp_string (cxx_pp, ") break; ");
2279 dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
2282 case EMPTY_CLASS_EXPR:
2283 dump_type (TREE_TYPE (t), flags);
2284 pp_cxx_left_paren (cxx_pp);
2285 pp_cxx_right_paren (cxx_pp);
2288 case NON_DEPENDENT_EXPR:
2289 dump_expr (TREE_OPERAND (t, 0), flags);
2292 case ARGUMENT_PACK_SELECT:
2293 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2305 pp_type_specifier_seq (cxx_pp, t);
2309 /* We get here when we want to print a dependent type as an
2310 id-expression, without any disambiguator decoration. */
2311 pp_id_expression (cxx_pp, t);
2314 case TEMPLATE_TYPE_PARM:
2315 case BOUND_TEMPLATE_TEMPLATE_PARM:
2316 dump_type (t, flags);
2320 pp_cxx_trait_expression (cxx_pp, t);
2324 pp_cxx_va_arg_expression (cxx_pp, t);
2328 pp_cxx_offsetof_expression (cxx_pp, t);
2332 dump_decl (t, flags);
2335 case EXPR_PACK_EXPANSION:
2342 case VEC_DELETE_EXPR:
2348 case UNORDERED_EXPR:
2358 case FIX_TRUNC_EXPR:
2360 pp_expression (cxx_pp, t);
2363 case TRUTH_AND_EXPR:
2365 case TRUTH_XOR_EXPR:
2366 if (flags & TFF_EXPR_IN_PARENS)
2367 pp_cxx_left_paren (cxx_pp);
2368 pp_expression (cxx_pp, t);
2369 if (flags & TFF_EXPR_IN_PARENS)
2370 pp_cxx_right_paren (cxx_pp);
2374 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2377 /* This list is incomplete, but should suffice for now.
2378 It is very important that `sorry' does not call
2379 `report_error_function'. That could cause an infinite loop. */
2381 pp_unsupported_tree (cxx_pp, t);
2382 /* fall through to ERROR_MARK... */
2384 pp_string (cxx_pp, M_("<expression error>"));
2390 dump_binary_op (const char *opstring, tree t, int flags)
2392 pp_cxx_left_paren (cxx_pp);
2393 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2394 pp_cxx_whitespace (cxx_pp);
2396 pp_cxx_ws_string (cxx_pp, opstring);
2398 pp_string (cxx_pp, M_("<unknown operator>"));
2399 pp_cxx_whitespace (cxx_pp);
2400 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2401 pp_cxx_right_paren (cxx_pp);
2405 dump_unary_op (const char *opstring, tree t, int flags)
2407 if (flags & TFF_EXPR_IN_PARENS)
2408 pp_cxx_left_paren (cxx_pp);
2409 pp_cxx_ws_string (cxx_pp, opstring);
2410 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2411 if (flags & TFF_EXPR_IN_PARENS)
2412 pp_cxx_right_paren (cxx_pp);
2416 reinit_cxx_pp (void)
2418 pp_clear_output_area (cxx_pp);
2419 pp_base (cxx_pp)->padding = pp_none;
2420 pp_indentation (cxx_pp) = 0;
2421 pp_needs_newline (cxx_pp) = false;
2422 cxx_pp->enclosing_scope = current_function_decl;
2426 /* Exported interface to stringifying types, exprs and decls under TFF_*
2430 type_as_string (tree typ, int flags)
2433 pp_translate_identifiers (cxx_pp) = false;
2434 dump_type (typ, flags);
2435 return pp_formatted_text (cxx_pp);
2439 type_as_string_translate (tree typ, int flags)
2442 dump_type (typ, flags);
2443 return pp_formatted_text (cxx_pp);
2447 expr_as_string (tree decl, int flags)
2450 pp_translate_identifiers (cxx_pp) = false;
2451 dump_expr (decl, flags);
2452 return pp_formatted_text (cxx_pp);
2456 decl_as_string (tree decl, int flags)
2459 pp_translate_identifiers (cxx_pp) = false;
2460 dump_decl (decl, flags);
2461 return pp_formatted_text (cxx_pp);
2465 decl_as_string_translate (tree decl, int flags)
2468 dump_decl (decl, flags);
2469 return pp_formatted_text (cxx_pp);
2472 /* Generate the three forms of printable names for cxx_printable_name. */
2475 lang_decl_name (tree decl, int v, bool translate)
2479 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2480 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2483 pp_translate_identifiers (cxx_pp) = translate;
2485 && (DECL_CLASS_SCOPE_P (decl)
2486 || (DECL_NAMESPACE_SCOPE_P (decl)
2487 && CP_DECL_CONTEXT (decl) != global_namespace)))
2489 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2490 pp_cxx_colon_colon (cxx_pp);
2493 if (TREE_CODE (decl) == FUNCTION_DECL)
2494 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2496 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2498 return pp_formatted_text (cxx_pp);
2501 /* Return the location of a tree passed to %+ formats. */
2504 location_of (tree t)
2506 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2507 t = DECL_CONTEXT (t);
2508 else if (TYPE_P (t))
2510 t = TYPE_MAIN_DECL (t);
2512 return input_location;
2514 else if (TREE_CODE (t) == OVERLOAD)
2515 t = OVL_FUNCTION (t);
2518 return DECL_SOURCE_LOCATION (t);
2519 return EXPR_LOC_OR_HERE (t);
2522 /* Now the interfaces from error et al to dump_type et al. Each takes an
2523 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2527 decl_to_string (tree decl, int verbose)
2531 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2532 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2533 flags = TFF_CLASS_KEY_OR_ENUM;
2535 flags |= TFF_DECL_SPECIFIERS;
2536 else if (TREE_CODE (decl) == FUNCTION_DECL)
2537 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2538 flags |= TFF_TEMPLATE_HEADER;
2541 dump_decl (decl, flags);
2542 return pp_formatted_text (cxx_pp);
2546 expr_to_string (tree decl)
2549 dump_expr (decl, 0);
2550 return pp_formatted_text (cxx_pp);
2554 fndecl_to_string (tree fndecl, int verbose)
2558 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2559 | TFF_TEMPLATE_HEADER;
2561 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2563 dump_decl (fndecl, flags);
2564 return pp_formatted_text (cxx_pp);
2569 code_to_string (enum tree_code c)
2571 return tree_code_name [c];
2575 language_to_string (enum languages c)
2582 case lang_cplusplus:
2594 /* Return the proper printed version of a parameter to a C++ function. */
2597 parm_to_string (int p)
2601 pp_string (cxx_pp, "'this'");
2603 pp_decimal_int (cxx_pp, p + 1);
2604 return pp_formatted_text (cxx_pp);
2608 op_to_string (enum tree_code p)
2610 tree id = operator_name_info[(int) p].identifier;
2611 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2615 type_to_string (tree typ, int verbose)
2619 flags |= TFF_CLASS_KEY_OR_ENUM;
2620 flags |= TFF_TEMPLATE_HEADER;
2623 dump_type (typ, flags);
2624 return pp_formatted_text (cxx_pp);
2628 assop_to_string (enum tree_code p)
2630 tree id = assignment_operator_name_info[(int) p].identifier;
2631 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2635 args_to_string (tree p, int verbose)
2639 flags |= TFF_CLASS_KEY_OR_ENUM;
2644 if (TYPE_P (TREE_VALUE (p)))
2645 return type_as_string_translate (p, flags);
2648 for (; p; p = TREE_CHAIN (p))
2650 if (TREE_VALUE (p) == null_node)
2651 pp_cxx_ws_string (cxx_pp, "NULL");
2653 dump_type (error_type (TREE_VALUE (p)), flags);
2655 pp_separate_with_comma (cxx_pp);
2657 return pp_formatted_text (cxx_pp);
2661 cv_to_string (tree p, int v)
2664 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2665 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2666 return pp_formatted_text (cxx_pp);
2669 /* Langhook for print_error_function. */
2671 cxx_print_error_function (diagnostic_context *context, const char *file,
2672 diagnostic_info *diagnostic)
2674 lhd_print_error_function (context, file, diagnostic);
2675 pp_base_set_prefix (context->printer, file);
2676 maybe_print_instantiation_context (context);
2680 cp_diagnostic_starter (diagnostic_context *context,
2681 diagnostic_info *diagnostic)
2683 diagnostic_report_current_module (context);
2684 cp_print_error_function (context, diagnostic);
2685 maybe_print_instantiation_context (context);
2686 maybe_print_constexpr_context (context);
2687 pp_base_set_prefix (context->printer, diagnostic_build_prefix (context,
2692 cp_diagnostic_finalizer (diagnostic_context *context,
2693 diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2695 pp_base_destroy_prefix (context->printer);
2698 /* Print current function onto BUFFER, in the process of reporting
2699 a diagnostic message. Called from cp_diagnostic_starter. */
2701 cp_print_error_function (diagnostic_context *context,
2702 diagnostic_info *diagnostic)
2704 if (diagnostic_last_function_changed (context, diagnostic))
2706 const char *old_prefix = context->printer->prefix;
2707 const char *file = LOCATION_FILE (diagnostic->location);
2708 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
2709 char *new_prefix = (file && abstract_origin == NULL)
2710 ? file_name_as_prefix (file) : NULL;
2712 pp_base_set_prefix (context->printer, new_prefix);
2714 if (current_function_decl == NULL)
2715 pp_base_string (context->printer, _("At global scope:"));
2720 if (abstract_origin)
2722 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2723 while (TREE_CODE (ao) == BLOCK
2724 && BLOCK_ABSTRACT_ORIGIN (ao)
2725 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2726 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2727 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2731 fndecl = current_function_decl;
2733 pp_printf (context->printer, function_category (fndecl),
2734 cxx_printable_name_translate (fndecl, 2));
2736 while (abstract_origin)
2739 tree block = abstract_origin;
2741 locus = &BLOCK_SOURCE_LOCATION (block);
2743 block = BLOCK_SUPERCONTEXT (block);
2744 while (block && TREE_CODE (block) == BLOCK
2745 && BLOCK_ABSTRACT_ORIGIN (block))
2747 ao = BLOCK_ABSTRACT_ORIGIN (block);
2749 while (TREE_CODE (ao) == BLOCK
2750 && BLOCK_ABSTRACT_ORIGIN (ao)
2751 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2752 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2754 if (TREE_CODE (ao) == FUNCTION_DECL)
2759 else if (TREE_CODE (ao) != BLOCK)
2762 block = BLOCK_SUPERCONTEXT (block);
2765 abstract_origin = block;
2768 while (block && TREE_CODE (block) == BLOCK)
2769 block = BLOCK_SUPERCONTEXT (block);
2771 if (block && TREE_CODE (block) == FUNCTION_DECL)
2773 abstract_origin = NULL;
2777 expanded_location s = expand_location (*locus);
2778 pp_base_character (context->printer, ',');
2779 pp_base_newline (context->printer);
2782 if (context->show_column && s.column != 0)
2783 pp_printf (context->printer,
2784 _(" inlined from %qs at %s:%d:%d"),
2785 cxx_printable_name_translate (fndecl, 2),
2786 s.file, s.line, s.column);
2788 pp_printf (context->printer,
2789 _(" inlined from %qs at %s:%d"),
2790 cxx_printable_name_translate (fndecl, 2),
2795 pp_printf (context->printer, _(" inlined from %qs"),
2796 cxx_printable_name_translate (fndecl, 2));
2799 pp_base_character (context->printer, ':');
2801 pp_base_newline (context->printer);
2803 diagnostic_set_last_function (context, diagnostic);
2804 pp_base_destroy_prefix (context->printer);
2805 context->printer->prefix = old_prefix;
2809 /* Returns a description of FUNCTION using standard terminology. The
2810 result is a format string of the form "In CATEGORY %qs". */
2812 function_category (tree fn)
2814 /* We can get called from the middle-end for diagnostics of function
2815 clones. Make sure we have language specific information before
2816 dereferencing it. */
2817 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
2818 && DECL_FUNCTION_MEMBER_P (fn))
2820 if (DECL_STATIC_FUNCTION_P (fn))
2821 return _("In static member function %qs");
2822 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2823 return _("In copy constructor %qs");
2824 else if (DECL_CONSTRUCTOR_P (fn))
2825 return _("In constructor %qs");
2826 else if (DECL_DESTRUCTOR_P (fn))
2827 return _("In destructor %qs");
2828 else if (LAMBDA_FUNCTION_P (fn))
2829 return _("In lambda function");
2831 return _("In member function %qs");
2834 return _("In function %qs");
2837 /* Report the full context of a current template instantiation,
2840 print_instantiation_full_context (diagnostic_context *context)
2842 struct tinst_level *p = current_instantiation ();
2843 location_t location = input_location;
2847 if (current_function_decl != p->decl
2848 && current_function_decl != NULL_TREE)
2849 /* We can get here during the processing of some synthesized
2850 method. Then, P->DECL will be the function that's causing
2855 if (current_function_decl == p->decl)
2856 /* Avoid redundancy with the "In function" line. */;
2858 pp_verbatim (context->printer,
2859 _("%s: In instantiation of %qs:\n"),
2860 LOCATION_FILE (location),
2861 decl_as_string_translate (p->decl,
2862 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2864 location = p->locus;
2869 print_instantiation_partial_context (context, p, location);
2872 /* Helper function of print_instantiation_partial_context() that
2873 prints a single line of instantiation context. */
2876 print_instantiation_partial_context_line (diagnostic_context *context,
2877 const struct tinst_level *t,
2878 location_t loc, bool recursive_p)
2880 expanded_location xloc;
2881 xloc = expand_location (loc);
2886 str = decl_as_string_translate (t->decl,
2887 TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE);
2888 if (context->show_column)
2889 pp_verbatim (context->printer,
2891 ? _("%s:%d:%d: recursively instantiated from %qs\n")
2892 : _("%s:%d:%d: instantiated from %qs\n"),
2893 xloc.file, xloc.line, xloc.column, str);
2895 pp_verbatim (context->printer,
2897 ? _("%s:%d: recursively instantiated from %qs\n")
2898 : _("%s:%d: recursively instantiated from %qs\n"),
2899 xloc.file, xloc.line, str);
2903 if (context->show_column)
2904 pp_verbatim (context->printer,
2906 ? _("%s:%d:%d: recursively instantiated from here")
2907 : _("%s:%d:%d: instantiated from here"),
2908 xloc.file, xloc.line, xloc.column);
2910 pp_verbatim (context->printer,
2912 ? _("%s:%d: recursively instantiated from here")
2913 : _("%s:%d: instantiated from here"),
2914 xloc.file, xloc.line);
2918 /* Same as print_instantiation_full_context but less verbose. */
2921 print_instantiation_partial_context (diagnostic_context *context,
2922 struct tinst_level *t0, location_t loc)
2924 struct tinst_level *t;
2927 location_t prev_loc = loc;
2929 for (t = t0; t != NULL; t = t->next)
2930 if (prev_loc != t->locus)
2932 prev_loc = t->locus;
2940 int skip = n_total - 10;
2941 for (n = 0; n < 5; n++)
2943 gcc_assert (t != NULL);
2944 if (loc != t->locus)
2945 print_instantiation_partial_context_line (context, t, loc,
2946 /*recursive_p=*/false);
2950 if (t != NULL && skip > 1)
2952 expanded_location xloc;
2953 xloc = expand_location (loc);
2954 if (context->show_column)
2955 pp_verbatim (context->printer,
2956 _("%s:%d:%d: [ skipping %d instantiation contexts ]\n"),
2957 xloc.file, xloc.line, xloc.column, skip);
2959 pp_verbatim (context->printer,
2960 _("%s:%d: [ skipping %d instantiation contexts ]\n"),
2961 xloc.file, xloc.line, skip);
2966 } while (t != NULL && --skip > 0);
2972 while (t->next != NULL && t->locus == t->next->locus)
2977 print_instantiation_partial_context_line (context, t, loc,
2982 print_instantiation_partial_context_line (context, NULL, loc,
2983 /*recursive_p=*/false);
2984 pp_base_newline (context->printer);
2987 /* Called from cp_thing to print the template context for an error. */
2989 maybe_print_instantiation_context (diagnostic_context *context)
2991 if (!problematic_instantiation_changed () || current_instantiation () == 0)
2994 record_last_problematic_instantiation ();
2995 print_instantiation_full_context (context);
2998 /* Report the bare minimum context of a template instantiation. */
3000 print_instantiation_context (void)
3002 print_instantiation_partial_context
3003 (global_dc, current_instantiation (), input_location);
3004 diagnostic_flush_buffer (global_dc);
3007 /* Report what constexpr call(s) we're trying to expand, if any. */
3010 maybe_print_constexpr_context (diagnostic_context *context)
3012 VEC(tree,heap) *call_stack = cx_error_context ();
3016 FOR_EACH_VEC_ELT (tree, call_stack, ix, t)
3018 expanded_location xloc = expand_location (EXPR_LOCATION (t));
3019 const char *s = expr_as_string (t, 0);
3020 if (context->show_column)
3021 pp_verbatim (context->printer,
3022 _("%s:%d:%d: in constexpr expansion of %qs"),
3023 xloc.file, xloc.line, xloc.column, s);
3025 pp_verbatim (context->printer,
3026 _("%s:%d: in constexpr expansion of %qs"),
3027 xloc.file, xloc.line, s);
3028 pp_base_newline (context->printer);
3032 /* Called from output_format -- during diagnostic message processing --
3033 to handle C++ specific format specifier with the following meanings:
3034 %A function argument-list.
3038 %F function declaration.
3039 %L language as used in extern "lang".
3041 %P function parameter whose position is indicated by an integer.
3042 %Q assignment operator.
3046 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
3047 int precision, bool wide, bool set_locus, bool verbose)
3051 #define next_tree (t = va_arg (*text->args_ptr, tree))
3052 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3053 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3054 #define next_int va_arg (*text->args_ptr, int)
3056 if (precision != 0 || wide)
3059 if (text->locus == NULL)
3064 case 'A': result = args_to_string (next_tree, verbose); break;
3065 case 'C': result = code_to_string (next_tcode); break;
3068 tree temp = next_tree;
3070 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
3072 temp = DECL_DEBUG_EXPR (temp);
3075 result = expr_to_string (temp);
3079 result = decl_to_string (temp, verbose);
3082 case 'E': result = expr_to_string (next_tree); break;
3083 case 'F': result = fndecl_to_string (next_tree, verbose); break;
3084 case 'L': result = language_to_string (next_lang); break;
3085 case 'O': result = op_to_string (next_tcode); break;
3086 case 'P': result = parm_to_string (next_int); break;
3087 case 'Q': result = assop_to_string (next_tcode); break;
3088 case 'T': result = type_to_string (next_tree, verbose); break;
3089 case 'V': result = cv_to_string (next_tree, verbose); break;
3092 percent_K_format (text);
3099 pp_base_string (pp, result);
3100 if (set_locus && t != NULL)
3101 *text->locus = location_of (t);
3109 /* Warn about the use of C++0x features when appropriate. */
3111 maybe_warn_cpp0x (cpp0x_warn_str str)
3113 if ((cxx_dialect == cxx98) && !in_system_header)
3114 /* We really want to suppress this warning in system headers,
3115 because libstdc++ uses variadic templates even when we aren't
3119 case CPP0X_INITIALIZER_LISTS:
3120 pedwarn (input_location, 0,
3121 "extended initializer lists "
3122 "only available with -std=c++0x or -std=gnu++0x");
3124 case CPP0X_EXPLICIT_CONVERSION:
3125 pedwarn (input_location, 0,
3126 "explicit conversion operators "
3127 "only available with -std=c++0x or -std=gnu++0x");
3129 case CPP0X_VARIADIC_TEMPLATES:
3130 pedwarn (input_location, 0,
3131 "variadic templates "
3132 "only available with -std=c++0x or -std=gnu++0x");
3134 case CPP0X_LAMBDA_EXPR:
3135 pedwarn (input_location, 0,
3136 "lambda expressions "
3137 "only available with -std=c++0x or -std=gnu++0x");
3140 pedwarn (input_location, 0,
3141 "C++0x auto only available with -std=c++0x or -std=gnu++0x");
3143 case CPP0X_SCOPED_ENUMS:
3144 pedwarn (input_location, 0,
3145 "scoped enums only available with -std=c++0x or -std=gnu++0x");
3147 case CPP0X_DEFAULTED_DELETED:
3148 pedwarn (input_location, 0,
3149 "defaulted and deleted functions "
3150 "only available with -std=c++0x or -std=gnu++0x");
3152 case CPP0X_INLINE_NAMESPACES:
3153 pedwarn (input_location, OPT_pedantic,
3154 "inline namespaces "
3155 "only available with -std=c++0x or -std=gnu++0x");
3162 /* Warn about the use of variadic templates when appropriate. */
3164 maybe_warn_variadic_templates (void)
3166 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3170 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3171 option OPT with text GMSGID. Use this function to report
3172 diagnostics for constructs that are invalid C++98, but valid
3175 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3177 diagnostic_info diagnostic;
3180 va_start (ap, gmsgid);
3181 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
3182 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3183 diagnostic.option_index = opt;
3185 return report_diagnostic (&diagnostic);
3188 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3189 we found when we tried to do the lookup. LOCATION is the location of
3190 the NAME identifier. */
3193 qualified_name_lookup_error (tree scope, tree name,
3194 tree decl, location_t location)
3196 if (scope == error_mark_node)
3197 ; /* We already complained. */
3198 else if (TYPE_P (scope))
3200 if (!COMPLETE_TYPE_P (scope))
3201 error_at (location, "incomplete type %qT used in nested name specifier",
3203 else if (TREE_CODE (decl) == TREE_LIST)
3205 error_at (location, "reference to %<%T::%D%> is ambiguous",
3207 print_candidates (decl);
3210 error_at (location, "%qD is not a member of %qT", name, scope);
3212 else if (scope != global_namespace)
3214 error_at (location, "%qD is not a member of %qD", name, scope);
3215 suggest_alternatives_for (location, name);
3219 error_at (location, "%<::%D%> has not been declared", name);
3220 suggest_alternatives_for (location, name);