1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003,
4 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "diagnostic.h"
30 #include "tree-diagnostic.h"
31 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
34 #include "tree-pretty-print.h"
35 #include "pointer-set.h"
36 #include "c-family/c-objc.h"
38 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
39 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
41 /* The global buffer where we dump everything. It is there only for
42 transitional purpose. It is expected, in the near future, to be
43 completely removed. */
44 static cxx_pretty_printer scratch_pretty_printer;
45 #define cxx_pp (&scratch_pretty_printer)
47 /* Translate if being used for diagnostics, but not for dump files or
49 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
51 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
53 static const char *args_to_string (tree, int);
54 static const char *assop_to_string (enum tree_code);
55 static const char *code_to_string (enum tree_code);
56 static const char *cv_to_string (tree, int);
57 static const char *decl_to_string (tree, int);
58 static const char *expr_to_string (tree);
59 static const char *fndecl_to_string (tree, int);
60 static const char *op_to_string (enum tree_code);
61 static const char *parm_to_string (int);
62 static const char *type_to_string (tree, int);
64 static void dump_alias_template_specialization (tree, int);
65 static void dump_type (tree, int);
66 static void dump_typename (tree, int);
67 static void dump_simple_decl (tree, tree, int);
68 static void dump_decl (tree, int);
69 static void dump_template_decl (tree, int);
70 static void dump_function_decl (tree, int);
71 static void dump_expr (tree, int);
72 static void dump_unary_op (const char *, tree, int);
73 static void dump_binary_op (const char *, tree, int);
74 static void dump_aggr_type (tree, int);
75 static void dump_type_prefix (tree, int);
76 static void dump_type_suffix (tree, int);
77 static void dump_function_name (tree, int);
78 static void dump_call_expr_args (tree, int, bool);
79 static void dump_aggr_init_expr_args (tree, int, bool);
80 static void dump_expr_list (tree, int);
81 static void dump_global_iord (tree);
82 static void dump_parameters (tree, int);
83 static void dump_exception_spec (tree, int);
84 static void dump_template_argument (tree, int);
85 static void dump_template_argument_list (tree, int);
86 static void dump_template_parameter (tree, int);
87 static void dump_template_bindings (tree, tree, VEC(tree,gc) *);
88 static void dump_scope (tree, int);
89 static void dump_template_parms (tree, int, int);
90 static int get_non_default_template_args_count (tree, int);
91 static const char *function_category (tree);
92 static void maybe_print_constexpr_context (diagnostic_context *);
93 static void maybe_print_instantiation_context (diagnostic_context *);
94 static void print_instantiation_full_context (diagnostic_context *);
95 static void print_instantiation_partial_context (diagnostic_context *,
98 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
99 static void cp_diagnostic_finalizer (diagnostic_context *, diagnostic_info *);
100 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
102 static bool cp_printer (pretty_printer *, text_info *, const char *,
103 int, bool, bool, bool);
108 diagnostic_starter (global_dc) = cp_diagnostic_starter;
109 diagnostic_finalizer (global_dc) = cp_diagnostic_finalizer;
110 diagnostic_format_decoder (global_dc) = cp_printer;
112 pp_construct (pp_base (cxx_pp), NULL, 0);
113 pp_cxx_pretty_printer_init (cxx_pp);
116 /* Dump a scope, if deemed necessary. */
119 dump_scope (tree scope, int flags)
121 int f = flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF);
123 if (scope == NULL_TREE)
126 if (TREE_CODE (scope) == NAMESPACE_DECL)
128 if (scope != global_namespace)
130 dump_decl (scope, f);
131 pp_cxx_colon_colon (cxx_pp);
134 else if (AGGREGATE_TYPE_P (scope))
136 dump_type (scope, f);
137 pp_cxx_colon_colon (cxx_pp);
139 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
141 dump_function_decl (scope, f);
142 pp_cxx_colon_colon (cxx_pp);
146 /* Dump the template ARGument under control of FLAGS. */
149 dump_template_argument (tree arg, int flags)
151 if (ARGUMENT_PACK_P (arg))
152 dump_template_argument_list (ARGUMENT_PACK_ARGS (arg),
153 /* No default args in argument packs. */
154 flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
155 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
156 dump_type (arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
159 if (TREE_CODE (arg) == TREE_LIST)
160 arg = TREE_VALUE (arg);
162 dump_expr (arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
166 /* Count the number of template arguments ARGS whose value does not
167 match the (optional) default template parameter in PARAMS */
170 get_non_default_template_args_count (tree args, int flags)
172 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
174 if (/* We use this flag when generating debug information. We don't
175 want to expand templates at this point, for this may generate
176 new decls, which gets decl counts out of sync, which may in
177 turn cause codegen differences between compilations with and
179 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
180 || !flag_pretty_templates)
183 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
186 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
190 dump_template_argument_list (tree args, int flags)
192 int n = get_non_default_template_args_count (args, flags);
196 for (i = 0; i < n; ++i)
198 tree arg = TREE_VEC_ELT (args, i);
200 /* Only print a comma if we know there is an argument coming. In
201 the case of an empty template argument pack, no actual
202 argument will be printed. */
204 && (!ARGUMENT_PACK_P (arg)
205 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
206 pp_separate_with_comma (cxx_pp);
208 dump_template_argument (arg, flags);
213 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
216 dump_template_parameter (tree parm, int flags)
221 if (parm == error_mark_node)
224 p = TREE_VALUE (parm);
225 a = TREE_PURPOSE (parm);
227 if (TREE_CODE (p) == TYPE_DECL)
229 if (flags & TFF_DECL_SPECIFIERS)
231 pp_cxx_ws_string (cxx_pp, "class");
232 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
233 pp_cxx_ws_string (cxx_pp, "...");
235 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
237 else if (DECL_NAME (p))
238 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (p));
240 pp_cxx_canonical_template_parameter (cxx_pp, TREE_TYPE (p));
243 dump_decl (p, flags | TFF_DECL_SPECIFIERS);
245 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
247 pp_cxx_whitespace (cxx_pp);
249 pp_cxx_whitespace (cxx_pp);
250 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
251 dump_type (a, flags & ~TFF_CHASE_TYPEDEF);
253 dump_expr (a, flags | TFF_EXPR_IN_PARENS);
257 /* Dump, under control of FLAGS, a template-parameter-list binding.
258 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
262 dump_template_bindings (tree parms, tree args, VEC(tree,gc)* typenames)
264 bool need_semicolon = false;
270 tree p = TREE_VALUE (parms);
271 int lvl = TMPL_PARMS_DEPTH (parms);
274 tree lvl_args = NULL_TREE;
276 /* Don't crash if we had an invalid argument list. */
277 if (TMPL_ARGS_DEPTH (args) >= lvl)
278 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
280 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
282 tree arg = NULL_TREE;
284 /* Don't crash if we had an invalid argument list. */
285 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
286 arg = TREE_VEC_ELT (lvl_args, arg_idx);
289 pp_separate_with_semicolon (cxx_pp);
290 dump_template_parameter (TREE_VEC_ELT (p, i), TFF_PLAIN_IDENTIFIER);
291 pp_cxx_whitespace (cxx_pp);
293 pp_cxx_whitespace (cxx_pp);
296 if (ARGUMENT_PACK_P (arg))
297 pp_cxx_left_brace (cxx_pp);
298 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
299 if (ARGUMENT_PACK_P (arg))
300 pp_cxx_right_brace (cxx_pp);
303 pp_string (cxx_pp, M_("<missing>"));
306 need_semicolon = true;
309 parms = TREE_CHAIN (parms);
312 /* Don't bother with typenames for a partial instantiation. */
313 if (VEC_empty (tree, typenames) || uses_template_parms (args))
316 FOR_EACH_VEC_ELT (tree, typenames, i, t)
319 pp_separate_with_semicolon (cxx_pp);
320 dump_type (t, TFF_PLAIN_IDENTIFIER);
321 pp_cxx_whitespace (cxx_pp);
323 pp_cxx_whitespace (cxx_pp);
324 push_deferring_access_checks (dk_no_check);
325 t = tsubst (t, args, tf_none, NULL_TREE);
326 pop_deferring_access_checks ();
327 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
328 pp_simple_type_specifier doesn't know about it. */
329 t = strip_typedefs (t);
330 dump_type (t, TFF_PLAIN_IDENTIFIER);
334 /* Dump a human-readable equivalent of the alias template
335 specialization of T. */
338 dump_alias_template_specialization (tree t, int flags)
342 gcc_assert (alias_template_specialization_p (t));
344 if (!(flags & TFF_UNQUALIFIED_NAME))
345 dump_scope (CP_DECL_CONTEXT (TYPE_NAME (t)), flags);
346 name = TYPE_IDENTIFIER (t);
347 pp_cxx_tree_identifier (cxx_pp, name);
348 dump_template_parms (TYPE_TEMPLATE_INFO (t),
350 flags & ~TFF_TEMPLATE_HEADER);
353 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
357 dump_type (tree t, int flags)
362 /* Don't print e.g. "struct mytypedef". */
363 if (TYPE_P (t) && typedef_variant_p (t))
365 tree decl = TYPE_NAME (t);
366 if ((flags & TFF_CHASE_TYPEDEF)
367 || DECL_SELF_REFERENCE_P (decl)
368 || (!flag_pretty_templates
369 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)))
370 t = strip_typedefs (t);
371 else if (alias_template_specialization_p (t))
373 dump_alias_template_specialization (t, flags);
376 else if (same_type_p (t, TREE_TYPE (decl)))
380 pp_cxx_cv_qualifier_seq (cxx_pp, t);
381 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
386 if (TYPE_PTRMEMFUNC_P (t))
389 switch (TREE_CODE (t))
392 if (t == init_list_type_node)
393 pp_string (cxx_pp, M_("<brace-enclosed initializer list>"));
394 else if (t == unknown_type_node)
395 pp_string (cxx_pp, M_("<unresolved overloaded function type>"));
398 pp_cxx_cv_qualifier_seq (cxx_pp, t);
399 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
404 /* A list of function parms. */
405 dump_parameters (t, flags);
408 case IDENTIFIER_NODE:
409 pp_cxx_tree_identifier (cxx_pp, t);
413 dump_type (BINFO_TYPE (t), flags);
419 dump_aggr_type (t, flags);
423 if (flags & TFF_CHASE_TYPEDEF)
425 dump_type (DECL_ORIGINAL_TYPE (t)
426 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
429 /* Else fall through. */
433 dump_decl (t, flags & ~TFF_DECL_SPECIFIERS);
442 case FIXED_POINT_TYPE:
443 pp_type_specifier_seq (cxx_pp, t);
446 case TEMPLATE_TEMPLATE_PARM:
447 /* For parameters inside template signature. */
448 if (TYPE_IDENTIFIER (t))
449 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
451 pp_cxx_canonical_template_parameter (cxx_pp, t);
454 case BOUND_TEMPLATE_TEMPLATE_PARM:
456 tree args = TYPE_TI_ARGS (t);
457 pp_cxx_cv_qualifier_seq (cxx_pp, t);
458 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
459 pp_cxx_begin_template_argument_list (cxx_pp);
460 dump_template_argument_list (args, flags);
461 pp_cxx_end_template_argument_list (cxx_pp);
465 case TEMPLATE_TYPE_PARM:
466 pp_cxx_cv_qualifier_seq (cxx_pp, t);
467 if (TYPE_IDENTIFIER (t))
468 pp_cxx_tree_identifier (cxx_pp, TYPE_IDENTIFIER (t));
470 pp_cxx_canonical_template_parameter
471 (cxx_pp, TEMPLATE_TYPE_PARM_INDEX (t));
474 /* This is not always necessary for pointers and such, but doing this
475 reduces code size. */
484 dump_type_prefix (t, flags);
485 dump_type_suffix (t, flags);
489 if (! (flags & TFF_CHASE_TYPEDEF)
490 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
492 dump_decl (TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
495 pp_cxx_cv_qualifier_seq (cxx_pp, t);
496 pp_cxx_ws_string (cxx_pp,
497 TYPENAME_IS_ENUM_P (t) ? "enum"
498 : TYPENAME_IS_CLASS_P (t) ? "class"
500 dump_typename (t, flags);
503 case UNBOUND_CLASS_TEMPLATE:
504 if (! (flags & TFF_UNQUALIFIED_NAME))
506 dump_type (TYPE_CONTEXT (t), flags);
507 pp_cxx_colon_colon (cxx_pp);
509 pp_cxx_ws_string (cxx_pp, "template");
510 dump_type (DECL_NAME (TYPE_NAME (t)), flags);
514 pp_cxx_ws_string (cxx_pp, "__typeof__");
515 pp_cxx_whitespace (cxx_pp);
516 pp_cxx_left_paren (cxx_pp);
517 dump_expr (TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
518 pp_cxx_right_paren (cxx_pp);
521 case UNDERLYING_TYPE:
522 pp_cxx_ws_string (cxx_pp, "__underlying_type");
523 pp_cxx_whitespace (cxx_pp);
524 pp_cxx_left_paren (cxx_pp);
525 dump_expr (UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
526 pp_cxx_right_paren (cxx_pp);
529 case TYPE_PACK_EXPANSION:
530 dump_type (PACK_EXPANSION_PATTERN (t), flags);
531 pp_cxx_ws_string (cxx_pp, "...");
534 case TYPE_ARGUMENT_PACK:
535 dump_template_argument (t, flags);
539 pp_cxx_ws_string (cxx_pp, "decltype");
540 pp_cxx_whitespace (cxx_pp);
541 pp_cxx_left_paren (cxx_pp);
542 dump_expr (DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
543 pp_cxx_right_paren (cxx_pp);
547 pp_string (cxx_pp, "std::nullptr_t");
551 pp_unsupported_tree (cxx_pp, t);
552 /* Fall through to error. */
555 pp_string (cxx_pp, M_("<type error>"));
560 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
564 dump_typename (tree t, int flags)
566 tree ctx = TYPE_CONTEXT (t);
568 if (TREE_CODE (ctx) == TYPENAME_TYPE)
569 dump_typename (ctx, flags);
571 dump_type (ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
572 pp_cxx_colon_colon (cxx_pp);
573 dump_decl (TYPENAME_TYPE_FULLNAME (t), flags);
576 /* Return the name of the supplied aggregate, or enumeral type. */
579 class_key_or_enum_as_string (tree t)
581 if (TREE_CODE (t) == ENUMERAL_TYPE)
583 if (SCOPED_ENUM_P (t))
588 else if (TREE_CODE (t) == UNION_TYPE)
590 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
596 /* Print out a class declaration T under the control of FLAGS,
597 in the form `class foo'. */
600 dump_aggr_type (tree t, int flags)
603 const char *variety = class_key_or_enum_as_string (t);
607 pp_cxx_cv_qualifier_seq (cxx_pp, t);
609 if (flags & TFF_CLASS_KEY_OR_ENUM)
610 pp_cxx_ws_string (cxx_pp, variety);
612 name = TYPE_NAME (t);
616 typdef = (!DECL_ARTIFICIAL (name)
617 /* An alias specialization is not considered to be a
619 && !alias_template_specialization_p (t));
622 && ((flags & TFF_CHASE_TYPEDEF)
623 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
624 && DECL_TEMPLATE_INFO (name))))
625 || DECL_SELF_REFERENCE_P (name))
627 t = TYPE_MAIN_VARIANT (t);
628 name = TYPE_NAME (t);
632 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
633 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
634 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
635 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
637 if (! (flags & TFF_UNQUALIFIED_NAME))
638 dump_scope (CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
639 flags &= ~TFF_UNQUALIFIED_NAME;
642 /* Because the template names are mangled, we have to locate
643 the most general template, and use that name. */
644 tree tpl = TYPE_TI_TEMPLATE (t);
646 while (DECL_TEMPLATE_INFO (tpl))
647 tpl = DECL_TI_TEMPLATE (tpl);
650 name = DECL_NAME (name);
653 if (name == 0 || ANON_AGGRNAME_P (name))
655 if (flags & TFF_CLASS_KEY_OR_ENUM)
656 pp_string (cxx_pp, M_("<anonymous>"));
658 pp_printf (pp_base (cxx_pp), M_("<anonymous %s>"), variety);
660 else if (LAMBDANAME_P (name))
662 /* A lambda's "type" is essentially its signature. */
663 pp_string (cxx_pp, M_("<lambda"));
664 if (lambda_function (t))
665 dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
667 pp_character(cxx_pp, '>');
670 pp_cxx_tree_identifier (cxx_pp, name);
672 dump_template_parms (TYPE_TEMPLATE_INFO (t),
673 !CLASSTYPE_USE_TEMPLATE (t),
674 flags & ~TFF_TEMPLATE_HEADER);
677 /* Dump into the obstack the initial part of the output for a given type.
678 This is necessary when dealing with things like functions returning
681 return type of `int (* fee ())()': pointer -> function -> int. Both
682 pointer (and reference and offset) and function (and member) types must
683 deal with prefix and suffix.
685 Arrays must also do this for DECL nodes, like int a[], and for things like
689 dump_type_prefix (tree t, int flags)
691 if (TYPE_PTRMEMFUNC_P (t))
693 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
697 switch (TREE_CODE (t))
702 tree sub = TREE_TYPE (t);
704 dump_type_prefix (sub, flags);
705 if (TREE_CODE (sub) == ARRAY_TYPE
706 || TREE_CODE (sub) == FUNCTION_TYPE)
708 pp_cxx_whitespace (cxx_pp);
709 pp_cxx_left_paren (cxx_pp);
710 pp_c_attributes_display (pp_c_base (cxx_pp),
711 TYPE_ATTRIBUTES (sub));
713 if (TREE_CODE (t) == POINTER_TYPE)
714 pp_character(cxx_pp, '*');
715 else if (TREE_CODE (t) == REFERENCE_TYPE)
717 if (TYPE_REF_IS_RVALUE (t))
718 pp_string (cxx_pp, "&&");
720 pp_character (cxx_pp, '&');
722 pp_base (cxx_pp)->padding = pp_before;
723 pp_cxx_cv_qualifier_seq (cxx_pp, t);
729 dump_type_prefix (TREE_TYPE (t), flags);
730 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
732 pp_maybe_space (cxx_pp);
733 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
734 pp_cxx_left_paren (cxx_pp);
735 dump_type (TYPE_OFFSET_BASETYPE (t), flags);
736 pp_cxx_colon_colon (cxx_pp);
738 pp_cxx_star (cxx_pp);
739 pp_cxx_cv_qualifier_seq (cxx_pp, t);
740 pp_base (cxx_pp)->padding = pp_before;
743 /* This can be reached without a pointer when dealing with
744 templates, e.g. std::is_function. */
746 dump_type_prefix (TREE_TYPE (t), flags);
750 dump_type_prefix (TREE_TYPE (t), flags);
751 pp_maybe_space (cxx_pp);
752 pp_cxx_left_paren (cxx_pp);
753 dump_aggr_type (TYPE_METHOD_BASETYPE (t), flags);
754 pp_cxx_colon_colon (cxx_pp);
758 dump_type_prefix (TREE_TYPE (t), flags);
762 case IDENTIFIER_NODE:
767 case TEMPLATE_TYPE_PARM:
768 case TEMPLATE_TEMPLATE_PARM:
769 case BOUND_TEMPLATE_TEMPLATE_PARM:
780 case UNDERLYING_TYPE:
782 case TYPE_PACK_EXPANSION:
783 case FIXED_POINT_TYPE:
785 dump_type (t, flags);
786 pp_base (cxx_pp)->padding = pp_before;
790 pp_unsupported_tree (cxx_pp, t);
793 pp_string (cxx_pp, M_("<typeprefixerror>"));
798 /* Dump the suffix of type T, under control of FLAGS. This is the part
799 which appears after the identifier (or function parms). */
802 dump_type_suffix (tree t, int flags)
804 if (TYPE_PTRMEMFUNC_P (t))
805 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
807 switch (TREE_CODE (t))
812 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
813 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
814 pp_cxx_right_paren (cxx_pp);
815 dump_type_suffix (TREE_TYPE (t), flags);
822 if (TREE_CODE (t) == METHOD_TYPE)
823 /* Can only be reached through a pointer. */
824 pp_cxx_right_paren (cxx_pp);
825 arg = TYPE_ARG_TYPES (t);
826 if (TREE_CODE (t) == METHOD_TYPE)
827 arg = TREE_CHAIN (arg);
829 /* Function pointers don't have default args. Not in standard C++,
830 anyway; they may in g++, but we'll just pretend otherwise. */
831 dump_parameters (arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
833 if (TREE_CODE (t) == METHOD_TYPE)
834 pp_cxx_cv_qualifier_seq (cxx_pp, class_of_this_parm (t));
836 pp_cxx_cv_qualifier_seq (cxx_pp, t);
837 dump_exception_spec (TYPE_RAISES_EXCEPTIONS (t), flags);
838 dump_type_suffix (TREE_TYPE (t), flags);
843 pp_maybe_space (cxx_pp);
844 pp_cxx_left_bracket (cxx_pp);
847 tree dtype = TYPE_DOMAIN (t);
848 tree max = TYPE_MAX_VALUE (dtype);
849 if (host_integerp (max, 0))
850 pp_wide_integer (cxx_pp, tree_low_cst (max, 0) + 1);
851 else if (TREE_CODE (max) == MINUS_EXPR)
852 dump_expr (TREE_OPERAND (max, 0),
853 flags & ~TFF_EXPR_IN_PARENS);
855 dump_expr (fold_build2_loc (input_location,
856 PLUS_EXPR, dtype, max,
857 build_int_cst (dtype, 1)),
858 flags & ~TFF_EXPR_IN_PARENS);
860 pp_cxx_right_bracket (cxx_pp);
861 dump_type_suffix (TREE_TYPE (t), flags);
865 case IDENTIFIER_NODE:
870 case TEMPLATE_TYPE_PARM:
871 case TEMPLATE_TEMPLATE_PARM:
872 case BOUND_TEMPLATE_TEMPLATE_PARM:
883 case UNDERLYING_TYPE:
885 case TYPE_PACK_EXPANSION:
886 case FIXED_POINT_TYPE:
891 pp_unsupported_tree (cxx_pp, t);
893 /* Don't mark it here, we should have already done in
900 dump_global_iord (tree t)
902 const char *p = NULL;
904 if (DECL_GLOBAL_CTOR_P (t))
905 p = M_("(static initializers for %s)");
906 else if (DECL_GLOBAL_DTOR_P (t))
907 p = M_("(static destructors for %s)");
911 pp_printf (pp_base (cxx_pp), p, input_filename);
915 dump_simple_decl (tree t, tree type, int flags)
917 if (flags & TFF_DECL_SPECIFIERS)
919 if (TREE_CODE (t) == VAR_DECL
920 && DECL_DECLARED_CONSTEXPR_P (t))
921 pp_cxx_ws_string (cxx_pp, "constexpr");
922 dump_type_prefix (type, flags & ~TFF_UNQUALIFIED_NAME);
923 pp_maybe_space (cxx_pp);
925 if (! (flags & TFF_UNQUALIFIED_NAME)
926 && TREE_CODE (t) != PARM_DECL
927 && (!DECL_INITIAL (t)
928 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
929 dump_scope (CP_DECL_CONTEXT (t), flags);
930 flags &= ~TFF_UNQUALIFIED_NAME;
931 if ((flags & TFF_DECL_SPECIFIERS)
932 && DECL_TEMPLATE_PARM_P (t)
933 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
934 pp_string (cxx_pp, "...");
936 dump_decl (DECL_NAME (t), flags);
938 pp_string (cxx_pp, M_("<anonymous>"));
939 if (flags & TFF_DECL_SPECIFIERS)
940 dump_type_suffix (type, flags);
943 /* Dump a human readable string for the decl T under control of FLAGS. */
946 dump_decl (tree t, int flags)
951 /* If doing Objective-C++, give Objective-C a chance to demangle
952 Objective-C method names. */
953 if (c_dialect_objc ())
955 const char *demangled = objc_maybe_printable_name (t, flags);
958 pp_string (cxx_pp, demangled);
963 switch (TREE_CODE (t))
966 /* Don't say 'typedef class A' */
967 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
969 if ((flags & TFF_DECL_SPECIFIERS)
970 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
972 /* Say `class T' not just `T'. */
973 pp_cxx_ws_string (cxx_pp, "class");
975 /* Emit the `...' for a parameter pack. */
976 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
977 pp_cxx_ws_string (cxx_pp, "...");
980 dump_type (TREE_TYPE (t), flags);
983 if (TYPE_DECL_ALIAS_P (t)
984 && (flags & TFF_DECL_SPECIFIERS
985 || flags & TFF_CLASS_KEY_OR_ENUM))
987 pp_cxx_ws_string (cxx_pp, "using");
988 dump_decl (DECL_NAME (t), flags);
989 pp_cxx_whitespace (cxx_pp);
990 pp_cxx_ws_string (cxx_pp, "=");
991 pp_cxx_whitespace (cxx_pp);
992 dump_type (DECL_ORIGINAL_TYPE (t), flags);
995 if ((flags & TFF_DECL_SPECIFIERS)
996 && !DECL_SELF_REFERENCE_P (t))
997 pp_cxx_ws_string (cxx_pp, "typedef");
998 dump_simple_decl (t, DECL_ORIGINAL_TYPE (t)
999 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
1004 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
1006 pp_string (cxx_pp, M_("vtable for "));
1007 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
1008 dump_type (DECL_CONTEXT (t), flags);
1011 /* Else fall through. */
1014 dump_simple_decl (t, TREE_TYPE (t), flags);
1018 pp_string (cxx_pp, M_("<return value> "));
1019 dump_simple_decl (t, TREE_TYPE (t), flags);
1022 case NAMESPACE_DECL:
1023 if (flags & TFF_DECL_SPECIFIERS)
1024 pp_cxx_declaration (cxx_pp, t);
1027 if (! (flags & TFF_UNQUALIFIED_NAME))
1028 dump_scope (CP_DECL_CONTEXT (t), flags);
1029 flags &= ~TFF_UNQUALIFIED_NAME;
1030 if (DECL_NAME (t) == NULL_TREE)
1031 pp_cxx_ws_string (cxx_pp, M_("{anonymous}"));
1033 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1038 dump_type (TREE_OPERAND (t, 0), flags);
1039 pp_string (cxx_pp, "::");
1040 dump_decl (TREE_OPERAND (t, 1), flags|TFF_UNQUALIFIED_NAME);
1044 dump_decl (TREE_OPERAND (t, 0), flags);
1045 pp_cxx_left_bracket (cxx_pp);
1046 dump_decl (TREE_OPERAND (t, 1), flags);
1047 pp_cxx_right_bracket (cxx_pp);
1050 /* So that we can do dump_decl on an aggr type. */
1054 dump_type (t, flags);
1058 /* This is a pseudo destructor call which has not been folded into
1059 a PSEUDO_DTOR_EXPR yet. */
1060 pp_cxx_complement (cxx_pp);
1061 dump_type (TREE_OPERAND (t, 0), flags);
1068 /* These special cases are duplicated here so that other functions
1069 can feed identifiers to error and get them demangled properly. */
1070 case IDENTIFIER_NODE:
1071 if (IDENTIFIER_TYPENAME_P (t))
1073 pp_cxx_ws_string (cxx_pp, "operator");
1074 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1075 dump_type (TREE_TYPE (t), flags);
1079 pp_cxx_tree_identifier (cxx_pp, t);
1085 t = OVL_CURRENT (t);
1086 if (DECL_CLASS_SCOPE_P (t))
1088 dump_type (DECL_CONTEXT (t), flags);
1089 pp_cxx_colon_colon (cxx_pp);
1091 else if (!DECL_FILE_SCOPE_P (t))
1093 dump_decl (DECL_CONTEXT (t), flags);
1094 pp_cxx_colon_colon (cxx_pp);
1096 dump_decl (DECL_NAME (t), flags);
1100 /* If there's only one function, just treat it like an ordinary
1102 t = OVL_CURRENT (t);
1106 if (! DECL_LANG_SPECIFIC (t))
1107 pp_string (cxx_pp, M_("<built-in>"));
1108 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1109 dump_global_iord (t);
1111 dump_function_decl (t, flags);
1115 dump_template_decl (t, flags);
1118 case TEMPLATE_ID_EXPR:
1120 tree name = TREE_OPERAND (t, 0);
1122 if (is_overloaded_fn (name))
1123 name = DECL_NAME (get_first_fn (name));
1124 dump_decl (name, flags);
1125 pp_cxx_begin_template_argument_list (cxx_pp);
1126 if (TREE_OPERAND (t, 1))
1127 dump_template_argument_list (TREE_OPERAND (t, 1), flags);
1128 pp_cxx_end_template_argument_list (cxx_pp);
1133 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (t));
1137 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1138 || (DECL_INITIAL (t) &&
1139 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1140 dump_simple_decl (t, TREE_TYPE (t), flags);
1141 else if (DECL_NAME (t))
1142 dump_decl (DECL_NAME (t), flags);
1143 else if (DECL_INITIAL (t))
1144 dump_expr (DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1146 pp_string (cxx_pp, M_("<enumerator>"));
1150 pp_cxx_ws_string (cxx_pp, "using");
1151 dump_type (USING_DECL_SCOPE (t), flags);
1152 pp_cxx_colon_colon (cxx_pp);
1153 dump_decl (DECL_NAME (t), flags);
1157 pp_cxx_declaration (cxx_pp, t);
1161 dump_decl (BASELINK_FUNCTIONS (t), flags);
1164 case NON_DEPENDENT_EXPR:
1165 dump_expr (t, flags);
1168 case TEMPLATE_TYPE_PARM:
1169 if (flags & TFF_DECL_SPECIFIERS)
1170 pp_cxx_declaration (cxx_pp, t);
1172 pp_type_id (cxx_pp, t);
1175 case UNBOUND_CLASS_TEMPLATE:
1176 case TYPE_PACK_EXPANSION:
1178 dump_type (t, flags);
1182 pp_unsupported_tree (cxx_pp, t);
1183 /* Fall through to error. */
1186 pp_string (cxx_pp, M_("<declaration error>"));
1191 /* Dump a template declaration T under control of FLAGS. This means the
1192 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1195 dump_template_decl (tree t, int flags)
1197 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1201 if (flags & TFF_TEMPLATE_HEADER)
1203 for (parms = orig_parms = nreverse (orig_parms);
1205 parms = TREE_CHAIN (parms))
1207 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1208 int len = TREE_VEC_LENGTH (inner_parms);
1210 pp_cxx_ws_string (cxx_pp, "template");
1211 pp_cxx_begin_template_argument_list (cxx_pp);
1213 /* If we've shown the template prefix, we'd better show the
1214 parameters' and decl's type too. */
1215 flags |= TFF_DECL_SPECIFIERS;
1217 for (i = 0; i < len; i++)
1220 pp_separate_with_comma (cxx_pp);
1221 dump_template_parameter (TREE_VEC_ELT (inner_parms, i), flags);
1223 pp_cxx_end_template_argument_list (cxx_pp);
1224 pp_cxx_whitespace (cxx_pp);
1226 nreverse(orig_parms);
1228 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1230 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1231 pp_cxx_ws_string (cxx_pp, "class");
1233 /* If this is a parameter pack, print the ellipsis. */
1234 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1235 pp_cxx_ws_string (cxx_pp, "...");
1239 if (DECL_CLASS_TEMPLATE_P (t))
1240 dump_type (TREE_TYPE (t),
1241 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1242 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1243 else if (DECL_TEMPLATE_RESULT (t)
1244 && (TREE_CODE (DECL_TEMPLATE_RESULT (t)) == VAR_DECL
1245 /* Alias template. */
1246 || DECL_TYPE_TEMPLATE_P (t)))
1247 dump_decl (DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1250 gcc_assert (TREE_TYPE (t));
1251 switch (NEXT_CODE (t))
1255 dump_function_decl (t, flags | TFF_TEMPLATE_NAME);
1258 /* This case can occur with some invalid code. */
1259 dump_type (TREE_TYPE (t),
1260 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1261 | (flags & TFF_DECL_SPECIFIERS
1262 ? TFF_CLASS_KEY_OR_ENUM : 0));
1267 /* find_typenames looks through the type of the function template T
1268 and returns a VEC containing any typedefs, decltypes or TYPENAME_TYPEs
1271 struct find_typenames_t
1273 struct pointer_set_t *p_set;
1274 VEC (tree,gc) *typenames;
1278 find_typenames_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, void *data)
1280 struct find_typenames_t *d = (struct find_typenames_t *)data;
1281 tree mv = NULL_TREE;
1283 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1284 /* Add the type of the typedef without any additional cv-quals. */
1285 mv = TREE_TYPE (TYPE_NAME (*tp));
1286 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1287 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1288 /* Add the typename without any cv-qualifiers. */
1289 mv = TYPE_MAIN_VARIANT (*tp);
1291 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1292 VEC_safe_push (tree, gc, d->typenames, mv);
1294 /* Search into class template arguments, which cp_walk_subtrees
1296 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1297 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1303 static VEC(tree,gc) *
1304 find_typenames (tree t)
1306 struct find_typenames_t ft;
1307 ft.p_set = pointer_set_create ();
1308 ft.typenames = NULL;
1309 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1310 find_typenames_r, &ft, ft.p_set);
1311 pointer_set_destroy (ft.p_set);
1312 return ft.typenames;
1315 /* Pretty print a function decl. There are several ways we want to print a
1316 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1317 As error can only apply the '#' flag once to give 0 and 1 for V, there
1318 is %D which doesn't print the throw specs, and %F which does. */
1321 dump_function_decl (tree t, int flags)
1325 tree cname = NULL_TREE;
1326 tree template_args = NULL_TREE;
1327 tree template_parms = NULL_TREE;
1328 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1329 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1331 VEC(tree,gc) *typenames = NULL;
1333 if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1335 /* A lambda's signature is essentially its "type", so defer. */
1336 gcc_assert (LAMBDA_TYPE_P (DECL_CONTEXT (t)));
1337 dump_type (DECL_CONTEXT (t), flags);
1341 flags &= ~TFF_UNQUALIFIED_NAME;
1342 if (TREE_CODE (t) == TEMPLATE_DECL)
1343 t = DECL_TEMPLATE_RESULT (t);
1345 /* Save the exceptions, in case t is a specialization and we are
1346 emitting an error about incompatible specifications. */
1347 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1349 /* Pretty print template instantiations only. */
1350 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1351 && flag_pretty_templates)
1355 template_args = DECL_TI_ARGS (t);
1356 tmpl = most_general_template (t);
1357 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1359 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1361 typenames = find_typenames (t);
1365 fntype = TREE_TYPE (t);
1366 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1368 if (DECL_CLASS_SCOPE_P (t))
1369 cname = DECL_CONTEXT (t);
1370 /* This is for partially instantiated template methods. */
1371 else if (TREE_CODE (fntype) == METHOD_TYPE)
1372 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1374 if (flags & TFF_DECL_SPECIFIERS)
1376 if (DECL_STATIC_FUNCTION_P (t))
1377 pp_cxx_ws_string (cxx_pp, "static");
1378 else if (DECL_VIRTUAL_P (t))
1379 pp_cxx_ws_string (cxx_pp, "virtual");
1381 if (DECL_DECLARED_CONSTEXPR_P (STRIP_TEMPLATE (t)))
1382 pp_cxx_ws_string (cxx_pp, "constexpr");
1385 /* Print the return type? */
1387 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1388 && !DECL_DESTRUCTOR_P (t);
1390 dump_type_prefix (TREE_TYPE (fntype), flags);
1392 /* Print the function name. */
1393 if (!do_outer_scope)
1397 dump_type (cname, flags);
1398 pp_cxx_colon_colon (cxx_pp);
1401 dump_scope (CP_DECL_CONTEXT (t), flags);
1403 dump_function_name (t, flags);
1405 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1407 dump_parameters (parmtypes, flags);
1409 if (TREE_CODE (fntype) == METHOD_TYPE)
1411 pp_base (cxx_pp)->padding = pp_before;
1412 pp_cxx_cv_qualifier_seq (cxx_pp, class_of_this_parm (fntype));
1415 if (flags & TFF_EXCEPTION_SPECIFICATION)
1417 pp_base (cxx_pp)->padding = pp_before;
1418 dump_exception_spec (exceptions, flags);
1422 dump_type_suffix (TREE_TYPE (fntype), flags);
1424 /* If T is a template instantiation, dump the parameter binding. */
1425 if (template_parms != NULL_TREE && template_args != NULL_TREE)
1427 pp_cxx_whitespace (cxx_pp);
1428 pp_cxx_left_bracket (cxx_pp);
1429 pp_cxx_ws_string (cxx_pp, M_("with"));
1430 pp_cxx_whitespace (cxx_pp);
1431 dump_template_bindings (template_parms, template_args, typenames);
1432 pp_cxx_right_bracket (cxx_pp);
1435 else if (template_args)
1437 bool need_comma = false;
1439 pp_cxx_begin_template_argument_list (cxx_pp);
1440 template_args = INNERMOST_TEMPLATE_ARGS (template_args);
1441 for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
1443 tree arg = TREE_VEC_ELT (template_args, i);
1445 pp_separate_with_comma (cxx_pp);
1446 if (ARGUMENT_PACK_P (arg))
1447 pp_cxx_left_brace (cxx_pp);
1448 dump_template_argument (arg, TFF_PLAIN_IDENTIFIER);
1449 if (ARGUMENT_PACK_P (arg))
1450 pp_cxx_right_brace (cxx_pp);
1453 pp_cxx_end_template_argument_list (cxx_pp);
1457 /* Print a parameter list. If this is for a member function, the
1458 member object ptr (and any other hidden args) should have
1459 already been removed. */
1462 dump_parameters (tree parmtypes, int flags)
1465 flags &= ~TFF_SCOPE;
1466 pp_cxx_left_paren (cxx_pp);
1468 for (first = 1; parmtypes != void_list_node;
1469 parmtypes = TREE_CHAIN (parmtypes))
1472 pp_separate_with_comma (cxx_pp);
1476 pp_cxx_ws_string (cxx_pp, "...");
1480 dump_type (TREE_VALUE (parmtypes), flags);
1482 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1484 pp_cxx_whitespace (cxx_pp);
1486 pp_cxx_whitespace (cxx_pp);
1487 dump_expr (TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1491 pp_cxx_right_paren (cxx_pp);
1494 /* Print an exception specification. T is the exception specification. */
1497 dump_exception_spec (tree t, int flags)
1499 if (t && TREE_PURPOSE (t))
1501 pp_cxx_ws_string (cxx_pp, "noexcept");
1502 pp_cxx_whitespace (cxx_pp);
1503 pp_cxx_left_paren (cxx_pp);
1504 if (DEFERRED_NOEXCEPT_SPEC_P (t))
1505 pp_cxx_ws_string (cxx_pp, "<uninstantiated>");
1507 dump_expr (TREE_PURPOSE (t), flags);
1508 pp_cxx_right_paren (cxx_pp);
1512 pp_cxx_ws_string (cxx_pp, "throw");
1513 pp_cxx_whitespace (cxx_pp);
1514 pp_cxx_left_paren (cxx_pp);
1515 if (TREE_VALUE (t) != NULL_TREE)
1518 dump_type (TREE_VALUE (t), flags);
1522 pp_separate_with_comma (cxx_pp);
1524 pp_cxx_right_paren (cxx_pp);
1528 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1529 and destructors properly. */
1532 dump_function_name (tree t, int flags)
1534 tree name = DECL_NAME (t);
1536 /* We can get here with a decl that was synthesized by language-
1537 independent machinery (e.g. coverage.c) in which case it won't
1538 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1539 will crash. In this case it is safe just to print out the
1541 if (!DECL_LANG_SPECIFIC (t))
1543 pp_cxx_tree_identifier (cxx_pp, name);
1547 if (TREE_CODE (t) == TEMPLATE_DECL)
1548 t = DECL_TEMPLATE_RESULT (t);
1550 /* Don't let the user see __comp_ctor et al. */
1551 if (DECL_CONSTRUCTOR_P (t)
1552 || DECL_DESTRUCTOR_P (t))
1554 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1555 name = get_identifier ("<lambda>");
1557 name = constructor_name (DECL_CONTEXT (t));
1560 if (DECL_DESTRUCTOR_P (t))
1562 pp_cxx_complement (cxx_pp);
1563 dump_decl (name, TFF_PLAIN_IDENTIFIER);
1565 else if (DECL_CONV_FN_P (t))
1567 /* This cannot use the hack that the operator's return
1568 type is stashed off of its name because it may be
1569 used for error reporting. In the case of conflicting
1570 declarations, both will have the same name, yet
1571 the types will be different, hence the TREE_TYPE field
1572 of the first name will be clobbered by the second. */
1573 pp_cxx_ws_string (cxx_pp, "operator");
1574 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1576 else if (name && IDENTIFIER_OPNAME_P (name))
1577 pp_cxx_tree_identifier (cxx_pp, name);
1578 else if (name && UDLIT_OPER_P (name))
1579 pp_cxx_tree_identifier (cxx_pp, name);
1581 dump_decl (name, flags);
1583 if (DECL_TEMPLATE_INFO (t)
1584 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1585 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1586 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1587 dump_template_parms (DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t), flags);
1590 /* Dump the template parameters from the template info INFO under control of
1591 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1592 specialization (partial or complete). For partial specializations we show
1593 the specialized parameter values. For a primary template we show no
1597 dump_template_parms (tree info, int primary, int flags)
1599 tree args = info ? TI_ARGS (info) : NULL_TREE;
1601 if (primary && flags & TFF_TEMPLATE_NAME)
1603 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1604 pp_cxx_begin_template_argument_list (cxx_pp);
1606 /* Be careful only to print things when we have them, so as not
1607 to crash producing error messages. */
1608 if (args && !primary)
1611 len = get_non_default_template_args_count (args, flags);
1613 args = INNERMOST_TEMPLATE_ARGS (args);
1614 for (ix = 0; ix != len; ix++)
1616 tree arg = TREE_VEC_ELT (args, ix);
1618 /* Only print a comma if we know there is an argument coming. In
1619 the case of an empty template argument pack, no actual
1620 argument will be printed. */
1622 && (!ARGUMENT_PACK_P (arg)
1623 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1624 pp_separate_with_comma (cxx_pp);
1627 pp_string (cxx_pp, M_("<template parameter error>"));
1629 dump_template_argument (arg, flags);
1634 tree tpl = TI_TEMPLATE (info);
1635 tree parms = DECL_TEMPLATE_PARMS (tpl);
1638 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1639 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1641 for (ix = 0; ix != len; ix++)
1645 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1647 pp_string (cxx_pp, M_("<template parameter error>"));
1651 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1654 pp_separate_with_comma (cxx_pp);
1656 dump_decl (parm, flags & ~TFF_DECL_SPECIFIERS);
1659 pp_cxx_end_template_argument_list (cxx_pp);
1662 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1663 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1666 dump_call_expr_args (tree t, int flags, bool skipfirst)
1669 call_expr_arg_iterator iter;
1671 pp_cxx_left_paren (cxx_pp);
1672 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1678 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1679 if (more_call_expr_args_p (&iter))
1680 pp_separate_with_comma (cxx_pp);
1683 pp_cxx_right_paren (cxx_pp);
1686 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1687 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1691 dump_aggr_init_expr_args (tree t, int flags, bool skipfirst)
1694 aggr_init_expr_arg_iterator iter;
1696 pp_cxx_left_paren (cxx_pp);
1697 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1703 dump_expr (arg, flags | TFF_EXPR_IN_PARENS);
1704 if (more_aggr_init_expr_args_p (&iter))
1705 pp_separate_with_comma (cxx_pp);
1708 pp_cxx_right_paren (cxx_pp);
1711 /* Print out a list of initializers (subr of dump_expr). */
1714 dump_expr_list (tree l, int flags)
1718 dump_expr (TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1721 pp_separate_with_comma (cxx_pp);
1725 /* Print out a vector of initializers (subr of dump_expr). */
1728 dump_expr_init_vec (VEC(constructor_elt,gc) *v, int flags)
1730 unsigned HOST_WIDE_INT idx;
1733 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1735 dump_expr (value, flags | TFF_EXPR_IN_PARENS);
1736 if (idx != VEC_length (constructor_elt, v) - 1)
1737 pp_separate_with_comma (cxx_pp);
1742 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1743 function. Resolve it to a close relative -- in the sense of static
1744 type -- variant being overridden. That is close to what was written in
1745 the source code. Subroutine of dump_expr. */
1748 resolve_virtual_fun_from_obj_type_ref (tree ref)
1750 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1751 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
1752 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1755 fun = TREE_CHAIN (fun);
1756 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1757 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1763 /* Print out an expression E under control of FLAGS. */
1766 dump_expr (tree t, int flags)
1771 if (STATEMENT_CLASS_P (t))
1773 pp_cxx_ws_string (cxx_pp, M_("<statement>"));
1777 switch (TREE_CODE (t))
1785 case NAMESPACE_DECL:
1789 case IDENTIFIER_NODE:
1790 dump_decl (t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
1791 |TFF_TEMPLATE_HEADER))
1792 | TFF_NO_FUNCTION_ARGUMENTS));
1799 pp_constant (cxx_pp, t);
1802 case USERDEF_LITERAL:
1803 pp_cxx_userdef_literal (cxx_pp, t);
1807 /* While waiting for caret diagnostics, avoid printing
1808 __cxa_allocate_exception, __cxa_throw, and the like. */
1809 pp_cxx_ws_string (cxx_pp, M_("<throw-expression>"));
1813 pp_ampersand (cxx_pp);
1814 dump_type (PTRMEM_CST_CLASS (t), flags);
1815 pp_cxx_colon_colon (cxx_pp);
1816 pp_cxx_tree_identifier (cxx_pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1820 pp_cxx_left_paren (cxx_pp);
1821 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1822 pp_separate_with_comma (cxx_pp);
1823 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1824 pp_cxx_right_paren (cxx_pp);
1828 pp_cxx_left_paren (cxx_pp);
1829 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1830 pp_string (cxx_pp, " ? ");
1831 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1832 pp_string (cxx_pp, " : ");
1833 dump_expr (TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1834 pp_cxx_right_paren (cxx_pp);
1838 if (TREE_HAS_CONSTRUCTOR (t))
1840 pp_cxx_ws_string (cxx_pp, "new");
1841 pp_cxx_whitespace (cxx_pp);
1842 dump_type (TREE_TYPE (TREE_TYPE (t)), flags);
1845 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1848 case AGGR_INIT_EXPR:
1850 tree fn = NULL_TREE;
1852 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1853 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1855 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1857 if (DECL_CONSTRUCTOR_P (fn))
1858 dump_type (DECL_CONTEXT (fn), flags);
1863 dump_expr (AGGR_INIT_EXPR_FN (t), 0);
1865 dump_aggr_init_expr_args (t, flags, true);
1870 tree fn = CALL_EXPR_FN (t);
1871 bool skipfirst = false;
1873 if (TREE_CODE (fn) == ADDR_EXPR)
1874 fn = TREE_OPERAND (fn, 0);
1876 /* Nobody is interested in seeing the guts of vcalls. */
1877 if (TREE_CODE (fn) == OBJ_TYPE_REF)
1878 fn = resolve_virtual_fun_from_obj_type_ref (fn);
1880 if (TREE_TYPE (fn) != NULL_TREE
1881 && NEXT_CODE (fn) == METHOD_TYPE
1882 && call_expr_nargs (t))
1884 tree ob = CALL_EXPR_ARG (t, 0);
1885 if (TREE_CODE (ob) == ADDR_EXPR)
1887 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1888 pp_cxx_dot (cxx_pp);
1890 else if (TREE_CODE (ob) != PARM_DECL
1891 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
1893 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1894 pp_cxx_arrow (cxx_pp);
1898 dump_expr (fn, flags | TFF_EXPR_IN_PARENS);
1899 dump_call_expr_args (t, flags, skipfirst);
1904 /* Note that this only works for G++ target exprs. If somebody
1905 builds a general TARGET_EXPR, there's no way to represent that
1906 it initializes anything other that the parameter slot for the
1907 default argument. Note we may have cleared out the first
1908 operand in expand_expr, so don't go killing ourselves. */
1909 if (TREE_OPERAND (t, 1))
1910 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1913 case POINTER_PLUS_EXPR:
1914 dump_binary_op ("+", t, flags);
1919 dump_binary_op (assignment_operator_name_info[(int)NOP_EXPR].name,
1926 case TRUNC_DIV_EXPR:
1927 case TRUNC_MOD_EXPR:
1935 case TRUTH_ANDIF_EXPR:
1936 case TRUTH_ORIF_EXPR:
1943 case EXACT_DIV_EXPR:
1944 dump_binary_op (operator_name_info[(int) TREE_CODE (t)].name, t, flags);
1948 case FLOOR_DIV_EXPR:
1949 case ROUND_DIV_EXPR:
1951 dump_binary_op ("/", t, flags);
1955 case FLOOR_MOD_EXPR:
1956 case ROUND_MOD_EXPR:
1957 dump_binary_op ("%", t, flags);
1962 tree ob = TREE_OPERAND (t, 0);
1963 if (TREE_CODE (ob) == INDIRECT_REF)
1965 ob = TREE_OPERAND (ob, 0);
1966 if (TREE_CODE (ob) != PARM_DECL
1968 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
1970 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1971 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
1972 pp_cxx_dot (cxx_pp);
1974 pp_cxx_arrow (cxx_pp);
1979 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1980 pp_cxx_dot (cxx_pp);
1982 dump_expr (TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
1987 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1988 pp_cxx_left_bracket (cxx_pp);
1989 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1990 pp_cxx_right_bracket (cxx_pp);
1993 case UNARY_PLUS_EXPR:
1994 dump_unary_op ("+", t, flags);
1998 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
1999 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
2000 /* An ADDR_EXPR can have reference type. In that case, we
2001 shouldn't print the `&' doing so indicates to the user
2002 that the expression has pointer type. */
2004 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
2005 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2006 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
2007 dump_unary_op ("&&", t, flags);
2009 dump_unary_op ("&", t, flags);
2013 if (TREE_HAS_CONSTRUCTOR (t))
2015 t = TREE_OPERAND (t, 0);
2016 gcc_assert (TREE_CODE (t) == CALL_EXPR);
2017 dump_expr (CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
2018 dump_call_expr_args (t, flags, true);
2022 if (TREE_OPERAND (t,0) != NULL_TREE
2023 && TREE_TYPE (TREE_OPERAND (t, 0))
2024 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
2025 dump_expr (TREE_OPERAND (t, 0), flags);
2027 dump_unary_op ("*", t, flags);
2032 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
2033 && integer_zerop (TREE_OPERAND (t, 1)))
2034 dump_expr (TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
2037 pp_cxx_star (cxx_pp);
2038 if (!integer_zerop (TREE_OPERAND (t, 1)))
2040 pp_cxx_left_paren (cxx_pp);
2041 if (!integer_onep (TYPE_SIZE_UNIT
2042 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
2044 pp_cxx_left_paren (cxx_pp);
2045 dump_type (ptr_type_node, flags);
2046 pp_cxx_right_paren (cxx_pp);
2049 dump_expr (TREE_OPERAND (t, 0), flags);
2050 if (!integer_zerop (TREE_OPERAND (t, 1)))
2052 pp_cxx_ws_string (cxx_pp, "+");
2053 dump_expr (fold_convert (ssizetype, TREE_OPERAND (t, 1)), flags);
2054 pp_cxx_right_paren (cxx_pp);
2061 case TRUTH_NOT_EXPR:
2062 case PREDECREMENT_EXPR:
2063 case PREINCREMENT_EXPR:
2064 dump_unary_op (operator_name_info [(int)TREE_CODE (t)].name, t, flags);
2067 case POSTDECREMENT_EXPR:
2068 case POSTINCREMENT_EXPR:
2069 pp_cxx_left_paren (cxx_pp);
2070 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2071 pp_cxx_ws_string (cxx_pp, operator_name_info[(int)TREE_CODE (t)].name);
2072 pp_cxx_right_paren (cxx_pp);
2075 case NON_LVALUE_EXPR:
2076 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2077 should be another level of INDIRECT_REF so that I don't have to do
2079 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2081 tree next = TREE_TYPE (TREE_TYPE (t));
2083 while (TREE_CODE (next) == POINTER_TYPE)
2084 next = TREE_TYPE (next);
2086 if (TREE_CODE (next) == FUNCTION_TYPE)
2088 if (flags & TFF_EXPR_IN_PARENS)
2089 pp_cxx_left_paren (cxx_pp);
2090 pp_cxx_star (cxx_pp);
2091 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2092 if (flags & TFF_EXPR_IN_PARENS)
2093 pp_cxx_right_paren (cxx_pp);
2096 /* Else fall through. */
2098 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2102 case IMPLICIT_CONV_EXPR:
2103 case VIEW_CONVERT_EXPR:
2105 tree op = TREE_OPERAND (t, 0);
2106 tree ttype = TREE_TYPE (t);
2107 tree optype = TREE_TYPE (op);
2109 if (TREE_CODE (ttype) != TREE_CODE (optype)
2110 && POINTER_TYPE_P (ttype)
2111 && POINTER_TYPE_P (optype)
2112 && same_type_p (TREE_TYPE (optype),
2115 if (TREE_CODE (ttype) == REFERENCE_TYPE)
2116 dump_unary_op ("*", t, flags);
2118 dump_unary_op ("&", t, flags);
2120 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2122 /* It is a cast, but we cannot tell whether it is a
2123 reinterpret or static cast. Use the C style notation. */
2124 if (flags & TFF_EXPR_IN_PARENS)
2125 pp_cxx_left_paren (cxx_pp);
2126 pp_cxx_left_paren (cxx_pp);
2127 dump_type (TREE_TYPE (t), flags);
2128 pp_cxx_right_paren (cxx_pp);
2129 dump_expr (op, flags | TFF_EXPR_IN_PARENS);
2130 if (flags & TFF_EXPR_IN_PARENS)
2131 pp_cxx_right_paren (cxx_pp);
2134 dump_expr (op, flags);
2139 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2141 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2143 if (integer_zerop (idx))
2145 /* A NULL pointer-to-member constant. */
2146 pp_cxx_left_paren (cxx_pp);
2147 pp_cxx_left_paren (cxx_pp);
2148 dump_type (TREE_TYPE (t), flags);
2149 pp_cxx_right_paren (cxx_pp);
2150 pp_character (cxx_pp, '0');
2151 pp_cxx_right_paren (cxx_pp);
2154 else if (host_integerp (idx, 0))
2157 unsigned HOST_WIDE_INT n;
2159 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2160 t = TYPE_METHOD_BASETYPE (t);
2161 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2163 n = tree_low_cst (idx, 0);
2165 /* Map vtable index back one, to allow for the null pointer to
2169 while (n > 0 && virtuals)
2172 virtuals = TREE_CHAIN (virtuals);
2176 dump_expr (BV_FN (virtuals),
2177 flags | TFF_EXPR_IN_PARENS);
2182 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2184 dump_type (TREE_TYPE (t), 0);
2185 pp_cxx_left_paren (cxx_pp);
2186 pp_cxx_right_paren (cxx_pp);
2190 pp_cxx_left_brace (cxx_pp);
2191 dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
2192 pp_cxx_right_brace (cxx_pp);
2199 tree ob = TREE_OPERAND (t, 0);
2200 if (is_dummy_object (ob))
2202 t = TREE_OPERAND (t, 1);
2203 if (TREE_CODE (t) == FUNCTION_DECL)
2205 dump_expr (t, flags | TFF_EXPR_IN_PARENS);
2206 else if (BASELINK_P (t))
2207 dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2208 flags | TFF_EXPR_IN_PARENS);
2210 dump_decl (t, flags);
2214 if (TREE_CODE (ob) == INDIRECT_REF)
2216 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2217 pp_cxx_arrow (cxx_pp);
2218 pp_cxx_star (cxx_pp);
2222 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
2223 pp_cxx_dot (cxx_pp);
2224 pp_cxx_star (cxx_pp);
2226 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2231 case TEMPLATE_PARM_INDEX:
2232 dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2236 if (TREE_OPERAND (t, 0) == NULL_TREE
2237 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2239 dump_type (TREE_TYPE (t), flags);
2240 pp_cxx_left_paren (cxx_pp);
2241 dump_expr_list (TREE_OPERAND (t, 0), flags);
2242 pp_cxx_right_paren (cxx_pp);
2246 pp_cxx_left_paren (cxx_pp);
2247 dump_type (TREE_TYPE (t), flags);
2248 pp_cxx_right_paren (cxx_pp);
2249 pp_cxx_left_paren (cxx_pp);
2250 dump_expr_list (TREE_OPERAND (t, 0), flags);
2251 pp_cxx_right_paren (cxx_pp);
2255 case STATIC_CAST_EXPR:
2256 pp_cxx_ws_string (cxx_pp, "static_cast");
2258 case REINTERPRET_CAST_EXPR:
2259 pp_cxx_ws_string (cxx_pp, "reinterpret_cast");
2261 case CONST_CAST_EXPR:
2262 pp_cxx_ws_string (cxx_pp, "const_cast");
2264 case DYNAMIC_CAST_EXPR:
2265 pp_cxx_ws_string (cxx_pp, "dynamic_cast");
2267 pp_cxx_begin_template_argument_list (cxx_pp);
2268 dump_type (TREE_TYPE (t), flags);
2269 pp_cxx_end_template_argument_list (cxx_pp);
2270 pp_cxx_left_paren (cxx_pp);
2271 dump_expr (TREE_OPERAND (t, 0), flags);
2272 pp_cxx_right_paren (cxx_pp);
2276 dump_expr (TREE_OPERAND (t, 0), flags);
2277 pp_cxx_arrow (cxx_pp);
2282 if (TREE_CODE (t) == SIZEOF_EXPR)
2283 pp_cxx_ws_string (cxx_pp, "sizeof");
2286 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2287 pp_cxx_ws_string (cxx_pp, "__alignof__");
2289 pp_cxx_whitespace (cxx_pp);
2290 pp_cxx_left_paren (cxx_pp);
2291 if (TYPE_P (TREE_OPERAND (t, 0)))
2292 dump_type (TREE_OPERAND (t, 0), flags);
2294 dump_expr (TREE_OPERAND (t, 0), flags);
2295 pp_cxx_right_paren (cxx_pp);
2298 case AT_ENCODE_EXPR:
2299 pp_cxx_ws_string (cxx_pp, "@encode");
2300 pp_cxx_whitespace (cxx_pp);
2301 pp_cxx_left_paren (cxx_pp);
2302 dump_type (TREE_OPERAND (t, 0), flags);
2303 pp_cxx_right_paren (cxx_pp);
2307 pp_cxx_ws_string (cxx_pp, "noexcept");
2308 pp_cxx_whitespace (cxx_pp);
2309 pp_cxx_left_paren (cxx_pp);
2310 dump_expr (TREE_OPERAND (t, 0), flags);
2311 pp_cxx_right_paren (cxx_pp);
2316 pp_cxx_ws_string (cxx_pp, operator_name_info[TREE_CODE (t)].name);
2317 pp_cxx_whitespace (cxx_pp);
2318 dump_expr (TREE_OPERAND (t, 0), flags);
2322 pp_string (cxx_pp, M_("<unparsed>"));
2325 case TRY_CATCH_EXPR:
2326 case WITH_CLEANUP_EXPR:
2327 case CLEANUP_POINT_EXPR:
2328 dump_expr (TREE_OPERAND (t, 0), flags);
2331 case PSEUDO_DTOR_EXPR:
2332 dump_expr (TREE_OPERAND (t, 2), flags);
2333 pp_cxx_dot (cxx_pp);
2334 dump_type (TREE_OPERAND (t, 0), flags);
2335 pp_cxx_colon_colon (cxx_pp);
2336 pp_cxx_complement (cxx_pp);
2337 dump_type (TREE_OPERAND (t, 1), flags);
2340 case TEMPLATE_ID_EXPR:
2341 dump_decl (t, flags);
2347 case STATEMENT_LIST:
2348 /* We don't yet have a way of dumping statements in a
2349 human-readable format. */
2350 pp_string (cxx_pp, "({...})");
2354 pp_string (cxx_pp, "while (1) { ");
2355 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2356 pp_cxx_right_brace (cxx_pp);
2360 pp_string (cxx_pp, "if (");
2361 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2362 pp_string (cxx_pp, ") break; ");
2366 dump_expr (BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
2369 case EMPTY_CLASS_EXPR:
2370 dump_type (TREE_TYPE (t), flags);
2371 pp_cxx_left_paren (cxx_pp);
2372 pp_cxx_right_paren (cxx_pp);
2375 case NON_DEPENDENT_EXPR:
2376 dump_expr (TREE_OPERAND (t, 0), flags);
2379 case ARGUMENT_PACK_SELECT:
2380 dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2392 pp_type_specifier_seq (cxx_pp, t);
2396 /* We get here when we want to print a dependent type as an
2397 id-expression, without any disambiguator decoration. */
2398 pp_id_expression (cxx_pp, t);
2401 case TEMPLATE_TYPE_PARM:
2402 case BOUND_TEMPLATE_TEMPLATE_PARM:
2403 dump_type (t, flags);
2407 pp_cxx_trait_expression (cxx_pp, t);
2411 pp_cxx_va_arg_expression (cxx_pp, t);
2415 pp_cxx_offsetof_expression (cxx_pp, t);
2419 dump_decl (t, flags);
2422 case EXPR_PACK_EXPANSION:
2429 case VEC_DELETE_EXPR:
2435 case UNORDERED_EXPR:
2445 case FIX_TRUNC_EXPR:
2447 pp_expression (cxx_pp, t);
2450 case TRUTH_AND_EXPR:
2452 case TRUTH_XOR_EXPR:
2453 if (flags & TFF_EXPR_IN_PARENS)
2454 pp_cxx_left_paren (cxx_pp);
2455 pp_expression (cxx_pp, t);
2456 if (flags & TFF_EXPR_IN_PARENS)
2457 pp_cxx_right_paren (cxx_pp);
2461 dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2464 /* This list is incomplete, but should suffice for now.
2465 It is very important that `sorry' does not call
2466 `report_error_function'. That could cause an infinite loop. */
2468 pp_unsupported_tree (cxx_pp, t);
2469 /* fall through to ERROR_MARK... */
2471 pp_string (cxx_pp, M_("<expression error>"));
2477 dump_binary_op (const char *opstring, tree t, int flags)
2479 pp_cxx_left_paren (cxx_pp);
2480 dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2481 pp_cxx_whitespace (cxx_pp);
2483 pp_cxx_ws_string (cxx_pp, opstring);
2485 pp_string (cxx_pp, M_("<unknown operator>"));
2486 pp_cxx_whitespace (cxx_pp);
2487 dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2488 pp_cxx_right_paren (cxx_pp);
2492 dump_unary_op (const char *opstring, tree t, int flags)
2494 if (flags & TFF_EXPR_IN_PARENS)
2495 pp_cxx_left_paren (cxx_pp);
2496 pp_cxx_ws_string (cxx_pp, opstring);
2497 dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2498 if (flags & TFF_EXPR_IN_PARENS)
2499 pp_cxx_right_paren (cxx_pp);
2503 reinit_cxx_pp (void)
2505 pp_clear_output_area (cxx_pp);
2506 pp_base (cxx_pp)->padding = pp_none;
2507 pp_indentation (cxx_pp) = 0;
2508 pp_needs_newline (cxx_pp) = false;
2509 cxx_pp->enclosing_scope = current_function_decl;
2513 /* Exported interface to stringifying types, exprs and decls under TFF_*
2517 type_as_string (tree typ, int flags)
2520 pp_translate_identifiers (cxx_pp) = false;
2521 dump_type (typ, flags);
2522 return pp_formatted_text (cxx_pp);
2526 type_as_string_translate (tree typ, int flags)
2529 dump_type (typ, flags);
2530 return pp_formatted_text (cxx_pp);
2534 expr_as_string (tree decl, int flags)
2537 pp_translate_identifiers (cxx_pp) = false;
2538 dump_expr (decl, flags);
2539 return pp_formatted_text (cxx_pp);
2543 decl_as_string (tree decl, int flags)
2546 pp_translate_identifiers (cxx_pp) = false;
2547 dump_decl (decl, flags);
2548 return pp_formatted_text (cxx_pp);
2552 decl_as_string_translate (tree decl, int flags)
2555 dump_decl (decl, flags);
2556 return pp_formatted_text (cxx_pp);
2559 /* Generate the three forms of printable names for cxx_printable_name. */
2562 lang_decl_name (tree decl, int v, bool translate)
2566 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2567 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2570 pp_translate_identifiers (cxx_pp) = translate;
2572 && (DECL_CLASS_SCOPE_P (decl)
2573 || (DECL_NAMESPACE_SCOPE_P (decl)
2574 && CP_DECL_CONTEXT (decl) != global_namespace)))
2576 dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2577 pp_cxx_colon_colon (cxx_pp);
2580 if (TREE_CODE (decl) == FUNCTION_DECL)
2581 dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2583 dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2585 return pp_formatted_text (cxx_pp);
2588 /* Return the location of a tree passed to %+ formats. */
2591 location_of (tree t)
2593 if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2594 t = DECL_CONTEXT (t);
2595 else if (TYPE_P (t))
2597 t = TYPE_MAIN_DECL (t);
2599 return input_location;
2601 else if (TREE_CODE (t) == OVERLOAD)
2602 t = OVL_FUNCTION (t);
2605 return DECL_SOURCE_LOCATION (t);
2606 return EXPR_LOC_OR_HERE (t);
2609 /* Now the interfaces from error et al to dump_type et al. Each takes an
2610 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2614 decl_to_string (tree decl, int verbose)
2618 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2619 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2620 flags = TFF_CLASS_KEY_OR_ENUM;
2622 flags |= TFF_DECL_SPECIFIERS;
2623 else if (TREE_CODE (decl) == FUNCTION_DECL)
2624 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2625 flags |= TFF_TEMPLATE_HEADER;
2628 dump_decl (decl, flags);
2629 return pp_formatted_text (cxx_pp);
2633 expr_to_string (tree decl)
2636 dump_expr (decl, 0);
2637 return pp_formatted_text (cxx_pp);
2641 fndecl_to_string (tree fndecl, int verbose)
2645 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2646 | TFF_TEMPLATE_HEADER;
2648 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2650 dump_decl (fndecl, flags);
2651 return pp_formatted_text (cxx_pp);
2656 code_to_string (enum tree_code c)
2658 return tree_code_name [c];
2662 language_to_string (enum languages c)
2669 case lang_cplusplus:
2681 /* Return the proper printed version of a parameter to a C++ function. */
2684 parm_to_string (int p)
2688 pp_string (cxx_pp, "'this'");
2690 pp_decimal_int (cxx_pp, p + 1);
2691 return pp_formatted_text (cxx_pp);
2695 op_to_string (enum tree_code p)
2697 tree id = operator_name_info[(int) p].identifier;
2698 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2702 type_to_string (tree typ, int verbose)
2706 flags |= TFF_CLASS_KEY_OR_ENUM;
2707 flags |= TFF_TEMPLATE_HEADER;
2710 dump_type (typ, flags);
2711 /* If we're printing a type that involves typedefs, also print the
2712 stripped version. But sometimes the stripped version looks
2713 exactly the same, so we don't want it after all. To avoid printing
2714 it in that case, we play ugly obstack games. */
2715 if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
2716 && !uses_template_parms (typ))
2718 int aka_start; char *p;
2719 struct obstack *ob = pp_base (cxx_pp)->buffer->obstack;
2720 /* Remember the end of the initial dump. */
2721 int len = obstack_object_size (ob);
2722 tree aka = strip_typedefs (typ);
2723 pp_string (cxx_pp, " {aka");
2724 pp_cxx_whitespace (cxx_pp);
2725 /* And remember the start of the aka dump. */
2726 aka_start = obstack_object_size (ob);
2727 dump_type (aka, flags);
2728 pp_character (cxx_pp, '}');
2729 p = (char*)obstack_base (ob);
2730 /* If they are identical, cut off the aka with a NUL. */
2731 if (memcmp (p, p+aka_start, len) == 0)
2734 return pp_formatted_text (cxx_pp);
2738 assop_to_string (enum tree_code p)
2740 tree id = assignment_operator_name_info[(int) p].identifier;
2741 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2745 args_to_string (tree p, int verbose)
2749 flags |= TFF_CLASS_KEY_OR_ENUM;
2754 if (TYPE_P (TREE_VALUE (p)))
2755 return type_as_string_translate (p, flags);
2758 for (; p; p = TREE_CHAIN (p))
2760 if (TREE_VALUE (p) == null_node)
2761 pp_cxx_ws_string (cxx_pp, "NULL");
2763 dump_type (error_type (TREE_VALUE (p)), flags);
2765 pp_separate_with_comma (cxx_pp);
2767 return pp_formatted_text (cxx_pp);
2770 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
2771 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
2775 subst_to_string (tree p)
2777 tree decl = TREE_PURPOSE (p);
2778 tree targs = TREE_VALUE (p);
2779 tree tparms = DECL_TEMPLATE_PARMS (decl);
2780 int flags = TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER;
2786 dump_template_decl (TREE_PURPOSE (p), flags);
2787 pp_cxx_whitespace (cxx_pp);
2788 pp_cxx_left_bracket (cxx_pp);
2789 pp_cxx_ws_string (cxx_pp, M_("with"));
2790 pp_cxx_whitespace (cxx_pp);
2791 dump_template_bindings (tparms, targs, NULL);
2792 pp_cxx_right_bracket (cxx_pp);
2793 return pp_formatted_text (cxx_pp);
2797 cv_to_string (tree p, int v)
2800 pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2801 pp_cxx_cv_qualifier_seq (cxx_pp, p);
2802 return pp_formatted_text (cxx_pp);
2805 /* Langhook for print_error_function. */
2807 cxx_print_error_function (diagnostic_context *context, const char *file,
2808 diagnostic_info *diagnostic)
2810 lhd_print_error_function (context, file, diagnostic);
2811 pp_base_set_prefix (context->printer, file);
2812 maybe_print_instantiation_context (context);
2816 cp_diagnostic_starter (diagnostic_context *context,
2817 diagnostic_info *diagnostic)
2819 diagnostic_report_current_module (context, diagnostic->location);
2820 cp_print_error_function (context, diagnostic);
2821 maybe_print_instantiation_context (context);
2822 maybe_print_constexpr_context (context);
2823 pp_base_set_prefix (context->printer, diagnostic_build_prefix (context,
2828 cp_diagnostic_finalizer (diagnostic_context *context,
2829 diagnostic_info *diagnostic)
2831 virt_loc_aware_diagnostic_finalizer (context, diagnostic);
2832 pp_base_destroy_prefix (context->printer);
2835 /* Print current function onto BUFFER, in the process of reporting
2836 a diagnostic message. Called from cp_diagnostic_starter. */
2838 cp_print_error_function (diagnostic_context *context,
2839 diagnostic_info *diagnostic)
2841 /* If we are in an instantiation context, current_function_decl is likely
2842 to be wrong, so just rely on print_instantiation_full_context. */
2843 if (current_instantiation ())
2845 if (diagnostic_last_function_changed (context, diagnostic))
2847 const char *old_prefix = context->printer->prefix;
2848 const char *file = LOCATION_FILE (diagnostic->location);
2849 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
2850 char *new_prefix = (file && abstract_origin == NULL)
2851 ? file_name_as_prefix (file) : NULL;
2853 pp_base_set_prefix (context->printer, new_prefix);
2855 if (current_function_decl == NULL)
2856 pp_base_string (context->printer, _("At global scope:"));
2861 if (abstract_origin)
2863 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2864 while (TREE_CODE (ao) == BLOCK
2865 && BLOCK_ABSTRACT_ORIGIN (ao)
2866 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2867 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2868 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2872 fndecl = current_function_decl;
2874 pp_printf (context->printer, function_category (fndecl),
2875 cxx_printable_name_translate (fndecl, 2));
2877 while (abstract_origin)
2880 tree block = abstract_origin;
2882 locus = &BLOCK_SOURCE_LOCATION (block);
2884 block = BLOCK_SUPERCONTEXT (block);
2885 while (block && TREE_CODE (block) == BLOCK
2886 && BLOCK_ABSTRACT_ORIGIN (block))
2888 ao = BLOCK_ABSTRACT_ORIGIN (block);
2890 while (TREE_CODE (ao) == BLOCK
2891 && BLOCK_ABSTRACT_ORIGIN (ao)
2892 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2893 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2895 if (TREE_CODE (ao) == FUNCTION_DECL)
2900 else if (TREE_CODE (ao) != BLOCK)
2903 block = BLOCK_SUPERCONTEXT (block);
2906 abstract_origin = block;
2909 while (block && TREE_CODE (block) == BLOCK)
2910 block = BLOCK_SUPERCONTEXT (block);
2912 if (block && TREE_CODE (block) == FUNCTION_DECL)
2914 abstract_origin = NULL;
2918 expanded_location s = expand_location (*locus);
2919 pp_base_character (context->printer, ',');
2920 pp_base_newline (context->printer);
2923 if (context->show_column && s.column != 0)
2924 pp_printf (context->printer,
2925 _(" inlined from %qs at %s:%d:%d"),
2926 cxx_printable_name_translate (fndecl, 2),
2927 s.file, s.line, s.column);
2929 pp_printf (context->printer,
2930 _(" inlined from %qs at %s:%d"),
2931 cxx_printable_name_translate (fndecl, 2),
2936 pp_printf (context->printer, _(" inlined from %qs"),
2937 cxx_printable_name_translate (fndecl, 2));
2940 pp_base_character (context->printer, ':');
2942 pp_base_newline (context->printer);
2944 diagnostic_set_last_function (context, diagnostic);
2945 pp_base_destroy_prefix (context->printer);
2946 context->printer->prefix = old_prefix;
2950 /* Returns a description of FUNCTION using standard terminology. The
2951 result is a format string of the form "In CATEGORY %qs". */
2953 function_category (tree fn)
2955 /* We can get called from the middle-end for diagnostics of function
2956 clones. Make sure we have language specific information before
2957 dereferencing it. */
2958 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
2959 && DECL_FUNCTION_MEMBER_P (fn))
2961 if (DECL_STATIC_FUNCTION_P (fn))
2962 return _("In static member function %qs");
2963 else if (DECL_COPY_CONSTRUCTOR_P (fn))
2964 return _("In copy constructor %qs");
2965 else if (DECL_CONSTRUCTOR_P (fn))
2966 return _("In constructor %qs");
2967 else if (DECL_DESTRUCTOR_P (fn))
2968 return _("In destructor %qs");
2969 else if (LAMBDA_FUNCTION_P (fn))
2970 return _("In lambda function");
2972 return _("In member function %qs");
2975 return _("In function %qs");
2978 /* Report the full context of a current template instantiation,
2981 print_instantiation_full_context (diagnostic_context *context)
2983 struct tinst_level *p = current_instantiation ();
2984 location_t location = input_location;
2988 pp_verbatim (context->printer,
2989 TREE_CODE (p->decl) == TREE_LIST
2990 ? _("%s: In substitution of %qS:\n")
2991 : _("%s: In instantiation of %q#D:\n"),
2992 LOCATION_FILE (location),
2995 location = p->locus;
2999 print_instantiation_partial_context (context, p, location);
3002 /* Helper function of print_instantiation_partial_context() that
3003 prints a single line of instantiation context. */
3006 print_instantiation_partial_context_line (diagnostic_context *context,
3007 const struct tinst_level *t,
3008 location_t loc, bool recursive_p)
3010 expanded_location xloc;
3011 xloc = expand_location (loc);
3013 if (context->show_column)
3014 pp_verbatim (context->printer, _("%s:%d:%d: "),
3015 xloc.file, xloc.line, xloc.column);
3017 pp_verbatim (context->printer, _("%s:%d: "),
3018 xloc.file, xloc.line);
3022 if (TREE_CODE (t->decl) == TREE_LIST)
3023 pp_verbatim (context->printer,
3025 ? _("recursively required by substitution of %qS\n")
3026 : _("required by substitution of %qS\n"),
3029 pp_verbatim (context->printer,
3031 ? _("recursively required from %q#D\n")
3032 : _("required from %q#D\n"),
3037 pp_verbatim (context->printer,
3039 ? _("recursively required from here")
3040 : _("required from here"));
3044 /* Same as print_instantiation_full_context but less verbose. */
3047 print_instantiation_partial_context (diagnostic_context *context,
3048 struct tinst_level *t0, location_t loc)
3050 struct tinst_level *t;
3053 location_t prev_loc = loc;
3055 for (t = t0; t != NULL; t = t->next)
3056 if (prev_loc != t->locus)
3058 prev_loc = t->locus;
3066 int skip = n_total - 10;
3067 for (n = 0; n < 5; n++)
3069 gcc_assert (t != NULL);
3070 if (loc != t->locus)
3071 print_instantiation_partial_context_line (context, t, loc,
3072 /*recursive_p=*/false);
3076 if (t != NULL && skip > 1)
3078 expanded_location xloc;
3079 xloc = expand_location (loc);
3080 if (context->show_column)
3081 pp_verbatim (context->printer,
3082 _("%s:%d:%d: [ skipping %d instantiation contexts ]\n"),
3083 xloc.file, xloc.line, xloc.column, skip);
3085 pp_verbatim (context->printer,
3086 _("%s:%d: [ skipping %d instantiation contexts ]\n"),
3087 xloc.file, xloc.line, skip);
3092 } while (t != NULL && --skip > 0);
3098 while (t->next != NULL && t->locus == t->next->locus)
3103 print_instantiation_partial_context_line (context, t, loc,
3108 print_instantiation_partial_context_line (context, NULL, loc,
3109 /*recursive_p=*/false);
3110 pp_base_newline (context->printer);
3113 /* Called from cp_thing to print the template context for an error. */
3115 maybe_print_instantiation_context (diagnostic_context *context)
3117 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3120 record_last_problematic_instantiation ();
3121 print_instantiation_full_context (context);
3124 /* Report the bare minimum context of a template instantiation. */
3126 print_instantiation_context (void)
3128 print_instantiation_partial_context
3129 (global_dc, current_instantiation (), input_location);
3130 diagnostic_flush_buffer (global_dc);
3133 /* Report what constexpr call(s) we're trying to expand, if any. */
3136 maybe_print_constexpr_context (diagnostic_context *context)
3138 VEC(tree,heap) *call_stack = cx_error_context ();
3142 FOR_EACH_VEC_ELT (tree, call_stack, ix, t)
3144 expanded_location xloc = expand_location (EXPR_LOCATION (t));
3145 const char *s = expr_as_string (t, 0);
3146 if (context->show_column)
3147 pp_verbatim (context->printer,
3148 _("%s:%d:%d: in constexpr expansion of %qs"),
3149 xloc.file, xloc.line, xloc.column, s);
3151 pp_verbatim (context->printer,
3152 _("%s:%d: in constexpr expansion of %qs"),
3153 xloc.file, xloc.line, s);
3154 pp_base_newline (context->printer);
3158 /* Called from output_format -- during diagnostic message processing --
3159 to handle C++ specific format specifier with the following meanings:
3160 %A function argument-list.
3164 %F function declaration.
3165 %L language as used in extern "lang".
3167 %P function parameter whose position is indicated by an integer.
3168 %Q assignment operator.
3172 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
3173 int precision, bool wide, bool set_locus, bool verbose)
3177 #define next_tree (t = va_arg (*text->args_ptr, tree))
3178 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3179 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3180 #define next_int va_arg (*text->args_ptr, int)
3182 if (precision != 0 || wide)
3185 if (text->locus == NULL)
3190 case 'A': result = args_to_string (next_tree, verbose); break;
3191 case 'C': result = code_to_string (next_tcode); break;
3194 tree temp = next_tree;
3196 && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
3198 temp = DECL_DEBUG_EXPR (temp);
3201 result = expr_to_string (temp);
3205 result = decl_to_string (temp, verbose);
3208 case 'E': result = expr_to_string (next_tree); break;
3209 case 'F': result = fndecl_to_string (next_tree, verbose); break;
3210 case 'L': result = language_to_string (next_lang); break;
3211 case 'O': result = op_to_string (next_tcode); break;
3212 case 'P': result = parm_to_string (next_int); break;
3213 case 'Q': result = assop_to_string (next_tcode); break;
3214 case 'S': result = subst_to_string (next_tree); break;
3215 case 'T': result = type_to_string (next_tree, verbose); break;
3216 case 'V': result = cv_to_string (next_tree, verbose); break;
3219 percent_K_format (text);
3226 pp_base_string (pp, result);
3227 if (set_locus && t != NULL)
3228 *text->locus = location_of (t);
3236 /* Warn about the use of C++0x features when appropriate. */
3238 maybe_warn_cpp0x (cpp0x_warn_str str)
3240 if ((cxx_dialect == cxx98) && !in_system_header)
3241 /* We really want to suppress this warning in system headers,
3242 because libstdc++ uses variadic templates even when we aren't
3246 case CPP0X_INITIALIZER_LISTS:
3247 pedwarn (input_location, 0,
3248 "extended initializer lists "
3249 "only available with -std=c++11 or -std=gnu++11");
3251 case CPP0X_EXPLICIT_CONVERSION:
3252 pedwarn (input_location, 0,
3253 "explicit conversion operators "
3254 "only available with -std=c++11 or -std=gnu++11");
3256 case CPP0X_VARIADIC_TEMPLATES:
3257 pedwarn (input_location, 0,
3258 "variadic templates "
3259 "only available with -std=c++11 or -std=gnu++11");
3261 case CPP0X_LAMBDA_EXPR:
3262 pedwarn (input_location, 0,
3263 "lambda expressions "
3264 "only available with -std=c++11 or -std=gnu++11");
3267 pedwarn (input_location, 0,
3268 "C++0x auto only available with -std=c++11 or -std=gnu++11");
3270 case CPP0X_SCOPED_ENUMS:
3271 pedwarn (input_location, 0,
3272 "scoped enums only available with -std=c++11 or -std=gnu++11");
3274 case CPP0X_DEFAULTED_DELETED:
3275 pedwarn (input_location, 0,
3276 "defaulted and deleted functions "
3277 "only available with -std=c++11 or -std=gnu++11");
3279 case CPP0X_INLINE_NAMESPACES:
3280 pedwarn (input_location, OPT_pedantic,
3281 "inline namespaces "
3282 "only available with -std=c++11 or -std=gnu++11");
3284 case CPP0X_OVERRIDE_CONTROLS:
3285 pedwarn (input_location, 0,
3286 "override controls (override/final) "
3287 "only available with -std=c++11 or -std=gnu++11");
3290 pedwarn (input_location, 0,
3291 "non-static data member initializers "
3292 "only available with -std=c++11 or -std=gnu++11");
3294 case CPP0X_USER_DEFINED_LITERALS:
3295 pedwarn (input_location, 0,
3296 "user-defined literals "
3297 "only available with -std=c++11 or -std=gnu++11");
3304 /* Warn about the use of variadic templates when appropriate. */
3306 maybe_warn_variadic_templates (void)
3308 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3312 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3313 option OPT with text GMSGID. Use this function to report
3314 diagnostics for constructs that are invalid C++98, but valid
3317 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3319 diagnostic_info diagnostic;
3322 va_start (ap, gmsgid);
3323 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
3324 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3325 diagnostic.option_index = opt;
3327 return report_diagnostic (&diagnostic);
3330 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3331 we found when we tried to do the lookup. LOCATION is the location of
3332 the NAME identifier. */
3335 qualified_name_lookup_error (tree scope, tree name,
3336 tree decl, location_t location)
3338 if (scope == error_mark_node)
3339 ; /* We already complained. */
3340 else if (TYPE_P (scope))
3342 if (!COMPLETE_TYPE_P (scope))
3343 error_at (location, "incomplete type %qT used in nested name specifier",
3345 else if (TREE_CODE (decl) == TREE_LIST)
3347 error_at (location, "reference to %<%T::%D%> is ambiguous",
3349 print_candidates (decl);
3352 error_at (location, "%qD is not a member of %qT", name, scope);
3354 else if (scope != global_namespace)
3356 error_at (location, "%qD is not a member of %qD", name, scope);
3357 suggest_alternatives_for (location, name);
3361 error_at (location, "%<::%D%> has not been declared", name);
3362 suggest_alternatives_for (location, name);