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
);
1162 else if (dguide_name_p (t
))
1163 dump_decl (pp
, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t
)),
1164 TFF_PLAIN_IDENTIFIER
);
1166 pp_cxx_tree_identifier (pp
, t
);
1172 t
= OVL_CURRENT (t
);
1173 if (DECL_CLASS_SCOPE_P (t
))
1175 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1176 pp_cxx_colon_colon (pp
);
1178 else if (!DECL_FILE_SCOPE_P (t
))
1180 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1181 pp_cxx_colon_colon (pp
);
1183 dump_decl (pp
, DECL_NAME (t
), flags
);
1187 /* If there's only one function, just treat it like an ordinary
1189 t
= OVL_CURRENT (t
);
1193 if (! DECL_LANG_SPECIFIC (t
))
1195 if (DECL_ABSTRACT_ORIGIN (t
))
1196 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1198 pp_string (pp
, M_("<built-in>"));
1200 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1201 dump_global_iord (pp
, t
);
1203 dump_function_decl (pp
, t
, flags
);
1207 dump_template_decl (pp
, t
, flags
);
1210 case TEMPLATE_ID_EXPR
:
1212 tree name
= TREE_OPERAND (t
, 0);
1213 tree args
= TREE_OPERAND (t
, 1);
1215 if (is_overloaded_fn (name
))
1216 name
= get_first_fn (name
);
1218 name
= DECL_NAME (name
);
1219 dump_decl (pp
, name
, flags
);
1220 pp_cxx_begin_template_argument_list (pp
);
1221 if (args
== error_mark_node
)
1222 pp_string (pp
, M_("<template arguments error>"));
1224 dump_template_argument_list
1225 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1226 pp_cxx_end_template_argument_list (pp
);
1231 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1235 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1236 || (DECL_INITIAL (t
) &&
1237 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1238 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1239 else if (DECL_NAME (t
))
1240 dump_decl (pp
, DECL_NAME (t
), flags
);
1241 else if (DECL_INITIAL (t
))
1242 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1244 pp_string (pp
, M_("<enumerator>"));
1248 pp_cxx_ws_string (pp
, "using");
1249 dump_type (pp
, USING_DECL_SCOPE (t
), flags
);
1250 pp_cxx_colon_colon (pp
);
1251 dump_decl (pp
, DECL_NAME (t
), flags
);
1255 pp
->declaration (t
);
1259 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1262 case NON_DEPENDENT_EXPR
:
1263 dump_expr (pp
, t
, flags
);
1266 case TEMPLATE_TYPE_PARM
:
1267 if (flags
& TFF_DECL_SPECIFIERS
)
1268 pp
->declaration (t
);
1273 case UNBOUND_CLASS_TEMPLATE
:
1274 case TYPE_PACK_EXPANSION
:
1276 dump_type (pp
, t
, flags
);
1280 pp_unsupported_tree (pp
, t
);
1284 pp_string (pp
, M_("<declaration error>"));
1289 /* Dump a template declaration T under control of FLAGS. This means the
1290 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1293 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1295 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1299 if (flags
& TFF_TEMPLATE_HEADER
)
1301 for (parms
= orig_parms
= nreverse (orig_parms
);
1303 parms
= TREE_CHAIN (parms
))
1305 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1306 int len
= TREE_VEC_LENGTH (inner_parms
);
1310 /* Skip over the dummy template levels of a template template
1312 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1316 pp_cxx_ws_string (pp
, "template");
1317 pp_cxx_begin_template_argument_list (pp
);
1319 /* If we've shown the template prefix, we'd better show the
1320 parameters' and decl's type too. */
1321 flags
|= TFF_DECL_SPECIFIERS
;
1323 for (i
= 0; i
< len
; i
++)
1326 pp_separate_with_comma (pp
);
1327 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1330 pp_cxx_end_template_argument_list (pp
);
1331 pp_cxx_whitespace (pp
);
1333 nreverse(orig_parms
);
1335 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1337 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1338 pp_cxx_ws_string (pp
, "class");
1340 /* If this is a parameter pack, print the ellipsis. */
1341 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1342 pp_cxx_ws_string (pp
, "...");
1345 /* Only print the requirements if we're also printing
1346 the template header. */
1348 if (tree ci
= get_constraints (t
))
1349 if (check_constraint_info (ci
))
1350 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1352 pp_cxx_requires_clause (pp
, reqs
);
1353 pp_cxx_whitespace (pp
);
1358 if (DECL_CLASS_TEMPLATE_P (t
))
1359 dump_type (pp
, TREE_TYPE (t
),
1360 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1361 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1362 else if (DECL_TEMPLATE_RESULT (t
)
1363 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1364 /* Alias template. */
1365 || DECL_TYPE_TEMPLATE_P (t
)))
1366 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1369 gcc_assert (TREE_TYPE (t
));
1370 switch (NEXT_CODE (t
))
1374 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1377 /* This case can occur with some invalid code. */
1378 dump_type (pp
, TREE_TYPE (t
),
1379 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1380 | (flags
& TFF_DECL_SPECIFIERS
1381 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1386 /* find_typenames looks through the type of the function template T
1387 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1390 struct find_typenames_t
1392 hash_set
<tree
> *p_set
;
1393 vec
<tree
, va_gc
> *typenames
;
1397 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1399 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1400 tree mv
= NULL_TREE
;
1402 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1403 /* Add the type of the typedef without any additional cv-quals. */
1404 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1405 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1406 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1407 /* Add the typename without any cv-qualifiers. */
1408 mv
= TYPE_MAIN_VARIANT (*tp
);
1410 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1412 /* Don't mess with parameter packs since we don't remember
1413 the pack expansion context for a particular typename. */
1414 *walk_subtrees
= false;
1418 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1419 vec_safe_push (d
->typenames
, mv
);
1421 /* Search into class template arguments, which cp_walk_subtrees
1423 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1424 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1430 static vec
<tree
, va_gc
> *
1431 find_typenames (tree t
)
1433 struct find_typenames_t ft
;
1434 ft
.p_set
= new hash_set
<tree
>;
1435 ft
.typenames
= NULL
;
1436 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1437 find_typenames_r
, &ft
, ft
.p_set
);
1439 return ft
.typenames
;
1442 /* Output the "[with ...]" clause for a template instantiation T iff
1443 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1444 formatting a deduction/substitution diagnostic rather than an
1448 dump_substitution (cxx_pretty_printer
*pp
,
1449 tree t
, tree template_parms
, tree template_args
,
1452 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1453 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1455 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1456 pp_cxx_whitespace (pp
);
1457 pp_cxx_left_bracket (pp
);
1458 pp
->translate_string ("with");
1459 pp_cxx_whitespace (pp
);
1460 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1461 pp_cxx_right_bracket (pp
);
1465 /* Dump the lambda function FN including its 'mutable' qualifier and any
1466 template bindings. */
1469 dump_lambda_function (cxx_pretty_printer
*pp
,
1470 tree fn
, tree template_parms
, tree template_args
,
1473 /* A lambda's signature is essentially its "type". */
1474 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1475 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1477 pp
->padding
= pp_before
;
1478 pp_c_ws_string (pp
, "mutable");
1480 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1483 /* Pretty print a function decl. There are several ways we want to print a
1484 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1485 As error can only apply the '#' flag once to give 0 and 1 for V, there
1486 is %D which doesn't print the throw specs, and %F which does. */
1489 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1493 tree cname
= NULL_TREE
;
1494 tree template_args
= NULL_TREE
;
1495 tree template_parms
= NULL_TREE
;
1496 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1497 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1501 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1502 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1503 t
= DECL_TEMPLATE_RESULT (t
);
1505 /* Save the exceptions, in case t is a specialization and we are
1506 emitting an error about incompatible specifications. */
1507 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1509 /* Likewise for the constexpr specifier, in case t is a specialization. */
1510 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1512 /* Pretty print template instantiations only. */
1513 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1514 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1515 && flag_pretty_templates
)
1519 template_args
= DECL_TI_ARGS (t
);
1520 tmpl
= most_general_template (t
);
1521 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1523 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1528 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1529 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1531 fntype
= TREE_TYPE (t
);
1532 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1534 if (DECL_CLASS_SCOPE_P (t
))
1535 cname
= DECL_CONTEXT (t
);
1536 /* This is for partially instantiated template methods. */
1537 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1538 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1540 if (flags
& TFF_DECL_SPECIFIERS
)
1542 if (DECL_STATIC_FUNCTION_P (t
))
1543 pp_cxx_ws_string (pp
, "static");
1544 else if (DECL_VIRTUAL_P (t
))
1545 pp_cxx_ws_string (pp
, "virtual");
1549 if (DECL_DECLARED_CONCEPT_P (t
))
1550 pp_cxx_ws_string (pp
, "concept");
1552 pp_cxx_ws_string (pp
, "constexpr");
1556 /* Print the return type? */
1558 show_return
= (!DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1559 && !DECL_DESTRUCTOR_P (t
) && !deduction_guide_p (t
));
1562 tree ret
= fndecl_declared_return_type (t
);
1563 dump_type_prefix (pp
, ret
, flags
);
1566 /* Print the function name. */
1567 if (!do_outer_scope
)
1571 dump_type (pp
, cname
, flags
);
1572 pp_cxx_colon_colon (pp
);
1575 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1577 dump_function_name (pp
, t
, flags
);
1579 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1581 dump_parameters (pp
, parmtypes
, flags
);
1583 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1585 pp
->padding
= pp_before
;
1586 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1587 dump_ref_qualifier (pp
, fntype
, flags
);
1590 if (tx_safe_fn_type_p (fntype
))
1592 pp
->padding
= pp_before
;
1593 pp_cxx_ws_string (pp
, "transaction_safe");
1596 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1598 pp
->padding
= pp_before
;
1599 dump_exception_spec (pp
, exceptions
, flags
);
1603 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1604 else if (deduction_guide_p (t
))
1606 pp_cxx_ws_string (pp
, "->");
1607 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1611 if (tree ci
= get_constraints (t
))
1612 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1613 pp_cxx_requires_clause (pp
, reqs
);
1615 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1617 else if (template_args
)
1619 bool need_comma
= false;
1621 pp_cxx_begin_template_argument_list (pp
);
1622 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1623 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1625 tree arg
= TREE_VEC_ELT (template_args
, i
);
1627 pp_separate_with_comma (pp
);
1628 if (ARGUMENT_PACK_P (arg
))
1629 pp_cxx_left_brace (pp
);
1630 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1631 if (ARGUMENT_PACK_P (arg
))
1632 pp_cxx_right_brace (pp
);
1635 pp_cxx_end_template_argument_list (pp
);
1639 /* Print a parameter list. If this is for a member function, the
1640 member object ptr (and any other hidden args) should have
1641 already been removed. */
1644 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1647 flags
&= ~TFF_SCOPE
;
1648 pp_cxx_left_paren (pp
);
1650 for (first
= 1; parmtypes
!= void_list_node
;
1651 parmtypes
= TREE_CHAIN (parmtypes
))
1654 pp_separate_with_comma (pp
);
1658 pp_cxx_ws_string (pp
, "...");
1662 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1664 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1666 pp_cxx_whitespace (pp
);
1668 pp_cxx_whitespace (pp
);
1669 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1673 pp_cxx_right_paren (pp
);
1676 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1679 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1681 if (FUNCTION_REF_QUALIFIED (t
))
1683 pp
->padding
= pp_before
;
1684 if (FUNCTION_RVALUE_QUALIFIED (t
))
1685 pp_cxx_ws_string (pp
, "&&");
1687 pp_cxx_ws_string (pp
, "&");
1691 /* Print an exception specification. T is the exception specification. */
1694 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1696 if (t
&& TREE_PURPOSE (t
))
1698 pp_cxx_ws_string (pp
, "noexcept");
1699 if (!integer_onep (TREE_PURPOSE (t
)))
1701 pp_cxx_whitespace (pp
);
1702 pp_cxx_left_paren (pp
);
1703 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1704 pp_cxx_ws_string (pp
, "<uninstantiated>");
1706 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1707 pp_cxx_right_paren (pp
);
1712 pp_cxx_ws_string (pp
, "throw");
1713 pp_cxx_whitespace (pp
);
1714 pp_cxx_left_paren (pp
);
1715 if (TREE_VALUE (t
) != NULL_TREE
)
1718 dump_type (pp
, TREE_VALUE (t
), flags
);
1722 pp_separate_with_comma (pp
);
1724 pp_cxx_right_paren (pp
);
1728 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1729 and destructors properly. */
1732 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1734 tree name
= DECL_NAME (t
);
1736 /* We can get here with a decl that was synthesized by language-
1737 independent machinery (e.g. coverage.c) in which case it won't
1738 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1739 will crash. In this case it is safe just to print out the
1741 if (!DECL_LANG_SPECIFIC (t
))
1743 pp_cxx_tree_identifier (pp
, name
);
1747 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1748 t
= DECL_TEMPLATE_RESULT (t
);
1750 /* Don't let the user see __comp_ctor et al. */
1751 if (DECL_CONSTRUCTOR_P (t
)
1752 || DECL_DESTRUCTOR_P (t
))
1754 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1755 name
= get_identifier ("<lambda>");
1756 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1757 name
= get_identifier ("<constructor>");
1759 name
= constructor_name (DECL_CONTEXT (t
));
1762 if (DECL_DESTRUCTOR_P (t
))
1764 pp_cxx_complement (pp
);
1765 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1767 else if (DECL_CONV_FN_P (t
))
1769 /* This cannot use the hack that the operator's return
1770 type is stashed off of its name because it may be
1771 used for error reporting. In the case of conflicting
1772 declarations, both will have the same name, yet
1773 the types will be different, hence the TREE_TYPE field
1774 of the first name will be clobbered by the second. */
1775 pp_cxx_ws_string (pp
, "operator");
1776 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1779 dump_decl (pp
, name
, flags
);
1781 if (DECL_TEMPLATE_INFO (t
)
1782 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1783 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1784 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1785 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1789 /* Dump the template parameters from the template info INFO under control of
1790 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1791 specialization (partial or complete). For partial specializations we show
1792 the specialized parameter values. For a primary template we show no
1796 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1797 int primary
, int flags
)
1799 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1801 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1803 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1804 pp_cxx_begin_template_argument_list (pp
);
1806 /* Be careful only to print things when we have them, so as not
1807 to crash producing error messages. */
1808 if (args
&& !primary
)
1811 len
= get_non_default_template_args_count (args
, flags
);
1813 args
= INNERMOST_TEMPLATE_ARGS (args
);
1814 for (ix
= 0; ix
!= len
; ix
++)
1816 tree arg
= TREE_VEC_ELT (args
, ix
);
1818 /* Only print a comma if we know there is an argument coming. In
1819 the case of an empty template argument pack, no actual
1820 argument will be printed. */
1822 && (!ARGUMENT_PACK_P (arg
)
1823 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1824 pp_separate_with_comma (pp
);
1827 pp_string (pp
, M_("<template parameter error>"));
1829 dump_template_argument (pp
, arg
, flags
);
1834 tree tpl
= TI_TEMPLATE (info
);
1835 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1838 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1839 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1841 for (ix
= 0; ix
!= len
; ix
++)
1845 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1847 pp_string (pp
, M_("<template parameter error>"));
1851 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1854 pp_separate_with_comma (pp
);
1856 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1859 pp_cxx_end_template_argument_list (pp
);
1862 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1863 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1866 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1869 call_expr_arg_iterator iter
;
1871 pp_cxx_left_paren (pp
);
1872 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1878 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1879 if (more_call_expr_args_p (&iter
))
1880 pp_separate_with_comma (pp
);
1883 pp_cxx_right_paren (pp
);
1886 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1887 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1891 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1895 aggr_init_expr_arg_iterator iter
;
1897 pp_cxx_left_paren (pp
);
1898 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1904 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1905 if (more_aggr_init_expr_args_p (&iter
))
1906 pp_separate_with_comma (pp
);
1909 pp_cxx_right_paren (pp
);
1912 /* Print out a list of initializers (subr of dump_expr). */
1915 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1919 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1922 pp_separate_with_comma (pp
);
1926 /* Print out a vector of initializers (subr of dump_expr). */
1929 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1932 unsigned HOST_WIDE_INT idx
;
1935 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1937 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1938 if (idx
!= v
->length () - 1)
1939 pp_separate_with_comma (pp
);
1944 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1945 function. Resolve it to a close relative -- in the sense of static
1946 type -- variant being overridden. That is close to what was written in
1947 the source code. Subroutine of dump_expr. */
1950 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1952 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1953 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1954 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1957 fun
= TREE_CHAIN (fun
);
1958 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1959 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1965 /* Print out an expression E under control of FLAGS. */
1968 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
1975 if (STATEMENT_CLASS_P (t
))
1977 pp_cxx_ws_string (pp
, M_("<statement>"));
1981 switch (TREE_CODE (t
))
1989 case NAMESPACE_DECL
:
1993 case IDENTIFIER_NODE
:
1994 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
1995 |TFF_TEMPLATE_HEADER
))
1996 | TFF_NO_TEMPLATE_BINDINGS
1997 | TFF_NO_FUNCTION_ARGUMENTS
));
2001 if (SSA_NAME_VAR (t
)
2002 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
2003 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2005 pp_cxx_ws_string (pp
, M_("<unknown>"));
2016 case USERDEF_LITERAL
:
2017 pp_cxx_userdef_literal (pp
, t
);
2021 /* While waiting for caret diagnostics, avoid printing
2022 __cxa_allocate_exception, __cxa_throw, and the like. */
2023 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2028 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2029 pp_cxx_colon_colon (pp
);
2030 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2034 pp_cxx_left_paren (pp
);
2035 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2036 pp_separate_with_comma (pp
);
2037 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2038 pp_cxx_right_paren (pp
);
2042 pp_cxx_left_paren (pp
);
2043 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2044 pp_string (pp
, " ? ");
2045 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2046 pp_string (pp
, " : ");
2047 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2048 pp_cxx_right_paren (pp
);
2052 if (TREE_HAS_CONSTRUCTOR (t
))
2054 pp_cxx_ws_string (pp
, "new");
2055 pp_cxx_whitespace (pp
);
2056 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2059 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2062 case AGGR_INIT_EXPR
:
2064 tree fn
= NULL_TREE
;
2066 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2067 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2069 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2071 if (DECL_CONSTRUCTOR_P (fn
))
2072 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2074 dump_decl (pp
, fn
, 0);
2077 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2079 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2084 tree fn
= CALL_EXPR_FN (t
);
2085 bool skipfirst
= false;
2087 /* Deal with internal functions. */
2088 if (fn
== NULL_TREE
)
2090 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2091 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2095 if (TREE_CODE (fn
) == ADDR_EXPR
)
2096 fn
= TREE_OPERAND (fn
, 0);
2098 /* Nobody is interested in seeing the guts of vcalls. */
2099 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2100 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2102 if (TREE_TYPE (fn
) != NULL_TREE
2103 && NEXT_CODE (fn
) == METHOD_TYPE
2104 && call_expr_nargs (t
))
2106 tree ob
= CALL_EXPR_ARG (t
, 0);
2107 if (TREE_CODE (ob
) == ADDR_EXPR
)
2109 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2110 flags
| TFF_EXPR_IN_PARENS
);
2113 else if (TREE_CODE (ob
) != PARM_DECL
2114 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2116 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2121 if (flag_sanitize
& SANITIZE_UNDEFINED
2122 && is_ubsan_builtin_p (fn
))
2124 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2127 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2128 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2133 /* Note that this only works for G++ target exprs. If somebody
2134 builds a general TARGET_EXPR, there's no way to represent that
2135 it initializes anything other that the parameter slot for the
2136 default argument. Note we may have cleared out the first
2137 operand in expand_expr, so don't go killing ourselves. */
2138 if (TREE_OPERAND (t
, 1))
2139 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2142 case POINTER_PLUS_EXPR
:
2143 dump_binary_op (pp
, "+", t
, flags
);
2148 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2155 case TRUNC_DIV_EXPR
:
2156 case TRUNC_MOD_EXPR
:
2164 case TRUTH_ANDIF_EXPR
:
2165 case TRUTH_ORIF_EXPR
:
2172 case EXACT_DIV_EXPR
:
2173 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2177 case FLOOR_DIV_EXPR
:
2178 case ROUND_DIV_EXPR
:
2180 dump_binary_op (pp
, "/", t
, flags
);
2184 case FLOOR_MOD_EXPR
:
2185 case ROUND_MOD_EXPR
:
2186 dump_binary_op (pp
, "%", t
, flags
);
2191 tree ob
= TREE_OPERAND (t
, 0);
2192 if (INDIRECT_REF_P (ob
))
2194 ob
= TREE_OPERAND (ob
, 0);
2195 if (TREE_CODE (ob
) != PARM_DECL
2197 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2199 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2200 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2208 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2211 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2216 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2217 pp_cxx_left_bracket (pp
);
2218 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2219 pp_cxx_right_bracket (pp
);
2222 case ARRAY_NOTATION_REF
:
2223 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2224 pp_cxx_left_bracket (pp
);
2225 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2227 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2229 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2230 pp_cxx_right_bracket (pp
);
2233 case UNARY_PLUS_EXPR
:
2234 dump_unary_op (pp
, "+", t
, flags
);
2238 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2239 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2240 /* An ADDR_EXPR can have reference type. In that case, we
2241 shouldn't print the `&' doing so indicates to the user
2242 that the expression has pointer type. */
2244 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2245 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2246 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2247 dump_unary_op (pp
, "&&", t
, flags
);
2249 dump_unary_op (pp
, "&", t
, flags
);
2253 if (TREE_HAS_CONSTRUCTOR (t
))
2255 t
= TREE_OPERAND (t
, 0);
2256 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2257 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2258 dump_call_expr_args (pp
, t
, flags
, true);
2262 if (TREE_OPERAND (t
,0) != NULL_TREE
2263 && TREE_TYPE (TREE_OPERAND (t
, 0))
2264 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2265 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2267 dump_unary_op (pp
, "*", t
, flags
);
2272 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2273 && integer_zerop (TREE_OPERAND (t
, 1)))
2274 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2278 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2280 pp_cxx_left_paren (pp
);
2281 if (!integer_onep (TYPE_SIZE_UNIT
2282 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2284 pp_cxx_left_paren (pp
);
2285 dump_type (pp
, ptr_type_node
, flags
);
2286 pp_cxx_right_paren (pp
);
2289 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2290 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2292 pp_cxx_ws_string (pp
, "+");
2293 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2295 pp_cxx_right_paren (pp
);
2302 case TRUTH_NOT_EXPR
:
2303 case PREDECREMENT_EXPR
:
2304 case PREINCREMENT_EXPR
:
2305 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2308 case POSTDECREMENT_EXPR
:
2309 case POSTINCREMENT_EXPR
:
2310 pp_cxx_left_paren (pp
);
2311 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2312 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2313 pp_cxx_right_paren (pp
);
2316 case NON_LVALUE_EXPR
:
2317 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2318 should be another level of INDIRECT_REF so that I don't have to do
2320 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2322 tree next
= TREE_TYPE (TREE_TYPE (t
));
2324 while (TYPE_PTR_P (next
))
2325 next
= TREE_TYPE (next
);
2327 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2329 if (flags
& TFF_EXPR_IN_PARENS
)
2330 pp_cxx_left_paren (pp
);
2332 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2333 if (flags
& TFF_EXPR_IN_PARENS
)
2334 pp_cxx_right_paren (pp
);
2337 /* Else fall through. */
2339 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2343 case IMPLICIT_CONV_EXPR
:
2344 case VIEW_CONVERT_EXPR
:
2346 tree op
= TREE_OPERAND (t
, 0);
2347 tree ttype
= TREE_TYPE (t
);
2348 tree optype
= TREE_TYPE (op
);
2350 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2351 && POINTER_TYPE_P (ttype
)
2352 && POINTER_TYPE_P (optype
)
2353 && same_type_p (TREE_TYPE (optype
),
2356 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2359 if (TREE_CODE (op
) == ADDR_EXPR
)
2360 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2362 dump_unary_op (pp
, "*", t
, flags
);
2365 dump_unary_op (pp
, "&", t
, flags
);
2367 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2369 /* It is a cast, but we cannot tell whether it is a
2370 reinterpret or static cast. Use the C style notation. */
2371 if (flags
& TFF_EXPR_IN_PARENS
)
2372 pp_cxx_left_paren (pp
);
2373 pp_cxx_left_paren (pp
);
2374 dump_type (pp
, TREE_TYPE (t
), flags
);
2375 pp_cxx_right_paren (pp
);
2376 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2377 if (flags
& TFF_EXPR_IN_PARENS
)
2378 pp_cxx_right_paren (pp
);
2381 dump_expr (pp
, op
, flags
);
2386 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2388 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2390 if (integer_zerop (idx
))
2392 /* A NULL pointer-to-member constant. */
2393 pp_cxx_left_paren (pp
);
2394 pp_cxx_left_paren (pp
);
2395 dump_type (pp
, TREE_TYPE (t
), flags
);
2396 pp_cxx_right_paren (pp
);
2397 pp_character (pp
, '0');
2398 pp_cxx_right_paren (pp
);
2401 else if (tree_fits_shwi_p (idx
))
2404 unsigned HOST_WIDE_INT n
;
2406 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2407 t
= TYPE_METHOD_BASETYPE (t
);
2408 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2410 n
= tree_to_shwi (idx
);
2412 /* Map vtable index back one, to allow for the null pointer to
2416 while (n
> 0 && virtuals
)
2419 virtuals
= TREE_CHAIN (virtuals
);
2423 dump_expr (pp
, BV_FN (virtuals
),
2424 flags
| TFF_EXPR_IN_PARENS
);
2429 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2430 pp_string (pp
, "<lambda closure object>");
2431 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2433 dump_type (pp
, TREE_TYPE (t
), 0);
2434 pp_cxx_left_paren (pp
);
2435 pp_cxx_right_paren (pp
);
2439 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2440 dump_type (pp
, TREE_TYPE (t
), 0);
2441 pp_cxx_left_brace (pp
);
2442 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2443 pp_cxx_right_brace (pp
);
2450 tree ob
= TREE_OPERAND (t
, 0);
2451 if (is_dummy_object (ob
))
2453 t
= TREE_OPERAND (t
, 1);
2454 if (TREE_CODE (t
) == FUNCTION_DECL
)
2456 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2457 else if (BASELINK_P (t
))
2458 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2459 flags
| TFF_EXPR_IN_PARENS
);
2461 dump_decl (pp
, t
, flags
);
2465 if (INDIRECT_REF_P (ob
))
2467 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2473 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2477 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2482 case TEMPLATE_PARM_INDEX
:
2483 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2487 if (TREE_OPERAND (t
, 0) == NULL_TREE
2488 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2490 dump_type (pp
, TREE_TYPE (t
), flags
);
2491 pp_cxx_left_paren (pp
);
2492 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2493 pp_cxx_right_paren (pp
);
2497 pp_cxx_left_paren (pp
);
2498 dump_type (pp
, TREE_TYPE (t
), flags
);
2499 pp_cxx_right_paren (pp
);
2500 pp_cxx_left_paren (pp
);
2501 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2502 pp_cxx_right_paren (pp
);
2506 case STATIC_CAST_EXPR
:
2507 pp_cxx_ws_string (pp
, "static_cast");
2509 case REINTERPRET_CAST_EXPR
:
2510 pp_cxx_ws_string (pp
, "reinterpret_cast");
2512 case CONST_CAST_EXPR
:
2513 pp_cxx_ws_string (pp
, "const_cast");
2515 case DYNAMIC_CAST_EXPR
:
2516 pp_cxx_ws_string (pp
, "dynamic_cast");
2518 pp_cxx_begin_template_argument_list (pp
);
2519 dump_type (pp
, TREE_TYPE (t
), flags
);
2520 pp_cxx_end_template_argument_list (pp
);
2521 pp_cxx_left_paren (pp
);
2522 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2523 pp_cxx_right_paren (pp
);
2527 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2533 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2534 pp_cxx_ws_string (pp
, "sizeof");
2537 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2538 pp_cxx_ws_string (pp
, "__alignof__");
2540 op
= TREE_OPERAND (t
, 0);
2541 if (PACK_EXPANSION_P (op
))
2543 pp_string (pp
, "...");
2544 op
= PACK_EXPANSION_PATTERN (op
);
2546 pp_cxx_whitespace (pp
);
2547 pp_cxx_left_paren (pp
);
2548 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2549 dump_type (pp
, TREE_TYPE (op
), flags
);
2550 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2551 dump_type (pp
, op
, flags
);
2553 dump_expr (pp
, op
, flags
);
2554 pp_cxx_right_paren (pp
);
2557 case AT_ENCODE_EXPR
:
2558 pp_cxx_ws_string (pp
, "@encode");
2559 pp_cxx_whitespace (pp
);
2560 pp_cxx_left_paren (pp
);
2561 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2562 pp_cxx_right_paren (pp
);
2566 pp_cxx_ws_string (pp
, "noexcept");
2567 pp_cxx_whitespace (pp
);
2568 pp_cxx_left_paren (pp
);
2569 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2570 pp_cxx_right_paren (pp
);
2575 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2576 pp_cxx_whitespace (pp
);
2577 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2581 pp_string (pp
, M_("<unparsed>"));
2584 case TRY_CATCH_EXPR
:
2585 case WITH_CLEANUP_EXPR
:
2586 case CLEANUP_POINT_EXPR
:
2587 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2590 case PSEUDO_DTOR_EXPR
:
2591 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2593 if (TREE_OPERAND (t
, 1))
2595 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2596 pp_cxx_colon_colon (pp
);
2598 pp_cxx_complement (pp
);
2599 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2602 case TEMPLATE_ID_EXPR
:
2603 dump_decl (pp
, t
, flags
);
2609 case STATEMENT_LIST
:
2610 /* We don't yet have a way of dumping statements in a
2611 human-readable format. */
2612 pp_string (pp
, "({...})");
2616 pp_string (pp
, "while (1) { ");
2617 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2618 pp_cxx_right_brace (pp
);
2622 pp_string (pp
, "if (");
2623 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2624 pp_string (pp
, ") break; ");
2628 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2631 case EMPTY_CLASS_EXPR
:
2632 dump_type (pp
, TREE_TYPE (t
), flags
);
2633 pp_cxx_left_paren (pp
);
2634 pp_cxx_right_paren (pp
);
2637 case NON_DEPENDENT_EXPR
:
2638 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2641 case ARGUMENT_PACK_SELECT
:
2642 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2654 pp_type_specifier_seq (pp
, t
);
2658 /* We get here when we want to print a dependent type as an
2659 id-expression, without any disambiguator decoration. */
2660 pp
->id_expression (t
);
2663 case TEMPLATE_TYPE_PARM
:
2664 case TEMPLATE_TEMPLATE_PARM
:
2665 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2666 dump_type (pp
, t
, flags
);
2670 pp_cxx_trait_expression (pp
, t
);
2674 pp_cxx_va_arg_expression (pp
, t
);
2678 pp_cxx_offsetof_expression (pp
, t
);
2682 dump_decl (pp
, t
, flags
);
2685 case EXPR_PACK_EXPANSION
:
2686 case UNARY_LEFT_FOLD_EXPR
:
2687 case UNARY_RIGHT_FOLD_EXPR
:
2688 case BINARY_LEFT_FOLD_EXPR
:
2689 case BINARY_RIGHT_FOLD_EXPR
:
2696 case VEC_DELETE_EXPR
:
2702 case UNORDERED_EXPR
:
2712 case FIX_TRUNC_EXPR
:
2717 case TRUTH_AND_EXPR
:
2719 case TRUTH_XOR_EXPR
:
2720 if (flags
& TFF_EXPR_IN_PARENS
)
2721 pp_cxx_left_paren (pp
);
2723 if (flags
& TFF_EXPR_IN_PARENS
)
2724 pp_cxx_right_paren (pp
);
2728 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2732 pp_string (pp
, M_("<lambda>"));
2736 pp_cxx_left_paren (pp
);
2737 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2738 pp_cxx_right_paren (pp
);
2742 pp_cxx_requires_expr (cxx_pp
, t
);
2746 pp_cxx_simple_requirement (cxx_pp
, t
);
2750 pp_cxx_type_requirement (cxx_pp
, t
);
2754 pp_cxx_compound_requirement (cxx_pp
, t
);
2758 pp_cxx_nested_requirement (cxx_pp
, t
);
2771 pp_cxx_constraint (cxx_pp
, t
);
2774 case PLACEHOLDER_EXPR
:
2775 pp_string (pp
, M_("*this"));
2778 /* This list is incomplete, but should suffice for now.
2779 It is very important that `sorry' does not call
2780 `report_error_function'. That could cause an infinite loop. */
2782 pp_unsupported_tree (pp
, t
);
2785 pp_string (pp
, M_("<expression error>"));
2791 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2794 pp_cxx_left_paren (pp
);
2795 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2796 pp_cxx_whitespace (pp
);
2798 pp_cxx_ws_string (pp
, opstring
);
2800 pp_string (pp
, M_("<unknown operator>"));
2801 pp_cxx_whitespace (pp
);
2802 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2803 pp_cxx_right_paren (pp
);
2807 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2809 if (flags
& TFF_EXPR_IN_PARENS
)
2810 pp_cxx_left_paren (pp
);
2811 pp_cxx_ws_string (pp
, opstring
);
2812 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2813 if (flags
& TFF_EXPR_IN_PARENS
)
2814 pp_cxx_right_paren (pp
);
2818 reinit_cxx_pp (void)
2820 pp_clear_output_area (cxx_pp
);
2821 cxx_pp
->padding
= pp_none
;
2822 pp_indentation (cxx_pp
) = 0;
2823 pp_needs_newline (cxx_pp
) = false;
2824 cxx_pp
->enclosing_scope
= current_function_decl
;
2827 /* Same as pp_formatted_text, except the return string is a separate
2828 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2831 pp_ggc_formatted_text (pretty_printer
*pp
)
2833 return ggc_strdup (pp_formatted_text (pp
));
2836 /* Exported interface to stringifying types, exprs and decls under TFF_*
2840 type_as_string (tree typ
, int flags
)
2843 pp_translate_identifiers (cxx_pp
) = false;
2844 dump_type (cxx_pp
, typ
, flags
);
2845 return pp_ggc_formatted_text (cxx_pp
);
2849 type_as_string_translate (tree typ
, int flags
)
2852 dump_type (cxx_pp
, typ
, flags
);
2853 return pp_ggc_formatted_text (cxx_pp
);
2857 expr_as_string (tree decl
, int flags
)
2860 pp_translate_identifiers (cxx_pp
) = false;
2861 dump_expr (cxx_pp
, decl
, flags
);
2862 return pp_ggc_formatted_text (cxx_pp
);
2865 /* Wrap decl_as_string with options appropriate for dwarf. */
2868 decl_as_dwarf_string (tree decl
, int flags
)
2871 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2872 here will be adequate to get the desired behavior. */
2873 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2874 name
= decl_as_string (decl
, flags
);
2875 /* Subsequent calls to the pretty printer shouldn't use this style. */
2876 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2881 decl_as_string (tree decl
, int flags
)
2884 pp_translate_identifiers (cxx_pp
) = false;
2885 dump_decl (cxx_pp
, decl
, flags
);
2886 return pp_ggc_formatted_text (cxx_pp
);
2890 decl_as_string_translate (tree decl
, int flags
)
2893 dump_decl (cxx_pp
, decl
, flags
);
2894 return pp_ggc_formatted_text (cxx_pp
);
2897 /* Wrap lang_decl_name with options appropriate for dwarf. */
2900 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2903 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2904 here will be adequate to get the desired behavior. */
2905 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2906 name
= lang_decl_name (decl
, v
, translate
);
2907 /* Subsequent calls to the pretty printer shouldn't use this style. */
2908 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2912 /* Generate the three forms of printable names for cxx_printable_name. */
2915 lang_decl_name (tree decl
, int v
, bool translate
)
2919 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2920 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2923 pp_translate_identifiers (cxx_pp
) = translate
;
2925 && (DECL_CLASS_SCOPE_P (decl
)
2926 || (DECL_NAMESPACE_SCOPE_P (decl
)
2927 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2929 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2930 pp_cxx_colon_colon (cxx_pp
);
2933 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2934 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2935 else if ((DECL_NAME (decl
) == NULL_TREE
)
2936 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2937 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2939 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2941 return pp_ggc_formatted_text (cxx_pp
);
2944 /* Return the location of a tree passed to %+ formats. */
2947 location_of (tree t
)
2951 t
= TYPE_MAIN_DECL (t
);
2953 return input_location
;
2955 else if (TREE_CODE (t
) == OVERLOAD
)
2956 t
= OVL_FUNCTION (t
);
2959 return DECL_SOURCE_LOCATION (t
);
2960 return EXPR_LOC_OR_LOC (t
, input_location
);
2963 /* Now the interfaces from error et al to dump_type et al. Each takes an
2964 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2968 decl_to_string (tree decl
, int verbose
)
2972 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2973 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2974 flags
= TFF_CLASS_KEY_OR_ENUM
;
2976 flags
|= TFF_DECL_SPECIFIERS
;
2977 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2978 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2979 flags
|= TFF_TEMPLATE_HEADER
;
2982 dump_decl (cxx_pp
, decl
, flags
);
2983 return pp_ggc_formatted_text (cxx_pp
);
2987 expr_to_string (tree decl
)
2990 dump_expr (cxx_pp
, decl
, 0);
2991 return pp_ggc_formatted_text (cxx_pp
);
2995 fndecl_to_string (tree fndecl
, int verbose
)
2999 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
3000 | TFF_TEMPLATE_HEADER
;
3002 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3004 dump_decl (cxx_pp
, fndecl
, flags
);
3005 return pp_ggc_formatted_text (cxx_pp
);
3010 code_to_string (enum tree_code c
)
3012 return get_tree_code_name (c
);
3016 language_to_string (enum languages c
)
3023 case lang_cplusplus
:
3032 /* Return the proper printed version of a parameter to a C++ function. */
3035 parm_to_string (int p
)
3039 pp_string (cxx_pp
, "'this'");
3041 pp_decimal_int (cxx_pp
, p
+ 1);
3042 return pp_ggc_formatted_text (cxx_pp
);
3046 op_to_string (enum tree_code p
)
3048 tree id
= operator_name_info
[p
].identifier
;
3049 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3053 type_to_string (tree typ
, int verbose
)
3057 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3058 flags
|= TFF_TEMPLATE_HEADER
;
3061 dump_type (cxx_pp
, typ
, flags
);
3062 /* If we're printing a type that involves typedefs, also print the
3063 stripped version. But sometimes the stripped version looks
3064 exactly the same, so we don't want it after all. To avoid printing
3065 it in that case, we play ugly obstack games. */
3066 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3067 && !uses_template_parms (typ
))
3069 int aka_start
, aka_len
; char *p
;
3070 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3071 /* Remember the end of the initial dump. */
3072 int len
= obstack_object_size (ob
);
3073 tree aka
= strip_typedefs (typ
);
3074 pp_string (cxx_pp
, " {aka");
3075 pp_cxx_whitespace (cxx_pp
);
3076 /* And remember the start of the aka dump. */
3077 aka_start
= obstack_object_size (ob
);
3078 dump_type (cxx_pp
, aka
, flags
);
3079 aka_len
= obstack_object_size (ob
) - aka_start
;
3080 pp_right_brace (cxx_pp
);
3081 p
= (char*)obstack_base (ob
);
3082 /* If they are identical, cut off the aka with a NUL. */
3083 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3086 return pp_ggc_formatted_text (cxx_pp
);
3090 assop_to_string (enum tree_code p
)
3092 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3093 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3097 args_to_string (tree p
, int verbose
)
3101 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3106 if (TYPE_P (TREE_VALUE (p
)))
3107 return type_as_string_translate (p
, flags
);
3110 for (; p
; p
= TREE_CHAIN (p
))
3112 if (TREE_VALUE (p
) == null_node
)
3113 pp_cxx_ws_string (cxx_pp
, "NULL");
3115 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3117 pp_separate_with_comma (cxx_pp
);
3119 return pp_ggc_formatted_text (cxx_pp
);
3122 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3123 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3127 subst_to_string (tree p
)
3129 tree decl
= TREE_PURPOSE (p
);
3130 tree targs
= TREE_VALUE (p
);
3131 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3132 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3133 |TFF_NO_TEMPLATE_BINDINGS
);
3139 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3140 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3141 return pp_ggc_formatted_text (cxx_pp
);
3145 cv_to_string (tree p
, int v
)
3148 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3149 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3150 return pp_ggc_formatted_text (cxx_pp
);
3154 eh_spec_to_string (tree p
, int /*v*/)
3158 dump_exception_spec (cxx_pp
, p
, flags
);
3159 return pp_ggc_formatted_text (cxx_pp
);
3162 /* Langhook for print_error_function. */
3164 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3165 diagnostic_info
*diagnostic
)
3167 lhd_print_error_function (context
, file
, diagnostic
);
3168 pp_set_prefix (context
->printer
, file
);
3169 maybe_print_instantiation_context (context
);
3173 cp_diagnostic_starter (diagnostic_context
*context
,
3174 diagnostic_info
*diagnostic
)
3176 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3177 cp_print_error_function (context
, diagnostic
);
3178 maybe_print_instantiation_context (context
);
3179 maybe_print_constexpr_context (context
);
3180 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3184 /* Print current function onto BUFFER, in the process of reporting
3185 a diagnostic message. Called from cp_diagnostic_starter. */
3187 cp_print_error_function (diagnostic_context
*context
,
3188 diagnostic_info
*diagnostic
)
3190 /* If we are in an instantiation context, current_function_decl is likely
3191 to be wrong, so just rely on print_instantiation_full_context. */
3192 if (current_instantiation ())
3194 if (diagnostic_last_function_changed (context
, diagnostic
))
3196 const char *old_prefix
= context
->printer
->prefix
;
3197 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3198 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3199 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3200 ? file_name_as_prefix (context
, file
) : NULL
;
3202 pp_set_prefix (context
->printer
, new_prefix
);
3204 if (current_function_decl
== NULL
)
3205 pp_string (context
->printer
, _("At global scope:"));
3210 if (abstract_origin
)
3212 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3213 while (TREE_CODE (ao
) == BLOCK
3214 && BLOCK_ABSTRACT_ORIGIN (ao
)
3215 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3216 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3217 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3221 fndecl
= current_function_decl
;
3223 pp_printf (context
->printer
, function_category (fndecl
),
3224 cxx_printable_name_translate (fndecl
, 2));
3226 while (abstract_origin
)
3229 tree block
= abstract_origin
;
3231 locus
= &BLOCK_SOURCE_LOCATION (block
);
3233 block
= BLOCK_SUPERCONTEXT (block
);
3234 while (block
&& TREE_CODE (block
) == BLOCK
3235 && BLOCK_ABSTRACT_ORIGIN (block
))
3237 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3239 while (TREE_CODE (ao
) == BLOCK
3240 && BLOCK_ABSTRACT_ORIGIN (ao
)
3241 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3242 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3244 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3249 else if (TREE_CODE (ao
) != BLOCK
)
3252 block
= BLOCK_SUPERCONTEXT (block
);
3255 abstract_origin
= block
;
3258 while (block
&& TREE_CODE (block
) == BLOCK
)
3259 block
= BLOCK_SUPERCONTEXT (block
);
3261 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3263 abstract_origin
= NULL
;
3267 expanded_location s
= expand_location (*locus
);
3268 pp_character (context
->printer
, ',');
3269 pp_newline (context
->printer
);
3272 if (context
->show_column
&& s
.column
!= 0)
3273 pp_printf (context
->printer
,
3274 _(" inlined from %qs at %r%s:%d:%d%R"),
3275 cxx_printable_name_translate (fndecl
, 2),
3276 "locus", s
.file
, s
.line
, s
.column
);
3278 pp_printf (context
->printer
,
3279 _(" inlined from %qs at %r%s:%d%R"),
3280 cxx_printable_name_translate (fndecl
, 2),
3281 "locus", s
.file
, s
.line
);
3285 pp_printf (context
->printer
, _(" inlined from %qs"),
3286 cxx_printable_name_translate (fndecl
, 2));
3289 pp_character (context
->printer
, ':');
3291 pp_newline (context
->printer
);
3293 diagnostic_set_last_function (context
, diagnostic
);
3294 pp_destroy_prefix (context
->printer
);
3295 context
->printer
->prefix
= old_prefix
;
3299 /* Returns a description of FUNCTION using standard terminology. The
3300 result is a format string of the form "In CATEGORY %qs". */
3302 function_category (tree fn
)
3304 /* We can get called from the middle-end for diagnostics of function
3305 clones. Make sure we have language specific information before
3306 dereferencing it. */
3307 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3308 && DECL_FUNCTION_MEMBER_P (fn
))
3310 if (DECL_STATIC_FUNCTION_P (fn
))
3311 return _("In static member function %qs");
3312 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3313 return _("In copy constructor %qs");
3314 else if (DECL_CONSTRUCTOR_P (fn
))
3315 return _("In constructor %qs");
3316 else if (DECL_DESTRUCTOR_P (fn
))
3317 return _("In destructor %qs");
3318 else if (LAMBDA_FUNCTION_P (fn
))
3319 return _("In lambda function");
3321 return _("In member function %qs");
3324 return _("In function %qs");
3327 /* Report the full context of a current template instantiation,
3330 print_instantiation_full_context (diagnostic_context
*context
)
3332 struct tinst_level
*p
= current_instantiation ();
3333 location_t location
= input_location
;
3337 pp_verbatim (context
->printer
,
3338 TREE_CODE (p
->decl
) == TREE_LIST
3339 ? _("%s: In substitution of %qS:\n")
3340 : _("%s: In instantiation of %q#D:\n"),
3341 LOCATION_FILE (location
),
3344 location
= p
->locus
;
3348 print_instantiation_partial_context (context
, p
, location
);
3351 /* Helper function of print_instantiation_partial_context() that
3352 prints a single line of instantiation context. */
3355 print_instantiation_partial_context_line (diagnostic_context
*context
,
3356 const struct tinst_level
*t
,
3357 location_t loc
, bool recursive_p
)
3359 if (loc
== UNKNOWN_LOCATION
)
3362 expanded_location xloc
= expand_location (loc
);
3364 if (context
->show_column
)
3365 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3366 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3368 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3369 "locus", xloc
.file
, xloc
.line
);
3373 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3374 pp_verbatim (context
->printer
,
3376 ? _("recursively required by substitution of %qS\n")
3377 : _("required by substitution of %qS\n"),
3380 pp_verbatim (context
->printer
,
3382 ? _("recursively required from %q#D\n")
3383 : _("required from %q#D\n"),
3388 pp_verbatim (context
->printer
,
3390 ? _("recursively required from here\n")
3391 : _("required from here\n"));
3395 /* Same as print_instantiation_full_context but less verbose. */
3398 print_instantiation_partial_context (diagnostic_context
*context
,
3399 struct tinst_level
*t0
, location_t loc
)
3401 struct tinst_level
*t
;
3404 location_t prev_loc
= loc
;
3406 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3407 if (prev_loc
!= t
->locus
)
3409 prev_loc
= t
->locus
;
3415 if (template_backtrace_limit
3416 && n_total
> template_backtrace_limit
)
3418 int skip
= n_total
- template_backtrace_limit
;
3419 int head
= template_backtrace_limit
/ 2;
3421 /* Avoid skipping just 1. If so, skip 2. */
3425 head
= (template_backtrace_limit
- 1) / 2;
3428 for (n
= 0; n
< head
; n
++)
3430 gcc_assert (t
!= NULL
);
3431 if (loc
!= t
->locus
)
3432 print_instantiation_partial_context_line (context
, t
, loc
,
3433 /*recursive_p=*/false);
3437 if (t
!= NULL
&& skip
> 0)
3439 expanded_location xloc
;
3440 xloc
= expand_location (loc
);
3441 if (context
->show_column
)
3442 pp_verbatim (context
->printer
,
3443 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3444 "contexts, use -ftemplate-backtrace-limit=0 to "
3446 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3448 pp_verbatim (context
->printer
,
3449 _("%r%s:%d:%R [ skipping %d instantiation "
3450 "contexts, use -ftemplate-backtrace-limit=0 to "
3452 "locus", xloc
.file
, xloc
.line
, skip
);
3457 } while (t
!= NULL
&& --skip
> 0);
3463 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3468 print_instantiation_partial_context_line (context
, t
, loc
,
3473 print_instantiation_partial_context_line (context
, NULL
, loc
,
3474 /*recursive_p=*/false);
3477 /* Called from cp_thing to print the template context for an error. */
3479 maybe_print_instantiation_context (diagnostic_context
*context
)
3481 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3484 record_last_problematic_instantiation ();
3485 print_instantiation_full_context (context
);
3488 /* Report what constexpr call(s) we're trying to expand, if any. */
3491 maybe_print_constexpr_context (diagnostic_context
*context
)
3493 vec
<tree
> call_stack
= cx_error_context ();
3497 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3499 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3500 const char *s
= expr_as_string (t
, 0);
3501 if (context
->show_column
)
3502 pp_verbatim (context
->printer
,
3503 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3504 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3506 pp_verbatim (context
->printer
,
3507 _("%r%s:%d:%R in constexpr expansion of %qs"),
3508 "locus", xloc
.file
, xloc
.line
, s
);
3509 pp_newline (context
->printer
);
3513 /* Called from output_format -- during diagnostic message processing --
3514 to handle C++ specific format specifier with the following meanings:
3515 %A function argument-list.
3519 %F function declaration.
3520 %L language as used in extern "lang".
3522 %P function parameter whose position is indicated by an integer.
3523 %Q assignment operator.
3524 %S substitution (template + args)
3527 %X exception-specification. */
3529 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3530 int precision
, bool wide
, bool set_locus
, bool verbose
)
3534 #define next_tree (t = va_arg (*text->args_ptr, tree))
3535 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3536 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3537 #define next_int va_arg (*text->args_ptr, int)
3539 if (precision
!= 0 || wide
)
3544 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3545 case 'C': result
= code_to_string (next_tcode
); break;
3548 tree temp
= next_tree
;
3550 && DECL_HAS_DEBUG_EXPR_P (temp
))
3552 temp
= DECL_DEBUG_EXPR (temp
);
3555 result
= expr_to_string (temp
);
3559 result
= decl_to_string (temp
, verbose
);
3562 case 'E': result
= expr_to_string (next_tree
); break;
3563 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3564 case 'L': result
= language_to_string (next_lang
); break;
3565 case 'O': result
= op_to_string (next_tcode
); break;
3566 case 'P': result
= parm_to_string (next_int
); break;
3567 case 'Q': result
= assop_to_string (next_tcode
); break;
3568 case 'S': result
= subst_to_string (next_tree
); break;
3569 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3570 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3571 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3574 percent_K_format (text
);
3581 pp_string (pp
, result
);
3582 if (set_locus
&& t
!= NULL
)
3583 text
->set_location (0, location_of (t
), true);
3591 /* Warn about the use of C++0x features when appropriate. */
3593 maybe_warn_cpp0x (cpp0x_warn_str str
)
3595 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3596 /* We really want to suppress this warning in system headers,
3597 because libstdc++ uses variadic templates even when we aren't
3601 case CPP0X_INITIALIZER_LISTS
:
3602 pedwarn (input_location
, 0,
3603 "extended initializer lists "
3604 "only available with -std=c++11 or -std=gnu++11");
3606 case CPP0X_EXPLICIT_CONVERSION
:
3607 pedwarn (input_location
, 0,
3608 "explicit conversion operators "
3609 "only available with -std=c++11 or -std=gnu++11");
3611 case CPP0X_VARIADIC_TEMPLATES
:
3612 pedwarn (input_location
, 0,
3613 "variadic templates "
3614 "only available with -std=c++11 or -std=gnu++11");
3616 case CPP0X_LAMBDA_EXPR
:
3617 pedwarn (input_location
, 0,
3618 "lambda expressions "
3619 "only available with -std=c++11 or -std=gnu++11");
3622 pedwarn (input_location
, 0,
3623 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3625 case CPP0X_SCOPED_ENUMS
:
3626 pedwarn (input_location
, 0,
3627 "scoped enums only available with -std=c++11 or -std=gnu++11");
3629 case CPP0X_DEFAULTED_DELETED
:
3630 pedwarn (input_location
, 0,
3631 "defaulted and deleted functions "
3632 "only available with -std=c++11 or -std=gnu++11");
3634 case CPP0X_INLINE_NAMESPACES
:
3635 pedwarn (input_location
, OPT_Wpedantic
,
3636 "inline namespaces "
3637 "only available with -std=c++11 or -std=gnu++11");
3639 case CPP0X_OVERRIDE_CONTROLS
:
3640 pedwarn (input_location
, 0,
3641 "override controls (override/final) "
3642 "only available with -std=c++11 or -std=gnu++11");
3645 pedwarn (input_location
, 0,
3646 "non-static data member initializers "
3647 "only available with -std=c++11 or -std=gnu++11");
3649 case CPP0X_USER_DEFINED_LITERALS
:
3650 pedwarn (input_location
, 0,
3651 "user-defined literals "
3652 "only available with -std=c++11 or -std=gnu++11");
3654 case CPP0X_DELEGATING_CTORS
:
3655 pedwarn (input_location
, 0,
3656 "delegating constructors "
3657 "only available with -std=c++11 or -std=gnu++11");
3659 case CPP0X_INHERITING_CTORS
:
3660 pedwarn (input_location
, 0,
3661 "inheriting constructors "
3662 "only available with -std=c++11 or -std=gnu++11");
3664 case CPP0X_ATTRIBUTES
:
3665 pedwarn (input_location
, 0,
3667 "only available with -std=c++11 or -std=gnu++11");
3669 case CPP0X_REF_QUALIFIER
:
3670 pedwarn (input_location
, 0,
3672 "only available with -std=c++11 or -std=gnu++11");
3679 /* Warn about the use of variadic templates when appropriate. */
3681 maybe_warn_variadic_templates (void)
3683 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3687 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3688 option OPT with text GMSGID. Use this function to report
3689 diagnostics for constructs that are invalid C++98, but valid
3692 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3694 diagnostic_info diagnostic
;
3697 rich_location
richloc (line_table
, location
);
3699 va_start (ap
, gmsgid
);
3700 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
3701 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3702 diagnostic
.option_index
= opt
;
3703 ret
= report_diagnostic (&diagnostic
);
3708 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3709 we found when we tried to do the lookup. LOCATION is the location of
3710 the NAME identifier. */
3713 qualified_name_lookup_error (tree scope
, tree name
,
3714 tree decl
, location_t location
)
3716 if (scope
== error_mark_node
)
3717 ; /* We already complained. */
3718 else if (TYPE_P (scope
))
3720 if (!COMPLETE_TYPE_P (scope
))
3721 error_at (location
, "incomplete type %qT used in nested name specifier",
3723 else if (TREE_CODE (decl
) == TREE_LIST
)
3725 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3727 print_candidates (decl
);
3730 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3732 else if (scope
!= global_namespace
)
3734 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3735 suggest_alternatives_for (location
, name
);
3739 error_at (location
, "%<::%D%> has not been declared", name
);
3740 suggest_alternatives_for (location
, name
);