1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2018 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 "gimple-pretty-print.h"
31 #include "c-family/c-objc.h"
33 #include "internal-fn.h"
35 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
36 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
38 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
39 dump C++ ASTs as strings. It is mostly used only by the various
40 tree -> string functions that are occasionally called from the
41 debugger or by the front-end for things like
42 __PRETTY_FUNCTION__. */
43 static cxx_pretty_printer actual_pretty_printer
;
44 static cxx_pretty_printer
* const cxx_pp
= &actual_pretty_printer
;
46 /* Translate if being used for diagnostics, but not for dump files or
48 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
50 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
52 static const char *args_to_string (tree
, int);
53 static const char *code_to_string (enum tree_code
);
54 static const char *cv_to_string (tree
, int);
55 static const char *decl_to_string (tree
, int);
56 static const char *expr_to_string (tree
);
57 static const char *fndecl_to_string (tree
, int);
58 static const char *op_to_string (bool, enum tree_code
);
59 static const char *parm_to_string (int);
60 static const char *type_to_string (tree
, int, bool, bool *, bool);
62 static void dump_alias_template_specialization (cxx_pretty_printer
*, tree
, int);
63 static void dump_type (cxx_pretty_printer
*, tree
, int);
64 static void dump_typename (cxx_pretty_printer
*, tree
, int);
65 static void dump_simple_decl (cxx_pretty_printer
*, tree
, tree
, int);
66 static void dump_decl (cxx_pretty_printer
*, tree
, int);
67 static void dump_template_decl (cxx_pretty_printer
*, tree
, int);
68 static void dump_function_decl (cxx_pretty_printer
*, tree
, int);
69 static void dump_expr (cxx_pretty_printer
*, tree
, int);
70 static void dump_unary_op (cxx_pretty_printer
*, const char *, tree
, int);
71 static void dump_binary_op (cxx_pretty_printer
*, const char *, tree
, int);
72 static void dump_aggr_type (cxx_pretty_printer
*, tree
, int);
73 static void dump_type_prefix (cxx_pretty_printer
*, tree
, int);
74 static void dump_type_suffix (cxx_pretty_printer
*, tree
, int);
75 static void dump_function_name (cxx_pretty_printer
*, tree
, int);
76 static void dump_call_expr_args (cxx_pretty_printer
*, tree
, int, bool);
77 static void dump_aggr_init_expr_args (cxx_pretty_printer
*, tree
, int, bool);
78 static void dump_expr_list (cxx_pretty_printer
*, tree
, int);
79 static void dump_global_iord (cxx_pretty_printer
*, tree
);
80 static void dump_parameters (cxx_pretty_printer
*, tree
, int);
81 static void dump_ref_qualifier (cxx_pretty_printer
*, tree
, int);
82 static void dump_exception_spec (cxx_pretty_printer
*, tree
, int);
83 static void dump_template_argument (cxx_pretty_printer
*, tree
, int);
84 static void dump_template_argument_list (cxx_pretty_printer
*, tree
, int);
85 static void dump_template_parameter (cxx_pretty_printer
*, tree
, int);
86 static void dump_template_bindings (cxx_pretty_printer
*, tree
, tree
,
88 static void dump_scope (cxx_pretty_printer
*, tree
, int);
89 static void dump_template_parms (cxx_pretty_printer
*, 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_print_error_function (diagnostic_context
*, diagnostic_info
*);
101 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
102 int, bool, bool, bool, bool *, const char **);
104 /* Struct for handling %H or %I, which require delaying printing the
105 type until a postprocessing stage. */
107 struct deferred_printed_type
109 deferred_printed_type ()
110 : m_tree (NULL_TREE
), m_buffer_ptr (NULL
), m_verbose (false), m_quote (false)
113 deferred_printed_type (tree type
, const char **buffer_ptr
, bool verbose
,
115 : m_tree (type
), m_buffer_ptr (buffer_ptr
), m_verbose (verbose
),
119 gcc_assert (buffer_ptr
);
122 /* The tree is not GTY-marked: they are only non-NULL within a
123 call to pp_format. */
125 const char **m_buffer_ptr
;
130 /* Subclass of format_postprocessor for the C++ frontend.
131 This handles the %H and %I formatting codes, printing them
132 in a postprocessing phase (since they affect each other). */
134 class cxx_format_postprocessor
: public format_postprocessor
137 cxx_format_postprocessor ()
138 : m_type_a (), m_type_b ()
141 void handle (pretty_printer
*pp
) FINAL OVERRIDE
;
143 deferred_printed_type m_type_a
;
144 deferred_printed_type m_type_b
;
147 /* CONTEXT->printer is a basic pretty printer that was constructed
148 presumably by diagnostic_initialize(), called early in the
149 compiler's initialization process (in general_init) Before the FE
150 is initialized. This (C++) FE-specific diagnostic initializer is
151 thus replacing the basic pretty printer with one that has C++-aware
155 cxx_initialize_diagnostics (diagnostic_context
*context
)
157 pretty_printer
*base
= context
->printer
;
158 cxx_pretty_printer
*pp
= XNEW (cxx_pretty_printer
);
159 context
->printer
= new (pp
) cxx_pretty_printer ();
161 /* It is safe to free this object because it was previously XNEW()'d. */
162 base
->~pretty_printer ();
165 c_common_diagnostics_set_defaults (context
);
166 diagnostic_starter (context
) = cp_diagnostic_starter
;
167 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
168 diagnostic_format_decoder (context
) = cp_printer
;
169 pp
->m_format_postprocessor
= new cxx_format_postprocessor ();
172 /* Dump a scope, if deemed necessary. */
175 dump_scope (cxx_pretty_printer
*pp
, tree scope
, int flags
)
177 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
179 if (scope
== NULL_TREE
)
182 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
184 if (scope
!= global_namespace
)
186 dump_decl (pp
, scope
, f
);
187 pp_cxx_colon_colon (pp
);
190 else if (AGGREGATE_TYPE_P (scope
))
192 dump_type (pp
, scope
, f
);
193 pp_cxx_colon_colon (pp
);
195 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
197 dump_function_decl (pp
, scope
, f
);
198 pp_cxx_colon_colon (pp
);
202 /* Dump the template ARGument under control of FLAGS. */
205 dump_template_argument (cxx_pretty_printer
*pp
, tree arg
, int flags
)
207 if (ARGUMENT_PACK_P (arg
))
208 dump_template_argument_list (pp
, ARGUMENT_PACK_ARGS (arg
),
209 /* No default args in argument packs. */
210 flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
211 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
212 dump_type (pp
, arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
215 if (TREE_CODE (arg
) == TREE_LIST
)
216 arg
= TREE_VALUE (arg
);
218 /* Strip implicit conversions. */
219 while (CONVERT_EXPR_P (arg
))
220 arg
= TREE_OPERAND (arg
, 0);
222 dump_expr (pp
, arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
226 /* Count the number of template arguments ARGS whose value does not
227 match the (optional) default template parameter in PARAMS */
230 get_non_default_template_args_count (tree args
, int flags
)
232 int n
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args
));
234 if (/* We use this flag when generating debug information. We don't
235 want to expand templates at this point, for this may generate
236 new decls, which gets decl counts out of sync, which may in
237 turn cause codegen differences between compilations with and
239 (flags
& TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
) != 0
240 || !flag_pretty_templates
)
243 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args
));
246 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
250 dump_template_argument_list (cxx_pretty_printer
*pp
, tree args
, int flags
)
252 int n
= get_non_default_template_args_count (args
, flags
);
256 for (i
= 0; i
< n
; ++i
)
258 tree arg
= TREE_VEC_ELT (args
, i
);
260 /* Only print a comma if we know there is an argument coming. In
261 the case of an empty template argument pack, no actual
262 argument will be printed. */
264 && (!ARGUMENT_PACK_P (arg
)
265 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
266 pp_separate_with_comma (pp
);
268 dump_template_argument (pp
, arg
, flags
);
273 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
276 dump_template_parameter (cxx_pretty_printer
*pp
, tree parm
, int flags
)
281 if (parm
== error_mark_node
)
284 p
= TREE_VALUE (parm
);
285 a
= TREE_PURPOSE (parm
);
287 if (TREE_CODE (p
) == TYPE_DECL
)
289 if (flags
& TFF_DECL_SPECIFIERS
)
291 pp_cxx_ws_string (pp
, "class");
292 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
293 pp_cxx_ws_string (pp
, "...");
295 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
297 else if (DECL_NAME (p
))
298 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
300 pp_cxx_canonical_template_parameter (pp
, TREE_TYPE (p
));
303 dump_decl (pp
, p
, flags
| TFF_DECL_SPECIFIERS
);
305 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
307 pp_cxx_whitespace (pp
);
309 pp_cxx_whitespace (pp
);
310 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
311 dump_type (pp
, a
, flags
& ~TFF_CHASE_TYPEDEF
);
313 dump_expr (pp
, a
, flags
| TFF_EXPR_IN_PARENS
);
317 /* Dump, under control of FLAGS, a template-parameter-list binding.
318 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
322 dump_template_bindings (cxx_pretty_printer
*pp
, tree parms
, tree args
,
323 vec
<tree
, va_gc
> *typenames
)
325 bool need_semicolon
= false;
331 tree p
= TREE_VALUE (parms
);
332 int lvl
= TMPL_PARMS_DEPTH (parms
);
335 tree lvl_args
= NULL_TREE
;
337 /* Don't crash if we had an invalid argument list. */
338 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
339 lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
341 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
343 tree arg
= NULL_TREE
;
345 /* Don't crash if we had an invalid argument list. */
346 if (lvl_args
&& NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
347 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
350 pp_separate_with_semicolon (pp
);
351 dump_template_parameter (pp
, TREE_VEC_ELT (p
, i
),
352 TFF_PLAIN_IDENTIFIER
);
353 pp_cxx_whitespace (pp
);
355 pp_cxx_whitespace (pp
);
358 if (ARGUMENT_PACK_P (arg
))
359 pp_cxx_left_brace (pp
);
360 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
361 if (ARGUMENT_PACK_P (arg
))
362 pp_cxx_right_brace (pp
);
365 pp_string (pp
, M_("<missing>"));
368 need_semicolon
= true;
371 parms
= TREE_CHAIN (parms
);
374 /* Don't bother with typenames for a partial instantiation. */
375 if (vec_safe_is_empty (typenames
) || uses_template_parms (args
))
378 /* Don't try to print typenames when we're processing a clone. */
379 if (current_function_decl
380 && !DECL_LANG_SPECIFIC (current_function_decl
))
383 /* Don't try to do this once cgraph starts throwing away front-end
388 FOR_EACH_VEC_SAFE_ELT (typenames
, i
, t
)
391 pp_separate_with_semicolon (pp
);
392 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
393 pp_cxx_whitespace (pp
);
395 pp_cxx_whitespace (pp
);
396 push_deferring_access_checks (dk_no_check
);
397 t
= tsubst (t
, args
, tf_none
, NULL_TREE
);
398 pop_deferring_access_checks ();
399 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
400 pp_simple_type_specifier doesn't know about it. */
401 t
= strip_typedefs (t
);
402 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
406 /* Dump a human-readable equivalent of the alias template
407 specialization of T. */
410 dump_alias_template_specialization (cxx_pretty_printer
*pp
, tree t
, int flags
)
412 gcc_assert (alias_template_specialization_p (t
));
414 tree decl
= TYPE_NAME (t
);
415 if (!(flags
& TFF_UNQUALIFIED_NAME
))
416 dump_scope (pp
, CP_DECL_CONTEXT (decl
), flags
);
417 pp_cxx_tree_identifier (pp
, DECL_NAME (decl
));
418 dump_template_parms (pp
, DECL_TEMPLATE_INFO (decl
),
420 flags
& ~TFF_TEMPLATE_HEADER
);
423 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
427 dump_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
432 /* Don't print e.g. "struct mytypedef". */
433 if (TYPE_P (t
) && typedef_variant_p (t
))
435 tree decl
= TYPE_NAME (t
);
436 if ((flags
& TFF_CHASE_TYPEDEF
)
437 || DECL_SELF_REFERENCE_P (decl
)
438 || (!flag_pretty_templates
439 && DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)))
440 t
= strip_typedefs (t
);
441 else if (alias_template_specialization_p (t
))
443 dump_alias_template_specialization (pp
, t
, flags
);
446 else if (same_type_p (t
, TREE_TYPE (decl
)))
450 pp_cxx_cv_qualifier_seq (pp
, t
);
451 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
456 if (TYPE_PTRMEMFUNC_P (t
))
459 switch (TREE_CODE (t
))
462 if (t
== init_list_type_node
)
463 pp_string (pp
, M_("<brace-enclosed initializer list>"));
464 else if (t
== unknown_type_node
)
465 pp_string (pp
, M_("<unresolved overloaded function type>"));
468 pp_cxx_cv_qualifier_seq (pp
, t
);
469 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
474 /* A list of function parms. */
475 dump_parameters (pp
, t
, flags
);
478 case IDENTIFIER_NODE
:
479 pp_cxx_tree_identifier (pp
, t
);
483 dump_type (pp
, BINFO_TYPE (t
), flags
);
489 dump_aggr_type (pp
, t
, flags
);
493 if (flags
& TFF_CHASE_TYPEDEF
)
495 dump_type (pp
, DECL_ORIGINAL_TYPE (t
)
496 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
503 dump_decl (pp
, t
, flags
& ~TFF_DECL_SPECIFIERS
);
512 case FIXED_POINT_TYPE
:
513 pp_type_specifier_seq (pp
, t
);
516 case TEMPLATE_TEMPLATE_PARM
:
517 /* For parameters inside template signature. */
518 if (TYPE_IDENTIFIER (t
))
519 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
521 pp_cxx_canonical_template_parameter (pp
, t
);
524 case BOUND_TEMPLATE_TEMPLATE_PARM
:
526 tree args
= TYPE_TI_ARGS (t
);
527 pp_cxx_cv_qualifier_seq (pp
, t
);
528 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
529 pp_cxx_begin_template_argument_list (pp
);
530 dump_template_argument_list (pp
, args
, flags
);
531 pp_cxx_end_template_argument_list (pp
);
535 case TEMPLATE_TYPE_PARM
:
536 pp_cxx_cv_qualifier_seq (pp
, t
);
537 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
538 pp_cxx_constrained_type_spec (pp
, c
);
539 else if (TYPE_IDENTIFIER (t
))
540 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
542 pp_cxx_canonical_template_parameter
543 (pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
546 /* This is not always necessary for pointers and such, but doing this
547 reduces code size. */
556 dump_type_prefix (pp
, t
, flags
);
557 dump_type_suffix (pp
, t
, flags
);
561 if (! (flags
& TFF_CHASE_TYPEDEF
)
562 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
564 dump_decl (pp
, TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
567 pp_cxx_cv_qualifier_seq (pp
, t
);
568 pp_cxx_ws_string (pp
,
569 TYPENAME_IS_ENUM_P (t
) ? "enum"
570 : TYPENAME_IS_CLASS_P (t
) ? "class"
572 dump_typename (pp
, t
, flags
);
575 case UNBOUND_CLASS_TEMPLATE
:
576 if (! (flags
& TFF_UNQUALIFIED_NAME
))
578 dump_type (pp
, TYPE_CONTEXT (t
), flags
);
579 pp_cxx_colon_colon (pp
);
581 pp_cxx_ws_string (pp
, "template");
582 dump_type (pp
, TYPE_IDENTIFIER (t
), flags
);
586 pp_cxx_ws_string (pp
, "__typeof__");
587 pp_cxx_whitespace (pp
);
588 pp_cxx_left_paren (pp
);
589 dump_expr (pp
, TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
590 pp_cxx_right_paren (pp
);
593 case UNDERLYING_TYPE
:
594 pp_cxx_ws_string (pp
, "__underlying_type");
595 pp_cxx_whitespace (pp
);
596 pp_cxx_left_paren (pp
);
597 dump_expr (pp
, UNDERLYING_TYPE_TYPE (t
), flags
& ~TFF_EXPR_IN_PARENS
);
598 pp_cxx_right_paren (pp
);
601 case TYPE_PACK_EXPANSION
:
602 dump_type (pp
, PACK_EXPANSION_PATTERN (t
), flags
);
603 pp_cxx_ws_string (pp
, "...");
606 case TYPE_ARGUMENT_PACK
:
607 dump_template_argument (pp
, t
, flags
);
611 pp_cxx_ws_string (pp
, "decltype");
612 pp_cxx_whitespace (pp
);
613 pp_cxx_left_paren (pp
);
614 dump_expr (pp
, DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
615 pp_cxx_right_paren (pp
);
619 pp_string (pp
, "std::nullptr_t");
623 pp_unsupported_tree (pp
, t
);
627 pp_string (pp
, M_("<type error>"));
632 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
636 dump_typename (cxx_pretty_printer
*pp
, tree t
, int flags
)
638 tree ctx
= TYPE_CONTEXT (t
);
640 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
641 dump_typename (pp
, ctx
, flags
);
643 dump_type (pp
, ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
644 pp_cxx_colon_colon (pp
);
645 dump_decl (pp
, TYPENAME_TYPE_FULLNAME (t
), flags
);
648 /* Return the name of the supplied aggregate, or enumeral type. */
651 class_key_or_enum_as_string (tree t
)
653 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
655 if (SCOPED_ENUM_P (t
))
660 else if (TREE_CODE (t
) == UNION_TYPE
)
662 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
668 /* Print out a class declaration T under the control of FLAGS,
669 in the form `class foo'. */
672 dump_aggr_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
675 const char *variety
= class_key_or_enum_as_string (t
);
679 pp_cxx_cv_qualifier_seq (pp
, t
);
681 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
682 pp_cxx_ws_string (pp
, variety
);
684 name
= TYPE_NAME (t
);
688 typdef
= (!DECL_ARTIFICIAL (name
)
689 /* An alias specialization is not considered to be a
691 && !alias_template_specialization_p (t
));
694 && ((flags
& TFF_CHASE_TYPEDEF
)
695 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
696 && DECL_TEMPLATE_INFO (name
))))
697 || DECL_SELF_REFERENCE_P (name
))
699 t
= TYPE_MAIN_VARIANT (t
);
700 name
= TYPE_NAME (t
);
704 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
705 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
706 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
707 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
709 if (! (flags
& TFF_UNQUALIFIED_NAME
))
710 dump_scope (pp
, CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
711 flags
&= ~TFF_UNQUALIFIED_NAME
;
714 /* Because the template names are mangled, we have to locate
715 the most general template, and use that name. */
716 tree tpl
= TYPE_TI_TEMPLATE (t
);
718 while (DECL_TEMPLATE_INFO (tpl
))
719 tpl
= DECL_TI_TEMPLATE (tpl
);
722 name
= DECL_NAME (name
);
725 if (name
== 0 || anon_aggrname_p (name
))
727 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
728 pp_string (pp
, M_("<unnamed>"));
730 pp_printf (pp
, M_("<unnamed %s>"), variety
);
732 else if (LAMBDA_TYPE_P (t
))
734 /* A lambda's "type" is essentially its signature. */
735 pp_string (pp
, M_("<lambda"));
736 if (lambda_function (t
))
738 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
743 pp_cxx_tree_identifier (pp
, name
);
745 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
746 !CLASSTYPE_USE_TEMPLATE (t
),
747 flags
& ~TFF_TEMPLATE_HEADER
);
750 /* Dump into the obstack the initial part of the output for a given type.
751 This is necessary when dealing with things like functions returning
754 return type of `int (* fee ())()': pointer -> function -> int. Both
755 pointer (and reference and offset) and function (and member) types must
756 deal with prefix and suffix.
758 Arrays must also do this for DECL nodes, like int a[], and for things like
762 dump_type_prefix (cxx_pretty_printer
*pp
, tree t
, int flags
)
764 if (TYPE_PTRMEMFUNC_P (t
))
766 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
770 switch (TREE_CODE (t
))
775 tree sub
= TREE_TYPE (t
);
777 dump_type_prefix (pp
, sub
, flags
);
778 if (TREE_CODE (sub
) == ARRAY_TYPE
779 || TREE_CODE (sub
) == FUNCTION_TYPE
)
781 pp_cxx_whitespace (pp
);
782 pp_cxx_left_paren (pp
);
783 pp_c_attributes_display (pp
, TYPE_ATTRIBUTES (sub
));
787 else if (TYPE_REF_P (t
))
789 if (TYPE_REF_IS_RVALUE (t
))
790 pp_ampersand_ampersand (pp
);
794 pp
->padding
= pp_before
;
795 pp_cxx_cv_qualifier_seq (pp
, t
);
801 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
802 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
805 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
806 pp_cxx_left_paren (pp
);
807 dump_type (pp
, TYPE_OFFSET_BASETYPE (t
), flags
);
808 pp_cxx_colon_colon (pp
);
811 pp_cxx_cv_qualifier_seq (pp
, t
);
812 pp
->padding
= pp_before
;
815 /* This can be reached without a pointer when dealing with
816 templates, e.g. std::is_function. */
818 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
822 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
824 pp_cxx_left_paren (pp
);
825 dump_aggr_type (pp
, TYPE_METHOD_BASETYPE (t
), flags
);
826 pp_cxx_colon_colon (pp
);
830 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
834 case IDENTIFIER_NODE
:
839 case TEMPLATE_TYPE_PARM
:
840 case TEMPLATE_TEMPLATE_PARM
:
841 case BOUND_TEMPLATE_TEMPLATE_PARM
:
852 case UNDERLYING_TYPE
:
854 case TYPE_PACK_EXPANSION
:
855 case FIXED_POINT_TYPE
:
857 dump_type (pp
, t
, flags
);
858 pp
->padding
= pp_before
;
862 pp_unsupported_tree (pp
, t
);
865 pp_string (pp
, M_("<typeprefixerror>"));
870 /* Dump the suffix of type T, under control of FLAGS. This is the part
871 which appears after the identifier (or function parms). */
874 dump_type_suffix (cxx_pretty_printer
*pp
, tree t
, int flags
)
876 if (TYPE_PTRMEMFUNC_P (t
))
877 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
879 switch (TREE_CODE (t
))
884 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
885 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
886 pp_cxx_right_paren (pp
);
887 if (TREE_CODE (t
) == POINTER_TYPE
)
888 flags
|= TFF_POINTER
;
889 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
896 if (TREE_CODE (t
) == METHOD_TYPE
)
897 /* Can only be reached through a pointer. */
898 pp_cxx_right_paren (pp
);
899 arg
= TYPE_ARG_TYPES (t
);
900 if (TREE_CODE (t
) == METHOD_TYPE
)
901 arg
= TREE_CHAIN (arg
);
903 /* Function pointers don't have default args. Not in standard C++,
904 anyway; they may in g++, but we'll just pretend otherwise. */
905 dump_parameters (pp
, arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
907 pp
->padding
= pp_before
;
908 pp_cxx_cv_qualifiers (pp
, type_memfn_quals (t
),
909 TREE_CODE (t
) == FUNCTION_TYPE
910 && (flags
& TFF_POINTER
));
911 dump_ref_qualifier (pp
, t
, flags
);
912 if (tx_safe_fn_type_p (t
))
913 pp_cxx_ws_string (pp
, "transaction_safe");
914 dump_exception_spec (pp
, TYPE_RAISES_EXCEPTIONS (t
), flags
);
915 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
921 pp_cxx_left_bracket (pp
);
922 if (tree dtype
= TYPE_DOMAIN (t
))
924 tree max
= TYPE_MAX_VALUE (dtype
);
925 /* Zero-length arrays have an upper bound of SIZE_MAX. */
926 if (integer_all_onesp (max
))
927 pp_character (pp
, '0');
928 else if (tree_fits_shwi_p (max
))
929 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
933 if (TREE_CODE (max
) == SAVE_EXPR
)
934 max
= TREE_OPERAND (max
, 0);
935 if (TREE_CODE (max
) == MINUS_EXPR
936 || TREE_CODE (max
) == PLUS_EXPR
)
938 max
= TREE_OPERAND (max
, 0);
939 while (CONVERT_EXPR_P (max
))
940 max
= TREE_OPERAND (max
, 0);
943 max
= fold_build2_loc (input_location
,
944 PLUS_EXPR
, dtype
, max
,
945 build_int_cst (dtype
, 1));
946 dump_expr (pp
, max
, flags
& ~TFF_EXPR_IN_PARENS
);
949 pp_cxx_right_bracket (pp
);
950 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
954 case IDENTIFIER_NODE
:
959 case TEMPLATE_TYPE_PARM
:
960 case TEMPLATE_TEMPLATE_PARM
:
961 case BOUND_TEMPLATE_TEMPLATE_PARM
:
972 case UNDERLYING_TYPE
:
974 case TYPE_PACK_EXPANSION
:
975 case FIXED_POINT_TYPE
:
980 pp_unsupported_tree (pp
, t
);
982 /* Don't mark it here, we should have already done in
989 dump_global_iord (cxx_pretty_printer
*pp
, tree t
)
991 const char *p
= NULL
;
993 if (DECL_GLOBAL_CTOR_P (t
))
994 p
= M_("(static initializers for %s)");
995 else if (DECL_GLOBAL_DTOR_P (t
))
996 p
= M_("(static destructors for %s)");
1000 pp_printf (pp
, p
, DECL_SOURCE_FILE (t
));
1004 dump_simple_decl (cxx_pretty_printer
*pp
, tree t
, tree type
, int flags
)
1006 if (flags
& TFF_DECL_SPECIFIERS
)
1008 if (VAR_P (t
) && DECL_DECLARED_CONSTEXPR_P (t
))
1010 if (DECL_LANG_SPECIFIC (t
) && DECL_DECLARED_CONCEPT_P (t
))
1011 pp_cxx_ws_string (pp
, "concept");
1013 pp_cxx_ws_string (pp
, "constexpr");
1015 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
1016 pp_maybe_space (pp
);
1018 if (! (flags
& TFF_UNQUALIFIED_NAME
)
1019 && TREE_CODE (t
) != PARM_DECL
1020 && (!DECL_INITIAL (t
)
1021 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
1022 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1023 flags
&= ~TFF_UNQUALIFIED_NAME
;
1024 if ((flags
& TFF_DECL_SPECIFIERS
)
1025 && DECL_TEMPLATE_PARM_P (t
)
1026 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
1027 pp_string (pp
, "...");
1030 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
1033 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
1034 pp_string (pp
, " capture>");
1037 dump_decl (pp
, DECL_NAME (t
), flags
);
1039 else if (DECL_DECOMPOSITION_P (t
))
1040 pp_string (pp
, M_("<structured bindings>"));
1042 pp_string (pp
, M_("<anonymous>"));
1043 if (flags
& TFF_DECL_SPECIFIERS
)
1044 dump_type_suffix (pp
, type
, flags
);
1047 /* Print an IDENTIFIER_NODE that is the name of a declaration. */
1050 dump_decl_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1052 /* These special cases are duplicated here so that other functions
1053 can feed identifiers to error and get them demangled properly. */
1054 if (IDENTIFIER_CONV_OP_P (t
))
1056 pp_cxx_ws_string (pp
, "operator");
1057 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1058 dump_type (pp
, TREE_TYPE (t
), flags
);
1061 if (dguide_name_p (t
))
1063 dump_decl (pp
, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t
)),
1064 TFF_UNQUALIFIED_NAME
);
1068 const char *str
= IDENTIFIER_POINTER (t
);
1069 if (!strncmp (str
, "_ZGR", 3))
1071 pp_cxx_ws_string (pp
, "<temporary>");
1075 pp_cxx_tree_identifier (pp
, t
);
1078 /* Dump a human readable string for the decl T under control of FLAGS. */
1081 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1086 /* If doing Objective-C++, give Objective-C a chance to demangle
1087 Objective-C method names. */
1088 if (c_dialect_objc ())
1090 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1093 pp_string (pp
, demangled
);
1098 switch (TREE_CODE (t
))
1101 /* Don't say 'typedef class A' */
1102 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1104 if ((flags
& TFF_DECL_SPECIFIERS
)
1105 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1107 /* Say `class T' not just `T'. */
1108 pp_cxx_ws_string (pp
, "class");
1110 /* Emit the `...' for a parameter pack. */
1111 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1112 pp_cxx_ws_string (pp
, "...");
1115 dump_type (pp
, TREE_TYPE (t
), flags
);
1118 if (TYPE_DECL_ALIAS_P (t
)
1119 && (flags
& TFF_DECL_SPECIFIERS
1120 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1122 pp_cxx_ws_string (pp
, "using");
1123 dump_decl (pp
, DECL_NAME (t
), flags
);
1124 pp_cxx_whitespace (pp
);
1125 pp_cxx_ws_string (pp
, "=");
1126 pp_cxx_whitespace (pp
);
1127 dump_type (pp
, (DECL_ORIGINAL_TYPE (t
)
1128 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
)),
1132 if ((flags
& TFF_DECL_SPECIFIERS
)
1133 && !DECL_SELF_REFERENCE_P (t
))
1134 pp_cxx_ws_string (pp
, "typedef");
1135 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1136 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1141 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1143 pp_string (pp
, M_("vtable for "));
1144 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1145 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1151 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1153 /* Handle variable template specializations. */
1155 && DECL_LANG_SPECIFIC (t
)
1156 && DECL_TEMPLATE_INFO (t
)
1157 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1159 pp_cxx_begin_template_argument_list (pp
);
1160 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1161 dump_template_argument_list (pp
, args
, flags
);
1162 pp_cxx_end_template_argument_list (pp
);
1167 pp_string (pp
, M_("<return value> "));
1168 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1171 case NAMESPACE_DECL
:
1172 if (flags
& TFF_DECL_SPECIFIERS
)
1173 pp
->declaration (t
);
1176 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1177 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1178 flags
&= ~TFF_UNQUALIFIED_NAME
;
1179 if (DECL_NAME (t
) == NULL_TREE
)
1181 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1182 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1184 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1187 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1192 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1193 pp_cxx_colon_colon (pp
);
1194 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1198 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1199 pp_cxx_left_bracket (pp
);
1200 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1201 pp_cxx_right_bracket (pp
);
1204 /* So that we can do dump_decl on an aggr type. */
1208 dump_type (pp
, t
, flags
);
1212 /* This is a pseudo destructor call which has not been folded into
1213 a PSEUDO_DTOR_EXPR yet. */
1214 pp_cxx_complement (pp
);
1215 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1222 case IDENTIFIER_NODE
:
1223 dump_decl_name (pp
, t
, flags
);
1227 if (!OVL_SINGLE_P (t
))
1229 tree ctx
= ovl_scope (t
);
1230 if (ctx
!= global_namespace
)
1233 dump_type (pp
, ctx
, flags
);
1235 dump_decl (pp
, ctx
, flags
);
1236 pp_cxx_colon_colon (pp
);
1238 dump_decl (pp
, OVL_NAME (t
), flags
);
1242 /* If there's only one function, just treat it like an ordinary
1248 if (! DECL_LANG_SPECIFIC (t
))
1250 if (DECL_ABSTRACT_ORIGIN (t
)
1251 && DECL_ABSTRACT_ORIGIN (t
) != t
)
1252 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1254 dump_function_name (pp
, t
, flags
);
1256 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1257 dump_global_iord (pp
, t
);
1259 dump_function_decl (pp
, t
, flags
);
1263 dump_template_decl (pp
, t
, flags
);
1266 case TEMPLATE_ID_EXPR
:
1268 tree name
= TREE_OPERAND (t
, 0);
1269 tree args
= TREE_OPERAND (t
, 1);
1271 if (!identifier_p (name
))
1272 name
= OVL_NAME (name
);
1273 dump_decl (pp
, name
, flags
);
1274 pp_cxx_begin_template_argument_list (pp
);
1275 if (args
== error_mark_node
)
1276 pp_string (pp
, M_("<template arguments error>"));
1278 dump_template_argument_list
1279 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1280 pp_cxx_end_template_argument_list (pp
);
1285 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1289 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1290 || (DECL_INITIAL (t
) &&
1291 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1292 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1293 else if (DECL_NAME (t
))
1294 dump_decl (pp
, DECL_NAME (t
), flags
);
1295 else if (DECL_INITIAL (t
))
1296 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1298 pp_string (pp
, M_("<enumerator>"));
1303 pp_cxx_ws_string (pp
, "using");
1304 tree scope
= USING_DECL_SCOPE (t
);
1305 bool variadic
= false;
1306 if (PACK_EXPANSION_P (scope
))
1308 scope
= PACK_EXPANSION_PATTERN (scope
);
1311 dump_type (pp
, scope
, flags
);
1312 pp_cxx_colon_colon (pp
);
1313 dump_decl (pp
, DECL_NAME (t
), flags
);
1315 pp_cxx_ws_string (pp
, "...");
1320 pp
->declaration (t
);
1324 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1327 case NON_DEPENDENT_EXPR
:
1328 dump_expr (pp
, t
, flags
);
1331 case TEMPLATE_TYPE_PARM
:
1332 if (flags
& TFF_DECL_SPECIFIERS
)
1333 pp
->declaration (t
);
1338 case UNBOUND_CLASS_TEMPLATE
:
1339 case TYPE_PACK_EXPANSION
:
1341 dump_type (pp
, t
, flags
);
1345 pp_unsupported_tree (pp
, t
);
1349 pp_string (pp
, M_("<declaration error>"));
1354 /* Dump a template declaration T under control of FLAGS. This means the
1355 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1358 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1360 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1364 if (flags
& TFF_TEMPLATE_HEADER
)
1366 for (parms
= orig_parms
= nreverse (orig_parms
);
1368 parms
= TREE_CHAIN (parms
))
1370 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1371 int len
= TREE_VEC_LENGTH (inner_parms
);
1375 /* Skip over the dummy template levels of a template template
1377 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1381 pp_cxx_ws_string (pp
, "template");
1382 pp_cxx_begin_template_argument_list (pp
);
1384 /* If we've shown the template prefix, we'd better show the
1385 parameters' and decl's type too. */
1386 flags
|= TFF_DECL_SPECIFIERS
;
1388 for (i
= 0; i
< len
; i
++)
1391 pp_separate_with_comma (pp
);
1392 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1395 pp_cxx_end_template_argument_list (pp
);
1396 pp_cxx_whitespace (pp
);
1398 nreverse(orig_parms
);
1400 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1402 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1403 pp_cxx_ws_string (pp
, "class");
1405 /* If this is a parameter pack, print the ellipsis. */
1406 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1407 pp_cxx_ws_string (pp
, "...");
1410 /* Only print the requirements if we're also printing
1411 the template header. */
1413 if (tree ci
= get_constraints (t
))
1414 if (check_constraint_info (ci
))
1415 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1417 pp_cxx_requires_clause (pp
, reqs
);
1418 pp_cxx_whitespace (pp
);
1423 if (DECL_CLASS_TEMPLATE_P (t
))
1424 dump_type (pp
, TREE_TYPE (t
),
1425 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1426 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1427 else if (DECL_TEMPLATE_RESULT (t
)
1428 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1429 /* Alias template. */
1430 || DECL_TYPE_TEMPLATE_P (t
)))
1431 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1434 gcc_assert (TREE_TYPE (t
));
1435 switch (NEXT_CODE (t
))
1439 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1442 /* This case can occur with some invalid code. */
1443 dump_type (pp
, TREE_TYPE (t
),
1444 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1445 | (flags
& TFF_DECL_SPECIFIERS
1446 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1451 /* find_typenames looks through the type of the function template T
1452 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1455 struct find_typenames_t
1457 hash_set
<tree
> *p_set
;
1458 vec
<tree
, va_gc
> *typenames
;
1462 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1464 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1465 tree mv
= NULL_TREE
;
1467 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1468 /* Add the type of the typedef without any additional cv-quals. */
1469 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1470 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1471 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1472 /* Add the typename without any cv-qualifiers. */
1473 mv
= TYPE_MAIN_VARIANT (*tp
);
1475 if (PACK_EXPANSION_P (*tp
))
1477 /* Don't mess with parameter packs since we don't remember
1478 the pack expansion context for a particular typename. */
1479 *walk_subtrees
= false;
1483 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1484 vec_safe_push (d
->typenames
, mv
);
1486 /* Search into class template arguments, which cp_walk_subtrees
1488 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1489 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1495 static vec
<tree
, va_gc
> *
1496 find_typenames (tree t
)
1498 struct find_typenames_t ft
;
1499 ft
.p_set
= new hash_set
<tree
>;
1500 ft
.typenames
= NULL
;
1501 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1502 find_typenames_r
, &ft
, ft
.p_set
);
1504 return ft
.typenames
;
1507 /* Output the "[with ...]" clause for a template instantiation T iff
1508 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1509 formatting a deduction/substitution diagnostic rather than an
1513 dump_substitution (cxx_pretty_printer
*pp
,
1514 tree t
, tree template_parms
, tree template_args
,
1517 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1518 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1520 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1521 pp_cxx_whitespace (pp
);
1522 pp_cxx_left_bracket (pp
);
1523 pp
->translate_string ("with");
1524 pp_cxx_whitespace (pp
);
1525 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1526 pp_cxx_right_bracket (pp
);
1530 /* Dump the lambda function FN including its 'mutable' qualifier and any
1531 template bindings. */
1534 dump_lambda_function (cxx_pretty_printer
*pp
,
1535 tree fn
, tree template_parms
, tree template_args
,
1538 /* A lambda's signature is essentially its "type". */
1539 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1540 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1542 pp
->padding
= pp_before
;
1543 pp_c_ws_string (pp
, "mutable");
1545 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1548 /* Pretty print a function decl. There are several ways we want to print a
1549 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1550 As error can only apply the '#' flag once to give 0 and 1 for V, there
1551 is %D which doesn't print the throw specs, and %F which does. */
1554 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1558 tree cname
= NULL_TREE
;
1559 tree template_args
= NULL_TREE
;
1560 tree template_parms
= NULL_TREE
;
1561 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1562 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1565 tree ret
= NULL_TREE
;
1567 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1568 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1569 t
= DECL_TEMPLATE_RESULT (t
);
1571 /* Save the exceptions, in case t is a specialization and we are
1572 emitting an error about incompatible specifications. */
1573 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1575 /* Likewise for the constexpr specifier, in case t is a specialization. */
1576 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1578 /* Pretty print template instantiations only. */
1579 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1580 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1581 && flag_pretty_templates
)
1585 template_args
= DECL_TI_ARGS (t
);
1586 tmpl
= most_general_template (t
);
1587 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1589 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1594 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1595 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1597 fntype
= TREE_TYPE (t
);
1598 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1600 if (DECL_CLASS_SCOPE_P (t
))
1601 cname
= DECL_CONTEXT (t
);
1602 /* This is for partially instantiated template methods. */
1603 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1604 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1606 if (flags
& TFF_DECL_SPECIFIERS
)
1608 if (DECL_STATIC_FUNCTION_P (t
))
1609 pp_cxx_ws_string (pp
, "static");
1610 else if (DECL_VIRTUAL_P (t
))
1611 pp_cxx_ws_string (pp
, "virtual");
1615 if (DECL_DECLARED_CONCEPT_P (t
))
1616 pp_cxx_ws_string (pp
, "concept");
1618 pp_cxx_ws_string (pp
, "constexpr");
1622 /* Print the return type? */
1624 show_return
= (!DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1625 && !DECL_DESTRUCTOR_P (t
) && !deduction_guide_p (t
));
1628 ret
= fndecl_declared_return_type (t
);
1629 dump_type_prefix (pp
, ret
, flags
);
1632 /* Print the function name. */
1633 if (!do_outer_scope
)
1637 dump_type (pp
, cname
, flags
);
1638 pp_cxx_colon_colon (pp
);
1641 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1643 dump_function_name (pp
, t
, flags
);
1645 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1647 dump_parameters (pp
, parmtypes
, flags
);
1649 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1651 pp
->padding
= pp_before
;
1652 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1653 dump_ref_qualifier (pp
, fntype
, flags
);
1656 if (tx_safe_fn_type_p (fntype
))
1658 pp
->padding
= pp_before
;
1659 pp_cxx_ws_string (pp
, "transaction_safe");
1662 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1664 pp
->padding
= pp_before
;
1665 dump_exception_spec (pp
, exceptions
, flags
);
1669 dump_type_suffix (pp
, ret
, flags
);
1670 else if (deduction_guide_p (t
))
1672 pp_cxx_ws_string (pp
, "->");
1673 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1677 if (tree ci
= get_constraints (t
))
1678 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1679 pp_cxx_requires_clause (pp
, reqs
);
1681 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1683 if (tree base
= DECL_INHERITED_CTOR_BASE (t
))
1685 pp_cxx_ws_string (pp
, "[inherited from");
1686 dump_type (pp
, base
, TFF_PLAIN_IDENTIFIER
);
1687 pp_character (pp
, ']');
1690 else if (template_args
)
1692 bool need_comma
= false;
1694 pp_cxx_begin_template_argument_list (pp
);
1695 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1696 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1698 tree arg
= TREE_VEC_ELT (template_args
, i
);
1700 pp_separate_with_comma (pp
);
1701 if (ARGUMENT_PACK_P (arg
))
1702 pp_cxx_left_brace (pp
);
1703 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1704 if (ARGUMENT_PACK_P (arg
))
1705 pp_cxx_right_brace (pp
);
1708 pp_cxx_end_template_argument_list (pp
);
1712 /* Print a parameter list. If this is for a member function, the
1713 member object ptr (and any other hidden args) should have
1714 already been removed. */
1717 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1720 flags
&= ~TFF_SCOPE
;
1721 pp_cxx_left_paren (pp
);
1723 for (first
= 1; parmtypes
!= void_list_node
;
1724 parmtypes
= TREE_CHAIN (parmtypes
))
1727 pp_separate_with_comma (pp
);
1731 pp_cxx_ws_string (pp
, "...");
1735 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1737 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1739 pp_cxx_whitespace (pp
);
1741 pp_cxx_whitespace (pp
);
1742 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1746 pp_cxx_right_paren (pp
);
1749 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1752 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1754 if (FUNCTION_REF_QUALIFIED (t
))
1756 pp
->padding
= pp_before
;
1757 if (FUNCTION_RVALUE_QUALIFIED (t
))
1758 pp_cxx_ws_string (pp
, "&&");
1760 pp_cxx_ws_string (pp
, "&");
1764 /* Print an exception specification. T is the exception specification. */
1767 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1769 if (t
&& TREE_PURPOSE (t
))
1771 pp_cxx_ws_string (pp
, "noexcept");
1772 if (!integer_onep (TREE_PURPOSE (t
)))
1774 pp_cxx_whitespace (pp
);
1775 pp_cxx_left_paren (pp
);
1776 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1777 pp_cxx_ws_string (pp
, "<uninstantiated>");
1779 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1780 pp_cxx_right_paren (pp
);
1785 pp_cxx_ws_string (pp
, "throw");
1786 pp_cxx_whitespace (pp
);
1787 pp_cxx_left_paren (pp
);
1788 if (TREE_VALUE (t
) != NULL_TREE
)
1791 dump_type (pp
, TREE_VALUE (t
), flags
);
1795 pp_separate_with_comma (pp
);
1797 pp_cxx_right_paren (pp
);
1801 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1802 and destructors properly. */
1805 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1807 tree name
= DECL_NAME (t
);
1809 /* We can get here with a decl that was synthesized by language-
1810 independent machinery (e.g. coverage.c) in which case it won't
1811 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1812 will crash. In this case it is safe just to print out the
1814 if (!DECL_LANG_SPECIFIC (t
))
1816 pp_cxx_tree_identifier (pp
, name
);
1820 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1821 t
= DECL_TEMPLATE_RESULT (t
);
1823 /* Don't let the user see __comp_ctor et al. */
1824 if (DECL_CONSTRUCTOR_P (t
)
1825 || DECL_DESTRUCTOR_P (t
))
1827 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1828 name
= get_identifier ("<lambda>");
1829 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1830 name
= get_identifier ("<constructor>");
1832 name
= constructor_name (DECL_CONTEXT (t
));
1835 if (DECL_DESTRUCTOR_P (t
))
1837 pp_cxx_complement (pp
);
1838 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1840 else if (DECL_CONV_FN_P (t
))
1842 /* This cannot use the hack that the operator's return
1843 type is stashed off of its name because it may be
1844 used for error reporting. In the case of conflicting
1845 declarations, both will have the same name, yet
1846 the types will be different, hence the TREE_TYPE field
1847 of the first name will be clobbered by the second. */
1848 pp_cxx_ws_string (pp
, "operator");
1849 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1852 dump_decl (pp
, name
, flags
);
1854 if (DECL_TEMPLATE_INFO (t
)
1855 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1856 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1857 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1858 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1862 /* Dump the template parameters from the template info INFO under control of
1863 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1864 specialization (partial or complete). For partial specializations we show
1865 the specialized parameter values. For a primary template we show no
1869 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1870 int primary
, int flags
)
1872 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1874 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1876 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1877 pp_cxx_begin_template_argument_list (pp
);
1879 /* Be careful only to print things when we have them, so as not
1880 to crash producing error messages. */
1881 if (args
&& !primary
)
1884 len
= get_non_default_template_args_count (args
, flags
);
1886 args
= INNERMOST_TEMPLATE_ARGS (args
);
1887 for (ix
= 0; ix
!= len
; ix
++)
1889 tree arg
= TREE_VEC_ELT (args
, ix
);
1891 /* Only print a comma if we know there is an argument coming. In
1892 the case of an empty template argument pack, no actual
1893 argument will be printed. */
1895 && (!ARGUMENT_PACK_P (arg
)
1896 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1897 pp_separate_with_comma (pp
);
1900 pp_string (pp
, M_("<template parameter error>"));
1902 dump_template_argument (pp
, arg
, flags
);
1907 tree tpl
= TI_TEMPLATE (info
);
1908 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1911 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1912 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1914 for (ix
= 0; ix
!= len
; ix
++)
1918 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1920 pp_string (pp
, M_("<template parameter error>"));
1924 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1927 pp_separate_with_comma (pp
);
1929 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1932 pp_cxx_end_template_argument_list (pp
);
1935 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1936 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1939 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1942 call_expr_arg_iterator iter
;
1944 pp_cxx_left_paren (pp
);
1945 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1951 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1952 if (more_call_expr_args_p (&iter
))
1953 pp_separate_with_comma (pp
);
1956 pp_cxx_right_paren (pp
);
1959 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1960 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1964 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1968 aggr_init_expr_arg_iterator iter
;
1970 pp_cxx_left_paren (pp
);
1971 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1977 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1978 if (more_aggr_init_expr_args_p (&iter
))
1979 pp_separate_with_comma (pp
);
1982 pp_cxx_right_paren (pp
);
1985 /* Print out a list of initializers (subr of dump_expr). */
1988 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1992 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1995 pp_separate_with_comma (pp
);
1999 /* Print out a vector of initializers (subr of dump_expr). */
2002 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
2005 unsigned HOST_WIDE_INT idx
;
2008 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
2010 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
2011 if (idx
!= v
->length () - 1)
2012 pp_separate_with_comma (pp
);
2017 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
2018 function. Resolve it to a close relative -- in the sense of static
2019 type -- variant being overridden. That is close to what was written in
2020 the source code. Subroutine of dump_expr. */
2023 resolve_virtual_fun_from_obj_type_ref (tree ref
)
2025 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
2026 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
2027 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
2030 fun
= TREE_CHAIN (fun
);
2031 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
2032 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
2038 /* Print out an expression E under control of FLAGS. */
2041 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
2048 if (STATEMENT_CLASS_P (t
))
2050 pp_cxx_ws_string (pp
, M_("<statement>"));
2054 switch (TREE_CODE (t
))
2062 case NAMESPACE_DECL
:
2066 case IDENTIFIER_NODE
:
2067 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
2068 |TFF_TEMPLATE_HEADER
))
2069 | TFF_NO_TEMPLATE_BINDINGS
2070 | TFF_NO_FUNCTION_ARGUMENTS
));
2074 if (SSA_NAME_VAR (t
)
2075 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
2076 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2078 pp_cxx_ws_string (pp
, M_("<unknown>"));
2089 case USERDEF_LITERAL
:
2090 pp_cxx_userdef_literal (pp
, t
);
2094 /* While waiting for caret diagnostics, avoid printing
2095 __cxa_allocate_exception, __cxa_throw, and the like. */
2096 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2101 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2102 pp_cxx_colon_colon (pp
);
2103 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2107 pp_cxx_left_paren (pp
);
2108 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2109 pp_separate_with_comma (pp
);
2110 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2111 pp_cxx_right_paren (pp
);
2116 pp_cxx_left_paren (pp
);
2117 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2118 pp_string (pp
, " ? ");
2119 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2120 pp_string (pp
, " : ");
2121 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2122 pp_cxx_right_paren (pp
);
2126 if (TREE_HAS_CONSTRUCTOR (t
))
2128 pp_cxx_ws_string (pp
, "new");
2129 pp_cxx_whitespace (pp
);
2130 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2133 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2136 case AGGR_INIT_EXPR
:
2138 tree fn
= NULL_TREE
;
2140 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2141 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2143 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2145 if (DECL_CONSTRUCTOR_P (fn
))
2146 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2148 dump_decl (pp
, fn
, 0);
2151 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2153 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2158 tree fn
= CALL_EXPR_FN (t
);
2159 bool skipfirst
= false;
2161 /* Deal with internal functions. */
2162 if (fn
== NULL_TREE
)
2164 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2165 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2169 if (TREE_CODE (fn
) == ADDR_EXPR
)
2170 fn
= TREE_OPERAND (fn
, 0);
2172 /* Nobody is interested in seeing the guts of vcalls. */
2173 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2174 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2176 if (TREE_TYPE (fn
) != NULL_TREE
2177 && NEXT_CODE (fn
) == METHOD_TYPE
2178 && call_expr_nargs (t
))
2180 tree ob
= CALL_EXPR_ARG (t
, 0);
2181 if (TREE_CODE (ob
) == ADDR_EXPR
)
2183 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2184 flags
| TFF_EXPR_IN_PARENS
);
2187 else if (!is_this_parameter (ob
))
2189 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2194 if (flag_sanitize
& SANITIZE_UNDEFINED
2195 && is_ubsan_builtin_p (fn
))
2197 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2200 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2201 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2206 /* Note that this only works for G++ target exprs. If somebody
2207 builds a general TARGET_EXPR, there's no way to represent that
2208 it initializes anything other that the parameter slot for the
2209 default argument. Note we may have cleared out the first
2210 operand in expand_expr, so don't go killing ourselves. */
2211 if (TREE_OPERAND (t
, 1))
2212 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2215 case POINTER_PLUS_EXPR
:
2216 dump_binary_op (pp
, "+", t
, flags
);
2219 case POINTER_DIFF_EXPR
:
2220 dump_binary_op (pp
, "-", t
, flags
);
2225 dump_binary_op (pp
, OVL_OP_INFO (true, NOP_EXPR
)->name
, t
, flags
);
2231 case TRUNC_DIV_EXPR
:
2232 case TRUNC_MOD_EXPR
:
2240 case TRUTH_ANDIF_EXPR
:
2241 case TRUTH_ORIF_EXPR
:
2248 case EXACT_DIV_EXPR
:
2249 dump_binary_op (pp
, OVL_OP_INFO (false, TREE_CODE (t
))->name
, t
, flags
);
2253 case FLOOR_DIV_EXPR
:
2254 case ROUND_DIV_EXPR
:
2256 dump_binary_op (pp
, "/", t
, flags
);
2260 case FLOOR_MOD_EXPR
:
2261 case ROUND_MOD_EXPR
:
2262 dump_binary_op (pp
, "%", t
, flags
);
2267 tree ob
= TREE_OPERAND (t
, 0);
2268 if (INDIRECT_REF_P (ob
))
2270 ob
= TREE_OPERAND (ob
, 0);
2271 if (!is_this_parameter (ob
))
2273 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2274 if (TYPE_REF_P (TREE_TYPE (ob
)))
2282 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2283 if (TREE_CODE (ob
) != ARROW_EXPR
)
2286 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2291 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2292 pp_cxx_left_bracket (pp
);
2293 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2294 pp_cxx_right_bracket (pp
);
2297 case UNARY_PLUS_EXPR
:
2298 dump_unary_op (pp
, "+", t
, flags
);
2302 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2303 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2304 /* An ADDR_EXPR can have reference type. In that case, we
2305 shouldn't print the `&' doing so indicates to the user
2306 that the expression has pointer type. */
2308 && TYPE_REF_P (TREE_TYPE (t
))))
2309 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2310 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2311 dump_unary_op (pp
, "&&", t
, flags
);
2313 dump_unary_op (pp
, "&", t
, flags
);
2317 if (TREE_HAS_CONSTRUCTOR (t
))
2319 t
= TREE_OPERAND (t
, 0);
2320 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2321 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2322 dump_call_expr_args (pp
, t
, flags
, true);
2326 if (TREE_OPERAND (t
,0) != NULL_TREE
2327 && TREE_TYPE (TREE_OPERAND (t
, 0))
2328 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2329 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2331 dump_unary_op (pp
, "*", t
, flags
);
2336 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2337 && integer_zerop (TREE_OPERAND (t
, 1)))
2338 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2342 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2344 pp_cxx_left_paren (pp
);
2345 if (!integer_onep (TYPE_SIZE_UNIT
2346 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2348 pp_cxx_left_paren (pp
);
2349 dump_type (pp
, ptr_type_node
, flags
);
2350 pp_cxx_right_paren (pp
);
2353 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2354 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2356 pp_cxx_ws_string (pp
, "+");
2357 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2359 pp_cxx_right_paren (pp
);
2366 case TRUTH_NOT_EXPR
:
2367 case PREDECREMENT_EXPR
:
2368 case PREINCREMENT_EXPR
:
2369 dump_unary_op (pp
, OVL_OP_INFO (false, TREE_CODE (t
))->name
, t
, flags
);
2372 case POSTDECREMENT_EXPR
:
2373 case POSTINCREMENT_EXPR
:
2374 pp_cxx_left_paren (pp
);
2375 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2376 pp_cxx_ws_string (pp
, OVL_OP_INFO (false, TREE_CODE (t
))->name
);
2377 pp_cxx_right_paren (pp
);
2380 case NON_LVALUE_EXPR
:
2381 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2382 should be another level of INDIRECT_REF so that I don't have to do
2384 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2386 tree next
= TREE_TYPE (TREE_TYPE (t
));
2388 while (TYPE_PTR_P (next
))
2389 next
= TREE_TYPE (next
);
2391 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2393 if (flags
& TFF_EXPR_IN_PARENS
)
2394 pp_cxx_left_paren (pp
);
2396 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2397 if (flags
& TFF_EXPR_IN_PARENS
)
2398 pp_cxx_right_paren (pp
);
2401 /* Else fall through. */
2403 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2407 case IMPLICIT_CONV_EXPR
:
2408 case VIEW_CONVERT_EXPR
:
2410 tree op
= TREE_OPERAND (t
, 0);
2411 tree ttype
= TREE_TYPE (t
);
2412 tree optype
= TREE_TYPE (op
);
2414 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2415 && INDIRECT_TYPE_P (ttype
)
2416 && INDIRECT_TYPE_P (optype
)
2417 && same_type_p (TREE_TYPE (optype
),
2420 if (TYPE_REF_P (ttype
))
2423 if (TREE_CODE (op
) == ADDR_EXPR
)
2424 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2426 dump_unary_op (pp
, "*", t
, flags
);
2429 dump_unary_op (pp
, "&", t
, flags
);
2431 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2433 /* It is a cast, but we cannot tell whether it is a
2434 reinterpret or static cast. Use the C style notation. */
2435 if (flags
& TFF_EXPR_IN_PARENS
)
2436 pp_cxx_left_paren (pp
);
2437 pp_cxx_left_paren (pp
);
2438 dump_type (pp
, TREE_TYPE (t
), flags
);
2439 pp_cxx_right_paren (pp
);
2440 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2441 if (flags
& TFF_EXPR_IN_PARENS
)
2442 pp_cxx_right_paren (pp
);
2445 dump_expr (pp
, op
, flags
);
2450 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2452 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2454 if (integer_zerop (idx
))
2456 /* A NULL pointer-to-member constant. */
2457 pp_cxx_left_paren (pp
);
2458 pp_cxx_left_paren (pp
);
2459 dump_type (pp
, TREE_TYPE (t
), flags
);
2460 pp_cxx_right_paren (pp
);
2461 pp_character (pp
, '0');
2462 pp_cxx_right_paren (pp
);
2465 else if (tree_fits_shwi_p (idx
))
2468 unsigned HOST_WIDE_INT n
;
2470 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2471 t
= TYPE_METHOD_BASETYPE (t
);
2472 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2474 n
= tree_to_shwi (idx
);
2476 /* Map vtable index back one, to allow for the null pointer to
2480 while (n
> 0 && virtuals
)
2483 virtuals
= TREE_CHAIN (virtuals
);
2487 dump_expr (pp
, BV_FN (virtuals
),
2488 flags
| TFF_EXPR_IN_PARENS
);
2493 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2494 pp_string (pp
, "<lambda closure object>");
2495 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2497 dump_type (pp
, TREE_TYPE (t
), 0);
2498 pp_cxx_left_paren (pp
);
2499 pp_cxx_right_paren (pp
);
2503 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2504 dump_type (pp
, TREE_TYPE (t
), 0);
2505 pp_cxx_left_brace (pp
);
2506 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2507 pp_cxx_right_brace (pp
);
2514 tree ob
= TREE_OPERAND (t
, 0);
2515 if (is_dummy_object (ob
))
2517 t
= TREE_OPERAND (t
, 1);
2518 if (TREE_CODE (t
) == FUNCTION_DECL
)
2520 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2521 else if (BASELINK_P (t
))
2522 dump_expr (pp
, OVL_FIRST (BASELINK_FUNCTIONS (t
)),
2523 flags
| TFF_EXPR_IN_PARENS
);
2525 dump_decl (pp
, t
, flags
);
2529 if (INDIRECT_REF_P (ob
))
2531 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2537 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2541 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2546 case TEMPLATE_PARM_INDEX
:
2547 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2551 if (TREE_OPERAND (t
, 0) == NULL_TREE
2552 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2554 dump_type (pp
, TREE_TYPE (t
), flags
);
2555 pp_cxx_left_paren (pp
);
2556 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2557 pp_cxx_right_paren (pp
);
2561 pp_cxx_left_paren (pp
);
2562 dump_type (pp
, TREE_TYPE (t
), flags
);
2563 pp_cxx_right_paren (pp
);
2564 pp_cxx_left_paren (pp
);
2565 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2566 pp_cxx_right_paren (pp
);
2570 case STATIC_CAST_EXPR
:
2571 pp_cxx_ws_string (pp
, "static_cast");
2573 case REINTERPRET_CAST_EXPR
:
2574 pp_cxx_ws_string (pp
, "reinterpret_cast");
2576 case CONST_CAST_EXPR
:
2577 pp_cxx_ws_string (pp
, "const_cast");
2579 case DYNAMIC_CAST_EXPR
:
2580 pp_cxx_ws_string (pp
, "dynamic_cast");
2582 pp_cxx_begin_template_argument_list (pp
);
2583 dump_type (pp
, TREE_TYPE (t
), flags
);
2584 pp_cxx_end_template_argument_list (pp
);
2585 pp_cxx_left_paren (pp
);
2586 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2587 pp_cxx_right_paren (pp
);
2591 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2597 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2598 pp_cxx_ws_string (pp
, "sizeof");
2601 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2602 pp_cxx_ws_string (pp
, "__alignof__");
2604 op
= TREE_OPERAND (t
, 0);
2605 if (PACK_EXPANSION_P (op
))
2607 pp_string (pp
, "...");
2608 op
= PACK_EXPANSION_PATTERN (op
);
2610 pp_cxx_whitespace (pp
);
2611 pp_cxx_left_paren (pp
);
2612 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2613 dump_type (pp
, TREE_TYPE (op
), flags
);
2614 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2615 dump_type (pp
, op
, flags
);
2617 dump_expr (pp
, op
, flags
);
2618 pp_cxx_right_paren (pp
);
2621 case AT_ENCODE_EXPR
:
2622 pp_cxx_ws_string (pp
, "@encode");
2623 pp_cxx_whitespace (pp
);
2624 pp_cxx_left_paren (pp
);
2625 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2626 pp_cxx_right_paren (pp
);
2630 pp_cxx_ws_string (pp
, "noexcept");
2631 pp_cxx_whitespace (pp
);
2632 pp_cxx_left_paren (pp
);
2633 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2634 pp_cxx_right_paren (pp
);
2639 pp_cxx_ws_string (pp
, OVL_OP_INFO (false, TREE_CODE (t
))->name
);
2640 pp_cxx_whitespace (pp
);
2641 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2645 pp_string (pp
, M_("<unparsed>"));
2648 case TRY_CATCH_EXPR
:
2649 case CLEANUP_POINT_EXPR
:
2650 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2653 case PSEUDO_DTOR_EXPR
:
2654 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2656 if (TREE_OPERAND (t
, 1))
2658 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2659 pp_cxx_colon_colon (pp
);
2661 pp_cxx_complement (pp
);
2662 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2665 case TEMPLATE_ID_EXPR
:
2666 dump_decl (pp
, t
, flags
);
2672 case STATEMENT_LIST
:
2673 /* We don't yet have a way of dumping statements in a
2674 human-readable format. */
2675 pp_string (pp
, "({...})");
2679 pp_string (pp
, "while (1) { ");
2680 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2681 pp_cxx_right_brace (pp
);
2685 pp_string (pp
, "if (");
2686 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2687 pp_string (pp
, ") break; ");
2691 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2694 case EMPTY_CLASS_EXPR
:
2695 dump_type (pp
, TREE_TYPE (t
), flags
);
2696 pp_cxx_left_paren (pp
);
2697 pp_cxx_right_paren (pp
);
2700 case NON_DEPENDENT_EXPR
:
2701 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2704 case ARGUMENT_PACK_SELECT
:
2705 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2718 pp_type_specifier_seq (pp
, t
);
2722 /* We get here when we want to print a dependent type as an
2723 id-expression, without any disambiguator decoration. */
2724 pp
->id_expression (t
);
2727 case TEMPLATE_TYPE_PARM
:
2728 case TEMPLATE_TEMPLATE_PARM
:
2729 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2730 dump_type (pp
, t
, flags
);
2734 pp_cxx_trait_expression (pp
, t
);
2738 pp_cxx_va_arg_expression (pp
, t
);
2742 pp_cxx_offsetof_expression (pp
, t
);
2745 case ADDRESSOF_EXPR
:
2746 pp_cxx_addressof_expression (pp
, t
);
2750 dump_decl (pp
, t
, flags
);
2753 case EXPR_PACK_EXPANSION
:
2754 case UNARY_LEFT_FOLD_EXPR
:
2755 case UNARY_RIGHT_FOLD_EXPR
:
2756 case BINARY_LEFT_FOLD_EXPR
:
2757 case BINARY_RIGHT_FOLD_EXPR
:
2764 case VEC_DELETE_EXPR
:
2771 case UNORDERED_EXPR
:
2781 case FIX_TRUNC_EXPR
:
2786 case TRUTH_AND_EXPR
:
2788 case TRUTH_XOR_EXPR
:
2789 if (flags
& TFF_EXPR_IN_PARENS
)
2790 pp_cxx_left_paren (pp
);
2792 if (flags
& TFF_EXPR_IN_PARENS
)
2793 pp_cxx_right_paren (pp
);
2797 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2801 pp_string (pp
, M_("<lambda>"));
2805 pp_cxx_left_paren (pp
);
2806 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2807 pp_cxx_right_paren (pp
);
2811 pp_cxx_requires_expr (cxx_pp
, t
);
2815 pp_cxx_simple_requirement (cxx_pp
, t
);
2819 pp_cxx_type_requirement (cxx_pp
, t
);
2823 pp_cxx_compound_requirement (cxx_pp
, t
);
2827 pp_cxx_nested_requirement (cxx_pp
, t
);
2840 pp_cxx_constraint (cxx_pp
, t
);
2843 case PLACEHOLDER_EXPR
:
2844 pp_string (pp
, M_("*this"));
2848 dump_expr_list (pp
, t
, flags
);
2851 /* This list is incomplete, but should suffice for now.
2852 It is very important that `sorry' does not call
2853 `report_error_function'. That could cause an infinite loop. */
2855 pp_unsupported_tree (pp
, t
);
2858 pp_string (pp
, M_("<expression error>"));
2864 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2867 pp_cxx_left_paren (pp
);
2868 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2869 pp_cxx_whitespace (pp
);
2871 pp_cxx_ws_string (pp
, opstring
);
2873 pp_string (pp
, M_("<unknown operator>"));
2874 pp_cxx_whitespace (pp
);
2875 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2876 pp_cxx_right_paren (pp
);
2880 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2882 if (flags
& TFF_EXPR_IN_PARENS
)
2883 pp_cxx_left_paren (pp
);
2884 pp_cxx_ws_string (pp
, opstring
);
2885 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2886 if (flags
& TFF_EXPR_IN_PARENS
)
2887 pp_cxx_right_paren (pp
);
2891 reinit_cxx_pp (void)
2893 pp_clear_output_area (cxx_pp
);
2894 cxx_pp
->padding
= pp_none
;
2895 pp_indentation (cxx_pp
) = 0;
2896 pp_needs_newline (cxx_pp
) = false;
2897 cxx_pp
->enclosing_scope
= current_function_decl
;
2900 /* Same as pp_formatted_text, except the return string is a separate
2901 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2904 pp_ggc_formatted_text (pretty_printer
*pp
)
2906 return ggc_strdup (pp_formatted_text (pp
));
2909 /* Exported interface to stringifying types, exprs and decls under TFF_*
2913 type_as_string (tree typ
, int flags
)
2916 pp_translate_identifiers (cxx_pp
) = false;
2917 dump_type (cxx_pp
, typ
, flags
);
2918 return pp_ggc_formatted_text (cxx_pp
);
2922 type_as_string_translate (tree typ
, int flags
)
2925 dump_type (cxx_pp
, typ
, flags
);
2926 return pp_ggc_formatted_text (cxx_pp
);
2930 expr_as_string (tree decl
, int flags
)
2933 pp_translate_identifiers (cxx_pp
) = false;
2934 dump_expr (cxx_pp
, decl
, flags
);
2935 return pp_ggc_formatted_text (cxx_pp
);
2938 /* Wrap decl_as_string with options appropriate for dwarf. */
2941 decl_as_dwarf_string (tree decl
, int flags
)
2944 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2945 here will be adequate to get the desired behavior. */
2946 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2947 name
= decl_as_string (decl
, flags
);
2948 /* Subsequent calls to the pretty printer shouldn't use this style. */
2949 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2954 decl_as_string (tree decl
, int flags
)
2957 pp_translate_identifiers (cxx_pp
) = false;
2958 dump_decl (cxx_pp
, decl
, flags
);
2959 return pp_ggc_formatted_text (cxx_pp
);
2963 decl_as_string_translate (tree decl
, int flags
)
2966 dump_decl (cxx_pp
, decl
, flags
);
2967 return pp_ggc_formatted_text (cxx_pp
);
2970 /* Wrap lang_decl_name with options appropriate for dwarf. */
2973 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2976 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2977 here will be adequate to get the desired behavior. */
2978 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2979 name
= lang_decl_name (decl
, v
, translate
);
2980 /* Subsequent calls to the pretty printer shouldn't use this style. */
2981 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2985 /* Generate the three forms of printable names for cxx_printable_name. */
2988 lang_decl_name (tree decl
, int v
, bool translate
)
2992 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2993 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2996 pp_translate_identifiers (cxx_pp
) = translate
;
2998 && (DECL_CLASS_SCOPE_P (decl
)
2999 || (DECL_NAMESPACE_SCOPE_P (decl
)
3000 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
3002 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
3003 pp_cxx_colon_colon (cxx_pp
);
3006 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3007 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
3008 else if ((DECL_NAME (decl
) == NULL_TREE
)
3009 && TREE_CODE (decl
) == NAMESPACE_DECL
)
3010 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
3012 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
3014 return pp_ggc_formatted_text (cxx_pp
);
3017 /* Return the location of a tree passed to %+ formats. */
3020 location_of (tree t
)
3024 t
= TYPE_MAIN_DECL (t
);
3026 return input_location
;
3028 else if (TREE_CODE (t
) == OVERLOAD
)
3032 return DECL_SOURCE_LOCATION (t
);
3033 if (TREE_CODE (t
) == DEFAULT_ARG
)
3034 return defarg_location (t
);
3035 return cp_expr_loc_or_loc (t
, input_location
);
3038 /* Now the interfaces from error et al to dump_type et al. Each takes an
3039 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
3043 decl_to_string (tree decl
, int verbose
)
3047 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
3048 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
3049 flags
= TFF_CLASS_KEY_OR_ENUM
;
3051 flags
|= TFF_DECL_SPECIFIERS
;
3052 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3053 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
3054 flags
|= TFF_TEMPLATE_HEADER
;
3057 dump_decl (cxx_pp
, decl
, flags
);
3058 return pp_ggc_formatted_text (cxx_pp
);
3062 expr_to_string (tree decl
)
3065 dump_expr (cxx_pp
, decl
, 0);
3066 return pp_ggc_formatted_text (cxx_pp
);
3070 fndecl_to_string (tree fndecl
, int verbose
)
3074 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
3075 | TFF_TEMPLATE_HEADER
;
3077 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3079 dump_decl (cxx_pp
, fndecl
, flags
);
3080 return pp_ggc_formatted_text (cxx_pp
);
3085 code_to_string (enum tree_code c
)
3087 return get_tree_code_name (c
);
3091 language_to_string (enum languages c
)
3098 case lang_cplusplus
:
3107 /* Return the proper printed version of a parameter to a C++ function. */
3110 parm_to_string (int p
)
3114 pp_string (cxx_pp
, "'this'");
3116 pp_decimal_int (cxx_pp
, p
+ 1);
3117 return pp_ggc_formatted_text (cxx_pp
);
3121 op_to_string (bool assop
, enum tree_code p
)
3123 tree id
= ovl_op_identifier (assop
, p
);
3124 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3127 /* Return a GC-allocated representation of type TYP, with verbosity VERBOSE.
3129 If QUOTE is non-NULL and if *QUOTE is true, then quotes are added to the
3130 string in appropriate places, and *QUOTE is written to with false
3131 to suppress pp_format's trailing close quote so that e.g.
3132 foo_typedef {aka underlying_foo} {enum}
3133 can be printed by "%qT" as:
3134 `foo_typedef' {aka `underlying_foo'} {enum}
3136 `foo_typedef {aka underlying_foo} {enum}'
3137 When adding such quotes, if POSTPROCESSED is true (for handling %H and %I)
3138 then a leading open quote will be added, whereas if POSTPROCESSED is false
3139 (for handling %T) then any leading quote has already been added by
3140 pp_format, or is not needed due to QUOTE being NULL (for template arguments
3143 SHOW_COLOR is used to determine the colorization of any quotes that
3147 type_to_string (tree typ
, int verbose
, bool postprocessed
, bool *quote
,
3152 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3153 flags
|= TFF_TEMPLATE_HEADER
;
3157 if (postprocessed
&& quote
&& *quote
)
3158 pp_begin_quote (cxx_pp
, show_color
);
3160 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3161 int type_start
, type_len
;
3162 type_start
= obstack_object_size (ob
);
3164 dump_type (cxx_pp
, typ
, flags
);
3166 /* Remember the end of the initial dump. */
3167 type_len
= obstack_object_size (ob
) - type_start
;
3169 /* If we're printing a type that involves typedefs, also print the
3170 stripped version. But sometimes the stripped version looks
3171 exactly the same, so we don't want it after all. To avoid printing
3172 it in that case, we play ugly obstack games. */
3173 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3174 && !uses_template_parms (typ
))
3176 int aka_start
, aka_len
; char *p
;
3177 tree aka
= strip_typedefs (typ
);
3178 if (quote
&& *quote
)
3179 pp_end_quote (cxx_pp
, show_color
);
3180 pp_string (cxx_pp
, " {aka");
3181 pp_cxx_whitespace (cxx_pp
);
3182 if (quote
&& *quote
)
3183 pp_begin_quote (cxx_pp
, show_color
);
3184 /* And remember the start of the aka dump. */
3185 aka_start
= obstack_object_size (ob
);
3186 dump_type (cxx_pp
, aka
, flags
);
3187 aka_len
= obstack_object_size (ob
) - aka_start
;
3188 if (quote
&& *quote
)
3189 pp_end_quote (cxx_pp
, show_color
);
3190 pp_right_brace (cxx_pp
);
3191 p
= (char*)obstack_base (ob
);
3192 /* If they are identical, cut off the aka by unwinding the obstack. */
3193 if (type_len
== aka_len
3194 && memcmp (p
+ type_start
, p
+aka_start
, type_len
) == 0)
3196 /* We can't add a '\0' here, since we may be adding a closing quote
3197 below, and it would be hidden by the '\0'.
3198 Instead, manually unwind the current object within the obstack
3199 so that the insertion point is at the end of the type, before
3201 int delta
= type_start
+ type_len
- obstack_object_size (ob
);
3202 gcc_assert (delta
<= 0);
3203 obstack_blank_fast (ob
, delta
);
3207 /* No further closing quotes are needed. */
3211 if (quote
&& *quote
)
3213 pp_end_quote (cxx_pp
, show_color
);
3216 return pp_ggc_formatted_text (cxx_pp
);
3220 args_to_string (tree p
, int verbose
)
3224 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3229 if (TYPE_P (TREE_VALUE (p
)))
3230 return type_as_string_translate (p
, flags
);
3233 for (; p
; p
= TREE_CHAIN (p
))
3235 if (null_node_p (TREE_VALUE (p
)))
3236 pp_cxx_ws_string (cxx_pp
, "NULL");
3238 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3240 pp_separate_with_comma (cxx_pp
);
3242 return pp_ggc_formatted_text (cxx_pp
);
3245 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3246 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3250 subst_to_string (tree p
)
3252 tree decl
= TREE_PURPOSE (p
);
3253 tree targs
= TREE_VALUE (p
);
3254 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3255 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3256 |TFF_NO_TEMPLATE_BINDINGS
);
3262 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3263 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3264 return pp_ggc_formatted_text (cxx_pp
);
3268 cv_to_string (tree p
, int v
)
3271 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3272 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3273 return pp_ggc_formatted_text (cxx_pp
);
3277 eh_spec_to_string (tree p
, int /*v*/)
3281 dump_exception_spec (cxx_pp
, p
, flags
);
3282 return pp_ggc_formatted_text (cxx_pp
);
3285 /* Langhook for print_error_function. */
3287 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3288 diagnostic_info
*diagnostic
)
3290 lhd_print_error_function (context
, file
, diagnostic
);
3291 pp_set_prefix (context
->printer
, file
);
3292 maybe_print_instantiation_context (context
);
3296 cp_diagnostic_starter (diagnostic_context
*context
,
3297 diagnostic_info
*diagnostic
)
3299 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3300 cp_print_error_function (context
, diagnostic
);
3301 maybe_print_instantiation_context (context
);
3302 maybe_print_constexpr_context (context
);
3303 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3307 /* Print current function onto BUFFER, in the process of reporting
3308 a diagnostic message. Called from cp_diagnostic_starter. */
3310 cp_print_error_function (diagnostic_context
*context
,
3311 diagnostic_info
*diagnostic
)
3313 /* If we are in an instantiation context, current_function_decl is likely
3314 to be wrong, so just rely on print_instantiation_full_context. */
3315 if (current_instantiation ())
3317 if (diagnostic_last_function_changed (context
, diagnostic
))
3319 const char *old_prefix
= context
->printer
->prefix
;
3320 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3321 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3322 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3323 ? file_name_as_prefix (context
, file
) : NULL
;
3325 pp_set_prefix (context
->printer
, new_prefix
);
3327 if (current_function_decl
== NULL
)
3328 pp_string (context
->printer
, _("At global scope:"));
3333 if (abstract_origin
)
3335 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3336 while (TREE_CODE (ao
) == BLOCK
3337 && BLOCK_ABSTRACT_ORIGIN (ao
)
3338 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3339 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3340 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3344 fndecl
= current_function_decl
;
3346 pp_printf (context
->printer
, function_category (fndecl
),
3347 cxx_printable_name_translate (fndecl
, 2));
3349 while (abstract_origin
)
3352 tree block
= abstract_origin
;
3354 locus
= &BLOCK_SOURCE_LOCATION (block
);
3356 block
= BLOCK_SUPERCONTEXT (block
);
3357 while (block
&& TREE_CODE (block
) == BLOCK
3358 && BLOCK_ABSTRACT_ORIGIN (block
))
3360 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3362 while (TREE_CODE (ao
) == BLOCK
3363 && BLOCK_ABSTRACT_ORIGIN (ao
)
3364 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3365 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3367 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3372 else if (TREE_CODE (ao
) != BLOCK
)
3375 block
= BLOCK_SUPERCONTEXT (block
);
3378 abstract_origin
= block
;
3381 while (block
&& TREE_CODE (block
) == BLOCK
)
3382 block
= BLOCK_SUPERCONTEXT (block
);
3384 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3386 abstract_origin
= NULL
;
3390 expanded_location s
= expand_location (*locus
);
3391 pp_character (context
->printer
, ',');
3392 pp_newline (context
->printer
);
3395 if (context
->show_column
&& s
.column
!= 0)
3396 pp_printf (context
->printer
,
3397 _(" inlined from %qs at %r%s:%d:%d%R"),
3398 cxx_printable_name_translate (fndecl
, 2),
3399 "locus", s
.file
, s
.line
, s
.column
);
3401 pp_printf (context
->printer
,
3402 _(" inlined from %qs at %r%s:%d%R"),
3403 cxx_printable_name_translate (fndecl
, 2),
3404 "locus", s
.file
, s
.line
);
3408 pp_printf (context
->printer
, _(" inlined from %qs"),
3409 cxx_printable_name_translate (fndecl
, 2));
3412 pp_character (context
->printer
, ':');
3414 pp_newline (context
->printer
);
3416 diagnostic_set_last_function (context
, diagnostic
);
3417 pp_destroy_prefix (context
->printer
);
3418 context
->printer
->prefix
= old_prefix
;
3422 /* Returns a description of FUNCTION using standard terminology. The
3423 result is a format string of the form "In CATEGORY %qs". */
3425 function_category (tree fn
)
3427 /* We can get called from the middle-end for diagnostics of function
3428 clones. Make sure we have language specific information before
3429 dereferencing it. */
3430 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3431 && DECL_FUNCTION_MEMBER_P (fn
))
3433 if (DECL_STATIC_FUNCTION_P (fn
))
3434 return _("In static member function %qs");
3435 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3436 return _("In copy constructor %qs");
3437 else if (DECL_CONSTRUCTOR_P (fn
))
3438 return _("In constructor %qs");
3439 else if (DECL_DESTRUCTOR_P (fn
))
3440 return _("In destructor %qs");
3441 else if (LAMBDA_FUNCTION_P (fn
))
3442 return _("In lambda function");
3444 return _("In member function %qs");
3447 return _("In function %qs");
3450 /* Report the full context of a current template instantiation,
3453 print_instantiation_full_context (diagnostic_context
*context
)
3455 struct tinst_level
*p
= current_instantiation ();
3456 location_t location
= input_location
;
3460 pp_verbatim (context
->printer
,
3462 ? _("%s: In substitution of %qS:\n")
3463 : _("%s: In instantiation of %q#D:\n"),
3464 LOCATION_FILE (location
),
3467 location
= p
->locus
;
3471 print_instantiation_partial_context (context
, p
, location
);
3474 /* Helper function of print_instantiation_partial_context() that
3475 prints a single line of instantiation context. */
3478 print_instantiation_partial_context_line (diagnostic_context
*context
,
3479 struct tinst_level
*t
,
3480 location_t loc
, bool recursive_p
)
3482 if (loc
== UNKNOWN_LOCATION
)
3485 expanded_location xloc
= expand_location (loc
);
3487 if (context
->show_column
)
3488 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3489 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3491 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3492 "locus", xloc
.file
, xloc
.line
);
3497 pp_verbatim (context
->printer
,
3499 ? _("recursively required by substitution of %qS\n")
3500 : _("required by substitution of %qS\n"),
3503 pp_verbatim (context
->printer
,
3505 ? _("recursively required from %q#D\n")
3506 : _("required from %q#D\n"),
3511 pp_verbatim (context
->printer
,
3513 ? _("recursively required from here\n")
3514 : _("required from here\n"));
3518 /* Same as print_instantiation_full_context but less verbose. */
3521 print_instantiation_partial_context (diagnostic_context
*context
,
3522 struct tinst_level
*t0
, location_t loc
)
3524 struct tinst_level
*t
;
3527 location_t prev_loc
= loc
;
3529 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3530 if (prev_loc
!= t
->locus
)
3532 prev_loc
= t
->locus
;
3538 if (template_backtrace_limit
3539 && n_total
> template_backtrace_limit
)
3541 int skip
= n_total
- template_backtrace_limit
;
3542 int head
= template_backtrace_limit
/ 2;
3544 /* Avoid skipping just 1. If so, skip 2. */
3548 head
= (template_backtrace_limit
- 1) / 2;
3551 for (n
= 0; n
< head
; n
++)
3553 gcc_assert (t
!= NULL
);
3554 if (loc
!= t
->locus
)
3555 print_instantiation_partial_context_line (context
, t
, loc
,
3556 /*recursive_p=*/false);
3560 if (t
!= NULL
&& skip
> 0)
3562 expanded_location xloc
;
3563 xloc
= expand_location (loc
);
3564 if (context
->show_column
)
3565 pp_verbatim (context
->printer
,
3566 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3567 "contexts, use -ftemplate-backtrace-limit=0 to "
3569 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3571 pp_verbatim (context
->printer
,
3572 _("%r%s:%d:%R [ skipping %d instantiation "
3573 "contexts, use -ftemplate-backtrace-limit=0 to "
3575 "locus", xloc
.file
, xloc
.line
, skip
);
3580 } while (t
!= NULL
&& --skip
> 0);
3586 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3591 print_instantiation_partial_context_line (context
, t
, loc
,
3596 print_instantiation_partial_context_line (context
, NULL
, loc
,
3597 /*recursive_p=*/false);
3600 /* Called from cp_thing to print the template context for an error. */
3602 maybe_print_instantiation_context (diagnostic_context
*context
)
3604 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3607 record_last_problematic_instantiation ();
3608 print_instantiation_full_context (context
);
3611 /* Report what constexpr call(s) we're trying to expand, if any. */
3614 maybe_print_constexpr_context (diagnostic_context
*context
)
3616 vec
<tree
> call_stack
= cx_error_context ();
3620 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3622 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3623 const char *s
= expr_as_string (t
, 0);
3624 if (context
->show_column
)
3625 pp_verbatim (context
->printer
,
3626 _("%r%s:%d:%d:%R in %<constexpr%> expansion of %qs"),
3627 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3629 pp_verbatim (context
->printer
,
3630 _("%r%s:%d:%R in %<constexpr%> expansion of %qs"),
3631 "locus", xloc
.file
, xloc
.line
, s
);
3632 pp_newline (context
->printer
);
3637 /* Return true iff TYPE_A and TYPE_B are template types that are
3638 meaningful to compare. */
3641 comparable_template_types_p (tree type_a
, tree type_b
)
3643 if (!CLASS_TYPE_P (type_a
))
3645 if (!CLASS_TYPE_P (type_b
))
3648 tree tinfo_a
= TYPE_TEMPLATE_INFO (type_a
);
3649 tree tinfo_b
= TYPE_TEMPLATE_INFO (type_b
);
3650 if (!tinfo_a
|| !tinfo_b
)
3653 return TI_TEMPLATE (tinfo_a
) == TI_TEMPLATE (tinfo_b
);
3656 /* Start a new line indented by SPC spaces on PP. */
3659 newline_and_indent (pretty_printer
*pp
, int spc
)
3662 for (int i
= 0; i
< spc
; i
++)
3666 /* Generate a GC-allocated string for ARG, an expression or type. */
3669 arg_to_string (tree arg
, bool verbose
)
3672 return type_to_string (arg
, verbose
, true, NULL
, false);
3674 return expr_to_string (arg
);
3677 /* Subroutine to type_to_string_with_compare and
3678 print_template_tree_comparison.
3680 Print a representation of ARG (an expression or type) to PP,
3681 colorizing it as "type-diff" if PP->show_color. */
3684 print_nonequal_arg (pretty_printer
*pp
, tree arg
, bool verbose
)
3686 pp_printf (pp
, "%r%s%R",
3689 ? arg_to_string (arg
, verbose
)
3690 : G_("(no argument)")));
3693 /* Recursively print template TYPE_A to PP, as compared to template TYPE_B.
3695 The types must satisfy comparable_template_types_p.
3697 If INDENT is 0, then this is equivalent to type_to_string (TYPE_A), but
3698 potentially colorizing/eliding in comparison with TYPE_B.
3700 For example given types:
3701 vector<map<int,double>>
3703 vector<map<int,float>>
3704 then the result on PP would be:
3705 vector<map<[...],double>>
3706 with type elision, and:
3707 vector<map<int,double>>
3708 without type elision.
3710 In both cases the parts of TYPE that differ from PEER will be colorized
3711 if pp_show_color (pp) is true. In the above example, this would be
3714 If INDENT is non-zero, then the types are printed in a tree-like form
3715 which shows both types. In the above example, the result on PP would be:
3722 and without type-elision would be:
3729 As before, the differing parts of the types are colorized if
3730 pp_show_color (pp) is true ("double" and "float" in this example).
3732 Template arguments in which both types are using the default arguments
3733 are not printed; if at least one of the two types is using a non-default
3734 argument, then that argument is printed (or both arguments for the
3735 tree-like print format). */
3738 print_template_differences (pretty_printer
*pp
, tree type_a
, tree type_b
,
3739 bool verbose
, int indent
)
3742 newline_and_indent (pp
, indent
);
3744 tree tinfo_a
= TYPE_TEMPLATE_INFO (type_a
);
3745 tree tinfo_b
= TYPE_TEMPLATE_INFO (type_b
);
3747 pp_printf (pp
, "%s<",
3748 IDENTIFIER_POINTER (DECL_NAME (TI_TEMPLATE (tinfo_a
))));
3750 tree args_a
= TI_ARGS (tinfo_a
);
3751 tree args_b
= TI_ARGS (tinfo_b
);
3752 gcc_assert (TREE_CODE (args_a
) == TREE_VEC
);
3753 gcc_assert (TREE_CODE (args_b
) == TREE_VEC
);
3755 int len_a
= get_non_default_template_args_count (args_a
, flags
);
3756 args_a
= INNERMOST_TEMPLATE_ARGS (args_a
);
3757 int len_b
= get_non_default_template_args_count (args_b
, flags
);
3758 args_b
= INNERMOST_TEMPLATE_ARGS (args_b
);
3759 /* Determine the maximum range of args for which non-default template args
3760 were used; beyond this, only default args (if any) were used, and so
3761 they will be equal from this point onwards.
3762 One of the two peers might have used default arguments within this
3763 range, but the other will be using non-default arguments, and so
3764 it's more readable to print both within this range, to highlight
3766 int len_max
= MAX (len_a
, len_b
);
3767 gcc_assert (TREE_CODE (args_a
) == TREE_VEC
);
3768 gcc_assert (TREE_CODE (args_b
) == TREE_VEC
);
3769 for (int idx
= 0; idx
< len_max
; idx
++)
3772 pp_character (pp
, ',');
3774 tree arg_a
= TREE_VEC_ELT (args_a
, idx
);
3775 tree arg_b
= TREE_VEC_ELT (args_b
, idx
);
3779 newline_and_indent (pp
, indent
+ 2);
3780 /* Can do elision here, printing "[...]". */
3781 if (flag_elide_type
)
3782 pp_string (pp
, G_("[...]"));
3784 pp_string (pp
, arg_to_string (arg_a
, verbose
));
3788 int new_indent
= indent
? indent
+ 2 : 0;
3789 if (comparable_template_types_p (arg_a
, arg_b
))
3790 print_template_differences (pp
, arg_a
, arg_b
, verbose
, new_indent
);
3794 newline_and_indent (pp
, indent
+ 2);
3795 pp_character (pp
, '[');
3796 print_nonequal_arg (pp
, arg_a
, verbose
);
3797 pp_string (pp
, " != ");
3798 print_nonequal_arg (pp
, arg_b
, verbose
);
3799 pp_character (pp
, ']');
3802 print_nonequal_arg (pp
, arg_a
, verbose
);
3805 pp_printf (pp
, ">");
3808 /* As type_to_string, but for a template, potentially colorizing/eliding
3809 in comparison with PEER.
3810 For example, if TYPE is map<int,double> and PEER is map<int,int>,
3811 then the resulting string would be:
3813 with type elision, and:
3815 without type elision.
3817 In both cases the parts of TYPE that differ from PEER will be colorized
3818 if SHOW_COLOR is true. In the above example, this would be "double".
3820 Template arguments in which both types are using the default arguments
3821 are not printed; if at least one of the two types is using a non-default
3822 argument, then both arguments are printed.
3824 The resulting string is in a GC-allocated buffer. */
3827 type_to_string_with_compare (tree type
, tree peer
, bool verbose
,
3830 pretty_printer inner_pp
;
3831 pretty_printer
*pp
= &inner_pp
;
3832 pp_show_color (pp
) = show_color
;
3834 print_template_differences (pp
, type
, peer
, verbose
, 0);
3835 return pp_ggc_formatted_text (pp
);
3838 /* Recursively print a tree-like comparison of TYPE_A and TYPE_B to PP,
3839 indented by INDENT spaces.
3841 For example given types:
3843 vector<map<int,double>>
3847 vector<map<double,float>>
3849 the output with type elision would be:
3856 and without type-elision would be:
3863 TYPE_A and TYPE_B must both be comparable template types
3864 (as per comparable_template_types_p).
3866 Template arguments in which both types are using the default arguments
3867 are not printed; if at least one of the two types is using a non-default
3868 argument, then both arguments are printed. */
3871 print_template_tree_comparison (pretty_printer
*pp
, tree type_a
, tree type_b
,
3872 bool verbose
, int indent
)
3874 print_template_differences (pp
, type_a
, type_b
, verbose
, indent
);
3877 /* Subroutine for use in a format_postprocessor::handle
3878 implementation. Adds a chunk to the end of
3879 formatted output, so that it will be printed
3880 by pp_output_formatted_text. */
3883 append_formatted_chunk (pretty_printer
*pp
, const char *content
)
3885 output_buffer
*buffer
= pp_buffer (pp
);
3886 struct chunk_info
*chunk_array
= buffer
->cur_chunk_array
;
3887 const char **args
= chunk_array
->args
;
3889 unsigned int chunk_idx
;
3890 for (chunk_idx
= 0; args
[chunk_idx
]; chunk_idx
++)
3892 args
[chunk_idx
++] = content
;
3893 args
[chunk_idx
] = NULL
;
3896 /* Create a copy of CONTENT, with quotes added, and,
3897 potentially, with colorization.
3898 No escaped is performed on CONTENT.
3899 The result is in a GC-allocated buffer. */
3902 add_quotes (const char *content
, bool show_color
)
3904 pretty_printer tmp_pp
;
3905 pp_show_color (&tmp_pp
) = show_color
;
3907 /* We have to use "%<%s%>" rather than "%qs" here in order to avoid
3908 quoting colorization bytes within the results. */
3909 pp_printf (&tmp_pp
, "%<%s%>", content
);
3911 return pp_ggc_formatted_text (&tmp_pp
);
3914 /* If we had %H and %I, and hence deferred printing them,
3915 print them now, storing the result into the chunk_info
3916 for pp_format. Quote them if 'q' was provided.
3917 Also print the difference in tree form, adding it as
3918 an additional chunk. */
3921 cxx_format_postprocessor::handle (pretty_printer
*pp
)
3923 /* If we have one of %H and %I, the other should have
3925 if (m_type_a
.m_tree
|| m_type_b
.m_tree
)
3927 /* Avoid reentrancy issues by working with a copy of
3928 m_type_a and m_type_b, resetting them now. */
3929 deferred_printed_type type_a
= m_type_a
;
3930 deferred_printed_type type_b
= m_type_b
;
3931 m_type_a
= deferred_printed_type ();
3932 m_type_b
= deferred_printed_type ();
3934 gcc_assert (type_a
.m_buffer_ptr
);
3935 gcc_assert (type_b
.m_buffer_ptr
);
3937 bool show_color
= pp_show_color (pp
);
3939 const char *type_a_text
;
3940 const char *type_b_text
;
3942 if (comparable_template_types_p (type_a
.m_tree
, type_b
.m_tree
))
3945 = type_to_string_with_compare (type_a
.m_tree
, type_b
.m_tree
,
3946 type_a
.m_verbose
, show_color
);
3948 = type_to_string_with_compare (type_b
.m_tree
, type_a
.m_tree
,
3949 type_b
.m_verbose
, show_color
);
3951 if (flag_diagnostics_show_template_tree
)
3953 pretty_printer inner_pp
;
3954 pp_show_color (&inner_pp
) = pp_show_color (pp
);
3955 print_template_tree_comparison
3956 (&inner_pp
, type_a
.m_tree
, type_b
.m_tree
, type_a
.m_verbose
, 2);
3957 append_formatted_chunk (pp
, pp_ggc_formatted_text (&inner_pp
));
3962 /* If the types were not comparable (or if only one of %H/%I was
3963 provided), they are printed normally, and no difference tree
3965 type_a_text
= type_to_string (type_a
.m_tree
, type_a
.m_verbose
,
3966 true, &type_a
.m_quote
, show_color
);
3967 type_b_text
= type_to_string (type_b
.m_tree
, type_b
.m_verbose
,
3968 true, &type_b
.m_quote
, show_color
);
3972 type_a_text
= add_quotes (type_a_text
, show_color
);
3973 *type_a
.m_buffer_ptr
= type_a_text
;
3976 type_b_text
= add_quotes (type_b_text
, show_color
);
3977 *type_b
.m_buffer_ptr
= type_b_text
;
3981 /* Subroutine for handling %H and %I, to support i18n of messages like:
3983 error_at (loc, "could not convert %qE from %qH to %qI",
3984 expr, type_a, type_b);
3986 so that we can print things like:
3988 could not convert 'foo' from 'map<int,double>' to 'map<int,int>'
3990 and, with type-elision:
3992 could not convert 'foo' from 'map<[...],double>' to 'map<[...],int>'
3994 (with color-coding of the differences between the types).
3996 The %H and %I format codes are peers: both must be present,
3997 and they affect each other. Hence to handle them, we must
3998 delay printing until we have both, deferring the printing to
3999 pretty_printer's m_format_postprocessor hook.
4001 This is called in phase 2 of pp_format, when it is accumulating
4002 a series of formatted chunks. We stash the location of the chunk
4003 we're meant to have written to, so that we can write to it in the
4004 m_format_postprocessor hook.
4006 We also need to stash whether a 'q' prefix was provided (the QUOTE
4007 param) so that we can add the quotes when writing out the delayed
4011 defer_phase_2_of_type_diff (deferred_printed_type
*deferred
,
4012 tree type
, const char **buffer_ptr
,
4013 bool verbose
, bool quote
)
4015 gcc_assert (deferred
->m_tree
== NULL_TREE
);
4016 gcc_assert (deferred
->m_buffer_ptr
== NULL
);
4017 *deferred
= deferred_printed_type (type
, buffer_ptr
, verbose
, quote
);
4021 /* Called from output_format -- during diagnostic message processing --
4022 to handle C++ specific format specifier with the following meanings:
4023 %A function argument-list.
4027 %F function declaration.
4029 %H type difference (from).
4030 %I type difference (to).
4032 %L language as used in extern "lang".
4034 %P function parameter whose position is indicated by an integer.
4035 %Q assignment operator.
4036 %S substitution (template + args)
4039 %X exception-specification. */
4041 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
4042 int precision
, bool wide
, bool set_locus
, bool verbose
,
4043 bool *quoted
, const char **buffer_ptr
)
4045 gcc_assert (pp
->m_format_postprocessor
);
4046 cxx_format_postprocessor
*postprocessor
4047 = static_cast <cxx_format_postprocessor
*> (pp
->m_format_postprocessor
);
4051 #define next_tree (t = va_arg (*text->args_ptr, tree))
4052 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
4053 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
4054 #define next_int va_arg (*text->args_ptr, int)
4056 if (precision
!= 0 || wide
)
4061 case 'A': result
= args_to_string (next_tree
, verbose
); break;
4062 case 'C': result
= code_to_string (next_tcode
); break;
4065 tree temp
= next_tree
;
4067 && DECL_HAS_DEBUG_EXPR_P (temp
))
4069 temp
= DECL_DEBUG_EXPR (temp
);
4072 result
= expr_to_string (temp
);
4076 result
= decl_to_string (temp
, verbose
);
4079 case 'E': result
= expr_to_string (next_tree
); break;
4080 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
4082 percent_G_format (text
);
4085 defer_phase_2_of_type_diff (&postprocessor
->m_type_a
, next_tree
,
4086 buffer_ptr
, verbose
, *quoted
);
4089 defer_phase_2_of_type_diff (&postprocessor
->m_type_b
, next_tree
,
4090 buffer_ptr
, verbose
, *quoted
);
4093 t
= va_arg (*text
->args_ptr
, tree
);
4094 percent_K_format (text
, EXPR_LOCATION (t
), TREE_BLOCK (t
));
4096 case 'L': result
= language_to_string (next_lang
); break;
4097 case 'O': result
= op_to_string (false, next_tcode
); break;
4098 case 'P': result
= parm_to_string (next_int
); break;
4099 case 'Q': result
= op_to_string (true, next_tcode
); break;
4100 case 'S': result
= subst_to_string (next_tree
); break;
4103 result
= type_to_string (next_tree
, verbose
, false, quoted
,
4104 pp_show_color (pp
));
4107 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
4108 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
4114 pp_string (pp
, result
);
4115 if (set_locus
&& t
!= NULL
)
4116 text
->set_location (0, location_of (t
), true);
4124 /* Warn about the use of C++0x features when appropriate. */
4126 maybe_warn_cpp0x (cpp0x_warn_str str
)
4128 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
4129 /* We really want to suppress this warning in system headers,
4130 because libstdc++ uses variadic templates even when we aren't
4134 case CPP0X_INITIALIZER_LISTS
:
4135 pedwarn (input_location
, 0,
4136 "extended initializer lists "
4137 "only available with -std=c++11 or -std=gnu++11");
4139 case CPP0X_EXPLICIT_CONVERSION
:
4140 pedwarn (input_location
, 0,
4141 "explicit conversion operators "
4142 "only available with -std=c++11 or -std=gnu++11");
4144 case CPP0X_VARIADIC_TEMPLATES
:
4145 pedwarn (input_location
, 0,
4146 "variadic templates "
4147 "only available with -std=c++11 or -std=gnu++11");
4149 case CPP0X_LAMBDA_EXPR
:
4150 pedwarn (input_location
, 0,
4151 "lambda expressions "
4152 "only available with -std=c++11 or -std=gnu++11");
4155 pedwarn (input_location
, 0,
4156 "C++11 auto only available with -std=c++11 or -std=gnu++11");
4158 case CPP0X_SCOPED_ENUMS
:
4159 pedwarn (input_location
, 0,
4160 "scoped enums only available with -std=c++11 or -std=gnu++11");
4162 case CPP0X_DEFAULTED_DELETED
:
4163 pedwarn (input_location
, 0,
4164 "defaulted and deleted functions "
4165 "only available with -std=c++11 or -std=gnu++11");
4167 case CPP0X_INLINE_NAMESPACES
:
4168 pedwarn (input_location
, OPT_Wpedantic
,
4169 "inline namespaces "
4170 "only available with -std=c++11 or -std=gnu++11");
4172 case CPP0X_OVERRIDE_CONTROLS
:
4173 pedwarn (input_location
, 0,
4174 "override controls (override/final) "
4175 "only available with -std=c++11 or -std=gnu++11");
4178 pedwarn (input_location
, 0,
4179 "non-static data member initializers "
4180 "only available with -std=c++11 or -std=gnu++11");
4182 case CPP0X_USER_DEFINED_LITERALS
:
4183 pedwarn (input_location
, 0,
4184 "user-defined literals "
4185 "only available with -std=c++11 or -std=gnu++11");
4187 case CPP0X_DELEGATING_CTORS
:
4188 pedwarn (input_location
, 0,
4189 "delegating constructors "
4190 "only available with -std=c++11 or -std=gnu++11");
4192 case CPP0X_INHERITING_CTORS
:
4193 pedwarn (input_location
, 0,
4194 "inheriting constructors "
4195 "only available with -std=c++11 or -std=gnu++11");
4197 case CPP0X_ATTRIBUTES
:
4198 pedwarn (input_location
, 0,
4200 "only available with -std=c++11 or -std=gnu++11");
4202 case CPP0X_REF_QUALIFIER
:
4203 pedwarn (input_location
, 0,
4205 "only available with -std=c++11 or -std=gnu++11");
4212 /* Warn about the use of variadic templates when appropriate. */
4214 maybe_warn_variadic_templates (void)
4216 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
4220 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
4221 option OPT with text GMSGID. Use this function to report
4222 diagnostics for constructs that are invalid C++98, but valid
4225 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
4227 diagnostic_info diagnostic
;
4230 rich_location
richloc (line_table
, location
);
4232 va_start (ap
, gmsgid
);
4233 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
4234 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
4235 diagnostic
.option_index
= opt
;
4236 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
4241 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
4242 we found when we tried to do the lookup. LOCATION is the location of
4243 the NAME identifier. */
4246 qualified_name_lookup_error (tree scope
, tree name
,
4247 tree decl
, location_t location
)
4249 if (scope
== error_mark_node
)
4250 ; /* We already complained. */
4251 else if (TYPE_P (scope
))
4253 if (!COMPLETE_TYPE_P (scope
))
4254 error_at (location
, "incomplete type %qT used in nested name specifier",
4256 else if (TREE_CODE (decl
) == TREE_LIST
)
4258 error_at (location
, "reference to %<%T::%D%> is ambiguous",
4260 print_candidates (decl
);
4263 error_at (location
, "%qD is not a member of %qT", name
, scope
);
4265 else if (scope
!= global_namespace
)
4267 error_at (location
, "%qD is not a member of %qD", name
, scope
);
4268 if (!suggest_alternative_in_explicit_scope (location
, name
, scope
))
4269 suggest_alternatives_for (location
, name
, false);
4273 error_at (location
, "%<::%D%> has not been declared", name
);
4274 suggest_alternatives_for (location
, name
, true);