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_TYPENAME_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 (TREE_CODE (ob
) != PARM_DECL
2198 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2200 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2205 if (flag_sanitize
& SANITIZE_UNDEFINED
2206 && is_ubsan_builtin_p (fn
))
2208 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2211 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2212 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2217 /* Note that this only works for G++ target exprs. If somebody
2218 builds a general TARGET_EXPR, there's no way to represent that
2219 it initializes anything other that the parameter slot for the
2220 default argument. Note we may have cleared out the first
2221 operand in expand_expr, so don't go killing ourselves. */
2222 if (TREE_OPERAND (t
, 1))
2223 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2226 case POINTER_PLUS_EXPR
:
2227 dump_binary_op (pp
, "+", t
, flags
);
2232 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2239 case TRUNC_DIV_EXPR
:
2240 case TRUNC_MOD_EXPR
:
2248 case TRUTH_ANDIF_EXPR
:
2249 case TRUTH_ORIF_EXPR
:
2256 case EXACT_DIV_EXPR
:
2257 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2261 case FLOOR_DIV_EXPR
:
2262 case ROUND_DIV_EXPR
:
2264 dump_binary_op (pp
, "/", t
, flags
);
2268 case FLOOR_MOD_EXPR
:
2269 case ROUND_MOD_EXPR
:
2270 dump_binary_op (pp
, "%", t
, flags
);
2275 tree ob
= TREE_OPERAND (t
, 0);
2276 if (INDIRECT_REF_P (ob
))
2278 ob
= TREE_OPERAND (ob
, 0);
2279 if (TREE_CODE (ob
) != PARM_DECL
2281 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2283 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2284 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2292 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2293 if (TREE_CODE (ob
) != ARROW_EXPR
)
2296 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2301 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2302 pp_cxx_left_bracket (pp
);
2303 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2304 pp_cxx_right_bracket (pp
);
2307 case ARRAY_NOTATION_REF
:
2308 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2309 pp_cxx_left_bracket (pp
);
2310 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2312 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2314 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2315 pp_cxx_right_bracket (pp
);
2318 case UNARY_PLUS_EXPR
:
2319 dump_unary_op (pp
, "+", t
, flags
);
2323 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2324 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2325 /* An ADDR_EXPR can have reference type. In that case, we
2326 shouldn't print the `&' doing so indicates to the user
2327 that the expression has pointer type. */
2329 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2330 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2331 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2332 dump_unary_op (pp
, "&&", t
, flags
);
2334 dump_unary_op (pp
, "&", t
, flags
);
2338 if (TREE_HAS_CONSTRUCTOR (t
))
2340 t
= TREE_OPERAND (t
, 0);
2341 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2342 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2343 dump_call_expr_args (pp
, t
, flags
, true);
2347 if (TREE_OPERAND (t
,0) != NULL_TREE
2348 && TREE_TYPE (TREE_OPERAND (t
, 0))
2349 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2350 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2352 dump_unary_op (pp
, "*", t
, flags
);
2357 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2358 && integer_zerop (TREE_OPERAND (t
, 1)))
2359 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2363 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2365 pp_cxx_left_paren (pp
);
2366 if (!integer_onep (TYPE_SIZE_UNIT
2367 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2369 pp_cxx_left_paren (pp
);
2370 dump_type (pp
, ptr_type_node
, flags
);
2371 pp_cxx_right_paren (pp
);
2374 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2375 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2377 pp_cxx_ws_string (pp
, "+");
2378 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2380 pp_cxx_right_paren (pp
);
2387 case TRUTH_NOT_EXPR
:
2388 case PREDECREMENT_EXPR
:
2389 case PREINCREMENT_EXPR
:
2390 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2393 case POSTDECREMENT_EXPR
:
2394 case POSTINCREMENT_EXPR
:
2395 pp_cxx_left_paren (pp
);
2396 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2397 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2398 pp_cxx_right_paren (pp
);
2401 case NON_LVALUE_EXPR
:
2402 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2403 should be another level of INDIRECT_REF so that I don't have to do
2405 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2407 tree next
= TREE_TYPE (TREE_TYPE (t
));
2409 while (TYPE_PTR_P (next
))
2410 next
= TREE_TYPE (next
);
2412 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2414 if (flags
& TFF_EXPR_IN_PARENS
)
2415 pp_cxx_left_paren (pp
);
2417 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2418 if (flags
& TFF_EXPR_IN_PARENS
)
2419 pp_cxx_right_paren (pp
);
2422 /* Else fall through. */
2424 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2428 case IMPLICIT_CONV_EXPR
:
2429 case VIEW_CONVERT_EXPR
:
2431 tree op
= TREE_OPERAND (t
, 0);
2432 tree ttype
= TREE_TYPE (t
);
2433 tree optype
= TREE_TYPE (op
);
2435 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2436 && POINTER_TYPE_P (ttype
)
2437 && POINTER_TYPE_P (optype
)
2438 && same_type_p (TREE_TYPE (optype
),
2441 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2444 if (TREE_CODE (op
) == ADDR_EXPR
)
2445 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2447 dump_unary_op (pp
, "*", t
, flags
);
2450 dump_unary_op (pp
, "&", t
, flags
);
2452 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2454 /* It is a cast, but we cannot tell whether it is a
2455 reinterpret or static cast. Use the C style notation. */
2456 if (flags
& TFF_EXPR_IN_PARENS
)
2457 pp_cxx_left_paren (pp
);
2458 pp_cxx_left_paren (pp
);
2459 dump_type (pp
, TREE_TYPE (t
), flags
);
2460 pp_cxx_right_paren (pp
);
2461 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2462 if (flags
& TFF_EXPR_IN_PARENS
)
2463 pp_cxx_right_paren (pp
);
2466 dump_expr (pp
, op
, flags
);
2471 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2473 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2475 if (integer_zerop (idx
))
2477 /* A NULL pointer-to-member constant. */
2478 pp_cxx_left_paren (pp
);
2479 pp_cxx_left_paren (pp
);
2480 dump_type (pp
, TREE_TYPE (t
), flags
);
2481 pp_cxx_right_paren (pp
);
2482 pp_character (pp
, '0');
2483 pp_cxx_right_paren (pp
);
2486 else if (tree_fits_shwi_p (idx
))
2489 unsigned HOST_WIDE_INT n
;
2491 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2492 t
= TYPE_METHOD_BASETYPE (t
);
2493 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2495 n
= tree_to_shwi (idx
);
2497 /* Map vtable index back one, to allow for the null pointer to
2501 while (n
> 0 && virtuals
)
2504 virtuals
= TREE_CHAIN (virtuals
);
2508 dump_expr (pp
, BV_FN (virtuals
),
2509 flags
| TFF_EXPR_IN_PARENS
);
2514 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2515 pp_string (pp
, "<lambda closure object>");
2516 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2518 dump_type (pp
, TREE_TYPE (t
), 0);
2519 pp_cxx_left_paren (pp
);
2520 pp_cxx_right_paren (pp
);
2524 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2525 dump_type (pp
, TREE_TYPE (t
), 0);
2526 pp_cxx_left_brace (pp
);
2527 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2528 pp_cxx_right_brace (pp
);
2535 tree ob
= TREE_OPERAND (t
, 0);
2536 if (is_dummy_object (ob
))
2538 t
= TREE_OPERAND (t
, 1);
2539 if (TREE_CODE (t
) == FUNCTION_DECL
)
2541 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2542 else if (BASELINK_P (t
))
2543 dump_expr (pp
, OVL_FIRST (BASELINK_FUNCTIONS (t
)),
2544 flags
| TFF_EXPR_IN_PARENS
);
2546 dump_decl (pp
, t
, flags
);
2550 if (INDIRECT_REF_P (ob
))
2552 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2558 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2562 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2567 case TEMPLATE_PARM_INDEX
:
2568 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2572 if (TREE_OPERAND (t
, 0) == NULL_TREE
2573 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2575 dump_type (pp
, TREE_TYPE (t
), flags
);
2576 pp_cxx_left_paren (pp
);
2577 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2578 pp_cxx_right_paren (pp
);
2582 pp_cxx_left_paren (pp
);
2583 dump_type (pp
, TREE_TYPE (t
), flags
);
2584 pp_cxx_right_paren (pp
);
2585 pp_cxx_left_paren (pp
);
2586 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2587 pp_cxx_right_paren (pp
);
2591 case STATIC_CAST_EXPR
:
2592 pp_cxx_ws_string (pp
, "static_cast");
2594 case REINTERPRET_CAST_EXPR
:
2595 pp_cxx_ws_string (pp
, "reinterpret_cast");
2597 case CONST_CAST_EXPR
:
2598 pp_cxx_ws_string (pp
, "const_cast");
2600 case DYNAMIC_CAST_EXPR
:
2601 pp_cxx_ws_string (pp
, "dynamic_cast");
2603 pp_cxx_begin_template_argument_list (pp
);
2604 dump_type (pp
, TREE_TYPE (t
), flags
);
2605 pp_cxx_end_template_argument_list (pp
);
2606 pp_cxx_left_paren (pp
);
2607 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2608 pp_cxx_right_paren (pp
);
2612 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2618 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2619 pp_cxx_ws_string (pp
, "sizeof");
2622 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2623 pp_cxx_ws_string (pp
, "__alignof__");
2625 op
= TREE_OPERAND (t
, 0);
2626 if (PACK_EXPANSION_P (op
))
2628 pp_string (pp
, "...");
2629 op
= PACK_EXPANSION_PATTERN (op
);
2631 pp_cxx_whitespace (pp
);
2632 pp_cxx_left_paren (pp
);
2633 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2634 dump_type (pp
, TREE_TYPE (op
), flags
);
2635 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2636 dump_type (pp
, op
, flags
);
2638 dump_expr (pp
, op
, flags
);
2639 pp_cxx_right_paren (pp
);
2642 case AT_ENCODE_EXPR
:
2643 pp_cxx_ws_string (pp
, "@encode");
2644 pp_cxx_whitespace (pp
);
2645 pp_cxx_left_paren (pp
);
2646 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2647 pp_cxx_right_paren (pp
);
2651 pp_cxx_ws_string (pp
, "noexcept");
2652 pp_cxx_whitespace (pp
);
2653 pp_cxx_left_paren (pp
);
2654 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2655 pp_cxx_right_paren (pp
);
2660 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2661 pp_cxx_whitespace (pp
);
2662 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2666 pp_string (pp
, M_("<unparsed>"));
2669 case TRY_CATCH_EXPR
:
2670 case WITH_CLEANUP_EXPR
:
2671 case CLEANUP_POINT_EXPR
:
2672 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2675 case PSEUDO_DTOR_EXPR
:
2676 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2678 if (TREE_OPERAND (t
, 1))
2680 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2681 pp_cxx_colon_colon (pp
);
2683 pp_cxx_complement (pp
);
2684 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2687 case TEMPLATE_ID_EXPR
:
2688 dump_decl (pp
, t
, flags
);
2694 case STATEMENT_LIST
:
2695 /* We don't yet have a way of dumping statements in a
2696 human-readable format. */
2697 pp_string (pp
, "({...})");
2701 pp_string (pp
, "while (1) { ");
2702 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2703 pp_cxx_right_brace (pp
);
2707 pp_string (pp
, "if (");
2708 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2709 pp_string (pp
, ") break; ");
2713 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2716 case EMPTY_CLASS_EXPR
:
2717 dump_type (pp
, TREE_TYPE (t
), flags
);
2718 pp_cxx_left_paren (pp
);
2719 pp_cxx_right_paren (pp
);
2722 case NON_DEPENDENT_EXPR
:
2723 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2726 case ARGUMENT_PACK_SELECT
:
2727 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2739 pp_type_specifier_seq (pp
, t
);
2743 /* We get here when we want to print a dependent type as an
2744 id-expression, without any disambiguator decoration. */
2745 pp
->id_expression (t
);
2748 case TEMPLATE_TYPE_PARM
:
2749 case TEMPLATE_TEMPLATE_PARM
:
2750 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2751 dump_type (pp
, t
, flags
);
2755 pp_cxx_trait_expression (pp
, t
);
2759 pp_cxx_va_arg_expression (pp
, t
);
2763 pp_cxx_offsetof_expression (pp
, t
);
2766 case ADDRESSOF_EXPR
:
2767 pp_cxx_addressof_expression (pp
, t
);
2771 dump_decl (pp
, t
, flags
);
2774 case EXPR_PACK_EXPANSION
:
2775 case UNARY_LEFT_FOLD_EXPR
:
2776 case UNARY_RIGHT_FOLD_EXPR
:
2777 case BINARY_LEFT_FOLD_EXPR
:
2778 case BINARY_RIGHT_FOLD_EXPR
:
2785 case VEC_DELETE_EXPR
:
2791 case UNORDERED_EXPR
:
2801 case FIX_TRUNC_EXPR
:
2806 case TRUTH_AND_EXPR
:
2808 case TRUTH_XOR_EXPR
:
2809 if (flags
& TFF_EXPR_IN_PARENS
)
2810 pp_cxx_left_paren (pp
);
2812 if (flags
& TFF_EXPR_IN_PARENS
)
2813 pp_cxx_right_paren (pp
);
2817 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2821 pp_string (pp
, M_("<lambda>"));
2825 pp_cxx_left_paren (pp
);
2826 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2827 pp_cxx_right_paren (pp
);
2831 pp_cxx_requires_expr (cxx_pp
, t
);
2835 pp_cxx_simple_requirement (cxx_pp
, t
);
2839 pp_cxx_type_requirement (cxx_pp
, t
);
2843 pp_cxx_compound_requirement (cxx_pp
, t
);
2847 pp_cxx_nested_requirement (cxx_pp
, t
);
2860 pp_cxx_constraint (cxx_pp
, t
);
2863 case PLACEHOLDER_EXPR
:
2864 pp_string (pp
, M_("*this"));
2868 dump_expr_list (pp
, t
, flags
);
2871 /* This list is incomplete, but should suffice for now.
2872 It is very important that `sorry' does not call
2873 `report_error_function'. That could cause an infinite loop. */
2875 pp_unsupported_tree (pp
, t
);
2878 pp_string (pp
, M_("<expression error>"));
2884 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2887 pp_cxx_left_paren (pp
);
2888 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2889 pp_cxx_whitespace (pp
);
2891 pp_cxx_ws_string (pp
, opstring
);
2893 pp_string (pp
, M_("<unknown operator>"));
2894 pp_cxx_whitespace (pp
);
2895 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2896 pp_cxx_right_paren (pp
);
2900 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2902 if (flags
& TFF_EXPR_IN_PARENS
)
2903 pp_cxx_left_paren (pp
);
2904 pp_cxx_ws_string (pp
, opstring
);
2905 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2906 if (flags
& TFF_EXPR_IN_PARENS
)
2907 pp_cxx_right_paren (pp
);
2911 reinit_cxx_pp (void)
2913 pp_clear_output_area (cxx_pp
);
2914 cxx_pp
->padding
= pp_none
;
2915 pp_indentation (cxx_pp
) = 0;
2916 pp_needs_newline (cxx_pp
) = false;
2917 cxx_pp
->enclosing_scope
= current_function_decl
;
2920 /* Same as pp_formatted_text, except the return string is a separate
2921 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2924 pp_ggc_formatted_text (pretty_printer
*pp
)
2926 return ggc_strdup (pp_formatted_text (pp
));
2929 /* Exported interface to stringifying types, exprs and decls under TFF_*
2933 type_as_string (tree typ
, int flags
)
2936 pp_translate_identifiers (cxx_pp
) = false;
2937 dump_type (cxx_pp
, typ
, flags
);
2938 return pp_ggc_formatted_text (cxx_pp
);
2942 type_as_string_translate (tree typ
, int flags
)
2945 dump_type (cxx_pp
, typ
, flags
);
2946 return pp_ggc_formatted_text (cxx_pp
);
2950 expr_as_string (tree decl
, int flags
)
2953 pp_translate_identifiers (cxx_pp
) = false;
2954 dump_expr (cxx_pp
, decl
, flags
);
2955 return pp_ggc_formatted_text (cxx_pp
);
2958 /* Wrap decl_as_string with options appropriate for dwarf. */
2961 decl_as_dwarf_string (tree decl
, int flags
)
2964 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2965 here will be adequate to get the desired behavior. */
2966 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2967 name
= decl_as_string (decl
, flags
);
2968 /* Subsequent calls to the pretty printer shouldn't use this style. */
2969 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2974 decl_as_string (tree decl
, int flags
)
2977 pp_translate_identifiers (cxx_pp
) = false;
2978 dump_decl (cxx_pp
, decl
, flags
);
2979 return pp_ggc_formatted_text (cxx_pp
);
2983 decl_as_string_translate (tree decl
, int flags
)
2986 dump_decl (cxx_pp
, decl
, flags
);
2987 return pp_ggc_formatted_text (cxx_pp
);
2990 /* Wrap lang_decl_name with options appropriate for dwarf. */
2993 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2996 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2997 here will be adequate to get the desired behavior. */
2998 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2999 name
= lang_decl_name (decl
, v
, translate
);
3000 /* Subsequent calls to the pretty printer shouldn't use this style. */
3001 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
3005 /* Generate the three forms of printable names for cxx_printable_name. */
3008 lang_decl_name (tree decl
, int v
, bool translate
)
3012 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
3013 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
3016 pp_translate_identifiers (cxx_pp
) = translate
;
3018 && (DECL_CLASS_SCOPE_P (decl
)
3019 || (DECL_NAMESPACE_SCOPE_P (decl
)
3020 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
3022 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
3023 pp_cxx_colon_colon (cxx_pp
);
3026 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3027 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
3028 else if ((DECL_NAME (decl
) == NULL_TREE
)
3029 && TREE_CODE (decl
) == NAMESPACE_DECL
)
3030 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
3032 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
3034 return pp_ggc_formatted_text (cxx_pp
);
3037 /* Return the location of a tree passed to %+ formats. */
3040 location_of (tree t
)
3044 t
= TYPE_MAIN_DECL (t
);
3046 return input_location
;
3048 else if (TREE_CODE (t
) == OVERLOAD
)
3052 return DECL_SOURCE_LOCATION (t
);
3053 return EXPR_LOC_OR_LOC (t
, input_location
);
3056 /* Now the interfaces from error et al to dump_type et al. Each takes an
3057 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
3061 decl_to_string (tree decl
, int verbose
)
3065 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
3066 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
3067 flags
= TFF_CLASS_KEY_OR_ENUM
;
3069 flags
|= TFF_DECL_SPECIFIERS
;
3070 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3071 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
3072 flags
|= TFF_TEMPLATE_HEADER
;
3075 dump_decl (cxx_pp
, decl
, flags
);
3076 return pp_ggc_formatted_text (cxx_pp
);
3080 expr_to_string (tree decl
)
3083 dump_expr (cxx_pp
, decl
, 0);
3084 return pp_ggc_formatted_text (cxx_pp
);
3088 fndecl_to_string (tree fndecl
, int verbose
)
3092 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
3093 | TFF_TEMPLATE_HEADER
;
3095 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3097 dump_decl (cxx_pp
, fndecl
, flags
);
3098 return pp_ggc_formatted_text (cxx_pp
);
3103 code_to_string (enum tree_code c
)
3105 return get_tree_code_name (c
);
3109 language_to_string (enum languages c
)
3116 case lang_cplusplus
:
3125 /* Return the proper printed version of a parameter to a C++ function. */
3128 parm_to_string (int p
)
3132 pp_string (cxx_pp
, "'this'");
3134 pp_decimal_int (cxx_pp
, p
+ 1);
3135 return pp_ggc_formatted_text (cxx_pp
);
3139 op_to_string (enum tree_code p
)
3141 tree id
= operator_name_info
[p
].identifier
;
3142 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3146 type_to_string (tree typ
, int verbose
)
3150 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3151 flags
|= TFF_TEMPLATE_HEADER
;
3154 dump_type (cxx_pp
, typ
, flags
);
3155 /* If we're printing a type that involves typedefs, also print the
3156 stripped version. But sometimes the stripped version looks
3157 exactly the same, so we don't want it after all. To avoid printing
3158 it in that case, we play ugly obstack games. */
3159 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3160 && !uses_template_parms (typ
))
3162 int aka_start
, aka_len
; char *p
;
3163 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3164 /* Remember the end of the initial dump. */
3165 int len
= obstack_object_size (ob
);
3166 tree aka
= strip_typedefs (typ
);
3167 pp_string (cxx_pp
, " {aka");
3168 pp_cxx_whitespace (cxx_pp
);
3169 /* And remember the start of the aka dump. */
3170 aka_start
= obstack_object_size (ob
);
3171 dump_type (cxx_pp
, aka
, flags
);
3172 aka_len
= obstack_object_size (ob
) - aka_start
;
3173 pp_right_brace (cxx_pp
);
3174 p
= (char*)obstack_base (ob
);
3175 /* If they are identical, cut off the aka with a NUL. */
3176 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3180 if (typ
&& TYPE_P (typ
) && TREE_CODE (typ
) == ENUMERAL_TYPE
)
3181 pp_string (cxx_pp
, M_(" {enum}"));
3183 return pp_ggc_formatted_text (cxx_pp
);
3187 assop_to_string (enum tree_code p
)
3189 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3190 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3194 args_to_string (tree p
, int verbose
)
3198 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3203 if (TYPE_P (TREE_VALUE (p
)))
3204 return type_as_string_translate (p
, flags
);
3207 for (; p
; p
= TREE_CHAIN (p
))
3209 if (TREE_VALUE (p
) == null_node
)
3210 pp_cxx_ws_string (cxx_pp
, "NULL");
3212 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3214 pp_separate_with_comma (cxx_pp
);
3216 return pp_ggc_formatted_text (cxx_pp
);
3219 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3220 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3224 subst_to_string (tree p
)
3226 tree decl
= TREE_PURPOSE (p
);
3227 tree targs
= TREE_VALUE (p
);
3228 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3229 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3230 |TFF_NO_TEMPLATE_BINDINGS
);
3236 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3237 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3238 return pp_ggc_formatted_text (cxx_pp
);
3242 cv_to_string (tree p
, int v
)
3245 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3246 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3247 return pp_ggc_formatted_text (cxx_pp
);
3251 eh_spec_to_string (tree p
, int /*v*/)
3255 dump_exception_spec (cxx_pp
, p
, flags
);
3256 return pp_ggc_formatted_text (cxx_pp
);
3259 /* Langhook for print_error_function. */
3261 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3262 diagnostic_info
*diagnostic
)
3264 lhd_print_error_function (context
, file
, diagnostic
);
3265 pp_set_prefix (context
->printer
, file
);
3266 maybe_print_instantiation_context (context
);
3270 cp_diagnostic_starter (diagnostic_context
*context
,
3271 diagnostic_info
*diagnostic
)
3273 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3274 cp_print_error_function (context
, diagnostic
);
3275 maybe_print_instantiation_context (context
);
3276 maybe_print_constexpr_context (context
);
3277 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3281 /* Print current function onto BUFFER, in the process of reporting
3282 a diagnostic message. Called from cp_diagnostic_starter. */
3284 cp_print_error_function (diagnostic_context
*context
,
3285 diagnostic_info
*diagnostic
)
3287 /* If we are in an instantiation context, current_function_decl is likely
3288 to be wrong, so just rely on print_instantiation_full_context. */
3289 if (current_instantiation ())
3291 if (diagnostic_last_function_changed (context
, diagnostic
))
3293 const char *old_prefix
= context
->printer
->prefix
;
3294 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3295 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3296 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3297 ? file_name_as_prefix (context
, file
) : NULL
;
3299 pp_set_prefix (context
->printer
, new_prefix
);
3301 if (current_function_decl
== NULL
)
3302 pp_string (context
->printer
, _("At global scope:"));
3307 if (abstract_origin
)
3309 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3310 while (TREE_CODE (ao
) == BLOCK
3311 && BLOCK_ABSTRACT_ORIGIN (ao
)
3312 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3313 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3314 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3318 fndecl
= current_function_decl
;
3320 pp_printf (context
->printer
, function_category (fndecl
),
3321 cxx_printable_name_translate (fndecl
, 2));
3323 while (abstract_origin
)
3326 tree block
= abstract_origin
;
3328 locus
= &BLOCK_SOURCE_LOCATION (block
);
3330 block
= BLOCK_SUPERCONTEXT (block
);
3331 while (block
&& TREE_CODE (block
) == BLOCK
3332 && BLOCK_ABSTRACT_ORIGIN (block
))
3334 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3336 while (TREE_CODE (ao
) == BLOCK
3337 && BLOCK_ABSTRACT_ORIGIN (ao
)
3338 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3339 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3341 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3346 else if (TREE_CODE (ao
) != BLOCK
)
3349 block
= BLOCK_SUPERCONTEXT (block
);
3352 abstract_origin
= block
;
3355 while (block
&& TREE_CODE (block
) == BLOCK
)
3356 block
= BLOCK_SUPERCONTEXT (block
);
3358 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3360 abstract_origin
= NULL
;
3364 expanded_location s
= expand_location (*locus
);
3365 pp_character (context
->printer
, ',');
3366 pp_newline (context
->printer
);
3369 if (context
->show_column
&& s
.column
!= 0)
3370 pp_printf (context
->printer
,
3371 _(" inlined from %qs at %r%s:%d:%d%R"),
3372 cxx_printable_name_translate (fndecl
, 2),
3373 "locus", s
.file
, s
.line
, s
.column
);
3375 pp_printf (context
->printer
,
3376 _(" inlined from %qs at %r%s:%d%R"),
3377 cxx_printable_name_translate (fndecl
, 2),
3378 "locus", s
.file
, s
.line
);
3382 pp_printf (context
->printer
, _(" inlined from %qs"),
3383 cxx_printable_name_translate (fndecl
, 2));
3386 pp_character (context
->printer
, ':');
3388 pp_newline (context
->printer
);
3390 diagnostic_set_last_function (context
, diagnostic
);
3391 pp_destroy_prefix (context
->printer
);
3392 context
->printer
->prefix
= old_prefix
;
3396 /* Returns a description of FUNCTION using standard terminology. The
3397 result is a format string of the form "In CATEGORY %qs". */
3399 function_category (tree fn
)
3401 /* We can get called from the middle-end for diagnostics of function
3402 clones. Make sure we have language specific information before
3403 dereferencing it. */
3404 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3405 && DECL_FUNCTION_MEMBER_P (fn
))
3407 if (DECL_STATIC_FUNCTION_P (fn
))
3408 return _("In static member function %qs");
3409 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3410 return _("In copy constructor %qs");
3411 else if (DECL_CONSTRUCTOR_P (fn
))
3412 return _("In constructor %qs");
3413 else if (DECL_DESTRUCTOR_P (fn
))
3414 return _("In destructor %qs");
3415 else if (LAMBDA_FUNCTION_P (fn
))
3416 return _("In lambda function");
3418 return _("In member function %qs");
3421 return _("In function %qs");
3424 /* Report the full context of a current template instantiation,
3427 print_instantiation_full_context (diagnostic_context
*context
)
3429 struct tinst_level
*p
= current_instantiation ();
3430 location_t location
= input_location
;
3434 pp_verbatim (context
->printer
,
3435 TREE_CODE (p
->decl
) == TREE_LIST
3436 ? _("%s: In substitution of %qS:\n")
3437 : _("%s: In instantiation of %q#D:\n"),
3438 LOCATION_FILE (location
),
3441 location
= p
->locus
;
3445 print_instantiation_partial_context (context
, p
, location
);
3448 /* Helper function of print_instantiation_partial_context() that
3449 prints a single line of instantiation context. */
3452 print_instantiation_partial_context_line (diagnostic_context
*context
,
3453 const struct tinst_level
*t
,
3454 location_t loc
, bool recursive_p
)
3456 if (loc
== UNKNOWN_LOCATION
)
3459 expanded_location xloc
= expand_location (loc
);
3461 if (context
->show_column
)
3462 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3463 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3465 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3466 "locus", xloc
.file
, xloc
.line
);
3470 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3471 pp_verbatim (context
->printer
,
3473 ? _("recursively required by substitution of %qS\n")
3474 : _("required by substitution of %qS\n"),
3477 pp_verbatim (context
->printer
,
3479 ? _("recursively required from %q#D\n")
3480 : _("required from %q#D\n"),
3485 pp_verbatim (context
->printer
,
3487 ? _("recursively required from here\n")
3488 : _("required from here\n"));
3492 /* Same as print_instantiation_full_context but less verbose. */
3495 print_instantiation_partial_context (diagnostic_context
*context
,
3496 struct tinst_level
*t0
, location_t loc
)
3498 struct tinst_level
*t
;
3501 location_t prev_loc
= loc
;
3503 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3504 if (prev_loc
!= t
->locus
)
3506 prev_loc
= t
->locus
;
3512 if (template_backtrace_limit
3513 && n_total
> template_backtrace_limit
)
3515 int skip
= n_total
- template_backtrace_limit
;
3516 int head
= template_backtrace_limit
/ 2;
3518 /* Avoid skipping just 1. If so, skip 2. */
3522 head
= (template_backtrace_limit
- 1) / 2;
3525 for (n
= 0; n
< head
; n
++)
3527 gcc_assert (t
!= NULL
);
3528 if (loc
!= t
->locus
)
3529 print_instantiation_partial_context_line (context
, t
, loc
,
3530 /*recursive_p=*/false);
3534 if (t
!= NULL
&& skip
> 0)
3536 expanded_location xloc
;
3537 xloc
= expand_location (loc
);
3538 if (context
->show_column
)
3539 pp_verbatim (context
->printer
,
3540 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3541 "contexts, use -ftemplate-backtrace-limit=0 to "
3543 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3545 pp_verbatim (context
->printer
,
3546 _("%r%s:%d:%R [ skipping %d instantiation "
3547 "contexts, use -ftemplate-backtrace-limit=0 to "
3549 "locus", xloc
.file
, xloc
.line
, skip
);
3554 } while (t
!= NULL
&& --skip
> 0);
3560 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3565 print_instantiation_partial_context_line (context
, t
, loc
,
3570 print_instantiation_partial_context_line (context
, NULL
, loc
,
3571 /*recursive_p=*/false);
3574 /* Called from cp_thing to print the template context for an error. */
3576 maybe_print_instantiation_context (diagnostic_context
*context
)
3578 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3581 record_last_problematic_instantiation ();
3582 print_instantiation_full_context (context
);
3585 /* Report what constexpr call(s) we're trying to expand, if any. */
3588 maybe_print_constexpr_context (diagnostic_context
*context
)
3590 vec
<tree
> call_stack
= cx_error_context ();
3594 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3596 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3597 const char *s
= expr_as_string (t
, 0);
3598 if (context
->show_column
)
3599 pp_verbatim (context
->printer
,
3600 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3601 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3603 pp_verbatim (context
->printer
,
3604 _("%r%s:%d:%R in constexpr expansion of %qs"),
3605 "locus", xloc
.file
, xloc
.line
, s
);
3606 pp_newline (context
->printer
);
3611 /* Return true iff TYPE_A and TYPE_B are template types that are
3612 meaningful to compare. */
3615 comparable_template_types_p (tree type_a
, tree type_b
)
3617 if (!CLASS_TYPE_P (type_a
))
3619 if (!CLASS_TYPE_P (type_b
))
3622 tree tinfo_a
= TYPE_TEMPLATE_INFO (type_a
);
3623 tree tinfo_b
= TYPE_TEMPLATE_INFO (type_b
);
3624 if (!tinfo_a
|| !tinfo_b
)
3627 return TI_TEMPLATE (tinfo_a
) == TI_TEMPLATE (tinfo_b
);
3630 /* Start a new line indented by SPC spaces on PP. */
3633 newline_and_indent (pretty_printer
*pp
, int spc
)
3636 for (int i
= 0; i
< spc
; i
++)
3640 /* Generate a GC-allocated string for ARG, an expression or type. */
3643 arg_to_string (tree arg
, bool verbose
)
3646 return type_to_string (arg
, verbose
);
3648 return expr_to_string (arg
);
3651 /* Subroutine to type_to_string_with_compare and
3652 print_template_tree_comparison.
3654 Print a representation of ARG (an expression or type) to PP,
3655 colorizing it as "type-diff" if PP->show_color. */
3658 print_nonequal_arg (pretty_printer
*pp
, tree arg
, bool verbose
)
3660 pp_printf (pp
, "%r%s%R",
3663 ? arg_to_string (arg
, verbose
)
3664 : G_("(no argument)")));
3667 /* Recursively print template TYPE_A to PP, as compared to template TYPE_B.
3669 The types must satisfy comparable_template_types_p.
3671 If INDENT is 0, then this is equivalent to type_to_string (TYPE_A), but
3672 potentially colorizing/eliding in comparison with TYPE_B.
3674 For example given types:
3675 vector<map<int,double>>
3677 vector<map<int,float>>
3678 then the result on PP would be:
3679 vector<map<[...],double>>
3680 with type elision, and:
3681 vector<map<int,double>>
3682 without type elision.
3684 In both cases the parts of TYPE that differ from PEER will be colorized
3685 if pp_show_color (pp) is true. In the above example, this would be
3688 If INDENT is non-zero, then the types are printed in a tree-like form
3689 which shows both types. In the above example, the result on PP would be:
3696 and without type-elision would be:
3703 As before, the differing parts of the types are colorized if
3704 pp_show_color (pp) is true ("double" and "float" in this example).
3706 Template arguments in which both types are using the default arguments
3707 are not printed; if at least one of the two types is using a non-default
3708 argument, then that argument is printed (or both arguments for the
3709 tree-like print format). */
3712 print_template_differences (pretty_printer
*pp
, tree type_a
, tree type_b
,
3713 bool verbose
, int indent
)
3716 newline_and_indent (pp
, indent
);
3718 tree tinfo_a
= TYPE_TEMPLATE_INFO (type_a
);
3719 tree tinfo_b
= TYPE_TEMPLATE_INFO (type_b
);
3721 pp_printf (pp
, "%s<",
3722 IDENTIFIER_POINTER (DECL_NAME (TI_TEMPLATE (tinfo_a
))));
3724 tree args_a
= TI_ARGS (tinfo_a
);
3725 tree args_b
= TI_ARGS (tinfo_b
);
3726 gcc_assert (TREE_CODE (args_a
) == TREE_VEC
);
3727 gcc_assert (TREE_CODE (args_b
) == TREE_VEC
);
3729 int len_a
= get_non_default_template_args_count (args_a
, flags
);
3730 args_a
= INNERMOST_TEMPLATE_ARGS (args_a
);
3731 int len_b
= get_non_default_template_args_count (args_b
, flags
);
3732 args_b
= INNERMOST_TEMPLATE_ARGS (args_b
);
3733 /* Determine the maximum range of args for which non-default template args
3734 were used; beyond this, only default args (if any) were used, and so
3735 they will be equal from this point onwards.
3736 One of the two peers might have used default arguments within this
3737 range, but the other will be using non-default arguments, and so
3738 it's more readable to print both within this range, to highlight
3740 int len_max
= MAX (len_a
, len_b
);
3741 gcc_assert (TREE_CODE (args_a
) == TREE_VEC
);
3742 gcc_assert (TREE_CODE (args_b
) == TREE_VEC
);
3743 for (int idx
= 0; idx
< len_max
; idx
++)
3746 pp_character (pp
, ',');
3748 tree arg_a
= TREE_VEC_ELT (args_a
, idx
);
3749 tree arg_b
= TREE_VEC_ELT (args_b
, idx
);
3753 newline_and_indent (pp
, indent
+ 2);
3754 /* Can do elision here, printing "[...]". */
3755 if (flag_elide_type
)
3756 pp_string (pp
, G_("[...]"));
3758 pp_string (pp
, arg_to_string (arg_a
, verbose
));
3762 int new_indent
= indent
? indent
+ 2 : 0;
3763 if (comparable_template_types_p (arg_a
, arg_b
))
3764 print_template_differences (pp
, arg_a
, arg_b
, verbose
, new_indent
);
3768 newline_and_indent (pp
, indent
+ 2);
3769 pp_character (pp
, '[');
3770 print_nonequal_arg (pp
, arg_a
, verbose
);
3771 pp_string (pp
, " != ");
3772 print_nonequal_arg (pp
, arg_b
, verbose
);
3773 pp_character (pp
, ']');
3776 print_nonequal_arg (pp
, arg_a
, verbose
);
3779 pp_printf (pp
, ">");
3782 /* As type_to_string, but for a template, potentially colorizing/eliding
3783 in comparison with PEER.
3784 For example, if TYPE is map<int,double> and PEER is map<int,int>,
3785 then the resulting string would be:
3787 with type elision, and:
3789 without type elision.
3791 In both cases the parts of TYPE that differ from PEER will be colorized
3792 if SHOW_COLOR is true. In the above example, this would be "double".
3794 Template arguments in which both types are using the default arguments
3795 are not printed; if at least one of the two types is using a non-default
3796 argument, then both arguments are printed.
3798 The resulting string is in a GC-allocated buffer. */
3801 type_to_string_with_compare (tree type
, tree peer
, bool verbose
,
3804 pretty_printer inner_pp
;
3805 pretty_printer
*pp
= &inner_pp
;
3806 pp_show_color (pp
) = show_color
;
3808 print_template_differences (pp
, type
, peer
, verbose
, 0);
3809 return pp_ggc_formatted_text (pp
);
3812 /* Recursively print a tree-like comparison of TYPE_A and TYPE_B to PP,
3813 indented by INDENT spaces.
3815 For example given types:
3817 vector<map<int,double>>
3821 vector<map<double,float>>
3823 the output with type elision would be:
3830 and without type-elision would be:
3837 TYPE_A and TYPE_B must both be comparable template types
3838 (as per comparable_template_types_p).
3840 Template arguments in which both types are using the default arguments
3841 are not printed; if at least one of the two types is using a non-default
3842 argument, then both arguments are printed. */
3845 print_template_tree_comparison (pretty_printer
*pp
, tree type_a
, tree type_b
,
3846 bool verbose
, int indent
)
3848 print_template_differences (pp
, type_a
, type_b
, verbose
, indent
);
3851 /* Subroutine for use in a format_postprocessor::handle
3852 implementation. Adds a chunk to the end of
3853 formatted output, so that it will be printed
3854 by pp_output_formatted_text. */
3857 append_formatted_chunk (pretty_printer
*pp
, const char *content
)
3859 output_buffer
*buffer
= pp_buffer (pp
);
3860 struct chunk_info
*chunk_array
= buffer
->cur_chunk_array
;
3861 const char **args
= chunk_array
->args
;
3863 unsigned int chunk_idx
;
3864 for (chunk_idx
= 0; args
[chunk_idx
]; chunk_idx
++)
3866 args
[chunk_idx
++] = content
;
3867 args
[chunk_idx
] = NULL
;
3870 /* Create a copy of CONTENT, with quotes added, and,
3871 potentially, with colorization.
3872 No escaped is performed on CONTENT.
3873 The result is in a GC-allocated buffer. */
3876 add_quotes (const char *content
, bool show_color
)
3878 pretty_printer tmp_pp
;
3879 pp_show_color (&tmp_pp
) = show_color
;
3881 /* We have to use "%<%s%>" rather than "%qs" here in order to avoid
3882 quoting colorization bytes within the results. */
3883 pp_printf (&tmp_pp
, "%<%s%>", content
);
3885 return pp_ggc_formatted_text (&tmp_pp
);
3888 /* If we had %H and %I, and hence deferred printing them,
3889 print them now, storing the result into the chunk_info
3890 for pp_format. Quote them if 'q' was provided.
3891 Also print the difference in tree form, adding it as
3892 an additional chunk. */
3895 cxx_format_postprocessor::handle (pretty_printer
*pp
)
3897 /* If we have one of %H and %I, the other should have
3899 if (m_type_a
.m_tree
|| m_type_b
.m_tree
)
3901 /* Avoid reentrancy issues by working with a copy of
3902 m_type_a and m_type_b, resetting them now. */
3903 deferred_printed_type type_a
= m_type_a
;
3904 deferred_printed_type type_b
= m_type_b
;
3905 m_type_a
= deferred_printed_type ();
3906 m_type_b
= deferred_printed_type ();
3908 gcc_assert (type_a
.m_buffer_ptr
);
3909 gcc_assert (type_b
.m_buffer_ptr
);
3911 bool show_color
= pp_show_color (pp
);
3913 const char *type_a_text
;
3914 const char *type_b_text
;
3916 if (comparable_template_types_p (type_a
.m_tree
, type_b
.m_tree
))
3919 = type_to_string_with_compare (type_a
.m_tree
, type_b
.m_tree
,
3920 type_a
.m_verbose
, show_color
);
3922 = type_to_string_with_compare (type_b
.m_tree
, type_a
.m_tree
,
3923 type_b
.m_verbose
, show_color
);
3925 if (flag_diagnostics_show_template_tree
)
3927 pretty_printer inner_pp
;
3928 pp_show_color (&inner_pp
) = pp_show_color (pp
);
3929 print_template_tree_comparison
3930 (&inner_pp
, type_a
.m_tree
, type_b
.m_tree
, type_a
.m_verbose
, 2);
3931 append_formatted_chunk (pp
, pp_ggc_formatted_text (&inner_pp
));
3936 /* If the types were not comparable, they are printed normally,
3937 and no difference tree is printed. */
3938 type_a_text
= type_to_string (type_a
.m_tree
, type_a
.m_verbose
);
3939 type_b_text
= type_to_string (type_b
.m_tree
, type_b
.m_verbose
);
3943 type_a_text
= add_quotes (type_a_text
, show_color
);
3944 *type_a
.m_buffer_ptr
= type_a_text
;
3947 type_b_text
= add_quotes (type_b_text
, show_color
);
3948 *type_b
.m_buffer_ptr
= type_b_text
;
3952 /* Subroutine for handling %H and %I, to support i18n of messages like:
3954 error_at (loc, "could not convert %qE from %qH to %qI",
3955 expr, type_a, type_b);
3957 so that we can print things like:
3959 could not convert 'foo' from 'map<int,double>' to 'map<int,int>'
3961 and, with type-elision:
3963 could not convert 'foo' from 'map<[...],double>' to 'map<[...],int>'
3965 (with color-coding of the differences between the types).
3967 The %H and %I format codes are peers: both must be present,
3968 and they affect each other. Hence to handle them, we must
3969 delay printing until we have both, deferring the printing to
3970 pretty_printer's m_format_postprocessor hook.
3972 This is called in phase 2 of pp_format, when it is accumulating
3973 a series of formatted chunks. We stash the location of the chunk
3974 we're meant to have written to, so that we can write to it in the
3975 m_format_postprocessor hook.
3977 We also need to stash whether a 'q' prefix was provided (the QUOTE
3978 param) so that we can add the quotes when writing out the delayed
3982 defer_phase_2_of_type_diff (deferred_printed_type
*deferred
,
3983 tree type
, const char **buffer_ptr
,
3984 bool verbose
, bool quote
)
3986 gcc_assert (deferred
->m_tree
== NULL_TREE
);
3987 gcc_assert (deferred
->m_buffer_ptr
== NULL
);
3988 *deferred
= deferred_printed_type (type
, buffer_ptr
, verbose
, quote
);
3992 /* Called from output_format -- during diagnostic message processing --
3993 to handle C++ specific format specifier with the following meanings:
3994 %A function argument-list.
3998 %F function declaration.
3999 %L language as used in extern "lang".
4001 %P function parameter whose position is indicated by an integer.
4002 %Q assignment operator.
4003 %S substitution (template + args)
4006 %X exception-specification.
4007 %H type difference (from)
4008 %I type difference (to). */
4010 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
4011 int precision
, bool wide
, bool set_locus
, bool verbose
,
4012 bool quoted
, const char **buffer_ptr
)
4014 gcc_assert (pp
->m_format_postprocessor
);
4015 cxx_format_postprocessor
*postprocessor
4016 = static_cast <cxx_format_postprocessor
*> (pp
->m_format_postprocessor
);
4020 #define next_tree (t = va_arg (*text->args_ptr, tree))
4021 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
4022 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
4023 #define next_int va_arg (*text->args_ptr, int)
4025 if (precision
!= 0 || wide
)
4030 case 'A': result
= args_to_string (next_tree
, verbose
); break;
4031 case 'C': result
= code_to_string (next_tcode
); break;
4034 tree temp
= next_tree
;
4036 && DECL_HAS_DEBUG_EXPR_P (temp
))
4038 temp
= DECL_DEBUG_EXPR (temp
);
4041 result
= expr_to_string (temp
);
4045 result
= decl_to_string (temp
, verbose
);
4048 case 'E': result
= expr_to_string (next_tree
); break;
4049 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
4050 case 'L': result
= language_to_string (next_lang
); break;
4051 case 'O': result
= op_to_string (next_tcode
); break;
4052 case 'P': result
= parm_to_string (next_int
); break;
4053 case 'Q': result
= assop_to_string (next_tcode
); break;
4054 case 'S': result
= subst_to_string (next_tree
); break;
4055 case 'T': result
= type_to_string (next_tree
, verbose
); break;
4056 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
4057 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
4060 percent_K_format (text
);
4065 defer_phase_2_of_type_diff (&postprocessor
->m_type_a
, next_tree
,
4066 buffer_ptr
, verbose
, quoted
);
4072 defer_phase_2_of_type_diff (&postprocessor
->m_type_b
, next_tree
,
4073 buffer_ptr
, verbose
, quoted
);
4081 pp_string (pp
, result
);
4082 if (set_locus
&& t
!= NULL
)
4083 text
->set_location (0, location_of (t
), true);
4091 /* Warn about the use of C++0x features when appropriate. */
4093 maybe_warn_cpp0x (cpp0x_warn_str str
)
4095 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
4096 /* We really want to suppress this warning in system headers,
4097 because libstdc++ uses variadic templates even when we aren't
4101 case CPP0X_INITIALIZER_LISTS
:
4102 pedwarn (input_location
, 0,
4103 "extended initializer lists "
4104 "only available with -std=c++11 or -std=gnu++11");
4106 case CPP0X_EXPLICIT_CONVERSION
:
4107 pedwarn (input_location
, 0,
4108 "explicit conversion operators "
4109 "only available with -std=c++11 or -std=gnu++11");
4111 case CPP0X_VARIADIC_TEMPLATES
:
4112 pedwarn (input_location
, 0,
4113 "variadic templates "
4114 "only available with -std=c++11 or -std=gnu++11");
4116 case CPP0X_LAMBDA_EXPR
:
4117 pedwarn (input_location
, 0,
4118 "lambda expressions "
4119 "only available with -std=c++11 or -std=gnu++11");
4122 pedwarn (input_location
, 0,
4123 "C++11 auto only available with -std=c++11 or -std=gnu++11");
4125 case CPP0X_SCOPED_ENUMS
:
4126 pedwarn (input_location
, 0,
4127 "scoped enums only available with -std=c++11 or -std=gnu++11");
4129 case CPP0X_DEFAULTED_DELETED
:
4130 pedwarn (input_location
, 0,
4131 "defaulted and deleted functions "
4132 "only available with -std=c++11 or -std=gnu++11");
4134 case CPP0X_INLINE_NAMESPACES
:
4135 pedwarn (input_location
, OPT_Wpedantic
,
4136 "inline namespaces "
4137 "only available with -std=c++11 or -std=gnu++11");
4139 case CPP0X_OVERRIDE_CONTROLS
:
4140 pedwarn (input_location
, 0,
4141 "override controls (override/final) "
4142 "only available with -std=c++11 or -std=gnu++11");
4145 pedwarn (input_location
, 0,
4146 "non-static data member initializers "
4147 "only available with -std=c++11 or -std=gnu++11");
4149 case CPP0X_USER_DEFINED_LITERALS
:
4150 pedwarn (input_location
, 0,
4151 "user-defined literals "
4152 "only available with -std=c++11 or -std=gnu++11");
4154 case CPP0X_DELEGATING_CTORS
:
4155 pedwarn (input_location
, 0,
4156 "delegating constructors "
4157 "only available with -std=c++11 or -std=gnu++11");
4159 case CPP0X_INHERITING_CTORS
:
4160 pedwarn (input_location
, 0,
4161 "inheriting constructors "
4162 "only available with -std=c++11 or -std=gnu++11");
4164 case CPP0X_ATTRIBUTES
:
4165 pedwarn (input_location
, 0,
4167 "only available with -std=c++11 or -std=gnu++11");
4169 case CPP0X_REF_QUALIFIER
:
4170 pedwarn (input_location
, 0,
4172 "only available with -std=c++11 or -std=gnu++11");
4179 /* Warn about the use of variadic templates when appropriate. */
4181 maybe_warn_variadic_templates (void)
4183 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
4187 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
4188 option OPT with text GMSGID. Use this function to report
4189 diagnostics for constructs that are invalid C++98, but valid
4192 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
4194 diagnostic_info diagnostic
;
4197 rich_location
richloc (line_table
, location
);
4199 va_start (ap
, gmsgid
);
4200 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
4201 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
4202 diagnostic
.option_index
= opt
;
4203 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
4208 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
4209 we found when we tried to do the lookup. LOCATION is the location of
4210 the NAME identifier. */
4213 qualified_name_lookup_error (tree scope
, tree name
,
4214 tree decl
, location_t location
)
4216 if (scope
== error_mark_node
)
4217 ; /* We already complained. */
4218 else if (TYPE_P (scope
))
4220 if (!COMPLETE_TYPE_P (scope
))
4221 error_at (location
, "incomplete type %qT used in nested name specifier",
4223 else if (TREE_CODE (decl
) == TREE_LIST
)
4225 error_at (location
, "reference to %<%T::%D%> is ambiguous",
4227 print_candidates (decl
);
4230 error_at (location
, "%qD is not a member of %qT", name
, scope
);
4232 else if (scope
!= global_namespace
)
4234 error_at (location
, "%qD is not a member of %qD", name
, scope
);
4235 if (!suggest_alternative_in_explicit_scope (location
, name
, scope
))
4236 suggest_alternatives_for (location
, name
, false);
4240 error_at (location
, "%<::%D%> has not been declared", name
);
4241 suggest_alternatives_for (location
, name
, true);