1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "stringpool.h"
25 #include "tree-diagnostic.h"
26 #include "langhooks-def.h"
28 #include "cxx-pretty-print.h"
29 #include "tree-pretty-print.h"
30 #include "c-family/c-objc.h"
32 #include "internal-fn.h"
34 #include <new> // For placement-new.
36 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
37 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
39 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
40 dump C++ ASTs as strings. It is mostly used only by the various
41 tree -> string functions that are occasionally called from the
42 debugger or by the front-end for things like
43 __PRETTY_FUNCTION__. */
44 static cxx_pretty_printer actual_pretty_printer
;
45 static cxx_pretty_printer
* const cxx_pp
= &actual_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 (cxx_pretty_printer
*, tree
, int);
65 static void dump_type (cxx_pretty_printer
*, tree
, int);
66 static void dump_typename (cxx_pretty_printer
*, tree
, int);
67 static void dump_simple_decl (cxx_pretty_printer
*, tree
, tree
, int);
68 static void dump_decl (cxx_pretty_printer
*, tree
, int);
69 static void dump_template_decl (cxx_pretty_printer
*, tree
, int);
70 static void dump_function_decl (cxx_pretty_printer
*, tree
, int);
71 static void dump_expr (cxx_pretty_printer
*, tree
, int);
72 static void dump_unary_op (cxx_pretty_printer
*, const char *, tree
, int);
73 static void dump_binary_op (cxx_pretty_printer
*, const char *, tree
, int);
74 static void dump_aggr_type (cxx_pretty_printer
*, tree
, int);
75 static void dump_type_prefix (cxx_pretty_printer
*, tree
, int);
76 static void dump_type_suffix (cxx_pretty_printer
*, tree
, int);
77 static void dump_function_name (cxx_pretty_printer
*, tree
, int);
78 static void dump_call_expr_args (cxx_pretty_printer
*, tree
, int, bool);
79 static void dump_aggr_init_expr_args (cxx_pretty_printer
*, tree
, int, bool);
80 static void dump_expr_list (cxx_pretty_printer
*, tree
, int);
81 static void dump_global_iord (cxx_pretty_printer
*, tree
);
82 static void dump_parameters (cxx_pretty_printer
*, tree
, int);
83 static void dump_ref_qualifier (cxx_pretty_printer
*, tree
, int);
84 static void dump_exception_spec (cxx_pretty_printer
*, tree
, int);
85 static void dump_template_argument (cxx_pretty_printer
*, tree
, int);
86 static void dump_template_argument_list (cxx_pretty_printer
*, tree
, int);
87 static void dump_template_parameter (cxx_pretty_printer
*, tree
, int);
88 static void dump_template_bindings (cxx_pretty_printer
*, tree
, tree
,
90 static void dump_scope (cxx_pretty_printer
*, tree
, int);
91 static void dump_template_parms (cxx_pretty_printer
*, tree
, int, int);
92 static int get_non_default_template_args_count (tree
, int);
93 static const char *function_category (tree
);
94 static void maybe_print_constexpr_context (diagnostic_context
*);
95 static void maybe_print_instantiation_context (diagnostic_context
*);
96 static void print_instantiation_full_context (diagnostic_context
*);
97 static void print_instantiation_partial_context (diagnostic_context
*,
100 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
101 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
103 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
104 int, bool, bool, bool);
106 /* CONTEXT->printer is a basic pretty printer that was constructed
107 presumably by diagnostic_initialize(), called early in the
108 compiler's initialization process (in general_init) Before the FE
109 is initialized. This (C++) FE-specific diagnostic initializer is
110 thus replacing the basic pretty printer with one that has C++-aware
114 cxx_initialize_diagnostics (diagnostic_context
*context
)
116 pretty_printer
*base
= context
->printer
;
117 cxx_pretty_printer
*pp
= XNEW (cxx_pretty_printer
);
118 context
->printer
= new (pp
) cxx_pretty_printer ();
120 /* It is safe to free this object because it was previously XNEW()'d. */
121 base
->~pretty_printer ();
124 c_common_diagnostics_set_defaults (context
);
125 diagnostic_starter (context
) = cp_diagnostic_starter
;
126 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
127 diagnostic_format_decoder (context
) = cp_printer
;
130 /* Dump a scope, if deemed necessary. */
133 dump_scope (cxx_pretty_printer
*pp
, tree scope
, int flags
)
135 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
137 if (scope
== NULL_TREE
)
140 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
142 if (scope
!= global_namespace
)
144 dump_decl (pp
, scope
, f
);
145 pp_cxx_colon_colon (pp
);
148 else if (AGGREGATE_TYPE_P (scope
))
150 dump_type (pp
, scope
, f
);
151 pp_cxx_colon_colon (pp
);
153 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
155 dump_function_decl (pp
, scope
, f
);
156 pp_cxx_colon_colon (pp
);
160 /* Dump the template ARGument under control of FLAGS. */
163 dump_template_argument (cxx_pretty_printer
*pp
, tree arg
, int flags
)
165 if (ARGUMENT_PACK_P (arg
))
166 dump_template_argument_list (pp
, ARGUMENT_PACK_ARGS (arg
),
167 /* No default args in argument packs. */
168 flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
169 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
170 dump_type (pp
, arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
173 if (TREE_CODE (arg
) == TREE_LIST
)
174 arg
= TREE_VALUE (arg
);
176 dump_expr (pp
, arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
180 /* Count the number of template arguments ARGS whose value does not
181 match the (optional) default template parameter in PARAMS */
184 get_non_default_template_args_count (tree args
, int flags
)
186 int n
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args
));
188 if (/* We use this flag when generating debug information. We don't
189 want to expand templates at this point, for this may generate
190 new decls, which gets decl counts out of sync, which may in
191 turn cause codegen differences between compilations with and
193 (flags
& TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
) != 0
194 || !flag_pretty_templates
)
197 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args
));
200 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
204 dump_template_argument_list (cxx_pretty_printer
*pp
, tree args
, int flags
)
206 int n
= get_non_default_template_args_count (args
, flags
);
210 for (i
= 0; i
< n
; ++i
)
212 tree arg
= TREE_VEC_ELT (args
, i
);
214 /* Only print a comma if we know there is an argument coming. In
215 the case of an empty template argument pack, no actual
216 argument will be printed. */
218 && (!ARGUMENT_PACK_P (arg
)
219 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
220 pp_separate_with_comma (pp
);
222 dump_template_argument (pp
, arg
, flags
);
227 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
230 dump_template_parameter (cxx_pretty_printer
*pp
, tree parm
, int flags
)
235 if (parm
== error_mark_node
)
238 p
= TREE_VALUE (parm
);
239 a
= TREE_PURPOSE (parm
);
241 if (TREE_CODE (p
) == TYPE_DECL
)
243 if (flags
& TFF_DECL_SPECIFIERS
)
245 pp_cxx_ws_string (pp
, "class");
246 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
247 pp_cxx_ws_string (pp
, "...");
249 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
251 else if (DECL_NAME (p
))
252 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
254 pp_cxx_canonical_template_parameter (pp
, TREE_TYPE (p
));
257 dump_decl (pp
, p
, flags
| TFF_DECL_SPECIFIERS
);
259 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
261 pp_cxx_whitespace (pp
);
263 pp_cxx_whitespace (pp
);
264 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
265 dump_type (pp
, a
, flags
& ~TFF_CHASE_TYPEDEF
);
267 dump_expr (pp
, a
, flags
| TFF_EXPR_IN_PARENS
);
271 /* Dump, under control of FLAGS, a template-parameter-list binding.
272 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
276 dump_template_bindings (cxx_pretty_printer
*pp
, tree parms
, tree args
,
277 vec
<tree
, va_gc
> *typenames
)
279 bool need_semicolon
= false;
285 tree p
= TREE_VALUE (parms
);
286 int lvl
= TMPL_PARMS_DEPTH (parms
);
289 tree lvl_args
= NULL_TREE
;
291 /* Don't crash if we had an invalid argument list. */
292 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
293 lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
295 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
297 tree arg
= NULL_TREE
;
299 /* Don't crash if we had an invalid argument list. */
300 if (lvl_args
&& NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
301 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
304 pp_separate_with_semicolon (pp
);
305 dump_template_parameter (pp
, TREE_VEC_ELT (p
, i
),
306 TFF_PLAIN_IDENTIFIER
);
307 pp_cxx_whitespace (pp
);
309 pp_cxx_whitespace (pp
);
312 if (ARGUMENT_PACK_P (arg
))
313 pp_cxx_left_brace (pp
);
314 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
315 if (ARGUMENT_PACK_P (arg
))
316 pp_cxx_right_brace (pp
);
319 pp_string (pp
, M_("<missing>"));
322 need_semicolon
= true;
325 parms
= TREE_CHAIN (parms
);
328 /* Don't bother with typenames for a partial instantiation. */
329 if (vec_safe_is_empty (typenames
) || uses_template_parms (args
))
332 /* Don't try to print typenames when we're processing a clone. */
333 if (current_function_decl
334 && !DECL_LANG_SPECIFIC (current_function_decl
))
337 /* Don't try to do this once cgraph starts throwing away front-end
342 FOR_EACH_VEC_SAFE_ELT (typenames
, i
, t
)
345 pp_separate_with_semicolon (pp
);
346 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
347 pp_cxx_whitespace (pp
);
349 pp_cxx_whitespace (pp
);
350 push_deferring_access_checks (dk_no_check
);
351 t
= tsubst (t
, args
, tf_none
, NULL_TREE
);
352 pop_deferring_access_checks ();
353 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
354 pp_simple_type_specifier doesn't know about it. */
355 t
= strip_typedefs (t
);
356 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
360 /* Dump a human-readable equivalent of the alias template
361 specialization of T. */
364 dump_alias_template_specialization (cxx_pretty_printer
*pp
, tree t
, int flags
)
368 gcc_assert (alias_template_specialization_p (t
));
370 if (!(flags
& TFF_UNQUALIFIED_NAME
))
371 dump_scope (pp
, CP_DECL_CONTEXT (TYPE_NAME (t
)), flags
);
372 name
= TYPE_IDENTIFIER (t
);
373 pp_cxx_tree_identifier (pp
, name
);
374 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
376 flags
& ~TFF_TEMPLATE_HEADER
);
379 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
383 dump_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
388 /* Don't print e.g. "struct mytypedef". */
389 if (TYPE_P (t
) && typedef_variant_p (t
))
391 tree decl
= TYPE_NAME (t
);
392 if ((flags
& TFF_CHASE_TYPEDEF
)
393 || DECL_SELF_REFERENCE_P (decl
)
394 || (!flag_pretty_templates
395 && DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)))
396 t
= strip_typedefs (t
);
397 else if (alias_template_specialization_p (t
))
399 dump_alias_template_specialization (pp
, t
, flags
);
402 else if (same_type_p (t
, TREE_TYPE (decl
)))
406 pp_cxx_cv_qualifier_seq (pp
, t
);
407 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
412 if (TYPE_PTRMEMFUNC_P (t
))
415 switch (TREE_CODE (t
))
418 if (t
== init_list_type_node
)
419 pp_string (pp
, M_("<brace-enclosed initializer list>"));
420 else if (t
== unknown_type_node
)
421 pp_string (pp
, M_("<unresolved overloaded function type>"));
424 pp_cxx_cv_qualifier_seq (pp
, t
);
425 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
430 /* A list of function parms. */
431 dump_parameters (pp
, t
, flags
);
434 case IDENTIFIER_NODE
:
435 pp_cxx_tree_identifier (pp
, t
);
439 dump_type (pp
, BINFO_TYPE (t
), flags
);
445 dump_aggr_type (pp
, t
, flags
);
449 if (flags
& TFF_CHASE_TYPEDEF
)
451 dump_type (pp
, DECL_ORIGINAL_TYPE (t
)
452 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
455 /* Else fall through. */
459 dump_decl (pp
, t
, flags
& ~TFF_DECL_SPECIFIERS
);
468 case FIXED_POINT_TYPE
:
469 pp_type_specifier_seq (pp
, t
);
472 case TEMPLATE_TEMPLATE_PARM
:
473 /* For parameters inside template signature. */
474 if (TYPE_IDENTIFIER (t
))
475 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
477 pp_cxx_canonical_template_parameter (pp
, t
);
480 case BOUND_TEMPLATE_TEMPLATE_PARM
:
482 tree args
= TYPE_TI_ARGS (t
);
483 pp_cxx_cv_qualifier_seq (pp
, t
);
484 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
485 pp_cxx_begin_template_argument_list (pp
);
486 dump_template_argument_list (pp
, args
, flags
);
487 pp_cxx_end_template_argument_list (pp
);
491 case TEMPLATE_TYPE_PARM
:
492 pp_cxx_cv_qualifier_seq (pp
, t
);
493 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
494 pp_cxx_constrained_type_spec (pp
, c
);
495 else if (TYPE_IDENTIFIER (t
))
496 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
498 pp_cxx_canonical_template_parameter
499 (pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
502 /* This is not always necessary for pointers and such, but doing this
503 reduces code size. */
512 dump_type_prefix (pp
, t
, flags
);
513 dump_type_suffix (pp
, t
, flags
);
517 if (! (flags
& TFF_CHASE_TYPEDEF
)
518 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
520 dump_decl (pp
, TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
523 pp_cxx_cv_qualifier_seq (pp
, t
);
524 pp_cxx_ws_string (pp
,
525 TYPENAME_IS_ENUM_P (t
) ? "enum"
526 : TYPENAME_IS_CLASS_P (t
) ? "class"
528 dump_typename (pp
, t
, flags
);
531 case UNBOUND_CLASS_TEMPLATE
:
532 if (! (flags
& TFF_UNQUALIFIED_NAME
))
534 dump_type (pp
, TYPE_CONTEXT (t
), flags
);
535 pp_cxx_colon_colon (pp
);
537 pp_cxx_ws_string (pp
, "template");
538 dump_type (pp
, TYPE_IDENTIFIER (t
), flags
);
542 pp_cxx_ws_string (pp
, "__typeof__");
543 pp_cxx_whitespace (pp
);
544 pp_cxx_left_paren (pp
);
545 dump_expr (pp
, TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
546 pp_cxx_right_paren (pp
);
549 case UNDERLYING_TYPE
:
550 pp_cxx_ws_string (pp
, "__underlying_type");
551 pp_cxx_whitespace (pp
);
552 pp_cxx_left_paren (pp
);
553 dump_expr (pp
, UNDERLYING_TYPE_TYPE (t
), flags
& ~TFF_EXPR_IN_PARENS
);
554 pp_cxx_right_paren (pp
);
557 case TYPE_PACK_EXPANSION
:
558 dump_type (pp
, PACK_EXPANSION_PATTERN (t
), flags
);
559 pp_cxx_ws_string (pp
, "...");
562 case TYPE_ARGUMENT_PACK
:
563 dump_template_argument (pp
, t
, flags
);
567 pp_cxx_ws_string (pp
, "decltype");
568 pp_cxx_whitespace (pp
);
569 pp_cxx_left_paren (pp
);
570 dump_expr (pp
, DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
571 pp_cxx_right_paren (pp
);
575 pp_string (pp
, "std::nullptr_t");
579 pp_unsupported_tree (pp
, t
);
580 /* Fall through to error. */
583 pp_string (pp
, M_("<type error>"));
588 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
592 dump_typename (cxx_pretty_printer
*pp
, tree t
, int flags
)
594 tree ctx
= TYPE_CONTEXT (t
);
596 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
597 dump_typename (pp
, ctx
, flags
);
599 dump_type (pp
, ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
600 pp_cxx_colon_colon (pp
);
601 dump_decl (pp
, TYPENAME_TYPE_FULLNAME (t
), flags
);
604 /* Return the name of the supplied aggregate, or enumeral type. */
607 class_key_or_enum_as_string (tree t
)
609 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
611 if (SCOPED_ENUM_P (t
))
616 else if (TREE_CODE (t
) == UNION_TYPE
)
618 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
624 /* Print out a class declaration T under the control of FLAGS,
625 in the form `class foo'. */
628 dump_aggr_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
631 const char *variety
= class_key_or_enum_as_string (t
);
635 pp_cxx_cv_qualifier_seq (pp
, t
);
637 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
638 pp_cxx_ws_string (pp
, variety
);
640 name
= TYPE_NAME (t
);
644 typdef
= (!DECL_ARTIFICIAL (name
)
645 /* An alias specialization is not considered to be a
647 && !alias_template_specialization_p (t
));
650 && ((flags
& TFF_CHASE_TYPEDEF
)
651 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
652 && DECL_TEMPLATE_INFO (name
))))
653 || DECL_SELF_REFERENCE_P (name
))
655 t
= TYPE_MAIN_VARIANT (t
);
656 name
= TYPE_NAME (t
);
660 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
661 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
662 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
663 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
665 if (! (flags
& TFF_UNQUALIFIED_NAME
))
666 dump_scope (pp
, CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
667 flags
&= ~TFF_UNQUALIFIED_NAME
;
670 /* Because the template names are mangled, we have to locate
671 the most general template, and use that name. */
672 tree tpl
= TYPE_TI_TEMPLATE (t
);
674 while (DECL_TEMPLATE_INFO (tpl
))
675 tpl
= DECL_TI_TEMPLATE (tpl
);
678 name
= DECL_NAME (name
);
681 if (name
== 0 || anon_aggrname_p (name
))
683 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
684 pp_string (pp
, M_("<anonymous>"));
686 pp_printf (pp
, M_("<anonymous %s>"), variety
);
688 else if (LAMBDA_TYPE_P (t
))
690 /* A lambda's "type" is essentially its signature. */
691 pp_string (pp
, M_("<lambda"));
692 if (lambda_function (t
))
694 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
699 pp_cxx_tree_identifier (pp
, name
);
701 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
702 !CLASSTYPE_USE_TEMPLATE (t
),
703 flags
& ~TFF_TEMPLATE_HEADER
);
706 /* Dump into the obstack the initial part of the output for a given type.
707 This is necessary when dealing with things like functions returning
710 return type of `int (* fee ())()': pointer -> function -> int. Both
711 pointer (and reference and offset) and function (and member) types must
712 deal with prefix and suffix.
714 Arrays must also do this for DECL nodes, like int a[], and for things like
718 dump_type_prefix (cxx_pretty_printer
*pp
, tree t
, int flags
)
720 if (TYPE_PTRMEMFUNC_P (t
))
722 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
726 switch (TREE_CODE (t
))
731 tree sub
= TREE_TYPE (t
);
733 dump_type_prefix (pp
, sub
, flags
);
734 if (TREE_CODE (sub
) == ARRAY_TYPE
735 || TREE_CODE (sub
) == FUNCTION_TYPE
)
737 pp_cxx_whitespace (pp
);
738 pp_cxx_left_paren (pp
);
739 pp_c_attributes_display (pp
, TYPE_ATTRIBUTES (sub
));
743 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
745 if (TYPE_REF_IS_RVALUE (t
))
746 pp_ampersand_ampersand (pp
);
750 pp
->padding
= pp_before
;
751 pp_cxx_cv_qualifier_seq (pp
, t
);
757 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
758 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
761 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
762 pp_cxx_left_paren (pp
);
763 dump_type (pp
, TYPE_OFFSET_BASETYPE (t
), flags
);
764 pp_cxx_colon_colon (pp
);
767 pp_cxx_cv_qualifier_seq (pp
, t
);
768 pp
->padding
= pp_before
;
771 /* This can be reached without a pointer when dealing with
772 templates, e.g. std::is_function. */
774 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
778 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
780 pp_cxx_left_paren (pp
);
781 dump_aggr_type (pp
, TYPE_METHOD_BASETYPE (t
), flags
);
782 pp_cxx_colon_colon (pp
);
786 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
790 case IDENTIFIER_NODE
:
795 case TEMPLATE_TYPE_PARM
:
796 case TEMPLATE_TEMPLATE_PARM
:
797 case BOUND_TEMPLATE_TEMPLATE_PARM
:
808 case UNDERLYING_TYPE
:
810 case TYPE_PACK_EXPANSION
:
811 case FIXED_POINT_TYPE
:
813 dump_type (pp
, t
, flags
);
814 pp
->padding
= pp_before
;
818 pp_unsupported_tree (pp
, t
);
821 pp_string (pp
, M_("<typeprefixerror>"));
826 /* Dump the suffix of type T, under control of FLAGS. This is the part
827 which appears after the identifier (or function parms). */
830 dump_type_suffix (cxx_pretty_printer
*pp
, tree t
, int flags
)
832 if (TYPE_PTRMEMFUNC_P (t
))
833 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
835 switch (TREE_CODE (t
))
840 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
841 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
842 pp_cxx_right_paren (pp
);
843 if (TREE_CODE (t
) == POINTER_TYPE
)
844 flags
|= TFF_POINTER
;
845 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
852 if (TREE_CODE (t
) == METHOD_TYPE
)
853 /* Can only be reached through a pointer. */
854 pp_cxx_right_paren (pp
);
855 arg
= TYPE_ARG_TYPES (t
);
856 if (TREE_CODE (t
) == METHOD_TYPE
)
857 arg
= TREE_CHAIN (arg
);
859 /* Function pointers don't have default args. Not in standard C++,
860 anyway; they may in g++, but we'll just pretend otherwise. */
861 dump_parameters (pp
, arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
863 pp
->padding
= pp_before
;
864 pp_cxx_cv_qualifiers (pp
, type_memfn_quals (t
),
865 TREE_CODE (t
) == FUNCTION_TYPE
866 && (flags
& TFF_POINTER
));
867 dump_ref_qualifier (pp
, t
, flags
);
868 if (tx_safe_fn_type_p (t
))
869 pp_cxx_ws_string (pp
, "transaction_safe");
870 dump_exception_spec (pp
, TYPE_RAISES_EXCEPTIONS (t
), flags
);
871 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
877 pp_cxx_left_bracket (pp
);
878 if (tree dtype
= TYPE_DOMAIN (t
))
880 tree max
= TYPE_MAX_VALUE (dtype
);
881 /* Zero-length arrays have an upper bound of SIZE_MAX. */
882 if (integer_all_onesp (max
))
883 pp_character (pp
, '0');
884 else if (tree_fits_shwi_p (max
))
885 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
889 if (TREE_CODE (max
) == SAVE_EXPR
)
890 max
= TREE_OPERAND (max
, 0);
891 if (TREE_CODE (max
) == MINUS_EXPR
892 || TREE_CODE (max
) == PLUS_EXPR
)
894 max
= TREE_OPERAND (max
, 0);
895 while (CONVERT_EXPR_P (max
))
896 max
= TREE_OPERAND (max
, 0);
899 max
= fold_build2_loc (input_location
,
900 PLUS_EXPR
, dtype
, max
,
901 build_int_cst (dtype
, 1));
902 dump_expr (pp
, max
, flags
& ~TFF_EXPR_IN_PARENS
);
905 pp_cxx_right_bracket (pp
);
906 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
910 case IDENTIFIER_NODE
:
915 case TEMPLATE_TYPE_PARM
:
916 case TEMPLATE_TEMPLATE_PARM
:
917 case BOUND_TEMPLATE_TEMPLATE_PARM
:
928 case UNDERLYING_TYPE
:
930 case TYPE_PACK_EXPANSION
:
931 case FIXED_POINT_TYPE
:
936 pp_unsupported_tree (pp
, t
);
938 /* Don't mark it here, we should have already done in
945 dump_global_iord (cxx_pretty_printer
*pp
, tree t
)
947 const char *p
= NULL
;
949 if (DECL_GLOBAL_CTOR_P (t
))
950 p
= M_("(static initializers for %s)");
951 else if (DECL_GLOBAL_DTOR_P (t
))
952 p
= M_("(static destructors for %s)");
956 pp_printf (pp
, p
, DECL_SOURCE_FILE (t
));
960 dump_simple_decl (cxx_pretty_printer
*pp
, tree t
, tree type
, int flags
)
962 if (flags
& TFF_DECL_SPECIFIERS
)
965 && DECL_DECLARED_CONSTEXPR_P (t
))
966 pp_cxx_ws_string (pp
, "constexpr");
967 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
970 if (! (flags
& TFF_UNQUALIFIED_NAME
)
971 && TREE_CODE (t
) != PARM_DECL
972 && (!DECL_INITIAL (t
)
973 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
974 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
975 flags
&= ~TFF_UNQUALIFIED_NAME
;
976 if ((flags
& TFF_DECL_SPECIFIERS
)
977 && DECL_TEMPLATE_PARM_P (t
)
978 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
979 pp_string (pp
, "...");
982 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
985 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
986 pp_string (pp
, " capture>");
989 dump_decl (pp
, DECL_NAME (t
), flags
);
992 pp_string (pp
, M_("<anonymous>"));
993 if (flags
& TFF_DECL_SPECIFIERS
)
994 dump_type_suffix (pp
, type
, flags
);
997 /* Dump a human readable string for the decl T under control of FLAGS. */
1000 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1005 /* If doing Objective-C++, give Objective-C a chance to demangle
1006 Objective-C method names. */
1007 if (c_dialect_objc ())
1009 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1012 pp_string (pp
, demangled
);
1017 switch (TREE_CODE (t
))
1020 /* Don't say 'typedef class A' */
1021 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1023 if ((flags
& TFF_DECL_SPECIFIERS
)
1024 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1026 /* Say `class T' not just `T'. */
1027 pp_cxx_ws_string (pp
, "class");
1029 /* Emit the `...' for a parameter pack. */
1030 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1031 pp_cxx_ws_string (pp
, "...");
1034 dump_type (pp
, TREE_TYPE (t
), flags
);
1037 if (TYPE_DECL_ALIAS_P (t
)
1038 && (flags
& TFF_DECL_SPECIFIERS
1039 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1041 pp_cxx_ws_string (pp
, "using");
1042 dump_decl (pp
, DECL_NAME (t
), flags
);
1043 pp_cxx_whitespace (pp
);
1044 pp_cxx_ws_string (pp
, "=");
1045 pp_cxx_whitespace (pp
);
1046 dump_type (pp
, DECL_ORIGINAL_TYPE (t
), flags
);
1049 if ((flags
& TFF_DECL_SPECIFIERS
)
1050 && !DECL_SELF_REFERENCE_P (t
))
1051 pp_cxx_ws_string (pp
, "typedef");
1052 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1053 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1058 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1060 pp_string (pp
, M_("vtable for "));
1061 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1062 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1065 /* Else fall through. */
1068 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1070 /* Handle variable template specializations. */
1072 && DECL_LANG_SPECIFIC (t
)
1073 && DECL_TEMPLATE_INFO (t
)
1074 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1076 pp_cxx_begin_template_argument_list (pp
);
1077 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1078 dump_template_argument_list (pp
, args
, flags
);
1079 pp_cxx_end_template_argument_list (pp
);
1084 pp_string (pp
, M_("<return value> "));
1085 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1088 case NAMESPACE_DECL
:
1089 if (flags
& TFF_DECL_SPECIFIERS
)
1090 pp
->declaration (t
);
1093 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1094 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1095 flags
&= ~TFF_UNQUALIFIED_NAME
;
1096 if (DECL_NAME (t
) == NULL_TREE
)
1098 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1099 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1101 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1104 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1109 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1110 pp_colon_colon (pp
);
1111 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1115 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1116 pp_cxx_left_bracket (pp
);
1117 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1118 pp_cxx_right_bracket (pp
);
1121 case ARRAY_NOTATION_REF
:
1122 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1123 pp_cxx_left_bracket (pp
);
1124 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1126 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1128 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1129 pp_cxx_right_bracket (pp
);
1132 /* So that we can do dump_decl on an aggr type. */
1136 dump_type (pp
, t
, flags
);
1140 /* This is a pseudo destructor call which has not been folded into
1141 a PSEUDO_DTOR_EXPR yet. */
1142 pp_cxx_complement (pp
);
1143 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1150 /* These special cases are duplicated here so that other functions
1151 can feed identifiers to error and get them demangled properly. */
1152 case IDENTIFIER_NODE
:
1153 if (IDENTIFIER_TYPENAME_P (t
))
1155 pp_cxx_ws_string (pp
, "operator");
1156 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1157 dump_type (pp
, TREE_TYPE (t
), flags
);
1161 pp_cxx_tree_identifier (pp
, t
);
1167 t
= OVL_CURRENT (t
);
1168 if (DECL_CLASS_SCOPE_P (t
))
1170 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1171 pp_cxx_colon_colon (pp
);
1173 else if (!DECL_FILE_SCOPE_P (t
))
1175 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1176 pp_cxx_colon_colon (pp
);
1178 dump_decl (pp
, DECL_NAME (t
), flags
);
1182 /* If there's only one function, just treat it like an ordinary
1184 t
= OVL_CURRENT (t
);
1188 if (! DECL_LANG_SPECIFIC (t
))
1190 if (DECL_ABSTRACT_ORIGIN (t
))
1191 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1193 pp_string (pp
, M_("<built-in>"));
1195 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1196 dump_global_iord (pp
, t
);
1198 dump_function_decl (pp
, t
, flags
);
1202 dump_template_decl (pp
, t
, flags
);
1205 case TEMPLATE_ID_EXPR
:
1207 tree name
= TREE_OPERAND (t
, 0);
1208 tree args
= TREE_OPERAND (t
, 1);
1210 if (is_overloaded_fn (name
))
1211 name
= get_first_fn (name
);
1213 name
= DECL_NAME (name
);
1214 dump_decl (pp
, name
, flags
);
1215 pp_cxx_begin_template_argument_list (pp
);
1216 if (args
== error_mark_node
)
1217 pp_string (pp
, M_("<template arguments error>"));
1219 dump_template_argument_list
1220 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1221 pp_cxx_end_template_argument_list (pp
);
1226 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1230 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1231 || (DECL_INITIAL (t
) &&
1232 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1233 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1234 else if (DECL_NAME (t
))
1235 dump_decl (pp
, DECL_NAME (t
), flags
);
1236 else if (DECL_INITIAL (t
))
1237 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1239 pp_string (pp
, M_("<enumerator>"));
1243 pp_cxx_ws_string (pp
, "using");
1244 dump_type (pp
, USING_DECL_SCOPE (t
), flags
);
1245 pp_cxx_colon_colon (pp
);
1246 dump_decl (pp
, DECL_NAME (t
), flags
);
1250 pp
->declaration (t
);
1254 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1257 case NON_DEPENDENT_EXPR
:
1258 dump_expr (pp
, t
, flags
);
1261 case TEMPLATE_TYPE_PARM
:
1262 if (flags
& TFF_DECL_SPECIFIERS
)
1263 pp
->declaration (t
);
1268 case UNBOUND_CLASS_TEMPLATE
:
1269 case TYPE_PACK_EXPANSION
:
1271 dump_type (pp
, t
, flags
);
1275 pp_unsupported_tree (pp
, t
);
1276 /* Fall through to error. */
1279 pp_string (pp
, M_("<declaration error>"));
1284 /* Dump a template declaration T under control of FLAGS. This means the
1285 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1288 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1290 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1294 if (flags
& TFF_TEMPLATE_HEADER
)
1296 for (parms
= orig_parms
= nreverse (orig_parms
);
1298 parms
= TREE_CHAIN (parms
))
1300 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1301 int len
= TREE_VEC_LENGTH (inner_parms
);
1305 /* Skip over the dummy template levels of a template template
1307 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1311 pp_cxx_ws_string (pp
, "template");
1312 pp_cxx_begin_template_argument_list (pp
);
1314 /* If we've shown the template prefix, we'd better show the
1315 parameters' and decl's type too. */
1316 flags
|= TFF_DECL_SPECIFIERS
;
1318 for (i
= 0; i
< len
; i
++)
1321 pp_separate_with_comma (pp
);
1322 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1325 pp_cxx_end_template_argument_list (pp
);
1326 pp_cxx_whitespace (pp
);
1328 nreverse(orig_parms
);
1330 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1332 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1333 pp_cxx_ws_string (pp
, "class");
1335 /* If this is a parameter pack, print the ellipsis. */
1336 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1337 pp_cxx_ws_string (pp
, "...");
1342 if (tree ci
= get_constraints (t
))
1343 if (check_constraint_info (ci
))
1344 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1346 pp_cxx_requires_clause (pp
, reqs
);
1347 pp_cxx_whitespace (pp
);
1350 if (DECL_CLASS_TEMPLATE_P (t
))
1351 dump_type (pp
, TREE_TYPE (t
),
1352 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1353 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1354 else if (DECL_TEMPLATE_RESULT (t
)
1355 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1356 /* Alias template. */
1357 || DECL_TYPE_TEMPLATE_P (t
)))
1358 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1361 gcc_assert (TREE_TYPE (t
));
1362 switch (NEXT_CODE (t
))
1366 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1369 /* This case can occur with some invalid code. */
1370 dump_type (pp
, TREE_TYPE (t
),
1371 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1372 | (flags
& TFF_DECL_SPECIFIERS
1373 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1378 /* find_typenames looks through the type of the function template T
1379 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1382 struct find_typenames_t
1384 hash_set
<tree
> *p_set
;
1385 vec
<tree
, va_gc
> *typenames
;
1389 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1391 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1392 tree mv
= NULL_TREE
;
1394 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1395 /* Add the type of the typedef without any additional cv-quals. */
1396 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1397 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1398 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1399 /* Add the typename without any cv-qualifiers. */
1400 mv
= TYPE_MAIN_VARIANT (*tp
);
1402 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1404 /* Don't mess with parameter packs since we don't remember
1405 the pack expansion context for a particular typename. */
1406 *walk_subtrees
= false;
1410 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1411 vec_safe_push (d
->typenames
, mv
);
1413 /* Search into class template arguments, which cp_walk_subtrees
1415 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1416 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1422 static vec
<tree
, va_gc
> *
1423 find_typenames (tree t
)
1425 struct find_typenames_t ft
;
1426 ft
.p_set
= new hash_set
<tree
>;
1427 ft
.typenames
= NULL
;
1428 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1429 find_typenames_r
, &ft
, ft
.p_set
);
1431 return ft
.typenames
;
1434 /* Output the "[with ...]" clause for a template instantiation T iff
1435 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1436 formatting a deduction/substitution diagnostic rather than an
1440 dump_substitution (cxx_pretty_printer
*pp
,
1441 tree t
, tree template_parms
, tree template_args
,
1444 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1445 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1447 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1448 pp_cxx_whitespace (pp
);
1449 pp_cxx_left_bracket (pp
);
1450 pp
->translate_string ("with");
1451 pp_cxx_whitespace (pp
);
1452 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1453 pp_cxx_right_bracket (pp
);
1457 /* Dump the lambda function FN including its 'mutable' qualifier and any
1458 template bindings. */
1461 dump_lambda_function (cxx_pretty_printer
*pp
,
1462 tree fn
, tree template_parms
, tree template_args
,
1465 /* A lambda's signature is essentially its "type". */
1466 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1467 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1469 pp
->padding
= pp_before
;
1470 pp_c_ws_string (pp
, "mutable");
1472 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1475 /* Pretty print a function decl. There are several ways we want to print a
1476 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1477 As error can only apply the '#' flag once to give 0 and 1 for V, there
1478 is %D which doesn't print the throw specs, and %F which does. */
1481 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1485 tree cname
= NULL_TREE
;
1486 tree template_args
= NULL_TREE
;
1487 tree template_parms
= NULL_TREE
;
1488 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1489 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1492 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1493 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1494 t
= DECL_TEMPLATE_RESULT (t
);
1496 /* Save the exceptions, in case t is a specialization and we are
1497 emitting an error about incompatible specifications. */
1498 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1500 /* Pretty print template instantiations only. */
1501 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1502 && flag_pretty_templates
)
1506 template_args
= DECL_TI_ARGS (t
);
1507 tmpl
= most_general_template (t
);
1508 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1510 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1515 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1516 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1518 fntype
= TREE_TYPE (t
);
1519 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1521 if (DECL_CLASS_SCOPE_P (t
))
1522 cname
= DECL_CONTEXT (t
);
1523 /* This is for partially instantiated template methods. */
1524 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1525 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1527 if (flags
& TFF_DECL_SPECIFIERS
)
1529 if (DECL_STATIC_FUNCTION_P (t
))
1530 pp_cxx_ws_string (pp
, "static");
1531 else if (DECL_VIRTUAL_P (t
))
1532 pp_cxx_ws_string (pp
, "virtual");
1534 if (DECL_DECLARED_CONSTEXPR_P (t
))
1535 pp_cxx_ws_string (pp
, "constexpr");
1538 /* Print the return type? */
1540 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1541 && !DECL_DESTRUCTOR_P (t
);
1544 tree ret
= fndecl_declared_return_type (t
);
1545 dump_type_prefix (pp
, ret
, flags
);
1548 /* Print the function name. */
1549 if (!do_outer_scope
)
1553 dump_type (pp
, cname
, flags
);
1554 pp_cxx_colon_colon (pp
);
1557 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1559 dump_function_name (pp
, t
, flags
);
1561 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1563 dump_parameters (pp
, parmtypes
, flags
);
1565 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1567 pp
->padding
= pp_before
;
1568 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1569 dump_ref_qualifier (pp
, fntype
, flags
);
1572 if (tx_safe_fn_type_p (fntype
))
1574 pp
->padding
= pp_before
;
1575 pp_cxx_ws_string (pp
, "transaction_safe");
1578 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1580 pp
->padding
= pp_before
;
1581 dump_exception_spec (pp
, exceptions
, flags
);
1585 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1588 if (tree ci
= get_constraints (t
))
1589 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1590 pp_cxx_requires_clause (pp
, reqs
);
1592 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1594 else if (template_args
)
1596 bool need_comma
= false;
1598 pp_cxx_begin_template_argument_list (pp
);
1599 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1600 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1602 tree arg
= TREE_VEC_ELT (template_args
, i
);
1604 pp_separate_with_comma (pp
);
1605 if (ARGUMENT_PACK_P (arg
))
1606 pp_cxx_left_brace (pp
);
1607 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1608 if (ARGUMENT_PACK_P (arg
))
1609 pp_cxx_right_brace (pp
);
1612 pp_cxx_end_template_argument_list (pp
);
1616 /* Print a parameter list. If this is for a member function, the
1617 member object ptr (and any other hidden args) should have
1618 already been removed. */
1621 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1624 flags
&= ~TFF_SCOPE
;
1625 pp_cxx_left_paren (pp
);
1627 for (first
= 1; parmtypes
!= void_list_node
;
1628 parmtypes
= TREE_CHAIN (parmtypes
))
1631 pp_separate_with_comma (pp
);
1635 pp_cxx_ws_string (pp
, "...");
1639 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1641 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1643 pp_cxx_whitespace (pp
);
1645 pp_cxx_whitespace (pp
);
1646 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1650 pp_cxx_right_paren (pp
);
1653 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1656 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1658 if (FUNCTION_REF_QUALIFIED (t
))
1660 pp
->padding
= pp_before
;
1661 if (FUNCTION_RVALUE_QUALIFIED (t
))
1662 pp_cxx_ws_string (pp
, "&&");
1664 pp_cxx_ws_string (pp
, "&");
1668 /* Print an exception specification. T is the exception specification. */
1671 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1673 if (t
&& TREE_PURPOSE (t
))
1675 pp_cxx_ws_string (pp
, "noexcept");
1676 if (!integer_onep (TREE_PURPOSE (t
)))
1678 pp_cxx_whitespace (pp
);
1679 pp_cxx_left_paren (pp
);
1680 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1681 pp_cxx_ws_string (pp
, "<uninstantiated>");
1683 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1684 pp_cxx_right_paren (pp
);
1689 pp_cxx_ws_string (pp
, "throw");
1690 pp_cxx_whitespace (pp
);
1691 pp_cxx_left_paren (pp
);
1692 if (TREE_VALUE (t
) != NULL_TREE
)
1695 dump_type (pp
, TREE_VALUE (t
), flags
);
1699 pp_separate_with_comma (pp
);
1701 pp_cxx_right_paren (pp
);
1705 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1706 and destructors properly. */
1709 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1711 tree name
= DECL_NAME (t
);
1713 /* We can get here with a decl that was synthesized by language-
1714 independent machinery (e.g. coverage.c) in which case it won't
1715 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1716 will crash. In this case it is safe just to print out the
1718 if (!DECL_LANG_SPECIFIC (t
))
1720 pp_cxx_tree_identifier (pp
, name
);
1724 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1725 t
= DECL_TEMPLATE_RESULT (t
);
1727 /* Don't let the user see __comp_ctor et al. */
1728 if (DECL_CONSTRUCTOR_P (t
)
1729 || DECL_DESTRUCTOR_P (t
))
1731 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1732 name
= get_identifier ("<lambda>");
1733 else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t
)))
1734 name
= get_identifier ("<constructor>");
1736 name
= constructor_name (DECL_CONTEXT (t
));
1739 if (DECL_DESTRUCTOR_P (t
))
1741 pp_cxx_complement (pp
);
1742 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1744 else if (DECL_CONV_FN_P (t
))
1746 /* This cannot use the hack that the operator's return
1747 type is stashed off of its name because it may be
1748 used for error reporting. In the case of conflicting
1749 declarations, both will have the same name, yet
1750 the types will be different, hence the TREE_TYPE field
1751 of the first name will be clobbered by the second. */
1752 pp_cxx_ws_string (pp
, "operator");
1753 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1755 else if (name
&& IDENTIFIER_OPNAME_P (name
))
1756 pp_cxx_tree_identifier (pp
, name
);
1757 else if (name
&& UDLIT_OPER_P (name
))
1758 pp_cxx_tree_identifier (pp
, name
);
1760 dump_decl (pp
, name
, flags
);
1762 if (DECL_TEMPLATE_INFO (t
)
1763 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1764 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1765 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1766 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1770 /* Dump the template parameters from the template info INFO under control of
1771 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1772 specialization (partial or complete). For partial specializations we show
1773 the specialized parameter values. For a primary template we show no
1777 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1778 int primary
, int flags
)
1780 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1782 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1784 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1785 pp_cxx_begin_template_argument_list (pp
);
1787 /* Be careful only to print things when we have them, so as not
1788 to crash producing error messages. */
1789 if (args
&& !primary
)
1792 len
= get_non_default_template_args_count (args
, flags
);
1794 args
= INNERMOST_TEMPLATE_ARGS (args
);
1795 for (ix
= 0; ix
!= len
; ix
++)
1797 tree arg
= TREE_VEC_ELT (args
, ix
);
1799 /* Only print a comma if we know there is an argument coming. In
1800 the case of an empty template argument pack, no actual
1801 argument will be printed. */
1803 && (!ARGUMENT_PACK_P (arg
)
1804 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1805 pp_separate_with_comma (pp
);
1808 pp_string (pp
, M_("<template parameter error>"));
1810 dump_template_argument (pp
, arg
, flags
);
1815 tree tpl
= TI_TEMPLATE (info
);
1816 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1819 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1820 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1822 for (ix
= 0; ix
!= len
; ix
++)
1826 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1828 pp_string (pp
, M_("<template parameter error>"));
1832 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1835 pp_separate_with_comma (pp
);
1837 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1840 pp_cxx_end_template_argument_list (pp
);
1843 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1844 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1847 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1850 call_expr_arg_iterator iter
;
1852 pp_cxx_left_paren (pp
);
1853 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1859 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1860 if (more_call_expr_args_p (&iter
))
1861 pp_separate_with_comma (pp
);
1864 pp_cxx_right_paren (pp
);
1867 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1868 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1872 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1876 aggr_init_expr_arg_iterator iter
;
1878 pp_cxx_left_paren (pp
);
1879 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1885 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1886 if (more_aggr_init_expr_args_p (&iter
))
1887 pp_separate_with_comma (pp
);
1890 pp_cxx_right_paren (pp
);
1893 /* Print out a list of initializers (subr of dump_expr). */
1896 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1900 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1903 pp_separate_with_comma (pp
);
1907 /* Print out a vector of initializers (subr of dump_expr). */
1910 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1913 unsigned HOST_WIDE_INT idx
;
1916 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1918 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1919 if (idx
!= v
->length () - 1)
1920 pp_separate_with_comma (pp
);
1925 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1926 function. Resolve it to a close relative -- in the sense of static
1927 type -- variant being overridden. That is close to what was written in
1928 the source code. Subroutine of dump_expr. */
1931 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1933 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1934 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1935 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1938 fun
= TREE_CHAIN (fun
);
1939 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1940 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1946 /* Print out an expression E under control of FLAGS. */
1949 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
1956 if (STATEMENT_CLASS_P (t
))
1958 pp_cxx_ws_string (pp
, M_("<statement>"));
1962 switch (TREE_CODE (t
))
1970 case NAMESPACE_DECL
:
1974 case IDENTIFIER_NODE
:
1975 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
1976 |TFF_TEMPLATE_HEADER
))
1977 | TFF_NO_FUNCTION_ARGUMENTS
));
1981 if (SSA_NAME_VAR (t
)
1982 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
1983 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
1985 pp_cxx_ws_string (pp
, M_("<unknown>"));
1996 case USERDEF_LITERAL
:
1997 pp_cxx_userdef_literal (pp
, t
);
2001 /* While waiting for caret diagnostics, avoid printing
2002 __cxa_allocate_exception, __cxa_throw, and the like. */
2003 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2008 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2009 pp_cxx_colon_colon (pp
);
2010 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2014 pp_cxx_left_paren (pp
);
2015 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2016 pp_separate_with_comma (pp
);
2017 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2018 pp_cxx_right_paren (pp
);
2022 pp_cxx_left_paren (pp
);
2023 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2024 pp_string (pp
, " ? ");
2025 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2026 pp_string (pp
, " : ");
2027 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2028 pp_cxx_right_paren (pp
);
2032 if (TREE_HAS_CONSTRUCTOR (t
))
2034 pp_cxx_ws_string (pp
, "new");
2035 pp_cxx_whitespace (pp
);
2036 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2039 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2042 case AGGR_INIT_EXPR
:
2044 tree fn
= NULL_TREE
;
2046 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2047 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2049 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2051 if (DECL_CONSTRUCTOR_P (fn
))
2052 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2054 dump_decl (pp
, fn
, 0);
2057 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2059 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2064 tree fn
= CALL_EXPR_FN (t
);
2065 bool skipfirst
= false;
2067 /* Deal with internal functions. */
2068 if (fn
== NULL_TREE
)
2070 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2071 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2075 if (TREE_CODE (fn
) == ADDR_EXPR
)
2076 fn
= TREE_OPERAND (fn
, 0);
2078 /* Nobody is interested in seeing the guts of vcalls. */
2079 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2080 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2082 if (TREE_TYPE (fn
) != NULL_TREE
2083 && NEXT_CODE (fn
) == METHOD_TYPE
2084 && call_expr_nargs (t
))
2086 tree ob
= CALL_EXPR_ARG (t
, 0);
2087 if (TREE_CODE (ob
) == ADDR_EXPR
)
2089 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2090 flags
| TFF_EXPR_IN_PARENS
);
2093 else if (TREE_CODE (ob
) != PARM_DECL
2094 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2096 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2101 if (flag_sanitize
& SANITIZE_UNDEFINED
2102 && is_ubsan_builtin_p (fn
))
2104 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2107 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2108 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2113 /* Note that this only works for G++ target exprs. If somebody
2114 builds a general TARGET_EXPR, there's no way to represent that
2115 it initializes anything other that the parameter slot for the
2116 default argument. Note we may have cleared out the first
2117 operand in expand_expr, so don't go killing ourselves. */
2118 if (TREE_OPERAND (t
, 1))
2119 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2122 case POINTER_PLUS_EXPR
:
2123 dump_binary_op (pp
, "+", t
, flags
);
2128 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2135 case TRUNC_DIV_EXPR
:
2136 case TRUNC_MOD_EXPR
:
2144 case TRUTH_ANDIF_EXPR
:
2145 case TRUTH_ORIF_EXPR
:
2152 case EXACT_DIV_EXPR
:
2153 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2157 case FLOOR_DIV_EXPR
:
2158 case ROUND_DIV_EXPR
:
2160 dump_binary_op (pp
, "/", t
, flags
);
2164 case FLOOR_MOD_EXPR
:
2165 case ROUND_MOD_EXPR
:
2166 dump_binary_op (pp
, "%", t
, flags
);
2171 tree ob
= TREE_OPERAND (t
, 0);
2172 if (INDIRECT_REF_P (ob
))
2174 ob
= TREE_OPERAND (ob
, 0);
2175 if (TREE_CODE (ob
) != PARM_DECL
2177 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2179 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2180 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2188 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2191 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2196 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2197 pp_cxx_left_bracket (pp
);
2198 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2199 pp_cxx_right_bracket (pp
);
2202 case ARRAY_NOTATION_REF
:
2203 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2204 pp_cxx_left_bracket (pp
);
2205 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2207 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2209 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2210 pp_cxx_right_bracket (pp
);
2213 case UNARY_PLUS_EXPR
:
2214 dump_unary_op (pp
, "+", t
, flags
);
2218 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2219 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2220 /* An ADDR_EXPR can have reference type. In that case, we
2221 shouldn't print the `&' doing so indicates to the user
2222 that the expression has pointer type. */
2224 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2225 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2226 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2227 dump_unary_op (pp
, "&&", t
, flags
);
2229 dump_unary_op (pp
, "&", t
, flags
);
2233 if (TREE_HAS_CONSTRUCTOR (t
))
2235 t
= TREE_OPERAND (t
, 0);
2236 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2237 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2238 dump_call_expr_args (pp
, t
, flags
, true);
2242 if (TREE_OPERAND (t
,0) != NULL_TREE
2243 && TREE_TYPE (TREE_OPERAND (t
, 0))
2244 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2245 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2247 dump_unary_op (pp
, "*", t
, flags
);
2252 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2253 && integer_zerop (TREE_OPERAND (t
, 1)))
2254 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2258 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2260 pp_cxx_left_paren (pp
);
2261 if (!integer_onep (TYPE_SIZE_UNIT
2262 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2264 pp_cxx_left_paren (pp
);
2265 dump_type (pp
, ptr_type_node
, flags
);
2266 pp_cxx_right_paren (pp
);
2269 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2270 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2272 pp_cxx_ws_string (pp
, "+");
2273 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2275 pp_cxx_right_paren (pp
);
2282 case TRUTH_NOT_EXPR
:
2283 case PREDECREMENT_EXPR
:
2284 case PREINCREMENT_EXPR
:
2285 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2288 case POSTDECREMENT_EXPR
:
2289 case POSTINCREMENT_EXPR
:
2290 pp_cxx_left_paren (pp
);
2291 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2292 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2293 pp_cxx_right_paren (pp
);
2296 case NON_LVALUE_EXPR
:
2297 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2298 should be another level of INDIRECT_REF so that I don't have to do
2300 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2302 tree next
= TREE_TYPE (TREE_TYPE (t
));
2304 while (TYPE_PTR_P (next
))
2305 next
= TREE_TYPE (next
);
2307 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2309 if (flags
& TFF_EXPR_IN_PARENS
)
2310 pp_cxx_left_paren (pp
);
2312 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2313 if (flags
& TFF_EXPR_IN_PARENS
)
2314 pp_cxx_right_paren (pp
);
2317 /* Else fall through. */
2319 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2323 case IMPLICIT_CONV_EXPR
:
2324 case VIEW_CONVERT_EXPR
:
2326 tree op
= TREE_OPERAND (t
, 0);
2327 tree ttype
= TREE_TYPE (t
);
2328 tree optype
= TREE_TYPE (op
);
2330 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2331 && POINTER_TYPE_P (ttype
)
2332 && POINTER_TYPE_P (optype
)
2333 && same_type_p (TREE_TYPE (optype
),
2336 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2339 if (TREE_CODE (op
) == ADDR_EXPR
)
2340 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2342 dump_unary_op (pp
, "*", t
, flags
);
2345 dump_unary_op (pp
, "&", t
, flags
);
2347 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2349 /* It is a cast, but we cannot tell whether it is a
2350 reinterpret or static cast. Use the C style notation. */
2351 if (flags
& TFF_EXPR_IN_PARENS
)
2352 pp_cxx_left_paren (pp
);
2353 pp_cxx_left_paren (pp
);
2354 dump_type (pp
, TREE_TYPE (t
), flags
);
2355 pp_cxx_right_paren (pp
);
2356 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2357 if (flags
& TFF_EXPR_IN_PARENS
)
2358 pp_cxx_right_paren (pp
);
2361 dump_expr (pp
, op
, flags
);
2366 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2368 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2370 if (integer_zerop (idx
))
2372 /* A NULL pointer-to-member constant. */
2373 pp_cxx_left_paren (pp
);
2374 pp_cxx_left_paren (pp
);
2375 dump_type (pp
, TREE_TYPE (t
), flags
);
2376 pp_cxx_right_paren (pp
);
2377 pp_character (pp
, '0');
2378 pp_cxx_right_paren (pp
);
2381 else if (tree_fits_shwi_p (idx
))
2384 unsigned HOST_WIDE_INT n
;
2386 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2387 t
= TYPE_METHOD_BASETYPE (t
);
2388 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2390 n
= tree_to_shwi (idx
);
2392 /* Map vtable index back one, to allow for the null pointer to
2396 while (n
> 0 && virtuals
)
2399 virtuals
= TREE_CHAIN (virtuals
);
2403 dump_expr (pp
, BV_FN (virtuals
),
2404 flags
| TFF_EXPR_IN_PARENS
);
2409 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2410 pp_string (pp
, "<lambda closure object>");
2411 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2413 dump_type (pp
, TREE_TYPE (t
), 0);
2414 pp_cxx_left_paren (pp
);
2415 pp_cxx_right_paren (pp
);
2419 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2420 dump_type (pp
, TREE_TYPE (t
), 0);
2421 pp_cxx_left_brace (pp
);
2422 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2423 pp_cxx_right_brace (pp
);
2430 tree ob
= TREE_OPERAND (t
, 0);
2431 if (is_dummy_object (ob
))
2433 t
= TREE_OPERAND (t
, 1);
2434 if (TREE_CODE (t
) == FUNCTION_DECL
)
2436 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2437 else if (BASELINK_P (t
))
2438 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2439 flags
| TFF_EXPR_IN_PARENS
);
2441 dump_decl (pp
, t
, flags
);
2445 if (INDIRECT_REF_P (ob
))
2447 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2453 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2457 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2462 case TEMPLATE_PARM_INDEX
:
2463 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2467 if (TREE_OPERAND (t
, 0) == NULL_TREE
2468 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2470 dump_type (pp
, TREE_TYPE (t
), flags
);
2471 pp_cxx_left_paren (pp
);
2472 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2473 pp_cxx_right_paren (pp
);
2477 pp_cxx_left_paren (pp
);
2478 dump_type (pp
, TREE_TYPE (t
), flags
);
2479 pp_cxx_right_paren (pp
);
2480 pp_cxx_left_paren (pp
);
2481 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2482 pp_cxx_right_paren (pp
);
2486 case STATIC_CAST_EXPR
:
2487 pp_cxx_ws_string (pp
, "static_cast");
2489 case REINTERPRET_CAST_EXPR
:
2490 pp_cxx_ws_string (pp
, "reinterpret_cast");
2492 case CONST_CAST_EXPR
:
2493 pp_cxx_ws_string (pp
, "const_cast");
2495 case DYNAMIC_CAST_EXPR
:
2496 pp_cxx_ws_string (pp
, "dynamic_cast");
2498 pp_cxx_begin_template_argument_list (pp
);
2499 dump_type (pp
, TREE_TYPE (t
), flags
);
2500 pp_cxx_end_template_argument_list (pp
);
2501 pp_cxx_left_paren (pp
);
2502 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2503 pp_cxx_right_paren (pp
);
2507 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2513 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2514 pp_cxx_ws_string (pp
, "sizeof");
2517 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2518 pp_cxx_ws_string (pp
, "__alignof__");
2520 op
= TREE_OPERAND (t
, 0);
2521 if (PACK_EXPANSION_P (op
))
2523 pp_string (pp
, "...");
2524 op
= PACK_EXPANSION_PATTERN (op
);
2526 pp_cxx_whitespace (pp
);
2527 pp_cxx_left_paren (pp
);
2528 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2529 dump_type (pp
, TREE_TYPE (op
), flags
);
2530 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2531 dump_type (pp
, op
, flags
);
2533 dump_expr (pp
, op
, flags
);
2534 pp_cxx_right_paren (pp
);
2537 case AT_ENCODE_EXPR
:
2538 pp_cxx_ws_string (pp
, "@encode");
2539 pp_cxx_whitespace (pp
);
2540 pp_cxx_left_paren (pp
);
2541 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2542 pp_cxx_right_paren (pp
);
2546 pp_cxx_ws_string (pp
, "noexcept");
2547 pp_cxx_whitespace (pp
);
2548 pp_cxx_left_paren (pp
);
2549 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2550 pp_cxx_right_paren (pp
);
2555 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2556 pp_cxx_whitespace (pp
);
2557 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2561 pp_string (pp
, M_("<unparsed>"));
2564 case TRY_CATCH_EXPR
:
2565 case WITH_CLEANUP_EXPR
:
2566 case CLEANUP_POINT_EXPR
:
2567 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2570 case PSEUDO_DTOR_EXPR
:
2571 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2573 if (TREE_OPERAND (t
, 1))
2575 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2576 pp_cxx_colon_colon (pp
);
2578 pp_cxx_complement (pp
);
2579 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2582 case TEMPLATE_ID_EXPR
:
2583 dump_decl (pp
, t
, flags
);
2589 case STATEMENT_LIST
:
2590 /* We don't yet have a way of dumping statements in a
2591 human-readable format. */
2592 pp_string (pp
, "({...})");
2596 pp_string (pp
, "while (1) { ");
2597 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2598 pp_cxx_right_brace (pp
);
2602 pp_string (pp
, "if (");
2603 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2604 pp_string (pp
, ") break; ");
2608 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2611 case EMPTY_CLASS_EXPR
:
2612 dump_type (pp
, TREE_TYPE (t
), flags
);
2613 pp_cxx_left_paren (pp
);
2614 pp_cxx_right_paren (pp
);
2617 case NON_DEPENDENT_EXPR
:
2618 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2621 case ARGUMENT_PACK_SELECT
:
2622 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2634 pp_type_specifier_seq (pp
, t
);
2638 /* We get here when we want to print a dependent type as an
2639 id-expression, without any disambiguator decoration. */
2640 pp
->id_expression (t
);
2643 case TEMPLATE_TYPE_PARM
:
2644 case TEMPLATE_TEMPLATE_PARM
:
2645 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2646 dump_type (pp
, t
, flags
);
2650 pp_cxx_trait_expression (pp
, t
);
2654 pp_cxx_va_arg_expression (pp
, t
);
2658 pp_cxx_offsetof_expression (pp
, t
);
2662 dump_decl (pp
, t
, flags
);
2665 case EXPR_PACK_EXPANSION
:
2672 case VEC_DELETE_EXPR
:
2678 case UNORDERED_EXPR
:
2688 case FIX_TRUNC_EXPR
:
2693 case TRUTH_AND_EXPR
:
2695 case TRUTH_XOR_EXPR
:
2696 if (flags
& TFF_EXPR_IN_PARENS
)
2697 pp_cxx_left_paren (pp
);
2699 if (flags
& TFF_EXPR_IN_PARENS
)
2700 pp_cxx_right_paren (pp
);
2704 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2708 pp_string (pp
, M_("<lambda>"));
2712 pp_cxx_left_paren (pp
);
2713 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2714 pp_cxx_right_paren (pp
);
2718 pp_cxx_requires_expr (cxx_pp
, t
);
2722 pp_cxx_simple_requirement (cxx_pp
, t
);
2726 pp_cxx_type_requirement (cxx_pp
, t
);
2730 pp_cxx_compound_requirement (cxx_pp
, t
);
2734 pp_cxx_nested_requirement (cxx_pp
, t
);
2746 pp_cxx_constraint (cxx_pp
, t
);
2749 case PLACEHOLDER_EXPR
:
2750 pp_string (pp
, M_("*this"));
2753 /* This list is incomplete, but should suffice for now.
2754 It is very important that `sorry' does not call
2755 `report_error_function'. That could cause an infinite loop. */
2757 pp_unsupported_tree (pp
, t
);
2758 /* fall through to ERROR_MARK... */
2760 pp_string (pp
, M_("<expression error>"));
2766 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2769 pp_cxx_left_paren (pp
);
2770 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2771 pp_cxx_whitespace (pp
);
2773 pp_cxx_ws_string (pp
, opstring
);
2775 pp_string (pp
, M_("<unknown operator>"));
2776 pp_cxx_whitespace (pp
);
2777 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2778 pp_cxx_right_paren (pp
);
2782 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2784 if (flags
& TFF_EXPR_IN_PARENS
)
2785 pp_cxx_left_paren (pp
);
2786 pp_cxx_ws_string (pp
, opstring
);
2787 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2788 if (flags
& TFF_EXPR_IN_PARENS
)
2789 pp_cxx_right_paren (pp
);
2793 reinit_cxx_pp (void)
2795 pp_clear_output_area (cxx_pp
);
2796 cxx_pp
->padding
= pp_none
;
2797 pp_indentation (cxx_pp
) = 0;
2798 pp_needs_newline (cxx_pp
) = false;
2799 cxx_pp
->enclosing_scope
= current_function_decl
;
2802 /* Same as pp_formatted_text, except the return string is a separate
2803 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2806 pp_ggc_formatted_text (pretty_printer
*pp
)
2808 return ggc_strdup (pp_formatted_text (pp
));
2811 /* Exported interface to stringifying types, exprs and decls under TFF_*
2815 type_as_string (tree typ
, int flags
)
2818 pp_translate_identifiers (cxx_pp
) = false;
2819 dump_type (cxx_pp
, typ
, flags
);
2820 return pp_ggc_formatted_text (cxx_pp
);
2824 type_as_string_translate (tree typ
, int flags
)
2827 dump_type (cxx_pp
, typ
, flags
);
2828 return pp_ggc_formatted_text (cxx_pp
);
2832 expr_as_string (tree decl
, int flags
)
2835 pp_translate_identifiers (cxx_pp
) = false;
2836 dump_expr (cxx_pp
, decl
, flags
);
2837 return pp_ggc_formatted_text (cxx_pp
);
2840 /* Wrap decl_as_string with options appropriate for dwarf. */
2843 decl_as_dwarf_string (tree decl
, int flags
)
2846 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2847 here will be adequate to get the desired behaviour. */
2848 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2849 name
= decl_as_string (decl
, flags
);
2850 /* Subsequent calls to the pretty printer shouldn't use this style. */
2851 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2856 decl_as_string (tree decl
, int flags
)
2859 pp_translate_identifiers (cxx_pp
) = false;
2860 dump_decl (cxx_pp
, decl
, flags
);
2861 return pp_ggc_formatted_text (cxx_pp
);
2865 decl_as_string_translate (tree decl
, int flags
)
2868 dump_decl (cxx_pp
, decl
, flags
);
2869 return pp_ggc_formatted_text (cxx_pp
);
2872 /* Wrap lang_decl_name with options appropriate for dwarf. */
2875 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2878 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2879 here will be adequate to get the desired behaviour. */
2880 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2881 name
= lang_decl_name (decl
, v
, translate
);
2882 /* Subsequent calls to the pretty printer shouldn't use this style. */
2883 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2887 /* Generate the three forms of printable names for cxx_printable_name. */
2890 lang_decl_name (tree decl
, int v
, bool translate
)
2894 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2895 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2898 pp_translate_identifiers (cxx_pp
) = translate
;
2900 && (DECL_CLASS_SCOPE_P (decl
)
2901 || (DECL_NAMESPACE_SCOPE_P (decl
)
2902 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2904 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2905 pp_cxx_colon_colon (cxx_pp
);
2908 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2909 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2910 else if ((DECL_NAME (decl
) == NULL_TREE
)
2911 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2912 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2914 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2916 return pp_ggc_formatted_text (cxx_pp
);
2919 /* Return the location of a tree passed to %+ formats. */
2922 location_of (tree t
)
2926 t
= TYPE_MAIN_DECL (t
);
2928 return input_location
;
2930 else if (TREE_CODE (t
) == OVERLOAD
)
2931 t
= OVL_FUNCTION (t
);
2934 return DECL_SOURCE_LOCATION (t
);
2935 return EXPR_LOC_OR_LOC (t
, input_location
);
2938 /* Now the interfaces from error et al to dump_type et al. Each takes an
2939 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2943 decl_to_string (tree decl
, int verbose
)
2947 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2948 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2949 flags
= TFF_CLASS_KEY_OR_ENUM
;
2951 flags
|= TFF_DECL_SPECIFIERS
;
2952 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2953 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2954 flags
|= TFF_TEMPLATE_HEADER
;
2957 dump_decl (cxx_pp
, decl
, flags
);
2958 return pp_ggc_formatted_text (cxx_pp
);
2962 expr_to_string (tree decl
)
2965 dump_expr (cxx_pp
, decl
, 0);
2966 return pp_ggc_formatted_text (cxx_pp
);
2970 fndecl_to_string (tree fndecl
, int verbose
)
2974 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2975 | TFF_TEMPLATE_HEADER
;
2977 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2979 dump_decl (cxx_pp
, fndecl
, flags
);
2980 return pp_ggc_formatted_text (cxx_pp
);
2985 code_to_string (enum tree_code c
)
2987 return get_tree_code_name (c
);
2991 language_to_string (enum languages c
)
2998 case lang_cplusplus
:
3010 /* Return the proper printed version of a parameter to a C++ function. */
3013 parm_to_string (int p
)
3017 pp_string (cxx_pp
, "'this'");
3019 pp_decimal_int (cxx_pp
, p
+ 1);
3020 return pp_ggc_formatted_text (cxx_pp
);
3024 op_to_string (enum tree_code p
)
3026 tree id
= operator_name_info
[p
].identifier
;
3027 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3031 type_to_string (tree typ
, int verbose
)
3035 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3036 flags
|= TFF_TEMPLATE_HEADER
;
3039 dump_type (cxx_pp
, typ
, flags
);
3040 /* If we're printing a type that involves typedefs, also print the
3041 stripped version. But sometimes the stripped version looks
3042 exactly the same, so we don't want it after all. To avoid printing
3043 it in that case, we play ugly obstack games. */
3044 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3045 && !uses_template_parms (typ
))
3047 int aka_start
, aka_len
; char *p
;
3048 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3049 /* Remember the end of the initial dump. */
3050 int len
= obstack_object_size (ob
);
3051 tree aka
= strip_typedefs (typ
);
3052 pp_string (cxx_pp
, " {aka");
3053 pp_cxx_whitespace (cxx_pp
);
3054 /* And remember the start of the aka dump. */
3055 aka_start
= obstack_object_size (ob
);
3056 dump_type (cxx_pp
, aka
, flags
);
3057 aka_len
= obstack_object_size (ob
) - aka_start
;
3058 pp_right_brace (cxx_pp
);
3059 p
= (char*)obstack_base (ob
);
3060 /* If they are identical, cut off the aka with a NUL. */
3061 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3064 return pp_ggc_formatted_text (cxx_pp
);
3068 assop_to_string (enum tree_code p
)
3070 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3071 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3075 args_to_string (tree p
, int verbose
)
3079 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3084 if (TYPE_P (TREE_VALUE (p
)))
3085 return type_as_string_translate (p
, flags
);
3088 for (; p
; p
= TREE_CHAIN (p
))
3090 if (TREE_VALUE (p
) == null_node
)
3091 pp_cxx_ws_string (cxx_pp
, "NULL");
3093 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3095 pp_separate_with_comma (cxx_pp
);
3097 return pp_ggc_formatted_text (cxx_pp
);
3100 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3101 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3105 subst_to_string (tree p
)
3107 tree decl
= TREE_PURPOSE (p
);
3108 tree targs
= TREE_VALUE (p
);
3109 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3110 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3111 |TFF_NO_TEMPLATE_BINDINGS
);
3117 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3118 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3119 return pp_ggc_formatted_text (cxx_pp
);
3123 cv_to_string (tree p
, int v
)
3126 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3127 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3128 return pp_ggc_formatted_text (cxx_pp
);
3132 eh_spec_to_string (tree p
, int /*v*/)
3136 dump_exception_spec (cxx_pp
, p
, flags
);
3137 return pp_ggc_formatted_text (cxx_pp
);
3140 /* Langhook for print_error_function. */
3142 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3143 diagnostic_info
*diagnostic
)
3145 lhd_print_error_function (context
, file
, diagnostic
);
3146 pp_set_prefix (context
->printer
, file
);
3147 maybe_print_instantiation_context (context
);
3151 cp_diagnostic_starter (diagnostic_context
*context
,
3152 diagnostic_info
*diagnostic
)
3154 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3155 cp_print_error_function (context
, diagnostic
);
3156 maybe_print_instantiation_context (context
);
3157 maybe_print_constexpr_context (context
);
3158 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3162 /* Print current function onto BUFFER, in the process of reporting
3163 a diagnostic message. Called from cp_diagnostic_starter. */
3165 cp_print_error_function (diagnostic_context
*context
,
3166 diagnostic_info
*diagnostic
)
3168 /* If we are in an instantiation context, current_function_decl is likely
3169 to be wrong, so just rely on print_instantiation_full_context. */
3170 if (current_instantiation ())
3172 if (diagnostic_last_function_changed (context
, diagnostic
))
3174 const char *old_prefix
= context
->printer
->prefix
;
3175 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3176 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3177 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3178 ? file_name_as_prefix (context
, file
) : NULL
;
3180 pp_set_prefix (context
->printer
, new_prefix
);
3182 if (current_function_decl
== NULL
)
3183 pp_string (context
->printer
, _("At global scope:"));
3188 if (abstract_origin
)
3190 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3191 while (TREE_CODE (ao
) == BLOCK
3192 && BLOCK_ABSTRACT_ORIGIN (ao
)
3193 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3194 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3195 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3199 fndecl
= current_function_decl
;
3201 pp_printf (context
->printer
, function_category (fndecl
),
3202 cxx_printable_name_translate (fndecl
, 2));
3204 while (abstract_origin
)
3207 tree block
= abstract_origin
;
3209 locus
= &BLOCK_SOURCE_LOCATION (block
);
3211 block
= BLOCK_SUPERCONTEXT (block
);
3212 while (block
&& TREE_CODE (block
) == BLOCK
3213 && BLOCK_ABSTRACT_ORIGIN (block
))
3215 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3217 while (TREE_CODE (ao
) == BLOCK
3218 && BLOCK_ABSTRACT_ORIGIN (ao
)
3219 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3220 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3222 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3227 else if (TREE_CODE (ao
) != BLOCK
)
3230 block
= BLOCK_SUPERCONTEXT (block
);
3233 abstract_origin
= block
;
3236 while (block
&& TREE_CODE (block
) == BLOCK
)
3237 block
= BLOCK_SUPERCONTEXT (block
);
3239 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3241 abstract_origin
= NULL
;
3245 expanded_location s
= expand_location (*locus
);
3246 pp_character (context
->printer
, ',');
3247 pp_newline (context
->printer
);
3250 if (context
->show_column
&& s
.column
!= 0)
3251 pp_printf (context
->printer
,
3252 _(" inlined from %qs at %r%s:%d:%d%R"),
3253 cxx_printable_name_translate (fndecl
, 2),
3254 "locus", s
.file
, s
.line
, s
.column
);
3256 pp_printf (context
->printer
,
3257 _(" inlined from %qs at %r%s:%d%R"),
3258 cxx_printable_name_translate (fndecl
, 2),
3259 "locus", s
.file
, s
.line
);
3263 pp_printf (context
->printer
, _(" inlined from %qs"),
3264 cxx_printable_name_translate (fndecl
, 2));
3267 pp_character (context
->printer
, ':');
3269 pp_newline (context
->printer
);
3271 diagnostic_set_last_function (context
, diagnostic
);
3272 pp_destroy_prefix (context
->printer
);
3273 context
->printer
->prefix
= old_prefix
;
3277 /* Returns a description of FUNCTION using standard terminology. The
3278 result is a format string of the form "In CATEGORY %qs". */
3280 function_category (tree fn
)
3282 /* We can get called from the middle-end for diagnostics of function
3283 clones. Make sure we have language specific information before
3284 dereferencing it. */
3285 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3286 && DECL_FUNCTION_MEMBER_P (fn
))
3288 if (DECL_STATIC_FUNCTION_P (fn
))
3289 return _("In static member function %qs");
3290 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3291 return _("In copy constructor %qs");
3292 else if (DECL_CONSTRUCTOR_P (fn
))
3293 return _("In constructor %qs");
3294 else if (DECL_DESTRUCTOR_P (fn
))
3295 return _("In destructor %qs");
3296 else if (LAMBDA_FUNCTION_P (fn
))
3297 return _("In lambda function");
3299 return _("In member function %qs");
3302 return _("In function %qs");
3305 /* Report the full context of a current template instantiation,
3308 print_instantiation_full_context (diagnostic_context
*context
)
3310 struct tinst_level
*p
= current_instantiation ();
3311 location_t location
= input_location
;
3315 pp_verbatim (context
->printer
,
3316 TREE_CODE (p
->decl
) == TREE_LIST
3317 ? _("%s: In substitution of %qS:\n")
3318 : _("%s: In instantiation of %q#D:\n"),
3319 LOCATION_FILE (location
),
3322 location
= p
->locus
;
3326 print_instantiation_partial_context (context
, p
, location
);
3329 /* Helper function of print_instantiation_partial_context() that
3330 prints a single line of instantiation context. */
3333 print_instantiation_partial_context_line (diagnostic_context
*context
,
3334 const struct tinst_level
*t
,
3335 location_t loc
, bool recursive_p
)
3337 if (loc
== UNKNOWN_LOCATION
)
3340 expanded_location xloc
= expand_location (loc
);
3342 if (context
->show_column
)
3343 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3344 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3346 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3347 "locus", xloc
.file
, xloc
.line
);
3351 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3352 pp_verbatim (context
->printer
,
3354 ? _("recursively required by substitution of %qS\n")
3355 : _("required by substitution of %qS\n"),
3358 pp_verbatim (context
->printer
,
3360 ? _("recursively required from %q#D\n")
3361 : _("required from %q#D\n"),
3366 pp_verbatim (context
->printer
,
3368 ? _("recursively required from here\n")
3369 : _("required from here\n"));
3373 /* Same as print_instantiation_full_context but less verbose. */
3376 print_instantiation_partial_context (diagnostic_context
*context
,
3377 struct tinst_level
*t0
, location_t loc
)
3379 struct tinst_level
*t
;
3382 location_t prev_loc
= loc
;
3384 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3385 if (prev_loc
!= t
->locus
)
3387 prev_loc
= t
->locus
;
3393 if (template_backtrace_limit
3394 && n_total
> template_backtrace_limit
)
3396 int skip
= n_total
- template_backtrace_limit
;
3397 int head
= template_backtrace_limit
/ 2;
3399 /* Avoid skipping just 1. If so, skip 2. */
3403 head
= (template_backtrace_limit
- 1) / 2;
3406 for (n
= 0; n
< head
; n
++)
3408 gcc_assert (t
!= NULL
);
3409 if (loc
!= t
->locus
)
3410 print_instantiation_partial_context_line (context
, t
, loc
,
3411 /*recursive_p=*/false);
3415 if (t
!= NULL
&& skip
> 0)
3417 expanded_location xloc
;
3418 xloc
= expand_location (loc
);
3419 if (context
->show_column
)
3420 pp_verbatim (context
->printer
,
3421 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3422 "contexts, use -ftemplate-backtrace-limit=0 to "
3424 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3426 pp_verbatim (context
->printer
,
3427 _("%r%s:%d:%R [ skipping %d instantiation "
3428 "contexts, use -ftemplate-backtrace-limit=0 to "
3430 "locus", xloc
.file
, xloc
.line
, skip
);
3435 } while (t
!= NULL
&& --skip
> 0);
3441 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3446 print_instantiation_partial_context_line (context
, t
, loc
,
3451 print_instantiation_partial_context_line (context
, NULL
, loc
,
3452 /*recursive_p=*/false);
3455 /* Called from cp_thing to print the template context for an error. */
3457 maybe_print_instantiation_context (diagnostic_context
*context
)
3459 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3462 record_last_problematic_instantiation ();
3463 print_instantiation_full_context (context
);
3466 /* Report what constexpr call(s) we're trying to expand, if any. */
3469 maybe_print_constexpr_context (diagnostic_context
*context
)
3471 vec
<tree
> call_stack
= cx_error_context ();
3475 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3477 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3478 const char *s
= expr_as_string (t
, 0);
3479 if (context
->show_column
)
3480 pp_verbatim (context
->printer
,
3481 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3482 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3484 pp_verbatim (context
->printer
,
3485 _("%r%s:%d:%R in constexpr expansion of %qs"),
3486 "locus", xloc
.file
, xloc
.line
, s
);
3487 pp_newline (context
->printer
);
3491 /* Called from output_format -- during diagnostic message processing --
3492 to handle C++ specific format specifier with the following meanings:
3493 %A function argument-list.
3497 %F function declaration.
3498 %L language as used in extern "lang".
3500 %P function parameter whose position is indicated by an integer.
3501 %Q assignment operator.
3502 %S substitution (template + args)
3505 %X exception-specification. */
3507 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3508 int precision
, bool wide
, bool set_locus
, bool verbose
)
3512 #define next_tree (t = va_arg (*text->args_ptr, tree))
3513 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3514 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3515 #define next_int va_arg (*text->args_ptr, int)
3517 if (precision
!= 0 || wide
)
3522 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3523 case 'C': result
= code_to_string (next_tcode
); break;
3526 tree temp
= next_tree
;
3528 && DECL_HAS_DEBUG_EXPR_P (temp
))
3530 temp
= DECL_DEBUG_EXPR (temp
);
3533 result
= expr_to_string (temp
);
3537 result
= decl_to_string (temp
, verbose
);
3540 case 'E': result
= expr_to_string (next_tree
); break;
3541 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3542 case 'L': result
= language_to_string (next_lang
); break;
3543 case 'O': result
= op_to_string (next_tcode
); break;
3544 case 'P': result
= parm_to_string (next_int
); break;
3545 case 'Q': result
= assop_to_string (next_tcode
); break;
3546 case 'S': result
= subst_to_string (next_tree
); break;
3547 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3548 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3549 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3552 percent_K_format (text
);
3559 pp_string (pp
, result
);
3560 if (set_locus
&& t
!= NULL
)
3561 text
->set_location (0, location_of (t
), true);
3569 /* Warn about the use of C++0x features when appropriate. */
3571 maybe_warn_cpp0x (cpp0x_warn_str str
)
3573 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3574 /* We really want to suppress this warning in system headers,
3575 because libstdc++ uses variadic templates even when we aren't
3579 case CPP0X_INITIALIZER_LISTS
:
3580 pedwarn (input_location
, 0,
3581 "extended initializer lists "
3582 "only available with -std=c++11 or -std=gnu++11");
3584 case CPP0X_EXPLICIT_CONVERSION
:
3585 pedwarn (input_location
, 0,
3586 "explicit conversion operators "
3587 "only available with -std=c++11 or -std=gnu++11");
3589 case CPP0X_VARIADIC_TEMPLATES
:
3590 pedwarn (input_location
, 0,
3591 "variadic templates "
3592 "only available with -std=c++11 or -std=gnu++11");
3594 case CPP0X_LAMBDA_EXPR
:
3595 pedwarn (input_location
, 0,
3596 "lambda expressions "
3597 "only available with -std=c++11 or -std=gnu++11");
3600 pedwarn (input_location
, 0,
3601 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3603 case CPP0X_SCOPED_ENUMS
:
3604 pedwarn (input_location
, 0,
3605 "scoped enums only available with -std=c++11 or -std=gnu++11");
3607 case CPP0X_DEFAULTED_DELETED
:
3608 pedwarn (input_location
, 0,
3609 "defaulted and deleted functions "
3610 "only available with -std=c++11 or -std=gnu++11");
3612 case CPP0X_INLINE_NAMESPACES
:
3613 pedwarn (input_location
, OPT_Wpedantic
,
3614 "inline namespaces "
3615 "only available with -std=c++11 or -std=gnu++11");
3617 case CPP0X_OVERRIDE_CONTROLS
:
3618 pedwarn (input_location
, 0,
3619 "override controls (override/final) "
3620 "only available with -std=c++11 or -std=gnu++11");
3623 pedwarn (input_location
, 0,
3624 "non-static data member initializers "
3625 "only available with -std=c++11 or -std=gnu++11");
3627 case CPP0X_USER_DEFINED_LITERALS
:
3628 pedwarn (input_location
, 0,
3629 "user-defined literals "
3630 "only available with -std=c++11 or -std=gnu++11");
3632 case CPP0X_DELEGATING_CTORS
:
3633 pedwarn (input_location
, 0,
3634 "delegating constructors "
3635 "only available with -std=c++11 or -std=gnu++11");
3637 case CPP0X_INHERITING_CTORS
:
3638 pedwarn (input_location
, 0,
3639 "inheriting constructors "
3640 "only available with -std=c++11 or -std=gnu++11");
3642 case CPP0X_ATTRIBUTES
:
3643 pedwarn (input_location
, 0,
3645 "only available with -std=c++11 or -std=gnu++11");
3647 case CPP0X_REF_QUALIFIER
:
3648 pedwarn (input_location
, 0,
3650 "only available with -std=c++11 or -std=gnu++11");
3657 /* Warn about the use of variadic templates when appropriate. */
3659 maybe_warn_variadic_templates (void)
3661 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3665 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3666 option OPT with text GMSGID. Use this function to report
3667 diagnostics for constructs that are invalid C++98, but valid
3670 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3672 diagnostic_info diagnostic
;
3675 rich_location
richloc (line_table
, location
);
3677 va_start (ap
, gmsgid
);
3678 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
3679 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3680 diagnostic
.option_index
= opt
;
3681 ret
= report_diagnostic (&diagnostic
);
3686 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3687 we found when we tried to do the lookup. LOCATION is the location of
3688 the NAME identifier. */
3691 qualified_name_lookup_error (tree scope
, tree name
,
3692 tree decl
, location_t location
)
3694 if (scope
== error_mark_node
)
3695 ; /* We already complained. */
3696 else if (TYPE_P (scope
))
3698 if (!COMPLETE_TYPE_P (scope
))
3699 error_at (location
, "incomplete type %qT used in nested name specifier",
3701 else if (TREE_CODE (decl
) == TREE_LIST
)
3703 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3705 print_candidates (decl
);
3708 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3710 else if (scope
!= global_namespace
)
3712 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3713 suggest_alternatives_for (location
, name
);
3717 error_at (location
, "%<::%D%> has not been declared", name
);
3718 suggest_alternatives_for (location
, name
);