1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "stringpool.h"
25 #include "tree-diagnostic.h"
26 #include "langhooks-def.h"
28 #include "cxx-pretty-print.h"
29 #include "tree-pretty-print.h"
30 #include "c-family/c-objc.h"
32 #include "internal-fn.h"
34 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
35 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
37 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
38 dump C++ ASTs as strings. It is mostly used only by the various
39 tree -> string functions that are occasionally called from the
40 debugger or by the front-end for things like
41 __PRETTY_FUNCTION__. */
42 static cxx_pretty_printer actual_pretty_printer
;
43 static cxx_pretty_printer
* const cxx_pp
= &actual_pretty_printer
;
45 /* Translate if being used for diagnostics, but not for dump files or
47 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
49 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
51 static const char *args_to_string (tree
, int);
52 static const char *assop_to_string (enum tree_code
);
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 (enum tree_code
);
59 static const char *parm_to_string (int);
60 static const char *type_to_string (tree
, int);
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 (TREE_CODE (t
) == REFERENCE_TYPE
)
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 case ARRAY_NOTATION_REF
:
1205 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1206 pp_cxx_left_bracket (pp
);
1207 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1209 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1211 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1212 pp_cxx_right_bracket (pp
);
1215 /* So that we can do dump_decl on an aggr type. */
1219 dump_type (pp
, t
, flags
);
1223 /* This is a pseudo destructor call which has not been folded into
1224 a PSEUDO_DTOR_EXPR yet. */
1225 pp_cxx_complement (pp
);
1226 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1233 case IDENTIFIER_NODE
:
1234 dump_decl_name (pp
, t
, flags
);
1238 if (!OVL_SINGLE_P (t
))
1240 tree ctx
= ovl_scope (t
);
1241 if (ctx
!= global_namespace
)
1244 dump_type (pp
, ctx
, flags
);
1246 dump_decl (pp
, ctx
, flags
);
1247 pp_cxx_colon_colon (pp
);
1249 dump_decl (pp
, OVL_NAME (t
), flags
);
1253 /* If there's only one function, just treat it like an ordinary
1259 if (! DECL_LANG_SPECIFIC (t
))
1261 if (DECL_ABSTRACT_ORIGIN (t
)
1262 && DECL_ABSTRACT_ORIGIN (t
) != t
)
1263 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1265 dump_function_name (pp
, t
, flags
);
1267 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1268 dump_global_iord (pp
, t
);
1270 dump_function_decl (pp
, t
, flags
);
1274 dump_template_decl (pp
, t
, flags
);
1277 case TEMPLATE_ID_EXPR
:
1279 tree name
= TREE_OPERAND (t
, 0);
1280 tree args
= TREE_OPERAND (t
, 1);
1282 if (!identifier_p (name
))
1283 name
= OVL_NAME (name
);
1284 dump_decl (pp
, name
, flags
);
1285 pp_cxx_begin_template_argument_list (pp
);
1286 if (args
== error_mark_node
)
1287 pp_string (pp
, M_("<template arguments error>"));
1289 dump_template_argument_list
1290 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1291 pp_cxx_end_template_argument_list (pp
);
1296 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1300 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1301 || (DECL_INITIAL (t
) &&
1302 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1303 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1304 else if (DECL_NAME (t
))
1305 dump_decl (pp
, DECL_NAME (t
), flags
);
1306 else if (DECL_INITIAL (t
))
1307 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1309 pp_string (pp
, M_("<enumerator>"));
1314 pp_cxx_ws_string (pp
, "using");
1315 tree scope
= USING_DECL_SCOPE (t
);
1316 bool variadic
= false;
1317 if (PACK_EXPANSION_P (scope
))
1319 scope
= PACK_EXPANSION_PATTERN (scope
);
1322 dump_type (pp
, scope
, flags
);
1323 pp_cxx_colon_colon (pp
);
1324 dump_decl (pp
, DECL_NAME (t
), flags
);
1326 pp_cxx_ws_string (pp
, "...");
1331 pp
->declaration (t
);
1335 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1338 case NON_DEPENDENT_EXPR
:
1339 dump_expr (pp
, t
, flags
);
1342 case TEMPLATE_TYPE_PARM
:
1343 if (flags
& TFF_DECL_SPECIFIERS
)
1344 pp
->declaration (t
);
1349 case UNBOUND_CLASS_TEMPLATE
:
1350 case TYPE_PACK_EXPANSION
:
1352 dump_type (pp
, t
, flags
);
1356 pp_unsupported_tree (pp
, t
);
1360 pp_string (pp
, M_("<declaration error>"));
1365 /* Dump a template declaration T under control of FLAGS. This means the
1366 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1369 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1371 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1375 if (flags
& TFF_TEMPLATE_HEADER
)
1377 for (parms
= orig_parms
= nreverse (orig_parms
);
1379 parms
= TREE_CHAIN (parms
))
1381 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1382 int len
= TREE_VEC_LENGTH (inner_parms
);
1386 /* Skip over the dummy template levels of a template template
1388 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1392 pp_cxx_ws_string (pp
, "template");
1393 pp_cxx_begin_template_argument_list (pp
);
1395 /* If we've shown the template prefix, we'd better show the
1396 parameters' and decl's type too. */
1397 flags
|= TFF_DECL_SPECIFIERS
;
1399 for (i
= 0; i
< len
; i
++)
1402 pp_separate_with_comma (pp
);
1403 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1406 pp_cxx_end_template_argument_list (pp
);
1407 pp_cxx_whitespace (pp
);
1409 nreverse(orig_parms
);
1411 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1413 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1414 pp_cxx_ws_string (pp
, "class");
1416 /* If this is a parameter pack, print the ellipsis. */
1417 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1418 pp_cxx_ws_string (pp
, "...");
1421 /* Only print the requirements if we're also printing
1422 the template header. */
1424 if (tree ci
= get_constraints (t
))
1425 if (check_constraint_info (ci
))
1426 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1428 pp_cxx_requires_clause (pp
, reqs
);
1429 pp_cxx_whitespace (pp
);
1434 if (DECL_CLASS_TEMPLATE_P (t
))
1435 dump_type (pp
, TREE_TYPE (t
),
1436 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1437 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1438 else if (DECL_TEMPLATE_RESULT (t
)
1439 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1440 /* Alias template. */
1441 || DECL_TYPE_TEMPLATE_P (t
)))
1442 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1445 gcc_assert (TREE_TYPE (t
));
1446 switch (NEXT_CODE (t
))
1450 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1453 /* This case can occur with some invalid code. */
1454 dump_type (pp
, TREE_TYPE (t
),
1455 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1456 | (flags
& TFF_DECL_SPECIFIERS
1457 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1462 /* find_typenames looks through the type of the function template T
1463 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1466 struct find_typenames_t
1468 hash_set
<tree
> *p_set
;
1469 vec
<tree
, va_gc
> *typenames
;
1473 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1475 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1476 tree mv
= NULL_TREE
;
1478 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1479 /* Add the type of the typedef without any additional cv-quals. */
1480 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1481 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1482 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1483 /* Add the typename without any cv-qualifiers. */
1484 mv
= TYPE_MAIN_VARIANT (*tp
);
1486 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1488 /* Don't mess with parameter packs since we don't remember
1489 the pack expansion context for a particular typename. */
1490 *walk_subtrees
= false;
1494 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1495 vec_safe_push (d
->typenames
, mv
);
1497 /* Search into class template arguments, which cp_walk_subtrees
1499 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1500 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1506 static vec
<tree
, va_gc
> *
1507 find_typenames (tree t
)
1509 struct find_typenames_t ft
;
1510 ft
.p_set
= new hash_set
<tree
>;
1511 ft
.typenames
= NULL
;
1512 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1513 find_typenames_r
, &ft
, ft
.p_set
);
1515 return ft
.typenames
;
1518 /* Output the "[with ...]" clause for a template instantiation T iff
1519 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1520 formatting a deduction/substitution diagnostic rather than an
1524 dump_substitution (cxx_pretty_printer
*pp
,
1525 tree t
, tree template_parms
, tree template_args
,
1528 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1529 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1531 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1532 pp_cxx_whitespace (pp
);
1533 pp_cxx_left_bracket (pp
);
1534 pp
->translate_string ("with");
1535 pp_cxx_whitespace (pp
);
1536 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1537 pp_cxx_right_bracket (pp
);
1541 /* Dump the lambda function FN including its 'mutable' qualifier and any
1542 template bindings. */
1545 dump_lambda_function (cxx_pretty_printer
*pp
,
1546 tree fn
, tree template_parms
, tree template_args
,
1549 /* A lambda's signature is essentially its "type". */
1550 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1551 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1553 pp
->padding
= pp_before
;
1554 pp_c_ws_string (pp
, "mutable");
1556 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1559 /* Pretty print a function decl. There are several ways we want to print a
1560 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1561 As error can only apply the '#' flag once to give 0 and 1 for V, there
1562 is %D which doesn't print the throw specs, and %F which does. */
1565 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1569 tree cname
= NULL_TREE
;
1570 tree template_args
= NULL_TREE
;
1571 tree template_parms
= NULL_TREE
;
1572 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1573 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1577 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1578 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1579 t
= DECL_TEMPLATE_RESULT (t
);
1581 /* Save the exceptions, in case t is a specialization and we are
1582 emitting an error about incompatible specifications. */
1583 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1585 /* Likewise for the constexpr specifier, in case t is a specialization. */
1586 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1588 /* Pretty print template instantiations only. */
1589 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1590 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1591 && flag_pretty_templates
)
1595 template_args
= DECL_TI_ARGS (t
);
1596 tmpl
= most_general_template (t
);
1597 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1599 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1604 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1605 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1607 fntype
= TREE_TYPE (t
);
1608 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1610 if (DECL_CLASS_SCOPE_P (t
))
1611 cname
= DECL_CONTEXT (t
);
1612 /* This is for partially instantiated template methods. */
1613 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1614 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1616 if (flags
& TFF_DECL_SPECIFIERS
)
1618 if (DECL_STATIC_FUNCTION_P (t
))
1619 pp_cxx_ws_string (pp
, "static");
1620 else if (DECL_VIRTUAL_P (t
))
1621 pp_cxx_ws_string (pp
, "virtual");
1625 if (DECL_DECLARED_CONCEPT_P (t
))
1626 pp_cxx_ws_string (pp
, "concept");
1628 pp_cxx_ws_string (pp
, "constexpr");
1632 /* Print the return type? */
1634 show_return
= (!DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1635 && !DECL_DESTRUCTOR_P (t
) && !deduction_guide_p (t
));
1638 tree ret
= fndecl_declared_return_type (t
);
1639 dump_type_prefix (pp
, ret
, flags
);
1642 /* Print the function name. */
1643 if (!do_outer_scope
)
1647 dump_type (pp
, cname
, flags
);
1648 pp_cxx_colon_colon (pp
);
1651 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1653 dump_function_name (pp
, t
, flags
);
1655 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1657 dump_parameters (pp
, parmtypes
, flags
);
1659 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1661 pp
->padding
= pp_before
;
1662 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1663 dump_ref_qualifier (pp
, fntype
, flags
);
1666 if (tx_safe_fn_type_p (fntype
))
1668 pp
->padding
= pp_before
;
1669 pp_cxx_ws_string (pp
, "transaction_safe");
1672 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1674 pp
->padding
= pp_before
;
1675 dump_exception_spec (pp
, exceptions
, flags
);
1679 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1680 else if (deduction_guide_p (t
))
1682 pp_cxx_ws_string (pp
, "->");
1683 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1687 if (tree ci
= get_constraints (t
))
1688 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1689 pp_cxx_requires_clause (pp
, reqs
);
1691 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1693 if (tree base
= DECL_INHERITED_CTOR_BASE (t
))
1695 pp_cxx_ws_string (pp
, "[inherited from");
1696 dump_type (pp
, base
, TFF_PLAIN_IDENTIFIER
);
1697 pp_character (pp
, ']');
1700 else if (template_args
)
1702 bool need_comma
= false;
1704 pp_cxx_begin_template_argument_list (pp
);
1705 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1706 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1708 tree arg
= TREE_VEC_ELT (template_args
, i
);
1710 pp_separate_with_comma (pp
);
1711 if (ARGUMENT_PACK_P (arg
))
1712 pp_cxx_left_brace (pp
);
1713 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1714 if (ARGUMENT_PACK_P (arg
))
1715 pp_cxx_right_brace (pp
);
1718 pp_cxx_end_template_argument_list (pp
);
1722 /* Print a parameter list. If this is for a member function, the
1723 member object ptr (and any other hidden args) should have
1724 already been removed. */
1727 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1730 flags
&= ~TFF_SCOPE
;
1731 pp_cxx_left_paren (pp
);
1733 for (first
= 1; parmtypes
!= void_list_node
;
1734 parmtypes
= TREE_CHAIN (parmtypes
))
1737 pp_separate_with_comma (pp
);
1741 pp_cxx_ws_string (pp
, "...");
1745 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1747 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1749 pp_cxx_whitespace (pp
);
1751 pp_cxx_whitespace (pp
);
1752 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1756 pp_cxx_right_paren (pp
);
1759 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1762 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1764 if (FUNCTION_REF_QUALIFIED (t
))
1766 pp
->padding
= pp_before
;
1767 if (FUNCTION_RVALUE_QUALIFIED (t
))
1768 pp_cxx_ws_string (pp
, "&&");
1770 pp_cxx_ws_string (pp
, "&");
1774 /* Print an exception specification. T is the exception specification. */
1777 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1779 if (t
&& TREE_PURPOSE (t
))
1781 pp_cxx_ws_string (pp
, "noexcept");
1782 if (!integer_onep (TREE_PURPOSE (t
)))
1784 pp_cxx_whitespace (pp
);
1785 pp_cxx_left_paren (pp
);
1786 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1787 pp_cxx_ws_string (pp
, "<uninstantiated>");
1789 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1790 pp_cxx_right_paren (pp
);
1795 pp_cxx_ws_string (pp
, "throw");
1796 pp_cxx_whitespace (pp
);
1797 pp_cxx_left_paren (pp
);
1798 if (TREE_VALUE (t
) != NULL_TREE
)
1801 dump_type (pp
, TREE_VALUE (t
), flags
);
1805 pp_separate_with_comma (pp
);
1807 pp_cxx_right_paren (pp
);
1811 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1812 and destructors properly. */
1815 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1817 tree name
= DECL_NAME (t
);
1819 /* We can get here with a decl that was synthesized by language-
1820 independent machinery (e.g. coverage.c) in which case it won't
1821 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1822 will crash. In this case it is safe just to print out the
1824 if (!DECL_LANG_SPECIFIC (t
))
1826 pp_cxx_tree_identifier (pp
, name
);
1830 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1831 t
= DECL_TEMPLATE_RESULT (t
);
1833 /* Don't let the user see __comp_ctor et al. */
1834 if (DECL_CONSTRUCTOR_P (t
)
1835 || DECL_DESTRUCTOR_P (t
))
1837 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1838 name
= get_identifier ("<lambda>");
1839 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1840 name
= get_identifier ("<constructor>");
1842 name
= constructor_name (DECL_CONTEXT (t
));
1845 if (DECL_DESTRUCTOR_P (t
))
1847 pp_cxx_complement (pp
);
1848 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1850 else if (DECL_CONV_FN_P (t
))
1852 /* This cannot use the hack that the operator's return
1853 type is stashed off of its name because it may be
1854 used for error reporting. In the case of conflicting
1855 declarations, both will have the same name, yet
1856 the types will be different, hence the TREE_TYPE field
1857 of the first name will be clobbered by the second. */
1858 pp_cxx_ws_string (pp
, "operator");
1859 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1862 dump_decl (pp
, name
, flags
);
1864 if (DECL_TEMPLATE_INFO (t
)
1865 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1866 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1867 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1868 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1872 /* Dump the template parameters from the template info INFO under control of
1873 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1874 specialization (partial or complete). For partial specializations we show
1875 the specialized parameter values. For a primary template we show no
1879 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1880 int primary
, int flags
)
1882 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1884 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1886 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1887 pp_cxx_begin_template_argument_list (pp
);
1889 /* Be careful only to print things when we have them, so as not
1890 to crash producing error messages. */
1891 if (args
&& !primary
)
1894 len
= get_non_default_template_args_count (args
, flags
);
1896 args
= INNERMOST_TEMPLATE_ARGS (args
);
1897 for (ix
= 0; ix
!= len
; ix
++)
1899 tree arg
= TREE_VEC_ELT (args
, ix
);
1901 /* Only print a comma if we know there is an argument coming. In
1902 the case of an empty template argument pack, no actual
1903 argument will be printed. */
1905 && (!ARGUMENT_PACK_P (arg
)
1906 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1907 pp_separate_with_comma (pp
);
1910 pp_string (pp
, M_("<template parameter error>"));
1912 dump_template_argument (pp
, arg
, flags
);
1917 tree tpl
= TI_TEMPLATE (info
);
1918 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1921 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1922 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1924 for (ix
= 0; ix
!= len
; ix
++)
1928 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1930 pp_string (pp
, M_("<template parameter error>"));
1934 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1937 pp_separate_with_comma (pp
);
1939 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1942 pp_cxx_end_template_argument_list (pp
);
1945 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1946 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1949 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1952 call_expr_arg_iterator iter
;
1954 pp_cxx_left_paren (pp
);
1955 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1961 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1962 if (more_call_expr_args_p (&iter
))
1963 pp_separate_with_comma (pp
);
1966 pp_cxx_right_paren (pp
);
1969 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1970 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1974 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1978 aggr_init_expr_arg_iterator iter
;
1980 pp_cxx_left_paren (pp
);
1981 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1987 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1988 if (more_aggr_init_expr_args_p (&iter
))
1989 pp_separate_with_comma (pp
);
1992 pp_cxx_right_paren (pp
);
1995 /* Print out a list of initializers (subr of dump_expr). */
1998 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
2002 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
2005 pp_separate_with_comma (pp
);
2009 /* Print out a vector of initializers (subr of dump_expr). */
2012 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
2015 unsigned HOST_WIDE_INT idx
;
2018 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
2020 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
2021 if (idx
!= v
->length () - 1)
2022 pp_separate_with_comma (pp
);
2027 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
2028 function. Resolve it to a close relative -- in the sense of static
2029 type -- variant being overridden. That is close to what was written in
2030 the source code. Subroutine of dump_expr. */
2033 resolve_virtual_fun_from_obj_type_ref (tree ref
)
2035 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
2036 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
2037 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
2040 fun
= TREE_CHAIN (fun
);
2041 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
2042 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
2048 /* Print out an expression E under control of FLAGS. */
2051 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
2058 if (STATEMENT_CLASS_P (t
))
2060 pp_cxx_ws_string (pp
, M_("<statement>"));
2064 switch (TREE_CODE (t
))
2072 case NAMESPACE_DECL
:
2076 case IDENTIFIER_NODE
:
2077 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
2078 |TFF_TEMPLATE_HEADER
))
2079 | TFF_NO_TEMPLATE_BINDINGS
2080 | TFF_NO_FUNCTION_ARGUMENTS
));
2084 if (SSA_NAME_VAR (t
)
2085 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
2086 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2088 pp_cxx_ws_string (pp
, M_("<unknown>"));
2099 case USERDEF_LITERAL
:
2100 pp_cxx_userdef_literal (pp
, t
);
2104 /* While waiting for caret diagnostics, avoid printing
2105 __cxa_allocate_exception, __cxa_throw, and the like. */
2106 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2111 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2112 pp_cxx_colon_colon (pp
);
2113 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2117 pp_cxx_left_paren (pp
);
2118 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2119 pp_separate_with_comma (pp
);
2120 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2121 pp_cxx_right_paren (pp
);
2126 pp_cxx_left_paren (pp
);
2127 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2128 pp_string (pp
, " ? ");
2129 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2130 pp_string (pp
, " : ");
2131 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2132 pp_cxx_right_paren (pp
);
2136 if (TREE_HAS_CONSTRUCTOR (t
))
2138 pp_cxx_ws_string (pp
, "new");
2139 pp_cxx_whitespace (pp
);
2140 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2143 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2146 case AGGR_INIT_EXPR
:
2148 tree fn
= NULL_TREE
;
2150 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2151 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2153 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2155 if (DECL_CONSTRUCTOR_P (fn
))
2156 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2158 dump_decl (pp
, fn
, 0);
2161 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2163 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2168 tree fn
= CALL_EXPR_FN (t
);
2169 bool skipfirst
= false;
2171 /* Deal with internal functions. */
2172 if (fn
== NULL_TREE
)
2174 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2175 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2179 if (TREE_CODE (fn
) == ADDR_EXPR
)
2180 fn
= TREE_OPERAND (fn
, 0);
2182 /* Nobody is interested in seeing the guts of vcalls. */
2183 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2184 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2186 if (TREE_TYPE (fn
) != NULL_TREE
2187 && NEXT_CODE (fn
) == METHOD_TYPE
2188 && call_expr_nargs (t
))
2190 tree ob
= CALL_EXPR_ARG (t
, 0);
2191 if (TREE_CODE (ob
) == ADDR_EXPR
)
2193 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2194 flags
| TFF_EXPR_IN_PARENS
);
2197 else if (!is_this_parameter (ob
))
2199 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2204 if (flag_sanitize
& SANITIZE_UNDEFINED
2205 && is_ubsan_builtin_p (fn
))
2207 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2210 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2211 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2216 /* Note that this only works for G++ target exprs. If somebody
2217 builds a general TARGET_EXPR, there's no way to represent that
2218 it initializes anything other that the parameter slot for the
2219 default argument. Note we may have cleared out the first
2220 operand in expand_expr, so don't go killing ourselves. */
2221 if (TREE_OPERAND (t
, 1))
2222 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2225 case POINTER_PLUS_EXPR
:
2226 dump_binary_op (pp
, "+", t
, flags
);
2231 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2238 case TRUNC_DIV_EXPR
:
2239 case TRUNC_MOD_EXPR
:
2247 case TRUTH_ANDIF_EXPR
:
2248 case TRUTH_ORIF_EXPR
:
2255 case EXACT_DIV_EXPR
:
2256 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2260 case FLOOR_DIV_EXPR
:
2261 case ROUND_DIV_EXPR
:
2263 dump_binary_op (pp
, "/", t
, flags
);
2267 case FLOOR_MOD_EXPR
:
2268 case ROUND_MOD_EXPR
:
2269 dump_binary_op (pp
, "%", t
, flags
);
2274 tree ob
= TREE_OPERAND (t
, 0);
2275 if (INDIRECT_REF_P (ob
))
2277 ob
= TREE_OPERAND (ob
, 0);
2278 if (!is_this_parameter (ob
))
2280 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2281 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2289 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2290 if (TREE_CODE (ob
) != ARROW_EXPR
)
2293 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2298 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2299 pp_cxx_left_bracket (pp
);
2300 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2301 pp_cxx_right_bracket (pp
);
2304 case ARRAY_NOTATION_REF
:
2305 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2306 pp_cxx_left_bracket (pp
);
2307 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2309 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2311 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2312 pp_cxx_right_bracket (pp
);
2315 case UNARY_PLUS_EXPR
:
2316 dump_unary_op (pp
, "+", t
, flags
);
2320 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2321 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2322 /* An ADDR_EXPR can have reference type. In that case, we
2323 shouldn't print the `&' doing so indicates to the user
2324 that the expression has pointer type. */
2326 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2327 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2328 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2329 dump_unary_op (pp
, "&&", t
, flags
);
2331 dump_unary_op (pp
, "&", t
, flags
);
2335 if (TREE_HAS_CONSTRUCTOR (t
))
2337 t
= TREE_OPERAND (t
, 0);
2338 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2339 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2340 dump_call_expr_args (pp
, t
, flags
, true);
2344 if (TREE_OPERAND (t
,0) != NULL_TREE
2345 && TREE_TYPE (TREE_OPERAND (t
, 0))
2346 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2347 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2349 dump_unary_op (pp
, "*", t
, flags
);
2354 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2355 && integer_zerop (TREE_OPERAND (t
, 1)))
2356 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2360 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2362 pp_cxx_left_paren (pp
);
2363 if (!integer_onep (TYPE_SIZE_UNIT
2364 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2366 pp_cxx_left_paren (pp
);
2367 dump_type (pp
, ptr_type_node
, flags
);
2368 pp_cxx_right_paren (pp
);
2371 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2372 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2374 pp_cxx_ws_string (pp
, "+");
2375 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2377 pp_cxx_right_paren (pp
);
2384 case TRUTH_NOT_EXPR
:
2385 case PREDECREMENT_EXPR
:
2386 case PREINCREMENT_EXPR
:
2387 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2390 case POSTDECREMENT_EXPR
:
2391 case POSTINCREMENT_EXPR
:
2392 pp_cxx_left_paren (pp
);
2393 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2394 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2395 pp_cxx_right_paren (pp
);
2398 case NON_LVALUE_EXPR
:
2399 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2400 should be another level of INDIRECT_REF so that I don't have to do
2402 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2404 tree next
= TREE_TYPE (TREE_TYPE (t
));
2406 while (TYPE_PTR_P (next
))
2407 next
= TREE_TYPE (next
);
2409 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2411 if (flags
& TFF_EXPR_IN_PARENS
)
2412 pp_cxx_left_paren (pp
);
2414 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2415 if (flags
& TFF_EXPR_IN_PARENS
)
2416 pp_cxx_right_paren (pp
);
2419 /* Else fall through. */
2421 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2425 case IMPLICIT_CONV_EXPR
:
2426 case VIEW_CONVERT_EXPR
:
2428 tree op
= TREE_OPERAND (t
, 0);
2429 tree ttype
= TREE_TYPE (t
);
2430 tree optype
= TREE_TYPE (op
);
2432 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2433 && POINTER_TYPE_P (ttype
)
2434 && POINTER_TYPE_P (optype
)
2435 && same_type_p (TREE_TYPE (optype
),
2438 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2441 if (TREE_CODE (op
) == ADDR_EXPR
)
2442 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2444 dump_unary_op (pp
, "*", t
, flags
);
2447 dump_unary_op (pp
, "&", t
, flags
);
2449 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2451 /* It is a cast, but we cannot tell whether it is a
2452 reinterpret or static cast. Use the C style notation. */
2453 if (flags
& TFF_EXPR_IN_PARENS
)
2454 pp_cxx_left_paren (pp
);
2455 pp_cxx_left_paren (pp
);
2456 dump_type (pp
, TREE_TYPE (t
), flags
);
2457 pp_cxx_right_paren (pp
);
2458 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2459 if (flags
& TFF_EXPR_IN_PARENS
)
2460 pp_cxx_right_paren (pp
);
2463 dump_expr (pp
, op
, flags
);
2468 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2470 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2472 if (integer_zerop (idx
))
2474 /* A NULL pointer-to-member constant. */
2475 pp_cxx_left_paren (pp
);
2476 pp_cxx_left_paren (pp
);
2477 dump_type (pp
, TREE_TYPE (t
), flags
);
2478 pp_cxx_right_paren (pp
);
2479 pp_character (pp
, '0');
2480 pp_cxx_right_paren (pp
);
2483 else if (tree_fits_shwi_p (idx
))
2486 unsigned HOST_WIDE_INT n
;
2488 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2489 t
= TYPE_METHOD_BASETYPE (t
);
2490 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2492 n
= tree_to_shwi (idx
);
2494 /* Map vtable index back one, to allow for the null pointer to
2498 while (n
> 0 && virtuals
)
2501 virtuals
= TREE_CHAIN (virtuals
);
2505 dump_expr (pp
, BV_FN (virtuals
),
2506 flags
| TFF_EXPR_IN_PARENS
);
2511 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2512 pp_string (pp
, "<lambda closure object>");
2513 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2515 dump_type (pp
, TREE_TYPE (t
), 0);
2516 pp_cxx_left_paren (pp
);
2517 pp_cxx_right_paren (pp
);
2521 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2522 dump_type (pp
, TREE_TYPE (t
), 0);
2523 pp_cxx_left_brace (pp
);
2524 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2525 pp_cxx_right_brace (pp
);
2532 tree ob
= TREE_OPERAND (t
, 0);
2533 if (is_dummy_object (ob
))
2535 t
= TREE_OPERAND (t
, 1);
2536 if (TREE_CODE (t
) == FUNCTION_DECL
)
2538 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2539 else if (BASELINK_P (t
))
2540 dump_expr (pp
, OVL_FIRST (BASELINK_FUNCTIONS (t
)),
2541 flags
| TFF_EXPR_IN_PARENS
);
2543 dump_decl (pp
, t
, flags
);
2547 if (INDIRECT_REF_P (ob
))
2549 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2555 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2559 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2564 case TEMPLATE_PARM_INDEX
:
2565 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2569 if (TREE_OPERAND (t
, 0) == NULL_TREE
2570 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2572 dump_type (pp
, TREE_TYPE (t
), flags
);
2573 pp_cxx_left_paren (pp
);
2574 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2575 pp_cxx_right_paren (pp
);
2579 pp_cxx_left_paren (pp
);
2580 dump_type (pp
, TREE_TYPE (t
), flags
);
2581 pp_cxx_right_paren (pp
);
2582 pp_cxx_left_paren (pp
);
2583 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2584 pp_cxx_right_paren (pp
);
2588 case STATIC_CAST_EXPR
:
2589 pp_cxx_ws_string (pp
, "static_cast");
2591 case REINTERPRET_CAST_EXPR
:
2592 pp_cxx_ws_string (pp
, "reinterpret_cast");
2594 case CONST_CAST_EXPR
:
2595 pp_cxx_ws_string (pp
, "const_cast");
2597 case DYNAMIC_CAST_EXPR
:
2598 pp_cxx_ws_string (pp
, "dynamic_cast");
2600 pp_cxx_begin_template_argument_list (pp
);
2601 dump_type (pp
, TREE_TYPE (t
), flags
);
2602 pp_cxx_end_template_argument_list (pp
);
2603 pp_cxx_left_paren (pp
);
2604 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2605 pp_cxx_right_paren (pp
);
2609 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2615 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2616 pp_cxx_ws_string (pp
, "sizeof");
2619 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2620 pp_cxx_ws_string (pp
, "__alignof__");
2622 op
= TREE_OPERAND (t
, 0);
2623 if (PACK_EXPANSION_P (op
))
2625 pp_string (pp
, "...");
2626 op
= PACK_EXPANSION_PATTERN (op
);
2628 pp_cxx_whitespace (pp
);
2629 pp_cxx_left_paren (pp
);
2630 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2631 dump_type (pp
, TREE_TYPE (op
), flags
);
2632 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2633 dump_type (pp
, op
, flags
);
2635 dump_expr (pp
, op
, flags
);
2636 pp_cxx_right_paren (pp
);
2639 case AT_ENCODE_EXPR
:
2640 pp_cxx_ws_string (pp
, "@encode");
2641 pp_cxx_whitespace (pp
);
2642 pp_cxx_left_paren (pp
);
2643 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2644 pp_cxx_right_paren (pp
);
2648 pp_cxx_ws_string (pp
, "noexcept");
2649 pp_cxx_whitespace (pp
);
2650 pp_cxx_left_paren (pp
);
2651 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2652 pp_cxx_right_paren (pp
);
2657 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2658 pp_cxx_whitespace (pp
);
2659 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2663 pp_string (pp
, M_("<unparsed>"));
2666 case TRY_CATCH_EXPR
:
2667 case CLEANUP_POINT_EXPR
:
2668 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2671 case PSEUDO_DTOR_EXPR
:
2672 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2674 if (TREE_OPERAND (t
, 1))
2676 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2677 pp_cxx_colon_colon (pp
);
2679 pp_cxx_complement (pp
);
2680 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2683 case TEMPLATE_ID_EXPR
:
2684 dump_decl (pp
, t
, flags
);
2690 case STATEMENT_LIST
:
2691 /* We don't yet have a way of dumping statements in a
2692 human-readable format. */
2693 pp_string (pp
, "({...})");
2697 pp_string (pp
, "while (1) { ");
2698 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2699 pp_cxx_right_brace (pp
);
2703 pp_string (pp
, "if (");
2704 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2705 pp_string (pp
, ") break; ");
2709 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2712 case EMPTY_CLASS_EXPR
:
2713 dump_type (pp
, TREE_TYPE (t
), flags
);
2714 pp_cxx_left_paren (pp
);
2715 pp_cxx_right_paren (pp
);
2718 case NON_DEPENDENT_EXPR
:
2719 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2722 case ARGUMENT_PACK_SELECT
:
2723 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2735 pp_type_specifier_seq (pp
, t
);
2739 /* We get here when we want to print a dependent type as an
2740 id-expression, without any disambiguator decoration. */
2741 pp
->id_expression (t
);
2744 case TEMPLATE_TYPE_PARM
:
2745 case TEMPLATE_TEMPLATE_PARM
:
2746 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2747 dump_type (pp
, t
, flags
);
2751 pp_cxx_trait_expression (pp
, t
);
2755 pp_cxx_va_arg_expression (pp
, t
);
2759 pp_cxx_offsetof_expression (pp
, t
);
2762 case ADDRESSOF_EXPR
:
2763 pp_cxx_addressof_expression (pp
, t
);
2767 dump_decl (pp
, t
, flags
);
2770 case EXPR_PACK_EXPANSION
:
2771 case UNARY_LEFT_FOLD_EXPR
:
2772 case UNARY_RIGHT_FOLD_EXPR
:
2773 case BINARY_LEFT_FOLD_EXPR
:
2774 case BINARY_RIGHT_FOLD_EXPR
:
2781 case VEC_DELETE_EXPR
:
2787 case UNORDERED_EXPR
:
2797 case FIX_TRUNC_EXPR
:
2802 case TRUTH_AND_EXPR
:
2804 case TRUTH_XOR_EXPR
:
2805 if (flags
& TFF_EXPR_IN_PARENS
)
2806 pp_cxx_left_paren (pp
);
2808 if (flags
& TFF_EXPR_IN_PARENS
)
2809 pp_cxx_right_paren (pp
);
2813 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2817 pp_string (pp
, M_("<lambda>"));
2821 pp_cxx_left_paren (pp
);
2822 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2823 pp_cxx_right_paren (pp
);
2827 pp_cxx_requires_expr (cxx_pp
, t
);
2831 pp_cxx_simple_requirement (cxx_pp
, t
);
2835 pp_cxx_type_requirement (cxx_pp
, t
);
2839 pp_cxx_compound_requirement (cxx_pp
, t
);
2843 pp_cxx_nested_requirement (cxx_pp
, t
);
2856 pp_cxx_constraint (cxx_pp
, t
);
2859 case PLACEHOLDER_EXPR
:
2860 pp_string (pp
, M_("*this"));
2864 dump_expr_list (pp
, t
, flags
);
2867 /* This list is incomplete, but should suffice for now.
2868 It is very important that `sorry' does not call
2869 `report_error_function'. That could cause an infinite loop. */
2871 pp_unsupported_tree (pp
, t
);
2874 pp_string (pp
, M_("<expression error>"));
2880 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2883 pp_cxx_left_paren (pp
);
2884 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2885 pp_cxx_whitespace (pp
);
2887 pp_cxx_ws_string (pp
, opstring
);
2889 pp_string (pp
, M_("<unknown operator>"));
2890 pp_cxx_whitespace (pp
);
2891 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2892 pp_cxx_right_paren (pp
);
2896 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2898 if (flags
& TFF_EXPR_IN_PARENS
)
2899 pp_cxx_left_paren (pp
);
2900 pp_cxx_ws_string (pp
, opstring
);
2901 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2902 if (flags
& TFF_EXPR_IN_PARENS
)
2903 pp_cxx_right_paren (pp
);
2907 reinit_cxx_pp (void)
2909 pp_clear_output_area (cxx_pp
);
2910 cxx_pp
->padding
= pp_none
;
2911 pp_indentation (cxx_pp
) = 0;
2912 pp_needs_newline (cxx_pp
) = false;
2913 cxx_pp
->enclosing_scope
= current_function_decl
;
2916 /* Same as pp_formatted_text, except the return string is a separate
2917 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2920 pp_ggc_formatted_text (pretty_printer
*pp
)
2922 return ggc_strdup (pp_formatted_text (pp
));
2925 /* Exported interface to stringifying types, exprs and decls under TFF_*
2929 type_as_string (tree typ
, int flags
)
2932 pp_translate_identifiers (cxx_pp
) = false;
2933 dump_type (cxx_pp
, typ
, flags
);
2934 return pp_ggc_formatted_text (cxx_pp
);
2938 type_as_string_translate (tree typ
, int flags
)
2941 dump_type (cxx_pp
, typ
, flags
);
2942 return pp_ggc_formatted_text (cxx_pp
);
2946 expr_as_string (tree decl
, int flags
)
2949 pp_translate_identifiers (cxx_pp
) = false;
2950 dump_expr (cxx_pp
, decl
, flags
);
2951 return pp_ggc_formatted_text (cxx_pp
);
2954 /* Wrap decl_as_string with options appropriate for dwarf. */
2957 decl_as_dwarf_string (tree decl
, int flags
)
2960 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2961 here will be adequate to get the desired behavior. */
2962 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2963 name
= decl_as_string (decl
, flags
);
2964 /* Subsequent calls to the pretty printer shouldn't use this style. */
2965 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2970 decl_as_string (tree decl
, int flags
)
2973 pp_translate_identifiers (cxx_pp
) = false;
2974 dump_decl (cxx_pp
, decl
, flags
);
2975 return pp_ggc_formatted_text (cxx_pp
);
2979 decl_as_string_translate (tree decl
, int flags
)
2982 dump_decl (cxx_pp
, decl
, flags
);
2983 return pp_ggc_formatted_text (cxx_pp
);
2986 /* Wrap lang_decl_name with options appropriate for dwarf. */
2989 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2992 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2993 here will be adequate to get the desired behavior. */
2994 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2995 name
= lang_decl_name (decl
, v
, translate
);
2996 /* Subsequent calls to the pretty printer shouldn't use this style. */
2997 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
3001 /* Generate the three forms of printable names for cxx_printable_name. */
3004 lang_decl_name (tree decl
, int v
, bool translate
)
3008 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
3009 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
3012 pp_translate_identifiers (cxx_pp
) = translate
;
3014 && (DECL_CLASS_SCOPE_P (decl
)
3015 || (DECL_NAMESPACE_SCOPE_P (decl
)
3016 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
3018 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
3019 pp_cxx_colon_colon (cxx_pp
);
3022 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3023 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
3024 else if ((DECL_NAME (decl
) == NULL_TREE
)
3025 && TREE_CODE (decl
) == NAMESPACE_DECL
)
3026 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
3028 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
3030 return pp_ggc_formatted_text (cxx_pp
);
3033 /* Return the location of a tree passed to %+ formats. */
3036 location_of (tree t
)
3040 t
= TYPE_MAIN_DECL (t
);
3042 return input_location
;
3044 else if (TREE_CODE (t
) == OVERLOAD
)
3048 return DECL_SOURCE_LOCATION (t
);
3049 return EXPR_LOC_OR_LOC (t
, input_location
);
3052 /* Now the interfaces from error et al to dump_type et al. Each takes an
3053 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
3057 decl_to_string (tree decl
, int verbose
)
3061 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
3062 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
3063 flags
= TFF_CLASS_KEY_OR_ENUM
;
3065 flags
|= TFF_DECL_SPECIFIERS
;
3066 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3067 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
3068 flags
|= TFF_TEMPLATE_HEADER
;
3071 dump_decl (cxx_pp
, decl
, flags
);
3072 return pp_ggc_formatted_text (cxx_pp
);
3076 expr_to_string (tree decl
)
3079 dump_expr (cxx_pp
, decl
, 0);
3080 return pp_ggc_formatted_text (cxx_pp
);
3084 fndecl_to_string (tree fndecl
, int verbose
)
3088 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
3089 | TFF_TEMPLATE_HEADER
;
3091 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3093 dump_decl (cxx_pp
, fndecl
, flags
);
3094 return pp_ggc_formatted_text (cxx_pp
);
3099 code_to_string (enum tree_code c
)
3101 return get_tree_code_name (c
);
3105 language_to_string (enum languages c
)
3112 case lang_cplusplus
:
3121 /* Return the proper printed version of a parameter to a C++ function. */
3124 parm_to_string (int p
)
3128 pp_string (cxx_pp
, "'this'");
3130 pp_decimal_int (cxx_pp
, p
+ 1);
3131 return pp_ggc_formatted_text (cxx_pp
);
3135 op_to_string (enum tree_code p
)
3137 tree id
= operator_name_info
[p
].identifier
;
3138 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3142 type_to_string (tree typ
, int verbose
)
3146 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3147 flags
|= TFF_TEMPLATE_HEADER
;
3150 dump_type (cxx_pp
, typ
, flags
);
3151 /* If we're printing a type that involves typedefs, also print the
3152 stripped version. But sometimes the stripped version looks
3153 exactly the same, so we don't want it after all. To avoid printing
3154 it in that case, we play ugly obstack games. */
3155 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3156 && !uses_template_parms (typ
))
3158 int aka_start
, aka_len
; char *p
;
3159 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3160 /* Remember the end of the initial dump. */
3161 int len
= obstack_object_size (ob
);
3162 tree aka
= strip_typedefs (typ
);
3163 pp_string (cxx_pp
, " {aka");
3164 pp_cxx_whitespace (cxx_pp
);
3165 /* And remember the start of the aka dump. */
3166 aka_start
= obstack_object_size (ob
);
3167 dump_type (cxx_pp
, aka
, flags
);
3168 aka_len
= obstack_object_size (ob
) - aka_start
;
3169 pp_right_brace (cxx_pp
);
3170 p
= (char*)obstack_base (ob
);
3171 /* If they are identical, cut off the aka with a NUL. */
3172 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3175 return pp_ggc_formatted_text (cxx_pp
);
3179 assop_to_string (enum tree_code p
)
3181 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3182 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3186 args_to_string (tree p
, int verbose
)
3190 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3195 if (TYPE_P (TREE_VALUE (p
)))
3196 return type_as_string_translate (p
, flags
);
3199 for (; p
; p
= TREE_CHAIN (p
))
3201 if (TREE_VALUE (p
) == null_node
)
3202 pp_cxx_ws_string (cxx_pp
, "NULL");
3204 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3206 pp_separate_with_comma (cxx_pp
);
3208 return pp_ggc_formatted_text (cxx_pp
);
3211 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3212 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3216 subst_to_string (tree p
)
3218 tree decl
= TREE_PURPOSE (p
);
3219 tree targs
= TREE_VALUE (p
);
3220 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3221 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3222 |TFF_NO_TEMPLATE_BINDINGS
);
3228 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3229 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3230 return pp_ggc_formatted_text (cxx_pp
);
3234 cv_to_string (tree p
, int v
)
3237 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3238 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3239 return pp_ggc_formatted_text (cxx_pp
);
3243 eh_spec_to_string (tree p
, int /*v*/)
3247 dump_exception_spec (cxx_pp
, p
, flags
);
3248 return pp_ggc_formatted_text (cxx_pp
);
3251 /* Langhook for print_error_function. */
3253 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3254 diagnostic_info
*diagnostic
)
3256 lhd_print_error_function (context
, file
, diagnostic
);
3257 pp_set_prefix (context
->printer
, file
);
3258 maybe_print_instantiation_context (context
);
3262 cp_diagnostic_starter (diagnostic_context
*context
,
3263 diagnostic_info
*diagnostic
)
3265 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3266 cp_print_error_function (context
, diagnostic
);
3267 maybe_print_instantiation_context (context
);
3268 maybe_print_constexpr_context (context
);
3269 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3273 /* Print current function onto BUFFER, in the process of reporting
3274 a diagnostic message. Called from cp_diagnostic_starter. */
3276 cp_print_error_function (diagnostic_context
*context
,
3277 diagnostic_info
*diagnostic
)
3279 /* If we are in an instantiation context, current_function_decl is likely
3280 to be wrong, so just rely on print_instantiation_full_context. */
3281 if (current_instantiation ())
3283 if (diagnostic_last_function_changed (context
, diagnostic
))
3285 const char *old_prefix
= context
->printer
->prefix
;
3286 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3287 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3288 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3289 ? file_name_as_prefix (context
, file
) : NULL
;
3291 pp_set_prefix (context
->printer
, new_prefix
);
3293 if (current_function_decl
== NULL
)
3294 pp_string (context
->printer
, _("At global scope:"));
3299 if (abstract_origin
)
3301 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3302 while (TREE_CODE (ao
) == BLOCK
3303 && BLOCK_ABSTRACT_ORIGIN (ao
)
3304 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3305 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3306 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3310 fndecl
= current_function_decl
;
3312 pp_printf (context
->printer
, function_category (fndecl
),
3313 cxx_printable_name_translate (fndecl
, 2));
3315 while (abstract_origin
)
3318 tree block
= abstract_origin
;
3320 locus
= &BLOCK_SOURCE_LOCATION (block
);
3322 block
= BLOCK_SUPERCONTEXT (block
);
3323 while (block
&& TREE_CODE (block
) == BLOCK
3324 && BLOCK_ABSTRACT_ORIGIN (block
))
3326 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3328 while (TREE_CODE (ao
) == BLOCK
3329 && BLOCK_ABSTRACT_ORIGIN (ao
)
3330 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3331 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3333 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3338 else if (TREE_CODE (ao
) != BLOCK
)
3341 block
= BLOCK_SUPERCONTEXT (block
);
3344 abstract_origin
= block
;
3347 while (block
&& TREE_CODE (block
) == BLOCK
)
3348 block
= BLOCK_SUPERCONTEXT (block
);
3350 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3352 abstract_origin
= NULL
;
3356 expanded_location s
= expand_location (*locus
);
3357 pp_character (context
->printer
, ',');
3358 pp_newline (context
->printer
);
3361 if (context
->show_column
&& s
.column
!= 0)
3362 pp_printf (context
->printer
,
3363 _(" inlined from %qs at %r%s:%d:%d%R"),
3364 cxx_printable_name_translate (fndecl
, 2),
3365 "locus", s
.file
, s
.line
, s
.column
);
3367 pp_printf (context
->printer
,
3368 _(" inlined from %qs at %r%s:%d%R"),
3369 cxx_printable_name_translate (fndecl
, 2),
3370 "locus", s
.file
, s
.line
);
3374 pp_printf (context
->printer
, _(" inlined from %qs"),
3375 cxx_printable_name_translate (fndecl
, 2));
3378 pp_character (context
->printer
, ':');
3380 pp_newline (context
->printer
);
3382 diagnostic_set_last_function (context
, diagnostic
);
3383 pp_destroy_prefix (context
->printer
);
3384 context
->printer
->prefix
= old_prefix
;
3388 /* Returns a description of FUNCTION using standard terminology. The
3389 result is a format string of the form "In CATEGORY %qs". */
3391 function_category (tree fn
)
3393 /* We can get called from the middle-end for diagnostics of function
3394 clones. Make sure we have language specific information before
3395 dereferencing it. */
3396 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3397 && DECL_FUNCTION_MEMBER_P (fn
))
3399 if (DECL_STATIC_FUNCTION_P (fn
))
3400 return _("In static member function %qs");
3401 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3402 return _("In copy constructor %qs");
3403 else if (DECL_CONSTRUCTOR_P (fn
))
3404 return _("In constructor %qs");
3405 else if (DECL_DESTRUCTOR_P (fn
))
3406 return _("In destructor %qs");
3407 else if (LAMBDA_FUNCTION_P (fn
))
3408 return _("In lambda function");
3410 return _("In member function %qs");
3413 return _("In function %qs");
3416 /* Report the full context of a current template instantiation,
3419 print_instantiation_full_context (diagnostic_context
*context
)
3421 struct tinst_level
*p
= current_instantiation ();
3422 location_t location
= input_location
;
3426 pp_verbatim (context
->printer
,
3427 TREE_CODE (p
->decl
) == TREE_LIST
3428 ? _("%s: In substitution of %qS:\n")
3429 : _("%s: In instantiation of %q#D:\n"),
3430 LOCATION_FILE (location
),
3433 location
= p
->locus
;
3437 print_instantiation_partial_context (context
, p
, location
);
3440 /* Helper function of print_instantiation_partial_context() that
3441 prints a single line of instantiation context. */
3444 print_instantiation_partial_context_line (diagnostic_context
*context
,
3445 const struct tinst_level
*t
,
3446 location_t loc
, bool recursive_p
)
3448 if (loc
== UNKNOWN_LOCATION
)
3451 expanded_location xloc
= expand_location (loc
);
3453 if (context
->show_column
)
3454 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3455 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3457 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3458 "locus", xloc
.file
, xloc
.line
);
3462 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3463 pp_verbatim (context
->printer
,
3465 ? _("recursively required by substitution of %qS\n")
3466 : _("required by substitution of %qS\n"),
3469 pp_verbatim (context
->printer
,
3471 ? _("recursively required from %q#D\n")
3472 : _("required from %q#D\n"),
3477 pp_verbatim (context
->printer
,
3479 ? _("recursively required from here\n")
3480 : _("required from here\n"));
3484 /* Same as print_instantiation_full_context but less verbose. */
3487 print_instantiation_partial_context (diagnostic_context
*context
,
3488 struct tinst_level
*t0
, location_t loc
)
3490 struct tinst_level
*t
;
3493 location_t prev_loc
= loc
;
3495 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3496 if (prev_loc
!= t
->locus
)
3498 prev_loc
= t
->locus
;
3504 if (template_backtrace_limit
3505 && n_total
> template_backtrace_limit
)
3507 int skip
= n_total
- template_backtrace_limit
;
3508 int head
= template_backtrace_limit
/ 2;
3510 /* Avoid skipping just 1. If so, skip 2. */
3514 head
= (template_backtrace_limit
- 1) / 2;
3517 for (n
= 0; n
< head
; n
++)
3519 gcc_assert (t
!= NULL
);
3520 if (loc
!= t
->locus
)
3521 print_instantiation_partial_context_line (context
, t
, loc
,
3522 /*recursive_p=*/false);
3526 if (t
!= NULL
&& skip
> 0)
3528 expanded_location xloc
;
3529 xloc
= expand_location (loc
);
3530 if (context
->show_column
)
3531 pp_verbatim (context
->printer
,
3532 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3533 "contexts, use -ftemplate-backtrace-limit=0 to "
3535 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3537 pp_verbatim (context
->printer
,
3538 _("%r%s:%d:%R [ skipping %d instantiation "
3539 "contexts, use -ftemplate-backtrace-limit=0 to "
3541 "locus", xloc
.file
, xloc
.line
, skip
);
3546 } while (t
!= NULL
&& --skip
> 0);
3552 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3557 print_instantiation_partial_context_line (context
, t
, loc
,
3562 print_instantiation_partial_context_line (context
, NULL
, loc
,
3563 /*recursive_p=*/false);
3566 /* Called from cp_thing to print the template context for an error. */
3568 maybe_print_instantiation_context (diagnostic_context
*context
)
3570 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3573 record_last_problematic_instantiation ();
3574 print_instantiation_full_context (context
);
3577 /* Report what constexpr call(s) we're trying to expand, if any. */
3580 maybe_print_constexpr_context (diagnostic_context
*context
)
3582 vec
<tree
> call_stack
= cx_error_context ();
3586 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3588 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3589 const char *s
= expr_as_string (t
, 0);
3590 if (context
->show_column
)
3591 pp_verbatim (context
->printer
,
3592 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3593 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3595 pp_verbatim (context
->printer
,
3596 _("%r%s:%d:%R in constexpr expansion of %qs"),
3597 "locus", xloc
.file
, xloc
.line
, s
);
3598 pp_newline (context
->printer
);
3603 /* Return true iff TYPE_A and TYPE_B are template types that are
3604 meaningful to compare. */
3607 comparable_template_types_p (tree type_a
, tree type_b
)
3609 if (!CLASS_TYPE_P (type_a
))
3611 if (!CLASS_TYPE_P (type_b
))
3614 tree tinfo_a
= TYPE_TEMPLATE_INFO (type_a
);
3615 tree tinfo_b
= TYPE_TEMPLATE_INFO (type_b
);
3616 if (!tinfo_a
|| !tinfo_b
)
3619 return TI_TEMPLATE (tinfo_a
) == TI_TEMPLATE (tinfo_b
);
3622 /* Start a new line indented by SPC spaces on PP. */
3625 newline_and_indent (pretty_printer
*pp
, int spc
)
3628 for (int i
= 0; i
< spc
; i
++)
3632 /* Generate a GC-allocated string for ARG, an expression or type. */
3635 arg_to_string (tree arg
, bool verbose
)
3638 return type_to_string (arg
, verbose
);
3640 return expr_to_string (arg
);
3643 /* Subroutine to type_to_string_with_compare and
3644 print_template_tree_comparison.
3646 Print a representation of ARG (an expression or type) to PP,
3647 colorizing it as "type-diff" if PP->show_color. */
3650 print_nonequal_arg (pretty_printer
*pp
, tree arg
, bool verbose
)
3652 pp_printf (pp
, "%r%s%R",
3655 ? arg_to_string (arg
, verbose
)
3656 : G_("(no argument)")));
3659 /* Recursively print template TYPE_A to PP, as compared to template TYPE_B.
3661 The types must satisfy comparable_template_types_p.
3663 If INDENT is 0, then this is equivalent to type_to_string (TYPE_A), but
3664 potentially colorizing/eliding in comparison with TYPE_B.
3666 For example given types:
3667 vector<map<int,double>>
3669 vector<map<int,float>>
3670 then the result on PP would be:
3671 vector<map<[...],double>>
3672 with type elision, and:
3673 vector<map<int,double>>
3674 without type elision.
3676 In both cases the parts of TYPE that differ from PEER will be colorized
3677 if pp_show_color (pp) is true. In the above example, this would be
3680 If INDENT is non-zero, then the types are printed in a tree-like form
3681 which shows both types. In the above example, the result on PP would be:
3688 and without type-elision would be:
3695 As before, the differing parts of the types are colorized if
3696 pp_show_color (pp) is true ("double" and "float" in this example).
3698 Template arguments in which both types are using the default arguments
3699 are not printed; if at least one of the two types is using a non-default
3700 argument, then that argument is printed (or both arguments for the
3701 tree-like print format). */
3704 print_template_differences (pretty_printer
*pp
, tree type_a
, tree type_b
,
3705 bool verbose
, int indent
)
3708 newline_and_indent (pp
, indent
);
3710 tree tinfo_a
= TYPE_TEMPLATE_INFO (type_a
);
3711 tree tinfo_b
= TYPE_TEMPLATE_INFO (type_b
);
3713 pp_printf (pp
, "%s<",
3714 IDENTIFIER_POINTER (DECL_NAME (TI_TEMPLATE (tinfo_a
))));
3716 tree args_a
= TI_ARGS (tinfo_a
);
3717 tree args_b
= TI_ARGS (tinfo_b
);
3718 gcc_assert (TREE_CODE (args_a
) == TREE_VEC
);
3719 gcc_assert (TREE_CODE (args_b
) == TREE_VEC
);
3721 int len_a
= get_non_default_template_args_count (args_a
, flags
);
3722 args_a
= INNERMOST_TEMPLATE_ARGS (args_a
);
3723 int len_b
= get_non_default_template_args_count (args_b
, flags
);
3724 args_b
= INNERMOST_TEMPLATE_ARGS (args_b
);
3725 /* Determine the maximum range of args for which non-default template args
3726 were used; beyond this, only default args (if any) were used, and so
3727 they will be equal from this point onwards.
3728 One of the two peers might have used default arguments within this
3729 range, but the other will be using non-default arguments, and so
3730 it's more readable to print both within this range, to highlight
3732 int len_max
= MAX (len_a
, len_b
);
3733 gcc_assert (TREE_CODE (args_a
) == TREE_VEC
);
3734 gcc_assert (TREE_CODE (args_b
) == TREE_VEC
);
3735 for (int idx
= 0; idx
< len_max
; idx
++)
3738 pp_character (pp
, ',');
3740 tree arg_a
= TREE_VEC_ELT (args_a
, idx
);
3741 tree arg_b
= TREE_VEC_ELT (args_b
, idx
);
3745 newline_and_indent (pp
, indent
+ 2);
3746 /* Can do elision here, printing "[...]". */
3747 if (flag_elide_type
)
3748 pp_string (pp
, G_("[...]"));
3750 pp_string (pp
, arg_to_string (arg_a
, verbose
));
3754 int new_indent
= indent
? indent
+ 2 : 0;
3755 if (comparable_template_types_p (arg_a
, arg_b
))
3756 print_template_differences (pp
, arg_a
, arg_b
, verbose
, new_indent
);
3760 newline_and_indent (pp
, indent
+ 2);
3761 pp_character (pp
, '[');
3762 print_nonequal_arg (pp
, arg_a
, verbose
);
3763 pp_string (pp
, " != ");
3764 print_nonequal_arg (pp
, arg_b
, verbose
);
3765 pp_character (pp
, ']');
3768 print_nonequal_arg (pp
, arg_a
, verbose
);
3771 pp_printf (pp
, ">");
3774 /* As type_to_string, but for a template, potentially colorizing/eliding
3775 in comparison with PEER.
3776 For example, if TYPE is map<int,double> and PEER is map<int,int>,
3777 then the resulting string would be:
3779 with type elision, and:
3781 without type elision.
3783 In both cases the parts of TYPE that differ from PEER will be colorized
3784 if SHOW_COLOR is true. In the above example, this would be "double".
3786 Template arguments in which both types are using the default arguments
3787 are not printed; if at least one of the two types is using a non-default
3788 argument, then both arguments are printed.
3790 The resulting string is in a GC-allocated buffer. */
3793 type_to_string_with_compare (tree type
, tree peer
, bool verbose
,
3796 pretty_printer inner_pp
;
3797 pretty_printer
*pp
= &inner_pp
;
3798 pp_show_color (pp
) = show_color
;
3800 print_template_differences (pp
, type
, peer
, verbose
, 0);
3801 return pp_ggc_formatted_text (pp
);
3804 /* Recursively print a tree-like comparison of TYPE_A and TYPE_B to PP,
3805 indented by INDENT spaces.
3807 For example given types:
3809 vector<map<int,double>>
3813 vector<map<double,float>>
3815 the output with type elision would be:
3822 and without type-elision would be:
3829 TYPE_A and TYPE_B must both be comparable template types
3830 (as per comparable_template_types_p).
3832 Template arguments in which both types are using the default arguments
3833 are not printed; if at least one of the two types is using a non-default
3834 argument, then both arguments are printed. */
3837 print_template_tree_comparison (pretty_printer
*pp
, tree type_a
, tree type_b
,
3838 bool verbose
, int indent
)
3840 print_template_differences (pp
, type_a
, type_b
, verbose
, indent
);
3843 /* Subroutine for use in a format_postprocessor::handle
3844 implementation. Adds a chunk to the end of
3845 formatted output, so that it will be printed
3846 by pp_output_formatted_text. */
3849 append_formatted_chunk (pretty_printer
*pp
, const char *content
)
3851 output_buffer
*buffer
= pp_buffer (pp
);
3852 struct chunk_info
*chunk_array
= buffer
->cur_chunk_array
;
3853 const char **args
= chunk_array
->args
;
3855 unsigned int chunk_idx
;
3856 for (chunk_idx
= 0; args
[chunk_idx
]; chunk_idx
++)
3858 args
[chunk_idx
++] = content
;
3859 args
[chunk_idx
] = NULL
;
3862 /* Create a copy of CONTENT, with quotes added, and,
3863 potentially, with colorization.
3864 No escaped is performed on CONTENT.
3865 The result is in a GC-allocated buffer. */
3868 add_quotes (const char *content
, bool show_color
)
3870 pretty_printer tmp_pp
;
3871 pp_show_color (&tmp_pp
) = show_color
;
3873 /* We have to use "%<%s%>" rather than "%qs" here in order to avoid
3874 quoting colorization bytes within the results. */
3875 pp_printf (&tmp_pp
, "%<%s%>", content
);
3877 return pp_ggc_formatted_text (&tmp_pp
);
3880 /* If we had %H and %I, and hence deferred printing them,
3881 print them now, storing the result into the chunk_info
3882 for pp_format. Quote them if 'q' was provided.
3883 Also print the difference in tree form, adding it as
3884 an additional chunk. */
3887 cxx_format_postprocessor::handle (pretty_printer
*pp
)
3889 /* If we have one of %H and %I, the other should have
3891 if (m_type_a
.m_tree
|| m_type_b
.m_tree
)
3893 /* Avoid reentrancy issues by working with a copy of
3894 m_type_a and m_type_b, resetting them now. */
3895 deferred_printed_type type_a
= m_type_a
;
3896 deferred_printed_type type_b
= m_type_b
;
3897 m_type_a
= deferred_printed_type ();
3898 m_type_b
= deferred_printed_type ();
3900 gcc_assert (type_a
.m_buffer_ptr
);
3901 gcc_assert (type_b
.m_buffer_ptr
);
3903 bool show_color
= pp_show_color (pp
);
3905 const char *type_a_text
;
3906 const char *type_b_text
;
3908 if (comparable_template_types_p (type_a
.m_tree
, type_b
.m_tree
))
3911 = type_to_string_with_compare (type_a
.m_tree
, type_b
.m_tree
,
3912 type_a
.m_verbose
, show_color
);
3914 = type_to_string_with_compare (type_b
.m_tree
, type_a
.m_tree
,
3915 type_b
.m_verbose
, show_color
);
3917 if (flag_diagnostics_show_template_tree
)
3919 pretty_printer inner_pp
;
3920 pp_show_color (&inner_pp
) = pp_show_color (pp
);
3921 print_template_tree_comparison
3922 (&inner_pp
, type_a
.m_tree
, type_b
.m_tree
, type_a
.m_verbose
, 2);
3923 append_formatted_chunk (pp
, pp_ggc_formatted_text (&inner_pp
));
3928 /* If the types were not comparable, they are printed normally,
3929 and no difference tree is printed. */
3930 type_a_text
= type_to_string (type_a
.m_tree
, type_a
.m_verbose
);
3931 type_b_text
= type_to_string (type_b
.m_tree
, type_b
.m_verbose
);
3935 type_a_text
= add_quotes (type_a_text
, show_color
);
3936 *type_a
.m_buffer_ptr
= type_a_text
;
3939 type_b_text
= add_quotes (type_b_text
, show_color
);
3940 *type_b
.m_buffer_ptr
= type_b_text
;
3944 /* Subroutine for handling %H and %I, to support i18n of messages like:
3946 error_at (loc, "could not convert %qE from %qH to %qI",
3947 expr, type_a, type_b);
3949 so that we can print things like:
3951 could not convert 'foo' from 'map<int,double>' to 'map<int,int>'
3953 and, with type-elision:
3955 could not convert 'foo' from 'map<[...],double>' to 'map<[...],int>'
3957 (with color-coding of the differences between the types).
3959 The %H and %I format codes are peers: both must be present,
3960 and they affect each other. Hence to handle them, we must
3961 delay printing until we have both, deferring the printing to
3962 pretty_printer's m_format_postprocessor hook.
3964 This is called in phase 2 of pp_format, when it is accumulating
3965 a series of formatted chunks. We stash the location of the chunk
3966 we're meant to have written to, so that we can write to it in the
3967 m_format_postprocessor hook.
3969 We also need to stash whether a 'q' prefix was provided (the QUOTE
3970 param) so that we can add the quotes when writing out the delayed
3974 defer_phase_2_of_type_diff (deferred_printed_type
*deferred
,
3975 tree type
, const char **buffer_ptr
,
3976 bool verbose
, bool quote
)
3978 gcc_assert (deferred
->m_tree
== NULL_TREE
);
3979 gcc_assert (deferred
->m_buffer_ptr
== NULL
);
3980 *deferred
= deferred_printed_type (type
, buffer_ptr
, verbose
, quote
);
3984 /* Called from output_format -- during diagnostic message processing --
3985 to handle C++ specific format specifier with the following meanings:
3986 %A function argument-list.
3990 %F function declaration.
3991 %L language as used in extern "lang".
3993 %P function parameter whose position is indicated by an integer.
3994 %Q assignment operator.
3995 %S substitution (template + args)
3998 %X exception-specification.
3999 %H type difference (from)
4000 %I type difference (to). */
4002 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
4003 int precision
, bool wide
, bool set_locus
, bool verbose
,
4004 bool quoted
, const char **buffer_ptr
)
4006 gcc_assert (pp
->m_format_postprocessor
);
4007 cxx_format_postprocessor
*postprocessor
4008 = static_cast <cxx_format_postprocessor
*> (pp
->m_format_postprocessor
);
4012 #define next_tree (t = va_arg (*text->args_ptr, tree))
4013 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
4014 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
4015 #define next_int va_arg (*text->args_ptr, int)
4017 if (precision
!= 0 || wide
)
4022 case 'A': result
= args_to_string (next_tree
, verbose
); break;
4023 case 'C': result
= code_to_string (next_tcode
); break;
4026 tree temp
= next_tree
;
4028 && DECL_HAS_DEBUG_EXPR_P (temp
))
4030 temp
= DECL_DEBUG_EXPR (temp
);
4033 result
= expr_to_string (temp
);
4037 result
= decl_to_string (temp
, verbose
);
4040 case 'E': result
= expr_to_string (next_tree
); break;
4041 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
4042 case 'L': result
= language_to_string (next_lang
); break;
4043 case 'O': result
= op_to_string (next_tcode
); break;
4044 case 'P': result
= parm_to_string (next_int
); break;
4045 case 'Q': result
= assop_to_string (next_tcode
); break;
4046 case 'S': result
= subst_to_string (next_tree
); break;
4047 case 'T': result
= type_to_string (next_tree
, verbose
); break;
4048 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
4049 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
4052 percent_K_format (text
);
4057 defer_phase_2_of_type_diff (&postprocessor
->m_type_a
, next_tree
,
4058 buffer_ptr
, verbose
, quoted
);
4064 defer_phase_2_of_type_diff (&postprocessor
->m_type_b
, next_tree
,
4065 buffer_ptr
, verbose
, quoted
);
4073 pp_string (pp
, result
);
4074 if (set_locus
&& t
!= NULL
)
4075 text
->set_location (0, location_of (t
), true);
4083 /* Warn about the use of C++0x features when appropriate. */
4085 maybe_warn_cpp0x (cpp0x_warn_str str
)
4087 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
4088 /* We really want to suppress this warning in system headers,
4089 because libstdc++ uses variadic templates even when we aren't
4093 case CPP0X_INITIALIZER_LISTS
:
4094 pedwarn (input_location
, 0,
4095 "extended initializer lists "
4096 "only available with -std=c++11 or -std=gnu++11");
4098 case CPP0X_EXPLICIT_CONVERSION
:
4099 pedwarn (input_location
, 0,
4100 "explicit conversion operators "
4101 "only available with -std=c++11 or -std=gnu++11");
4103 case CPP0X_VARIADIC_TEMPLATES
:
4104 pedwarn (input_location
, 0,
4105 "variadic templates "
4106 "only available with -std=c++11 or -std=gnu++11");
4108 case CPP0X_LAMBDA_EXPR
:
4109 pedwarn (input_location
, 0,
4110 "lambda expressions "
4111 "only available with -std=c++11 or -std=gnu++11");
4114 pedwarn (input_location
, 0,
4115 "C++11 auto only available with -std=c++11 or -std=gnu++11");
4117 case CPP0X_SCOPED_ENUMS
:
4118 pedwarn (input_location
, 0,
4119 "scoped enums only available with -std=c++11 or -std=gnu++11");
4121 case CPP0X_DEFAULTED_DELETED
:
4122 pedwarn (input_location
, 0,
4123 "defaulted and deleted functions "
4124 "only available with -std=c++11 or -std=gnu++11");
4126 case CPP0X_INLINE_NAMESPACES
:
4127 pedwarn (input_location
, OPT_Wpedantic
,
4128 "inline namespaces "
4129 "only available with -std=c++11 or -std=gnu++11");
4131 case CPP0X_OVERRIDE_CONTROLS
:
4132 pedwarn (input_location
, 0,
4133 "override controls (override/final) "
4134 "only available with -std=c++11 or -std=gnu++11");
4137 pedwarn (input_location
, 0,
4138 "non-static data member initializers "
4139 "only available with -std=c++11 or -std=gnu++11");
4141 case CPP0X_USER_DEFINED_LITERALS
:
4142 pedwarn (input_location
, 0,
4143 "user-defined literals "
4144 "only available with -std=c++11 or -std=gnu++11");
4146 case CPP0X_DELEGATING_CTORS
:
4147 pedwarn (input_location
, 0,
4148 "delegating constructors "
4149 "only available with -std=c++11 or -std=gnu++11");
4151 case CPP0X_INHERITING_CTORS
:
4152 pedwarn (input_location
, 0,
4153 "inheriting constructors "
4154 "only available with -std=c++11 or -std=gnu++11");
4156 case CPP0X_ATTRIBUTES
:
4157 pedwarn (input_location
, 0,
4159 "only available with -std=c++11 or -std=gnu++11");
4161 case CPP0X_REF_QUALIFIER
:
4162 pedwarn (input_location
, 0,
4164 "only available with -std=c++11 or -std=gnu++11");
4171 /* Warn about the use of variadic templates when appropriate. */
4173 maybe_warn_variadic_templates (void)
4175 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
4179 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
4180 option OPT with text GMSGID. Use this function to report
4181 diagnostics for constructs that are invalid C++98, but valid
4184 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
4186 diagnostic_info diagnostic
;
4189 rich_location
richloc (line_table
, location
);
4191 va_start (ap
, gmsgid
);
4192 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
4193 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
4194 diagnostic
.option_index
= opt
;
4195 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
4200 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
4201 we found when we tried to do the lookup. LOCATION is the location of
4202 the NAME identifier. */
4205 qualified_name_lookup_error (tree scope
, tree name
,
4206 tree decl
, location_t location
)
4208 if (scope
== error_mark_node
)
4209 ; /* We already complained. */
4210 else if (TYPE_P (scope
))
4212 if (!COMPLETE_TYPE_P (scope
))
4213 error_at (location
, "incomplete type %qT used in nested name specifier",
4215 else if (TREE_CODE (decl
) == TREE_LIST
)
4217 error_at (location
, "reference to %<%T::%D%> is ambiguous",
4219 print_candidates (decl
);
4222 error_at (location
, "%qD is not a member of %qT", name
, scope
);
4224 else if (scope
!= global_namespace
)
4226 error_at (location
, "%qD is not a member of %qD", name
, scope
);
4227 if (!suggest_alternative_in_explicit_scope (location
, name
, scope
))
4228 suggest_alternatives_for (location
, name
, false);
4232 error_at (location
, "%<::%D%> has not been declared", name
);
4233 suggest_alternatives_for (location
, name
, true);