1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "stringpool.h"
25 #include "tree-diagnostic.h"
26 #include "langhooks-def.h"
28 #include "cxx-pretty-print.h"
29 #include "tree-pretty-print.h"
30 #include "c-family/c-objc.h"
32 #include "internal-fn.h"
34 #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);
104 /* CONTEXT->printer is a basic pretty printer that was constructed
105 presumably by diagnostic_initialize(), called early in the
106 compiler's initialization process (in general_init) Before the FE
107 is initialized. This (C++) FE-specific diagnostic initializer is
108 thus replacing the basic pretty printer with one that has C++-aware
112 cxx_initialize_diagnostics (diagnostic_context
*context
)
114 pretty_printer
*base
= context
->printer
;
115 cxx_pretty_printer
*pp
= XNEW (cxx_pretty_printer
);
116 context
->printer
= new (pp
) cxx_pretty_printer ();
118 /* It is safe to free this object because it was previously XNEW()'d. */
119 base
->~pretty_printer ();
122 c_common_diagnostics_set_defaults (context
);
123 diagnostic_starter (context
) = cp_diagnostic_starter
;
124 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
125 diagnostic_format_decoder (context
) = cp_printer
;
128 /* Dump a scope, if deemed necessary. */
131 dump_scope (cxx_pretty_printer
*pp
, tree scope
, int flags
)
133 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
135 if (scope
== NULL_TREE
)
138 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
140 if (scope
!= global_namespace
)
142 dump_decl (pp
, scope
, f
);
143 pp_cxx_colon_colon (pp
);
146 else if (AGGREGATE_TYPE_P (scope
))
148 dump_type (pp
, scope
, f
);
149 pp_cxx_colon_colon (pp
);
151 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
153 dump_function_decl (pp
, scope
, f
);
154 pp_cxx_colon_colon (pp
);
158 /* Dump the template ARGument under control of FLAGS. */
161 dump_template_argument (cxx_pretty_printer
*pp
, tree arg
, int flags
)
163 if (ARGUMENT_PACK_P (arg
))
164 dump_template_argument_list (pp
, ARGUMENT_PACK_ARGS (arg
),
165 /* No default args in argument packs. */
166 flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
167 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
168 dump_type (pp
, arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
171 if (TREE_CODE (arg
) == TREE_LIST
)
172 arg
= TREE_VALUE (arg
);
174 dump_expr (pp
, arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
178 /* Count the number of template arguments ARGS whose value does not
179 match the (optional) default template parameter in PARAMS */
182 get_non_default_template_args_count (tree args
, int flags
)
184 int n
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args
));
186 if (/* We use this flag when generating debug information. We don't
187 want to expand templates at this point, for this may generate
188 new decls, which gets decl counts out of sync, which may in
189 turn cause codegen differences between compilations with and
191 (flags
& TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
) != 0
192 || !flag_pretty_templates
)
195 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args
));
198 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
202 dump_template_argument_list (cxx_pretty_printer
*pp
, tree args
, int flags
)
204 int n
= get_non_default_template_args_count (args
, flags
);
208 for (i
= 0; i
< n
; ++i
)
210 tree arg
= TREE_VEC_ELT (args
, i
);
212 /* Only print a comma if we know there is an argument coming. In
213 the case of an empty template argument pack, no actual
214 argument will be printed. */
216 && (!ARGUMENT_PACK_P (arg
)
217 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
218 pp_separate_with_comma (pp
);
220 dump_template_argument (pp
, arg
, flags
);
225 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
228 dump_template_parameter (cxx_pretty_printer
*pp
, tree parm
, int flags
)
233 if (parm
== error_mark_node
)
236 p
= TREE_VALUE (parm
);
237 a
= TREE_PURPOSE (parm
);
239 if (TREE_CODE (p
) == TYPE_DECL
)
241 if (flags
& TFF_DECL_SPECIFIERS
)
243 pp_cxx_ws_string (pp
, "class");
244 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
245 pp_cxx_ws_string (pp
, "...");
247 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
249 else if (DECL_NAME (p
))
250 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
252 pp_cxx_canonical_template_parameter (pp
, TREE_TYPE (p
));
255 dump_decl (pp
, p
, flags
| TFF_DECL_SPECIFIERS
);
257 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
259 pp_cxx_whitespace (pp
);
261 pp_cxx_whitespace (pp
);
262 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
263 dump_type (pp
, a
, flags
& ~TFF_CHASE_TYPEDEF
);
265 dump_expr (pp
, a
, flags
| TFF_EXPR_IN_PARENS
);
269 /* Dump, under control of FLAGS, a template-parameter-list binding.
270 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
274 dump_template_bindings (cxx_pretty_printer
*pp
, tree parms
, tree args
,
275 vec
<tree
, va_gc
> *typenames
)
277 bool need_semicolon
= false;
283 tree p
= TREE_VALUE (parms
);
284 int lvl
= TMPL_PARMS_DEPTH (parms
);
287 tree lvl_args
= NULL_TREE
;
289 /* Don't crash if we had an invalid argument list. */
290 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
291 lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
293 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
295 tree arg
= NULL_TREE
;
297 /* Don't crash if we had an invalid argument list. */
298 if (lvl_args
&& NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
299 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
302 pp_separate_with_semicolon (pp
);
303 dump_template_parameter (pp
, TREE_VEC_ELT (p
, i
),
304 TFF_PLAIN_IDENTIFIER
);
305 pp_cxx_whitespace (pp
);
307 pp_cxx_whitespace (pp
);
310 if (ARGUMENT_PACK_P (arg
))
311 pp_cxx_left_brace (pp
);
312 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
313 if (ARGUMENT_PACK_P (arg
))
314 pp_cxx_right_brace (pp
);
317 pp_string (pp
, M_("<missing>"));
320 need_semicolon
= true;
323 parms
= TREE_CHAIN (parms
);
326 /* Don't bother with typenames for a partial instantiation. */
327 if (vec_safe_is_empty (typenames
) || uses_template_parms (args
))
330 /* Don't try to print typenames when we're processing a clone. */
331 if (current_function_decl
332 && !DECL_LANG_SPECIFIC (current_function_decl
))
335 /* Don't try to do this once cgraph starts throwing away front-end
340 FOR_EACH_VEC_SAFE_ELT (typenames
, i
, t
)
343 pp_separate_with_semicolon (pp
);
344 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
345 pp_cxx_whitespace (pp
);
347 pp_cxx_whitespace (pp
);
348 push_deferring_access_checks (dk_no_check
);
349 t
= tsubst (t
, args
, tf_none
, NULL_TREE
);
350 pop_deferring_access_checks ();
351 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
352 pp_simple_type_specifier doesn't know about it. */
353 t
= strip_typedefs (t
);
354 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
358 /* Dump a human-readable equivalent of the alias template
359 specialization of T. */
362 dump_alias_template_specialization (cxx_pretty_printer
*pp
, tree t
, int flags
)
366 gcc_assert (alias_template_specialization_p (t
));
368 if (!(flags
& TFF_UNQUALIFIED_NAME
))
369 dump_scope (pp
, CP_DECL_CONTEXT (TYPE_NAME (t
)), flags
);
370 name
= TYPE_IDENTIFIER (t
);
371 pp_cxx_tree_identifier (pp
, name
);
372 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
374 flags
& ~TFF_TEMPLATE_HEADER
);
377 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
381 dump_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
386 /* Don't print e.g. "struct mytypedef". */
387 if (TYPE_P (t
) && typedef_variant_p (t
))
389 tree decl
= TYPE_NAME (t
);
390 if ((flags
& TFF_CHASE_TYPEDEF
)
391 || DECL_SELF_REFERENCE_P (decl
)
392 || (!flag_pretty_templates
393 && DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)))
394 t
= strip_typedefs (t
);
395 else if (alias_template_specialization_p (t
))
397 dump_alias_template_specialization (pp
, t
, flags
);
400 else if (same_type_p (t
, TREE_TYPE (decl
)))
404 pp_cxx_cv_qualifier_seq (pp
, t
);
405 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
410 if (TYPE_PTRMEMFUNC_P (t
))
413 switch (TREE_CODE (t
))
416 if (t
== init_list_type_node
)
417 pp_string (pp
, M_("<brace-enclosed initializer list>"));
418 else if (t
== unknown_type_node
)
419 pp_string (pp
, M_("<unresolved overloaded function type>"));
422 pp_cxx_cv_qualifier_seq (pp
, t
);
423 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
428 /* A list of function parms. */
429 dump_parameters (pp
, t
, flags
);
432 case IDENTIFIER_NODE
:
433 pp_cxx_tree_identifier (pp
, t
);
437 dump_type (pp
, BINFO_TYPE (t
), flags
);
443 dump_aggr_type (pp
, t
, flags
);
447 if (flags
& TFF_CHASE_TYPEDEF
)
449 dump_type (pp
, DECL_ORIGINAL_TYPE (t
)
450 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
457 dump_decl (pp
, t
, flags
& ~TFF_DECL_SPECIFIERS
);
466 case FIXED_POINT_TYPE
:
467 pp_type_specifier_seq (pp
, t
);
470 case TEMPLATE_TEMPLATE_PARM
:
471 /* For parameters inside template signature. */
472 if (TYPE_IDENTIFIER (t
))
473 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
475 pp_cxx_canonical_template_parameter (pp
, t
);
478 case BOUND_TEMPLATE_TEMPLATE_PARM
:
480 tree args
= TYPE_TI_ARGS (t
);
481 pp_cxx_cv_qualifier_seq (pp
, t
);
482 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
483 pp_cxx_begin_template_argument_list (pp
);
484 dump_template_argument_list (pp
, args
, flags
);
485 pp_cxx_end_template_argument_list (pp
);
489 case TEMPLATE_TYPE_PARM
:
490 pp_cxx_cv_qualifier_seq (pp
, t
);
491 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
492 pp_cxx_constrained_type_spec (pp
, c
);
493 else if (TYPE_IDENTIFIER (t
))
494 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
496 pp_cxx_canonical_template_parameter
497 (pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
500 /* This is not always necessary for pointers and such, but doing this
501 reduces code size. */
510 dump_type_prefix (pp
, t
, flags
);
511 dump_type_suffix (pp
, t
, flags
);
515 if (! (flags
& TFF_CHASE_TYPEDEF
)
516 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
518 dump_decl (pp
, TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
521 pp_cxx_cv_qualifier_seq (pp
, t
);
522 pp_cxx_ws_string (pp
,
523 TYPENAME_IS_ENUM_P (t
) ? "enum"
524 : TYPENAME_IS_CLASS_P (t
) ? "class"
526 dump_typename (pp
, t
, flags
);
529 case UNBOUND_CLASS_TEMPLATE
:
530 if (! (flags
& TFF_UNQUALIFIED_NAME
))
532 dump_type (pp
, TYPE_CONTEXT (t
), flags
);
533 pp_cxx_colon_colon (pp
);
535 pp_cxx_ws_string (pp
, "template");
536 dump_type (pp
, TYPE_IDENTIFIER (t
), flags
);
540 pp_cxx_ws_string (pp
, "__typeof__");
541 pp_cxx_whitespace (pp
);
542 pp_cxx_left_paren (pp
);
543 dump_expr (pp
, TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
544 pp_cxx_right_paren (pp
);
547 case UNDERLYING_TYPE
:
548 pp_cxx_ws_string (pp
, "__underlying_type");
549 pp_cxx_whitespace (pp
);
550 pp_cxx_left_paren (pp
);
551 dump_expr (pp
, UNDERLYING_TYPE_TYPE (t
), flags
& ~TFF_EXPR_IN_PARENS
);
552 pp_cxx_right_paren (pp
);
555 case TYPE_PACK_EXPANSION
:
556 dump_type (pp
, PACK_EXPANSION_PATTERN (t
), flags
);
557 pp_cxx_ws_string (pp
, "...");
560 case TYPE_ARGUMENT_PACK
:
561 dump_template_argument (pp
, t
, flags
);
565 pp_cxx_ws_string (pp
, "decltype");
566 pp_cxx_whitespace (pp
);
567 pp_cxx_left_paren (pp
);
568 dump_expr (pp
, DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
569 pp_cxx_right_paren (pp
);
573 pp_string (pp
, "std::nullptr_t");
577 pp_unsupported_tree (pp
, t
);
581 pp_string (pp
, M_("<type error>"));
586 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
590 dump_typename (cxx_pretty_printer
*pp
, tree t
, int flags
)
592 tree ctx
= TYPE_CONTEXT (t
);
594 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
595 dump_typename (pp
, ctx
, flags
);
597 dump_type (pp
, ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
598 pp_cxx_colon_colon (pp
);
599 dump_decl (pp
, TYPENAME_TYPE_FULLNAME (t
), flags
);
602 /* Return the name of the supplied aggregate, or enumeral type. */
605 class_key_or_enum_as_string (tree t
)
607 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
609 if (SCOPED_ENUM_P (t
))
614 else if (TREE_CODE (t
) == UNION_TYPE
)
616 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
622 /* Print out a class declaration T under the control of FLAGS,
623 in the form `class foo'. */
626 dump_aggr_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
629 const char *variety
= class_key_or_enum_as_string (t
);
633 pp_cxx_cv_qualifier_seq (pp
, t
);
635 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
636 pp_cxx_ws_string (pp
, variety
);
638 name
= TYPE_NAME (t
);
642 typdef
= (!DECL_ARTIFICIAL (name
)
643 /* An alias specialization is not considered to be a
645 && !alias_template_specialization_p (t
));
648 && ((flags
& TFF_CHASE_TYPEDEF
)
649 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
650 && DECL_TEMPLATE_INFO (name
))))
651 || DECL_SELF_REFERENCE_P (name
))
653 t
= TYPE_MAIN_VARIANT (t
);
654 name
= TYPE_NAME (t
);
658 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
659 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
660 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
661 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
663 if (! (flags
& TFF_UNQUALIFIED_NAME
))
664 dump_scope (pp
, CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
665 flags
&= ~TFF_UNQUALIFIED_NAME
;
668 /* Because the template names are mangled, we have to locate
669 the most general template, and use that name. */
670 tree tpl
= TYPE_TI_TEMPLATE (t
);
672 while (DECL_TEMPLATE_INFO (tpl
))
673 tpl
= DECL_TI_TEMPLATE (tpl
);
676 name
= DECL_NAME (name
);
679 if (name
== 0 || anon_aggrname_p (name
))
681 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
682 pp_string (pp
, M_("<unnamed>"));
684 pp_printf (pp
, M_("<unnamed %s>"), variety
);
686 else if (LAMBDA_TYPE_P (t
))
688 /* A lambda's "type" is essentially its signature. */
689 pp_string (pp
, M_("<lambda"));
690 if (lambda_function (t
))
692 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
697 pp_cxx_tree_identifier (pp
, name
);
699 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
700 !CLASSTYPE_USE_TEMPLATE (t
),
701 flags
& ~TFF_TEMPLATE_HEADER
);
704 /* Dump into the obstack the initial part of the output for a given type.
705 This is necessary when dealing with things like functions returning
708 return type of `int (* fee ())()': pointer -> function -> int. Both
709 pointer (and reference and offset) and function (and member) types must
710 deal with prefix and suffix.
712 Arrays must also do this for DECL nodes, like int a[], and for things like
716 dump_type_prefix (cxx_pretty_printer
*pp
, tree t
, int flags
)
718 if (TYPE_PTRMEMFUNC_P (t
))
720 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
724 switch (TREE_CODE (t
))
729 tree sub
= TREE_TYPE (t
);
731 dump_type_prefix (pp
, sub
, flags
);
732 if (TREE_CODE (sub
) == ARRAY_TYPE
733 || TREE_CODE (sub
) == FUNCTION_TYPE
)
735 pp_cxx_whitespace (pp
);
736 pp_cxx_left_paren (pp
);
737 pp_c_attributes_display (pp
, TYPE_ATTRIBUTES (sub
));
741 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
743 if (TYPE_REF_IS_RVALUE (t
))
744 pp_ampersand_ampersand (pp
);
748 pp
->padding
= pp_before
;
749 pp_cxx_cv_qualifier_seq (pp
, t
);
755 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
756 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
759 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
760 pp_cxx_left_paren (pp
);
761 dump_type (pp
, TYPE_OFFSET_BASETYPE (t
), flags
);
762 pp_cxx_colon_colon (pp
);
765 pp_cxx_cv_qualifier_seq (pp
, t
);
766 pp
->padding
= pp_before
;
769 /* This can be reached without a pointer when dealing with
770 templates, e.g. std::is_function. */
772 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
776 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
778 pp_cxx_left_paren (pp
);
779 dump_aggr_type (pp
, TYPE_METHOD_BASETYPE (t
), flags
);
780 pp_cxx_colon_colon (pp
);
784 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
788 case IDENTIFIER_NODE
:
793 case TEMPLATE_TYPE_PARM
:
794 case TEMPLATE_TEMPLATE_PARM
:
795 case BOUND_TEMPLATE_TEMPLATE_PARM
:
806 case UNDERLYING_TYPE
:
808 case TYPE_PACK_EXPANSION
:
809 case FIXED_POINT_TYPE
:
811 dump_type (pp
, t
, flags
);
812 pp
->padding
= pp_before
;
816 pp_unsupported_tree (pp
, t
);
819 pp_string (pp
, M_("<typeprefixerror>"));
824 /* Dump the suffix of type T, under control of FLAGS. This is the part
825 which appears after the identifier (or function parms). */
828 dump_type_suffix (cxx_pretty_printer
*pp
, tree t
, int flags
)
830 if (TYPE_PTRMEMFUNC_P (t
))
831 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
833 switch (TREE_CODE (t
))
838 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
839 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
840 pp_cxx_right_paren (pp
);
841 if (TREE_CODE (t
) == POINTER_TYPE
)
842 flags
|= TFF_POINTER
;
843 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
850 if (TREE_CODE (t
) == METHOD_TYPE
)
851 /* Can only be reached through a pointer. */
852 pp_cxx_right_paren (pp
);
853 arg
= TYPE_ARG_TYPES (t
);
854 if (TREE_CODE (t
) == METHOD_TYPE
)
855 arg
= TREE_CHAIN (arg
);
857 /* Function pointers don't have default args. Not in standard C++,
858 anyway; they may in g++, but we'll just pretend otherwise. */
859 dump_parameters (pp
, arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
861 pp
->padding
= pp_before
;
862 pp_cxx_cv_qualifiers (pp
, type_memfn_quals (t
),
863 TREE_CODE (t
) == FUNCTION_TYPE
864 && (flags
& TFF_POINTER
));
865 dump_ref_qualifier (pp
, t
, flags
);
866 if (tx_safe_fn_type_p (t
))
867 pp_cxx_ws_string (pp
, "transaction_safe");
868 dump_exception_spec (pp
, TYPE_RAISES_EXCEPTIONS (t
), flags
);
869 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
875 pp_cxx_left_bracket (pp
);
876 if (tree dtype
= TYPE_DOMAIN (t
))
878 tree max
= TYPE_MAX_VALUE (dtype
);
879 /* Zero-length arrays have an upper bound of SIZE_MAX. */
880 if (integer_all_onesp (max
))
881 pp_character (pp
, '0');
882 else if (tree_fits_shwi_p (max
))
883 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
887 if (TREE_CODE (max
) == SAVE_EXPR
)
888 max
= TREE_OPERAND (max
, 0);
889 if (TREE_CODE (max
) == MINUS_EXPR
890 || TREE_CODE (max
) == PLUS_EXPR
)
892 max
= TREE_OPERAND (max
, 0);
893 while (CONVERT_EXPR_P (max
))
894 max
= TREE_OPERAND (max
, 0);
897 max
= fold_build2_loc (input_location
,
898 PLUS_EXPR
, dtype
, max
,
899 build_int_cst (dtype
, 1));
900 dump_expr (pp
, max
, flags
& ~TFF_EXPR_IN_PARENS
);
903 pp_cxx_right_bracket (pp
);
904 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
908 case IDENTIFIER_NODE
:
913 case TEMPLATE_TYPE_PARM
:
914 case TEMPLATE_TEMPLATE_PARM
:
915 case BOUND_TEMPLATE_TEMPLATE_PARM
:
926 case UNDERLYING_TYPE
:
928 case TYPE_PACK_EXPANSION
:
929 case FIXED_POINT_TYPE
:
934 pp_unsupported_tree (pp
, t
);
936 /* Don't mark it here, we should have already done in
943 dump_global_iord (cxx_pretty_printer
*pp
, tree t
)
945 const char *p
= NULL
;
947 if (DECL_GLOBAL_CTOR_P (t
))
948 p
= M_("(static initializers for %s)");
949 else if (DECL_GLOBAL_DTOR_P (t
))
950 p
= M_("(static destructors for %s)");
954 pp_printf (pp
, p
, DECL_SOURCE_FILE (t
));
958 dump_simple_decl (cxx_pretty_printer
*pp
, tree t
, tree type
, int flags
)
960 if (flags
& TFF_DECL_SPECIFIERS
)
962 if (VAR_P (t
) && DECL_DECLARED_CONSTEXPR_P (t
))
964 if (DECL_LANG_SPECIFIC (t
) && DECL_DECLARED_CONCEPT_P (t
))
965 pp_cxx_ws_string (pp
, "concept");
967 pp_cxx_ws_string (pp
, "constexpr");
969 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
972 if (! (flags
& TFF_UNQUALIFIED_NAME
)
973 && TREE_CODE (t
) != PARM_DECL
974 && (!DECL_INITIAL (t
)
975 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
976 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
977 flags
&= ~TFF_UNQUALIFIED_NAME
;
978 if ((flags
& TFF_DECL_SPECIFIERS
)
979 && DECL_TEMPLATE_PARM_P (t
)
980 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
981 pp_string (pp
, "...");
984 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
987 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
988 pp_string (pp
, " capture>");
991 dump_decl (pp
, DECL_NAME (t
), flags
);
994 pp_string (pp
, M_("<anonymous>"));
995 if (flags
& TFF_DECL_SPECIFIERS
)
996 dump_type_suffix (pp
, type
, flags
);
999 /* Dump a human readable string for the decl T under control of FLAGS. */
1002 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1007 /* If doing Objective-C++, give Objective-C a chance to demangle
1008 Objective-C method names. */
1009 if (c_dialect_objc ())
1011 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1014 pp_string (pp
, demangled
);
1019 switch (TREE_CODE (t
))
1022 /* Don't say 'typedef class A' */
1023 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1025 if ((flags
& TFF_DECL_SPECIFIERS
)
1026 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1028 /* Say `class T' not just `T'. */
1029 pp_cxx_ws_string (pp
, "class");
1031 /* Emit the `...' for a parameter pack. */
1032 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1033 pp_cxx_ws_string (pp
, "...");
1036 dump_type (pp
, TREE_TYPE (t
), flags
);
1039 if (TYPE_DECL_ALIAS_P (t
)
1040 && (flags
& TFF_DECL_SPECIFIERS
1041 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1043 pp_cxx_ws_string (pp
, "using");
1044 dump_decl (pp
, DECL_NAME (t
), flags
);
1045 pp_cxx_whitespace (pp
);
1046 pp_cxx_ws_string (pp
, "=");
1047 pp_cxx_whitespace (pp
);
1048 dump_type (pp
, DECL_ORIGINAL_TYPE (t
), flags
);
1051 if ((flags
& TFF_DECL_SPECIFIERS
)
1052 && !DECL_SELF_REFERENCE_P (t
))
1053 pp_cxx_ws_string (pp
, "typedef");
1054 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1055 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1060 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1062 pp_string (pp
, M_("vtable for "));
1063 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1064 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1070 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1072 /* Handle variable template specializations. */
1074 && DECL_LANG_SPECIFIC (t
)
1075 && DECL_TEMPLATE_INFO (t
)
1076 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1078 pp_cxx_begin_template_argument_list (pp
);
1079 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1080 dump_template_argument_list (pp
, args
, flags
);
1081 pp_cxx_end_template_argument_list (pp
);
1086 pp_string (pp
, M_("<return value> "));
1087 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1090 case NAMESPACE_DECL
:
1091 if (flags
& TFF_DECL_SPECIFIERS
)
1092 pp
->declaration (t
);
1095 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1096 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1097 flags
&= ~TFF_UNQUALIFIED_NAME
;
1098 if (DECL_NAME (t
) == NULL_TREE
)
1100 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1101 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1103 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1106 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1111 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1112 pp_colon_colon (pp
);
1113 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1117 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1118 pp_cxx_left_bracket (pp
);
1119 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1120 pp_cxx_right_bracket (pp
);
1123 case ARRAY_NOTATION_REF
:
1124 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1125 pp_cxx_left_bracket (pp
);
1126 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1128 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1130 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1131 pp_cxx_right_bracket (pp
);
1134 /* So that we can do dump_decl on an aggr type. */
1138 dump_type (pp
, t
, flags
);
1142 /* This is a pseudo destructor call which has not been folded into
1143 a PSEUDO_DTOR_EXPR yet. */
1144 pp_cxx_complement (pp
);
1145 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1152 /* These special cases are duplicated here so that other functions
1153 can feed identifiers to error and get them demangled properly. */
1154 case IDENTIFIER_NODE
:
1155 if (IDENTIFIER_TYPENAME_P (t
))
1157 pp_cxx_ws_string (pp
, "operator");
1158 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1159 dump_type (pp
, TREE_TYPE (t
), flags
);
1163 pp_cxx_tree_identifier (pp
, t
);
1169 t
= OVL_CURRENT (t
);
1170 if (DECL_CLASS_SCOPE_P (t
))
1172 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1173 pp_cxx_colon_colon (pp
);
1175 else if (!DECL_FILE_SCOPE_P (t
))
1177 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1178 pp_cxx_colon_colon (pp
);
1180 dump_decl (pp
, DECL_NAME (t
), flags
);
1184 /* If there's only one function, just treat it like an ordinary
1186 t
= OVL_CURRENT (t
);
1190 if (! DECL_LANG_SPECIFIC (t
))
1192 if (DECL_ABSTRACT_ORIGIN (t
))
1193 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1195 pp_string (pp
, M_("<built-in>"));
1197 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1198 dump_global_iord (pp
, t
);
1200 dump_function_decl (pp
, t
, flags
);
1204 dump_template_decl (pp
, t
, flags
);
1207 case TEMPLATE_ID_EXPR
:
1209 tree name
= TREE_OPERAND (t
, 0);
1210 tree args
= TREE_OPERAND (t
, 1);
1212 if (is_overloaded_fn (name
))
1213 name
= get_first_fn (name
);
1215 name
= DECL_NAME (name
);
1216 dump_decl (pp
, name
, flags
);
1217 pp_cxx_begin_template_argument_list (pp
);
1218 if (args
== error_mark_node
)
1219 pp_string (pp
, M_("<template arguments error>"));
1221 dump_template_argument_list
1222 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1223 pp_cxx_end_template_argument_list (pp
);
1228 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1232 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1233 || (DECL_INITIAL (t
) &&
1234 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1235 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1236 else if (DECL_NAME (t
))
1237 dump_decl (pp
, DECL_NAME (t
), flags
);
1238 else if (DECL_INITIAL (t
))
1239 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1241 pp_string (pp
, M_("<enumerator>"));
1245 pp_cxx_ws_string (pp
, "using");
1246 dump_type (pp
, USING_DECL_SCOPE (t
), flags
);
1247 pp_cxx_colon_colon (pp
);
1248 dump_decl (pp
, DECL_NAME (t
), flags
);
1252 pp
->declaration (t
);
1256 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1259 case NON_DEPENDENT_EXPR
:
1260 dump_expr (pp
, t
, flags
);
1263 case TEMPLATE_TYPE_PARM
:
1264 if (flags
& TFF_DECL_SPECIFIERS
)
1265 pp
->declaration (t
);
1270 case UNBOUND_CLASS_TEMPLATE
:
1271 case TYPE_PACK_EXPANSION
:
1273 dump_type (pp
, t
, flags
);
1277 pp_unsupported_tree (pp
, t
);
1281 pp_string (pp
, M_("<declaration error>"));
1286 /* Dump a template declaration T under control of FLAGS. This means the
1287 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1290 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1292 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1296 if (flags
& TFF_TEMPLATE_HEADER
)
1298 for (parms
= orig_parms
= nreverse (orig_parms
);
1300 parms
= TREE_CHAIN (parms
))
1302 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1303 int len
= TREE_VEC_LENGTH (inner_parms
);
1307 /* Skip over the dummy template levels of a template template
1309 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1313 pp_cxx_ws_string (pp
, "template");
1314 pp_cxx_begin_template_argument_list (pp
);
1316 /* If we've shown the template prefix, we'd better show the
1317 parameters' and decl's type too. */
1318 flags
|= TFF_DECL_SPECIFIERS
;
1320 for (i
= 0; i
< len
; i
++)
1323 pp_separate_with_comma (pp
);
1324 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1327 pp_cxx_end_template_argument_list (pp
);
1328 pp_cxx_whitespace (pp
);
1330 nreverse(orig_parms
);
1332 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1334 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1335 pp_cxx_ws_string (pp
, "class");
1337 /* If this is a parameter pack, print the ellipsis. */
1338 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1339 pp_cxx_ws_string (pp
, "...");
1342 /* Only print the requirements if we're also printing
1343 the template header. */
1345 if (tree ci
= get_constraints (t
))
1346 if (check_constraint_info (ci
))
1347 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1349 pp_cxx_requires_clause (pp
, reqs
);
1350 pp_cxx_whitespace (pp
);
1355 if (DECL_CLASS_TEMPLATE_P (t
))
1356 dump_type (pp
, TREE_TYPE (t
),
1357 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1358 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1359 else if (DECL_TEMPLATE_RESULT (t
)
1360 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1361 /* Alias template. */
1362 || DECL_TYPE_TEMPLATE_P (t
)))
1363 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1366 gcc_assert (TREE_TYPE (t
));
1367 switch (NEXT_CODE (t
))
1371 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1374 /* This case can occur with some invalid code. */
1375 dump_type (pp
, TREE_TYPE (t
),
1376 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1377 | (flags
& TFF_DECL_SPECIFIERS
1378 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1383 /* find_typenames looks through the type of the function template T
1384 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1387 struct find_typenames_t
1389 hash_set
<tree
> *p_set
;
1390 vec
<tree
, va_gc
> *typenames
;
1394 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1396 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1397 tree mv
= NULL_TREE
;
1399 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1400 /* Add the type of the typedef without any additional cv-quals. */
1401 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1402 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1403 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1404 /* Add the typename without any cv-qualifiers. */
1405 mv
= TYPE_MAIN_VARIANT (*tp
);
1407 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1409 /* Don't mess with parameter packs since we don't remember
1410 the pack expansion context for a particular typename. */
1411 *walk_subtrees
= false;
1415 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1416 vec_safe_push (d
->typenames
, mv
);
1418 /* Search into class template arguments, which cp_walk_subtrees
1420 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1421 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1427 static vec
<tree
, va_gc
> *
1428 find_typenames (tree t
)
1430 struct find_typenames_t ft
;
1431 ft
.p_set
= new hash_set
<tree
>;
1432 ft
.typenames
= NULL
;
1433 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1434 find_typenames_r
, &ft
, ft
.p_set
);
1436 return ft
.typenames
;
1439 /* Output the "[with ...]" clause for a template instantiation T iff
1440 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1441 formatting a deduction/substitution diagnostic rather than an
1445 dump_substitution (cxx_pretty_printer
*pp
,
1446 tree t
, tree template_parms
, tree template_args
,
1449 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1450 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1452 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1453 pp_cxx_whitespace (pp
);
1454 pp_cxx_left_bracket (pp
);
1455 pp
->translate_string ("with");
1456 pp_cxx_whitespace (pp
);
1457 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1458 pp_cxx_right_bracket (pp
);
1462 /* Dump the lambda function FN including its 'mutable' qualifier and any
1463 template bindings. */
1466 dump_lambda_function (cxx_pretty_printer
*pp
,
1467 tree fn
, tree template_parms
, tree template_args
,
1470 /* A lambda's signature is essentially its "type". */
1471 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1472 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1474 pp
->padding
= pp_before
;
1475 pp_c_ws_string (pp
, "mutable");
1477 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1480 /* Pretty print a function decl. There are several ways we want to print a
1481 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1482 As error can only apply the '#' flag once to give 0 and 1 for V, there
1483 is %D which doesn't print the throw specs, and %F which does. */
1486 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1490 tree cname
= NULL_TREE
;
1491 tree template_args
= NULL_TREE
;
1492 tree template_parms
= NULL_TREE
;
1493 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1494 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1498 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1499 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1500 t
= DECL_TEMPLATE_RESULT (t
);
1502 /* Save the exceptions, in case t is a specialization and we are
1503 emitting an error about incompatible specifications. */
1504 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1506 /* Likewise for the constexpr specifier, in case t is a specialization. */
1507 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1509 /* Pretty print template instantiations only. */
1510 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1511 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1512 && flag_pretty_templates
)
1516 template_args
= DECL_TI_ARGS (t
);
1517 tmpl
= most_general_template (t
);
1518 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1520 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1525 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1526 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1528 fntype
= TREE_TYPE (t
);
1529 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1531 if (DECL_CLASS_SCOPE_P (t
))
1532 cname
= DECL_CONTEXT (t
);
1533 /* This is for partially instantiated template methods. */
1534 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1535 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1537 if (flags
& TFF_DECL_SPECIFIERS
)
1539 if (DECL_STATIC_FUNCTION_P (t
))
1540 pp_cxx_ws_string (pp
, "static");
1541 else if (DECL_VIRTUAL_P (t
))
1542 pp_cxx_ws_string (pp
, "virtual");
1546 if (DECL_DECLARED_CONCEPT_P (t
))
1547 pp_cxx_ws_string (pp
, "concept");
1549 pp_cxx_ws_string (pp
, "constexpr");
1553 /* Print the return type? */
1555 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1556 && !DECL_DESTRUCTOR_P (t
);
1559 tree ret
= fndecl_declared_return_type (t
);
1560 dump_type_prefix (pp
, ret
, flags
);
1563 /* Print the function name. */
1564 if (!do_outer_scope
)
1568 dump_type (pp
, cname
, flags
);
1569 pp_cxx_colon_colon (pp
);
1572 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1574 dump_function_name (pp
, t
, flags
);
1576 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1578 dump_parameters (pp
, parmtypes
, flags
);
1580 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1582 pp
->padding
= pp_before
;
1583 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1584 dump_ref_qualifier (pp
, fntype
, flags
);
1587 if (tx_safe_fn_type_p (fntype
))
1589 pp
->padding
= pp_before
;
1590 pp_cxx_ws_string (pp
, "transaction_safe");
1593 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1595 pp
->padding
= pp_before
;
1596 dump_exception_spec (pp
, exceptions
, flags
);
1600 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1603 if (tree ci
= get_constraints (t
))
1604 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1605 pp_cxx_requires_clause (pp
, reqs
);
1607 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1609 else if (template_args
)
1611 bool need_comma
= false;
1613 pp_cxx_begin_template_argument_list (pp
);
1614 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1615 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1617 tree arg
= TREE_VEC_ELT (template_args
, i
);
1619 pp_separate_with_comma (pp
);
1620 if (ARGUMENT_PACK_P (arg
))
1621 pp_cxx_left_brace (pp
);
1622 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1623 if (ARGUMENT_PACK_P (arg
))
1624 pp_cxx_right_brace (pp
);
1627 pp_cxx_end_template_argument_list (pp
);
1631 /* Print a parameter list. If this is for a member function, the
1632 member object ptr (and any other hidden args) should have
1633 already been removed. */
1636 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1639 flags
&= ~TFF_SCOPE
;
1640 pp_cxx_left_paren (pp
);
1642 for (first
= 1; parmtypes
!= void_list_node
;
1643 parmtypes
= TREE_CHAIN (parmtypes
))
1646 pp_separate_with_comma (pp
);
1650 pp_cxx_ws_string (pp
, "...");
1654 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1656 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1658 pp_cxx_whitespace (pp
);
1660 pp_cxx_whitespace (pp
);
1661 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1665 pp_cxx_right_paren (pp
);
1668 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1671 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1673 if (FUNCTION_REF_QUALIFIED (t
))
1675 pp
->padding
= pp_before
;
1676 if (FUNCTION_RVALUE_QUALIFIED (t
))
1677 pp_cxx_ws_string (pp
, "&&");
1679 pp_cxx_ws_string (pp
, "&");
1683 /* Print an exception specification. T is the exception specification. */
1686 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1688 if (t
&& TREE_PURPOSE (t
))
1690 pp_cxx_ws_string (pp
, "noexcept");
1691 if (!integer_onep (TREE_PURPOSE (t
)))
1693 pp_cxx_whitespace (pp
);
1694 pp_cxx_left_paren (pp
);
1695 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1696 pp_cxx_ws_string (pp
, "<uninstantiated>");
1698 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1699 pp_cxx_right_paren (pp
);
1704 pp_cxx_ws_string (pp
, "throw");
1705 pp_cxx_whitespace (pp
);
1706 pp_cxx_left_paren (pp
);
1707 if (TREE_VALUE (t
) != NULL_TREE
)
1710 dump_type (pp
, TREE_VALUE (t
), flags
);
1714 pp_separate_with_comma (pp
);
1716 pp_cxx_right_paren (pp
);
1720 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1721 and destructors properly. */
1724 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1726 tree name
= DECL_NAME (t
);
1728 /* We can get here with a decl that was synthesized by language-
1729 independent machinery (e.g. coverage.c) in which case it won't
1730 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1731 will crash. In this case it is safe just to print out the
1733 if (!DECL_LANG_SPECIFIC (t
))
1735 pp_cxx_tree_identifier (pp
, name
);
1739 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1740 t
= DECL_TEMPLATE_RESULT (t
);
1742 /* Don't let the user see __comp_ctor et al. */
1743 if (DECL_CONSTRUCTOR_P (t
)
1744 || DECL_DESTRUCTOR_P (t
))
1746 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1747 name
= get_identifier ("<lambda>");
1748 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1749 name
= get_identifier ("<constructor>");
1751 name
= constructor_name (DECL_CONTEXT (t
));
1754 if (DECL_DESTRUCTOR_P (t
))
1756 pp_cxx_complement (pp
);
1757 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1759 else if (DECL_CONV_FN_P (t
))
1761 /* This cannot use the hack that the operator's return
1762 type is stashed off of its name because it may be
1763 used for error reporting. In the case of conflicting
1764 declarations, both will have the same name, yet
1765 the types will be different, hence the TREE_TYPE field
1766 of the first name will be clobbered by the second. */
1767 pp_cxx_ws_string (pp
, "operator");
1768 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1770 else if (name
&& IDENTIFIER_OPNAME_P (name
))
1771 pp_cxx_tree_identifier (pp
, name
);
1772 else if (name
&& UDLIT_OPER_P (name
))
1773 pp_cxx_tree_identifier (pp
, name
);
1775 dump_decl (pp
, name
, flags
);
1777 if (DECL_TEMPLATE_INFO (t
)
1778 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1779 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1780 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1781 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1785 /* Dump the template parameters from the template info INFO under control of
1786 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1787 specialization (partial or complete). For partial specializations we show
1788 the specialized parameter values. For a primary template we show no
1792 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1793 int primary
, int flags
)
1795 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1797 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1799 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1800 pp_cxx_begin_template_argument_list (pp
);
1802 /* Be careful only to print things when we have them, so as not
1803 to crash producing error messages. */
1804 if (args
&& !primary
)
1807 len
= get_non_default_template_args_count (args
, flags
);
1809 args
= INNERMOST_TEMPLATE_ARGS (args
);
1810 for (ix
= 0; ix
!= len
; ix
++)
1812 tree arg
= TREE_VEC_ELT (args
, ix
);
1814 /* Only print a comma if we know there is an argument coming. In
1815 the case of an empty template argument pack, no actual
1816 argument will be printed. */
1818 && (!ARGUMENT_PACK_P (arg
)
1819 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1820 pp_separate_with_comma (pp
);
1823 pp_string (pp
, M_("<template parameter error>"));
1825 dump_template_argument (pp
, arg
, flags
);
1830 tree tpl
= TI_TEMPLATE (info
);
1831 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1834 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1835 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1837 for (ix
= 0; ix
!= len
; ix
++)
1841 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1843 pp_string (pp
, M_("<template parameter error>"));
1847 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1850 pp_separate_with_comma (pp
);
1852 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1855 pp_cxx_end_template_argument_list (pp
);
1858 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1859 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1862 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1865 call_expr_arg_iterator iter
;
1867 pp_cxx_left_paren (pp
);
1868 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1874 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1875 if (more_call_expr_args_p (&iter
))
1876 pp_separate_with_comma (pp
);
1879 pp_cxx_right_paren (pp
);
1882 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1883 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1887 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1891 aggr_init_expr_arg_iterator iter
;
1893 pp_cxx_left_paren (pp
);
1894 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1900 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1901 if (more_aggr_init_expr_args_p (&iter
))
1902 pp_separate_with_comma (pp
);
1905 pp_cxx_right_paren (pp
);
1908 /* Print out a list of initializers (subr of dump_expr). */
1911 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1915 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1918 pp_separate_with_comma (pp
);
1922 /* Print out a vector of initializers (subr of dump_expr). */
1925 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1928 unsigned HOST_WIDE_INT idx
;
1931 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1933 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1934 if (idx
!= v
->length () - 1)
1935 pp_separate_with_comma (pp
);
1940 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1941 function. Resolve it to a close relative -- in the sense of static
1942 type -- variant being overridden. That is close to what was written in
1943 the source code. Subroutine of dump_expr. */
1946 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1948 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1949 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1950 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1953 fun
= TREE_CHAIN (fun
);
1954 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1955 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1961 /* Print out an expression E under control of FLAGS. */
1964 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
1971 if (STATEMENT_CLASS_P (t
))
1973 pp_cxx_ws_string (pp
, M_("<statement>"));
1977 switch (TREE_CODE (t
))
1985 case NAMESPACE_DECL
:
1989 case IDENTIFIER_NODE
:
1990 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
1991 |TFF_TEMPLATE_HEADER
))
1992 | TFF_NO_TEMPLATE_BINDINGS
1993 | TFF_NO_FUNCTION_ARGUMENTS
));
1997 if (SSA_NAME_VAR (t
)
1998 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
1999 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2001 pp_cxx_ws_string (pp
, M_("<unknown>"));
2012 case USERDEF_LITERAL
:
2013 pp_cxx_userdef_literal (pp
, t
);
2017 /* While waiting for caret diagnostics, avoid printing
2018 __cxa_allocate_exception, __cxa_throw, and the like. */
2019 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2024 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2025 pp_cxx_colon_colon (pp
);
2026 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2030 pp_cxx_left_paren (pp
);
2031 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2032 pp_separate_with_comma (pp
);
2033 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2034 pp_cxx_right_paren (pp
);
2038 pp_cxx_left_paren (pp
);
2039 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2040 pp_string (pp
, " ? ");
2041 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2042 pp_string (pp
, " : ");
2043 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2044 pp_cxx_right_paren (pp
);
2048 if (TREE_HAS_CONSTRUCTOR (t
))
2050 pp_cxx_ws_string (pp
, "new");
2051 pp_cxx_whitespace (pp
);
2052 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2055 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2058 case AGGR_INIT_EXPR
:
2060 tree fn
= NULL_TREE
;
2062 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2063 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2065 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2067 if (DECL_CONSTRUCTOR_P (fn
))
2068 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2070 dump_decl (pp
, fn
, 0);
2073 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2075 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2080 tree fn
= CALL_EXPR_FN (t
);
2081 bool skipfirst
= false;
2083 /* Deal with internal functions. */
2084 if (fn
== NULL_TREE
)
2086 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2087 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2091 if (TREE_CODE (fn
) == ADDR_EXPR
)
2092 fn
= TREE_OPERAND (fn
, 0);
2094 /* Nobody is interested in seeing the guts of vcalls. */
2095 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2096 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2098 if (TREE_TYPE (fn
) != NULL_TREE
2099 && NEXT_CODE (fn
) == METHOD_TYPE
2100 && call_expr_nargs (t
))
2102 tree ob
= CALL_EXPR_ARG (t
, 0);
2103 if (TREE_CODE (ob
) == ADDR_EXPR
)
2105 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2106 flags
| TFF_EXPR_IN_PARENS
);
2109 else if (TREE_CODE (ob
) != PARM_DECL
2110 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2112 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2117 if (flag_sanitize
& SANITIZE_UNDEFINED
2118 && is_ubsan_builtin_p (fn
))
2120 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2123 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2124 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2129 /* Note that this only works for G++ target exprs. If somebody
2130 builds a general TARGET_EXPR, there's no way to represent that
2131 it initializes anything other that the parameter slot for the
2132 default argument. Note we may have cleared out the first
2133 operand in expand_expr, so don't go killing ourselves. */
2134 if (TREE_OPERAND (t
, 1))
2135 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2138 case POINTER_PLUS_EXPR
:
2139 dump_binary_op (pp
, "+", t
, flags
);
2144 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2151 case TRUNC_DIV_EXPR
:
2152 case TRUNC_MOD_EXPR
:
2160 case TRUTH_ANDIF_EXPR
:
2161 case TRUTH_ORIF_EXPR
:
2168 case EXACT_DIV_EXPR
:
2169 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2173 case FLOOR_DIV_EXPR
:
2174 case ROUND_DIV_EXPR
:
2176 dump_binary_op (pp
, "/", t
, flags
);
2180 case FLOOR_MOD_EXPR
:
2181 case ROUND_MOD_EXPR
:
2182 dump_binary_op (pp
, "%", t
, flags
);
2187 tree ob
= TREE_OPERAND (t
, 0);
2188 if (INDIRECT_REF_P (ob
))
2190 ob
= TREE_OPERAND (ob
, 0);
2191 if (TREE_CODE (ob
) != PARM_DECL
2193 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2195 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2196 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2204 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2207 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2212 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2213 pp_cxx_left_bracket (pp
);
2214 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2215 pp_cxx_right_bracket (pp
);
2218 case ARRAY_NOTATION_REF
:
2219 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2220 pp_cxx_left_bracket (pp
);
2221 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2223 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2225 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2226 pp_cxx_right_bracket (pp
);
2229 case UNARY_PLUS_EXPR
:
2230 dump_unary_op (pp
, "+", t
, flags
);
2234 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2235 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2236 /* An ADDR_EXPR can have reference type. In that case, we
2237 shouldn't print the `&' doing so indicates to the user
2238 that the expression has pointer type. */
2240 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2241 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2242 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2243 dump_unary_op (pp
, "&&", t
, flags
);
2245 dump_unary_op (pp
, "&", t
, flags
);
2249 if (TREE_HAS_CONSTRUCTOR (t
))
2251 t
= TREE_OPERAND (t
, 0);
2252 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2253 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2254 dump_call_expr_args (pp
, t
, flags
, true);
2258 if (TREE_OPERAND (t
,0) != NULL_TREE
2259 && TREE_TYPE (TREE_OPERAND (t
, 0))
2260 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2261 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2263 dump_unary_op (pp
, "*", t
, flags
);
2268 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2269 && integer_zerop (TREE_OPERAND (t
, 1)))
2270 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2274 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2276 pp_cxx_left_paren (pp
);
2277 if (!integer_onep (TYPE_SIZE_UNIT
2278 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2280 pp_cxx_left_paren (pp
);
2281 dump_type (pp
, ptr_type_node
, flags
);
2282 pp_cxx_right_paren (pp
);
2285 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2286 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2288 pp_cxx_ws_string (pp
, "+");
2289 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2291 pp_cxx_right_paren (pp
);
2298 case TRUTH_NOT_EXPR
:
2299 case PREDECREMENT_EXPR
:
2300 case PREINCREMENT_EXPR
:
2301 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2304 case POSTDECREMENT_EXPR
:
2305 case POSTINCREMENT_EXPR
:
2306 pp_cxx_left_paren (pp
);
2307 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2308 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2309 pp_cxx_right_paren (pp
);
2312 case NON_LVALUE_EXPR
:
2313 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2314 should be another level of INDIRECT_REF so that I don't have to do
2316 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2318 tree next
= TREE_TYPE (TREE_TYPE (t
));
2320 while (TYPE_PTR_P (next
))
2321 next
= TREE_TYPE (next
);
2323 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2325 if (flags
& TFF_EXPR_IN_PARENS
)
2326 pp_cxx_left_paren (pp
);
2328 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2329 if (flags
& TFF_EXPR_IN_PARENS
)
2330 pp_cxx_right_paren (pp
);
2333 /* Else fall through. */
2335 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2339 case IMPLICIT_CONV_EXPR
:
2340 case VIEW_CONVERT_EXPR
:
2342 tree op
= TREE_OPERAND (t
, 0);
2343 tree ttype
= TREE_TYPE (t
);
2344 tree optype
= TREE_TYPE (op
);
2346 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2347 && POINTER_TYPE_P (ttype
)
2348 && POINTER_TYPE_P (optype
)
2349 && same_type_p (TREE_TYPE (optype
),
2352 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2355 if (TREE_CODE (op
) == ADDR_EXPR
)
2356 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2358 dump_unary_op (pp
, "*", t
, flags
);
2361 dump_unary_op (pp
, "&", t
, flags
);
2363 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2365 /* It is a cast, but we cannot tell whether it is a
2366 reinterpret or static cast. Use the C style notation. */
2367 if (flags
& TFF_EXPR_IN_PARENS
)
2368 pp_cxx_left_paren (pp
);
2369 pp_cxx_left_paren (pp
);
2370 dump_type (pp
, TREE_TYPE (t
), flags
);
2371 pp_cxx_right_paren (pp
);
2372 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2373 if (flags
& TFF_EXPR_IN_PARENS
)
2374 pp_cxx_right_paren (pp
);
2377 dump_expr (pp
, op
, flags
);
2382 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2384 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2386 if (integer_zerop (idx
))
2388 /* A NULL pointer-to-member constant. */
2389 pp_cxx_left_paren (pp
);
2390 pp_cxx_left_paren (pp
);
2391 dump_type (pp
, TREE_TYPE (t
), flags
);
2392 pp_cxx_right_paren (pp
);
2393 pp_character (pp
, '0');
2394 pp_cxx_right_paren (pp
);
2397 else if (tree_fits_shwi_p (idx
))
2400 unsigned HOST_WIDE_INT n
;
2402 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2403 t
= TYPE_METHOD_BASETYPE (t
);
2404 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2406 n
= tree_to_shwi (idx
);
2408 /* Map vtable index back one, to allow for the null pointer to
2412 while (n
> 0 && virtuals
)
2415 virtuals
= TREE_CHAIN (virtuals
);
2419 dump_expr (pp
, BV_FN (virtuals
),
2420 flags
| TFF_EXPR_IN_PARENS
);
2425 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2426 pp_string (pp
, "<lambda closure object>");
2427 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2429 dump_type (pp
, TREE_TYPE (t
), 0);
2430 pp_cxx_left_paren (pp
);
2431 pp_cxx_right_paren (pp
);
2435 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2436 dump_type (pp
, TREE_TYPE (t
), 0);
2437 pp_cxx_left_brace (pp
);
2438 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2439 pp_cxx_right_brace (pp
);
2446 tree ob
= TREE_OPERAND (t
, 0);
2447 if (is_dummy_object (ob
))
2449 t
= TREE_OPERAND (t
, 1);
2450 if (TREE_CODE (t
) == FUNCTION_DECL
)
2452 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2453 else if (BASELINK_P (t
))
2454 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2455 flags
| TFF_EXPR_IN_PARENS
);
2457 dump_decl (pp
, t
, flags
);
2461 if (INDIRECT_REF_P (ob
))
2463 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2469 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2473 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2478 case TEMPLATE_PARM_INDEX
:
2479 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2483 if (TREE_OPERAND (t
, 0) == NULL_TREE
2484 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2486 dump_type (pp
, TREE_TYPE (t
), flags
);
2487 pp_cxx_left_paren (pp
);
2488 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2489 pp_cxx_right_paren (pp
);
2493 pp_cxx_left_paren (pp
);
2494 dump_type (pp
, TREE_TYPE (t
), flags
);
2495 pp_cxx_right_paren (pp
);
2496 pp_cxx_left_paren (pp
);
2497 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2498 pp_cxx_right_paren (pp
);
2502 case STATIC_CAST_EXPR
:
2503 pp_cxx_ws_string (pp
, "static_cast");
2505 case REINTERPRET_CAST_EXPR
:
2506 pp_cxx_ws_string (pp
, "reinterpret_cast");
2508 case CONST_CAST_EXPR
:
2509 pp_cxx_ws_string (pp
, "const_cast");
2511 case DYNAMIC_CAST_EXPR
:
2512 pp_cxx_ws_string (pp
, "dynamic_cast");
2514 pp_cxx_begin_template_argument_list (pp
);
2515 dump_type (pp
, TREE_TYPE (t
), flags
);
2516 pp_cxx_end_template_argument_list (pp
);
2517 pp_cxx_left_paren (pp
);
2518 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2519 pp_cxx_right_paren (pp
);
2523 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2529 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2530 pp_cxx_ws_string (pp
, "sizeof");
2533 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2534 pp_cxx_ws_string (pp
, "__alignof__");
2536 op
= TREE_OPERAND (t
, 0);
2537 if (PACK_EXPANSION_P (op
))
2539 pp_string (pp
, "...");
2540 op
= PACK_EXPANSION_PATTERN (op
);
2542 pp_cxx_whitespace (pp
);
2543 pp_cxx_left_paren (pp
);
2544 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2545 dump_type (pp
, TREE_TYPE (op
), flags
);
2546 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2547 dump_type (pp
, op
, flags
);
2549 dump_expr (pp
, op
, flags
);
2550 pp_cxx_right_paren (pp
);
2553 case AT_ENCODE_EXPR
:
2554 pp_cxx_ws_string (pp
, "@encode");
2555 pp_cxx_whitespace (pp
);
2556 pp_cxx_left_paren (pp
);
2557 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2558 pp_cxx_right_paren (pp
);
2562 pp_cxx_ws_string (pp
, "noexcept");
2563 pp_cxx_whitespace (pp
);
2564 pp_cxx_left_paren (pp
);
2565 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2566 pp_cxx_right_paren (pp
);
2571 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2572 pp_cxx_whitespace (pp
);
2573 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2577 pp_string (pp
, M_("<unparsed>"));
2580 case TRY_CATCH_EXPR
:
2581 case WITH_CLEANUP_EXPR
:
2582 case CLEANUP_POINT_EXPR
:
2583 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2586 case PSEUDO_DTOR_EXPR
:
2587 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2589 if (TREE_OPERAND (t
, 1))
2591 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2592 pp_cxx_colon_colon (pp
);
2594 pp_cxx_complement (pp
);
2595 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2598 case TEMPLATE_ID_EXPR
:
2599 dump_decl (pp
, t
, flags
);
2605 case STATEMENT_LIST
:
2606 /* We don't yet have a way of dumping statements in a
2607 human-readable format. */
2608 pp_string (pp
, "({...})");
2612 pp_string (pp
, "while (1) { ");
2613 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2614 pp_cxx_right_brace (pp
);
2618 pp_string (pp
, "if (");
2619 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2620 pp_string (pp
, ") break; ");
2624 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2627 case EMPTY_CLASS_EXPR
:
2628 dump_type (pp
, TREE_TYPE (t
), flags
);
2629 pp_cxx_left_paren (pp
);
2630 pp_cxx_right_paren (pp
);
2633 case NON_DEPENDENT_EXPR
:
2634 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2637 case ARGUMENT_PACK_SELECT
:
2638 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2650 pp_type_specifier_seq (pp
, t
);
2654 /* We get here when we want to print a dependent type as an
2655 id-expression, without any disambiguator decoration. */
2656 pp
->id_expression (t
);
2659 case TEMPLATE_TYPE_PARM
:
2660 case TEMPLATE_TEMPLATE_PARM
:
2661 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2662 dump_type (pp
, t
, flags
);
2666 pp_cxx_trait_expression (pp
, t
);
2670 pp_cxx_va_arg_expression (pp
, t
);
2674 pp_cxx_offsetof_expression (pp
, t
);
2678 dump_decl (pp
, t
, flags
);
2681 case EXPR_PACK_EXPANSION
:
2682 case UNARY_LEFT_FOLD_EXPR
:
2683 case UNARY_RIGHT_FOLD_EXPR
:
2684 case BINARY_LEFT_FOLD_EXPR
:
2685 case BINARY_RIGHT_FOLD_EXPR
:
2692 case VEC_DELETE_EXPR
:
2698 case UNORDERED_EXPR
:
2708 case FIX_TRUNC_EXPR
:
2713 case TRUTH_AND_EXPR
:
2715 case TRUTH_XOR_EXPR
:
2716 if (flags
& TFF_EXPR_IN_PARENS
)
2717 pp_cxx_left_paren (pp
);
2719 if (flags
& TFF_EXPR_IN_PARENS
)
2720 pp_cxx_right_paren (pp
);
2724 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2728 pp_string (pp
, M_("<lambda>"));
2732 pp_cxx_left_paren (pp
);
2733 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2734 pp_cxx_right_paren (pp
);
2738 pp_cxx_requires_expr (cxx_pp
, t
);
2742 pp_cxx_simple_requirement (cxx_pp
, t
);
2746 pp_cxx_type_requirement (cxx_pp
, t
);
2750 pp_cxx_compound_requirement (cxx_pp
, t
);
2754 pp_cxx_nested_requirement (cxx_pp
, t
);
2767 pp_cxx_constraint (cxx_pp
, t
);
2770 case PLACEHOLDER_EXPR
:
2771 pp_string (pp
, M_("*this"));
2774 /* This list is incomplete, but should suffice for now.
2775 It is very important that `sorry' does not call
2776 `report_error_function'. That could cause an infinite loop. */
2778 pp_unsupported_tree (pp
, t
);
2781 pp_string (pp
, M_("<expression error>"));
2787 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2790 pp_cxx_left_paren (pp
);
2791 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2792 pp_cxx_whitespace (pp
);
2794 pp_cxx_ws_string (pp
, opstring
);
2796 pp_string (pp
, M_("<unknown operator>"));
2797 pp_cxx_whitespace (pp
);
2798 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2799 pp_cxx_right_paren (pp
);
2803 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2805 if (flags
& TFF_EXPR_IN_PARENS
)
2806 pp_cxx_left_paren (pp
);
2807 pp_cxx_ws_string (pp
, opstring
);
2808 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2809 if (flags
& TFF_EXPR_IN_PARENS
)
2810 pp_cxx_right_paren (pp
);
2814 reinit_cxx_pp (void)
2816 pp_clear_output_area (cxx_pp
);
2817 cxx_pp
->padding
= pp_none
;
2818 pp_indentation (cxx_pp
) = 0;
2819 pp_needs_newline (cxx_pp
) = false;
2820 cxx_pp
->enclosing_scope
= current_function_decl
;
2823 /* Same as pp_formatted_text, except the return string is a separate
2824 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2827 pp_ggc_formatted_text (pretty_printer
*pp
)
2829 return ggc_strdup (pp_formatted_text (pp
));
2832 /* Exported interface to stringifying types, exprs and decls under TFF_*
2836 type_as_string (tree typ
, int flags
)
2839 pp_translate_identifiers (cxx_pp
) = false;
2840 dump_type (cxx_pp
, typ
, flags
);
2841 return pp_ggc_formatted_text (cxx_pp
);
2845 type_as_string_translate (tree typ
, int flags
)
2848 dump_type (cxx_pp
, typ
, flags
);
2849 return pp_ggc_formatted_text (cxx_pp
);
2853 expr_as_string (tree decl
, int flags
)
2856 pp_translate_identifiers (cxx_pp
) = false;
2857 dump_expr (cxx_pp
, decl
, flags
);
2858 return pp_ggc_formatted_text (cxx_pp
);
2861 /* Wrap decl_as_string with options appropriate for dwarf. */
2864 decl_as_dwarf_string (tree decl
, int flags
)
2867 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2868 here will be adequate to get the desired behavior. */
2869 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2870 name
= decl_as_string (decl
, flags
);
2871 /* Subsequent calls to the pretty printer shouldn't use this style. */
2872 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2877 decl_as_string (tree decl
, int flags
)
2880 pp_translate_identifiers (cxx_pp
) = false;
2881 dump_decl (cxx_pp
, decl
, flags
);
2882 return pp_ggc_formatted_text (cxx_pp
);
2886 decl_as_string_translate (tree decl
, int flags
)
2889 dump_decl (cxx_pp
, decl
, flags
);
2890 return pp_ggc_formatted_text (cxx_pp
);
2893 /* Wrap lang_decl_name with options appropriate for dwarf. */
2896 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2899 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2900 here will be adequate to get the desired behavior. */
2901 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2902 name
= lang_decl_name (decl
, v
, translate
);
2903 /* Subsequent calls to the pretty printer shouldn't use this style. */
2904 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2908 /* Generate the three forms of printable names for cxx_printable_name. */
2911 lang_decl_name (tree decl
, int v
, bool translate
)
2915 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2916 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2919 pp_translate_identifiers (cxx_pp
) = translate
;
2921 && (DECL_CLASS_SCOPE_P (decl
)
2922 || (DECL_NAMESPACE_SCOPE_P (decl
)
2923 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2925 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2926 pp_cxx_colon_colon (cxx_pp
);
2929 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2930 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2931 else if ((DECL_NAME (decl
) == NULL_TREE
)
2932 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2933 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2935 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2937 return pp_ggc_formatted_text (cxx_pp
);
2940 /* Return the location of a tree passed to %+ formats. */
2943 location_of (tree t
)
2947 t
= TYPE_MAIN_DECL (t
);
2949 return input_location
;
2951 else if (TREE_CODE (t
) == OVERLOAD
)
2952 t
= OVL_FUNCTION (t
);
2955 return DECL_SOURCE_LOCATION (t
);
2956 return EXPR_LOC_OR_LOC (t
, input_location
);
2959 /* Now the interfaces from error et al to dump_type et al. Each takes an
2960 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2964 decl_to_string (tree decl
, int verbose
)
2968 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2969 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2970 flags
= TFF_CLASS_KEY_OR_ENUM
;
2972 flags
|= TFF_DECL_SPECIFIERS
;
2973 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2974 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2975 flags
|= TFF_TEMPLATE_HEADER
;
2978 dump_decl (cxx_pp
, decl
, flags
);
2979 return pp_ggc_formatted_text (cxx_pp
);
2983 expr_to_string (tree decl
)
2986 dump_expr (cxx_pp
, decl
, 0);
2987 return pp_ggc_formatted_text (cxx_pp
);
2991 fndecl_to_string (tree fndecl
, int verbose
)
2995 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2996 | TFF_TEMPLATE_HEADER
;
2998 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3000 dump_decl (cxx_pp
, fndecl
, flags
);
3001 return pp_ggc_formatted_text (cxx_pp
);
3006 code_to_string (enum tree_code c
)
3008 return get_tree_code_name (c
);
3012 language_to_string (enum languages c
)
3019 case lang_cplusplus
:
3031 /* Return the proper printed version of a parameter to a C++ function. */
3034 parm_to_string (int p
)
3038 pp_string (cxx_pp
, "'this'");
3040 pp_decimal_int (cxx_pp
, p
+ 1);
3041 return pp_ggc_formatted_text (cxx_pp
);
3045 op_to_string (enum tree_code p
)
3047 tree id
= operator_name_info
[p
].identifier
;
3048 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3052 type_to_string (tree typ
, int verbose
)
3056 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3057 flags
|= TFF_TEMPLATE_HEADER
;
3060 dump_type (cxx_pp
, typ
, flags
);
3061 /* If we're printing a type that involves typedefs, also print the
3062 stripped version. But sometimes the stripped version looks
3063 exactly the same, so we don't want it after all. To avoid printing
3064 it in that case, we play ugly obstack games. */
3065 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3066 && !uses_template_parms (typ
))
3068 int aka_start
, aka_len
; char *p
;
3069 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3070 /* Remember the end of the initial dump. */
3071 int len
= obstack_object_size (ob
);
3072 tree aka
= strip_typedefs (typ
);
3073 pp_string (cxx_pp
, " {aka");
3074 pp_cxx_whitespace (cxx_pp
);
3075 /* And remember the start of the aka dump. */
3076 aka_start
= obstack_object_size (ob
);
3077 dump_type (cxx_pp
, aka
, flags
);
3078 aka_len
= obstack_object_size (ob
) - aka_start
;
3079 pp_right_brace (cxx_pp
);
3080 p
= (char*)obstack_base (ob
);
3081 /* If they are identical, cut off the aka with a NUL. */
3082 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3085 return pp_ggc_formatted_text (cxx_pp
);
3089 assop_to_string (enum tree_code p
)
3091 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3092 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3096 args_to_string (tree p
, int verbose
)
3100 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3105 if (TYPE_P (TREE_VALUE (p
)))
3106 return type_as_string_translate (p
, flags
);
3109 for (; p
; p
= TREE_CHAIN (p
))
3111 if (TREE_VALUE (p
) == null_node
)
3112 pp_cxx_ws_string (cxx_pp
, "NULL");
3114 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3116 pp_separate_with_comma (cxx_pp
);
3118 return pp_ggc_formatted_text (cxx_pp
);
3121 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3122 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3126 subst_to_string (tree p
)
3128 tree decl
= TREE_PURPOSE (p
);
3129 tree targs
= TREE_VALUE (p
);
3130 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3131 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3132 |TFF_NO_TEMPLATE_BINDINGS
);
3138 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3139 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3140 return pp_ggc_formatted_text (cxx_pp
);
3144 cv_to_string (tree p
, int v
)
3147 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3148 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3149 return pp_ggc_formatted_text (cxx_pp
);
3153 eh_spec_to_string (tree p
, int /*v*/)
3157 dump_exception_spec (cxx_pp
, p
, flags
);
3158 return pp_ggc_formatted_text (cxx_pp
);
3161 /* Langhook for print_error_function. */
3163 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3164 diagnostic_info
*diagnostic
)
3166 lhd_print_error_function (context
, file
, diagnostic
);
3167 pp_set_prefix (context
->printer
, file
);
3168 maybe_print_instantiation_context (context
);
3172 cp_diagnostic_starter (diagnostic_context
*context
,
3173 diagnostic_info
*diagnostic
)
3175 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3176 cp_print_error_function (context
, diagnostic
);
3177 maybe_print_instantiation_context (context
);
3178 maybe_print_constexpr_context (context
);
3179 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3183 /* Print current function onto BUFFER, in the process of reporting
3184 a diagnostic message. Called from cp_diagnostic_starter. */
3186 cp_print_error_function (diagnostic_context
*context
,
3187 diagnostic_info
*diagnostic
)
3189 /* If we are in an instantiation context, current_function_decl is likely
3190 to be wrong, so just rely on print_instantiation_full_context. */
3191 if (current_instantiation ())
3193 if (diagnostic_last_function_changed (context
, diagnostic
))
3195 const char *old_prefix
= context
->printer
->prefix
;
3196 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3197 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3198 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3199 ? file_name_as_prefix (context
, file
) : NULL
;
3201 pp_set_prefix (context
->printer
, new_prefix
);
3203 if (current_function_decl
== NULL
)
3204 pp_string (context
->printer
, _("At global scope:"));
3209 if (abstract_origin
)
3211 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3212 while (TREE_CODE (ao
) == BLOCK
3213 && BLOCK_ABSTRACT_ORIGIN (ao
)
3214 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3215 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3216 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3220 fndecl
= current_function_decl
;
3222 pp_printf (context
->printer
, function_category (fndecl
),
3223 cxx_printable_name_translate (fndecl
, 2));
3225 while (abstract_origin
)
3228 tree block
= abstract_origin
;
3230 locus
= &BLOCK_SOURCE_LOCATION (block
);
3232 block
= BLOCK_SUPERCONTEXT (block
);
3233 while (block
&& TREE_CODE (block
) == BLOCK
3234 && BLOCK_ABSTRACT_ORIGIN (block
))
3236 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3238 while (TREE_CODE (ao
) == BLOCK
3239 && BLOCK_ABSTRACT_ORIGIN (ao
)
3240 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3241 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3243 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3248 else if (TREE_CODE (ao
) != BLOCK
)
3251 block
= BLOCK_SUPERCONTEXT (block
);
3254 abstract_origin
= block
;
3257 while (block
&& TREE_CODE (block
) == BLOCK
)
3258 block
= BLOCK_SUPERCONTEXT (block
);
3260 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3262 abstract_origin
= NULL
;
3266 expanded_location s
= expand_location (*locus
);
3267 pp_character (context
->printer
, ',');
3268 pp_newline (context
->printer
);
3271 if (context
->show_column
&& s
.column
!= 0)
3272 pp_printf (context
->printer
,
3273 _(" inlined from %qs at %r%s:%d:%d%R"),
3274 cxx_printable_name_translate (fndecl
, 2),
3275 "locus", s
.file
, s
.line
, s
.column
);
3277 pp_printf (context
->printer
,
3278 _(" inlined from %qs at %r%s:%d%R"),
3279 cxx_printable_name_translate (fndecl
, 2),
3280 "locus", s
.file
, s
.line
);
3284 pp_printf (context
->printer
, _(" inlined from %qs"),
3285 cxx_printable_name_translate (fndecl
, 2));
3288 pp_character (context
->printer
, ':');
3290 pp_newline (context
->printer
);
3292 diagnostic_set_last_function (context
, diagnostic
);
3293 pp_destroy_prefix (context
->printer
);
3294 context
->printer
->prefix
= old_prefix
;
3298 /* Returns a description of FUNCTION using standard terminology. The
3299 result is a format string of the form "In CATEGORY %qs". */
3301 function_category (tree fn
)
3303 /* We can get called from the middle-end for diagnostics of function
3304 clones. Make sure we have language specific information before
3305 dereferencing it. */
3306 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3307 && DECL_FUNCTION_MEMBER_P (fn
))
3309 if (DECL_STATIC_FUNCTION_P (fn
))
3310 return _("In static member function %qs");
3311 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3312 return _("In copy constructor %qs");
3313 else if (DECL_CONSTRUCTOR_P (fn
))
3314 return _("In constructor %qs");
3315 else if (DECL_DESTRUCTOR_P (fn
))
3316 return _("In destructor %qs");
3317 else if (LAMBDA_FUNCTION_P (fn
))
3318 return _("In lambda function");
3320 return _("In member function %qs");
3323 return _("In function %qs");
3326 /* Report the full context of a current template instantiation,
3329 print_instantiation_full_context (diagnostic_context
*context
)
3331 struct tinst_level
*p
= current_instantiation ();
3332 location_t location
= input_location
;
3336 pp_verbatim (context
->printer
,
3337 TREE_CODE (p
->decl
) == TREE_LIST
3338 ? _("%s: In substitution of %qS:\n")
3339 : _("%s: In instantiation of %q#D:\n"),
3340 LOCATION_FILE (location
),
3343 location
= p
->locus
;
3347 print_instantiation_partial_context (context
, p
, location
);
3350 /* Helper function of print_instantiation_partial_context() that
3351 prints a single line of instantiation context. */
3354 print_instantiation_partial_context_line (diagnostic_context
*context
,
3355 const struct tinst_level
*t
,
3356 location_t loc
, bool recursive_p
)
3358 if (loc
== UNKNOWN_LOCATION
)
3361 expanded_location xloc
= expand_location (loc
);
3363 if (context
->show_column
)
3364 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3365 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3367 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3368 "locus", xloc
.file
, xloc
.line
);
3372 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3373 pp_verbatim (context
->printer
,
3375 ? _("recursively required by substitution of %qS\n")
3376 : _("required by substitution of %qS\n"),
3379 pp_verbatim (context
->printer
,
3381 ? _("recursively required from %q#D\n")
3382 : _("required from %q#D\n"),
3387 pp_verbatim (context
->printer
,
3389 ? _("recursively required from here\n")
3390 : _("required from here\n"));
3394 /* Same as print_instantiation_full_context but less verbose. */
3397 print_instantiation_partial_context (diagnostic_context
*context
,
3398 struct tinst_level
*t0
, location_t loc
)
3400 struct tinst_level
*t
;
3403 location_t prev_loc
= loc
;
3405 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3406 if (prev_loc
!= t
->locus
)
3408 prev_loc
= t
->locus
;
3414 if (template_backtrace_limit
3415 && n_total
> template_backtrace_limit
)
3417 int skip
= n_total
- template_backtrace_limit
;
3418 int head
= template_backtrace_limit
/ 2;
3420 /* Avoid skipping just 1. If so, skip 2. */
3424 head
= (template_backtrace_limit
- 1) / 2;
3427 for (n
= 0; n
< head
; n
++)
3429 gcc_assert (t
!= NULL
);
3430 if (loc
!= t
->locus
)
3431 print_instantiation_partial_context_line (context
, t
, loc
,
3432 /*recursive_p=*/false);
3436 if (t
!= NULL
&& skip
> 0)
3438 expanded_location xloc
;
3439 xloc
= expand_location (loc
);
3440 if (context
->show_column
)
3441 pp_verbatim (context
->printer
,
3442 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3443 "contexts, use -ftemplate-backtrace-limit=0 to "
3445 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3447 pp_verbatim (context
->printer
,
3448 _("%r%s:%d:%R [ skipping %d instantiation "
3449 "contexts, use -ftemplate-backtrace-limit=0 to "
3451 "locus", xloc
.file
, xloc
.line
, skip
);
3456 } while (t
!= NULL
&& --skip
> 0);
3462 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3467 print_instantiation_partial_context_line (context
, t
, loc
,
3472 print_instantiation_partial_context_line (context
, NULL
, loc
,
3473 /*recursive_p=*/false);
3476 /* Called from cp_thing to print the template context for an error. */
3478 maybe_print_instantiation_context (diagnostic_context
*context
)
3480 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3483 record_last_problematic_instantiation ();
3484 print_instantiation_full_context (context
);
3487 /* Report what constexpr call(s) we're trying to expand, if any. */
3490 maybe_print_constexpr_context (diagnostic_context
*context
)
3492 vec
<tree
> call_stack
= cx_error_context ();
3496 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3498 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3499 const char *s
= expr_as_string (t
, 0);
3500 if (context
->show_column
)
3501 pp_verbatim (context
->printer
,
3502 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3503 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3505 pp_verbatim (context
->printer
,
3506 _("%r%s:%d:%R in constexpr expansion of %qs"),
3507 "locus", xloc
.file
, xloc
.line
, s
);
3508 pp_newline (context
->printer
);
3512 /* Called from output_format -- during diagnostic message processing --
3513 to handle C++ specific format specifier with the following meanings:
3514 %A function argument-list.
3518 %F function declaration.
3519 %L language as used in extern "lang".
3521 %P function parameter whose position is indicated by an integer.
3522 %Q assignment operator.
3523 %S substitution (template + args)
3526 %X exception-specification. */
3528 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3529 int precision
, bool wide
, bool set_locus
, bool verbose
)
3533 #define next_tree (t = va_arg (*text->args_ptr, tree))
3534 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3535 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3536 #define next_int va_arg (*text->args_ptr, int)
3538 if (precision
!= 0 || wide
)
3543 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3544 case 'C': result
= code_to_string (next_tcode
); break;
3547 tree temp
= next_tree
;
3549 && DECL_HAS_DEBUG_EXPR_P (temp
))
3551 temp
= DECL_DEBUG_EXPR (temp
);
3554 result
= expr_to_string (temp
);
3558 result
= decl_to_string (temp
, verbose
);
3561 case 'E': result
= expr_to_string (next_tree
); break;
3562 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3563 case 'L': result
= language_to_string (next_lang
); break;
3564 case 'O': result
= op_to_string (next_tcode
); break;
3565 case 'P': result
= parm_to_string (next_int
); break;
3566 case 'Q': result
= assop_to_string (next_tcode
); break;
3567 case 'S': result
= subst_to_string (next_tree
); break;
3568 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3569 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3570 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3573 percent_K_format (text
);
3580 pp_string (pp
, result
);
3581 if (set_locus
&& t
!= NULL
)
3582 text
->set_location (0, location_of (t
), true);
3590 /* Warn about the use of C++0x features when appropriate. */
3592 maybe_warn_cpp0x (cpp0x_warn_str str
)
3594 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3595 /* We really want to suppress this warning in system headers,
3596 because libstdc++ uses variadic templates even when we aren't
3600 case CPP0X_INITIALIZER_LISTS
:
3601 pedwarn (input_location
, 0,
3602 "extended initializer lists "
3603 "only available with -std=c++11 or -std=gnu++11");
3605 case CPP0X_EXPLICIT_CONVERSION
:
3606 pedwarn (input_location
, 0,
3607 "explicit conversion operators "
3608 "only available with -std=c++11 or -std=gnu++11");
3610 case CPP0X_VARIADIC_TEMPLATES
:
3611 pedwarn (input_location
, 0,
3612 "variadic templates "
3613 "only available with -std=c++11 or -std=gnu++11");
3615 case CPP0X_LAMBDA_EXPR
:
3616 pedwarn (input_location
, 0,
3617 "lambda expressions "
3618 "only available with -std=c++11 or -std=gnu++11");
3621 pedwarn (input_location
, 0,
3622 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3624 case CPP0X_SCOPED_ENUMS
:
3625 pedwarn (input_location
, 0,
3626 "scoped enums only available with -std=c++11 or -std=gnu++11");
3628 case CPP0X_DEFAULTED_DELETED
:
3629 pedwarn (input_location
, 0,
3630 "defaulted and deleted functions "
3631 "only available with -std=c++11 or -std=gnu++11");
3633 case CPP0X_INLINE_NAMESPACES
:
3634 pedwarn (input_location
, OPT_Wpedantic
,
3635 "inline namespaces "
3636 "only available with -std=c++11 or -std=gnu++11");
3638 case CPP0X_OVERRIDE_CONTROLS
:
3639 pedwarn (input_location
, 0,
3640 "override controls (override/final) "
3641 "only available with -std=c++11 or -std=gnu++11");
3644 pedwarn (input_location
, 0,
3645 "non-static data member initializers "
3646 "only available with -std=c++11 or -std=gnu++11");
3648 case CPP0X_USER_DEFINED_LITERALS
:
3649 pedwarn (input_location
, 0,
3650 "user-defined literals "
3651 "only available with -std=c++11 or -std=gnu++11");
3653 case CPP0X_DELEGATING_CTORS
:
3654 pedwarn (input_location
, 0,
3655 "delegating constructors "
3656 "only available with -std=c++11 or -std=gnu++11");
3658 case CPP0X_INHERITING_CTORS
:
3659 pedwarn (input_location
, 0,
3660 "inheriting constructors "
3661 "only available with -std=c++11 or -std=gnu++11");
3663 case CPP0X_ATTRIBUTES
:
3664 pedwarn (input_location
, 0,
3666 "only available with -std=c++11 or -std=gnu++11");
3668 case CPP0X_REF_QUALIFIER
:
3669 pedwarn (input_location
, 0,
3671 "only available with -std=c++11 or -std=gnu++11");
3678 /* Warn about the use of variadic templates when appropriate. */
3680 maybe_warn_variadic_templates (void)
3682 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3686 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3687 option OPT with text GMSGID. Use this function to report
3688 diagnostics for constructs that are invalid C++98, but valid
3691 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3693 diagnostic_info diagnostic
;
3696 rich_location
richloc (line_table
, location
);
3698 va_start (ap
, gmsgid
);
3699 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
3700 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3701 diagnostic
.option_index
= opt
;
3702 ret
= report_diagnostic (&diagnostic
);
3707 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3708 we found when we tried to do the lookup. LOCATION is the location of
3709 the NAME identifier. */
3712 qualified_name_lookup_error (tree scope
, tree name
,
3713 tree decl
, location_t location
)
3715 if (scope
== error_mark_node
)
3716 ; /* We already complained. */
3717 else if (TYPE_P (scope
))
3719 if (!COMPLETE_TYPE_P (scope
))
3720 error_at (location
, "incomplete type %qT used in nested name specifier",
3722 else if (TREE_CODE (decl
) == TREE_LIST
)
3724 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3726 print_candidates (decl
);
3729 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3731 else if (scope
!= global_namespace
)
3733 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3734 suggest_alternatives_for (location
, name
);
3738 error_at (location
, "%<::%D%> has not been declared", name
);
3739 suggest_alternatives_for (location
, name
);