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
);
453 /* Else fall through. */
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
);
578 /* Fall through to error. */
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_("<anonymous>"));
684 pp_printf (pp
, M_("<anonymous %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
)
963 && DECL_DECLARED_CONSTEXPR_P (t
))
964 pp_cxx_ws_string (pp
, "constexpr");
965 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
968 if (! (flags
& TFF_UNQUALIFIED_NAME
)
969 && TREE_CODE (t
) != PARM_DECL
970 && (!DECL_INITIAL (t
)
971 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
972 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
973 flags
&= ~TFF_UNQUALIFIED_NAME
;
974 if ((flags
& TFF_DECL_SPECIFIERS
)
975 && DECL_TEMPLATE_PARM_P (t
)
976 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
977 pp_string (pp
, "...");
980 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
983 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
984 pp_string (pp
, " capture>");
987 dump_decl (pp
, DECL_NAME (t
), flags
);
990 pp_string (pp
, M_("<anonymous>"));
991 if (flags
& TFF_DECL_SPECIFIERS
)
992 dump_type_suffix (pp
, type
, flags
);
995 /* Dump a human readable string for the decl T under control of FLAGS. */
998 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1003 /* If doing Objective-C++, give Objective-C a chance to demangle
1004 Objective-C method names. */
1005 if (c_dialect_objc ())
1007 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1010 pp_string (pp
, demangled
);
1015 switch (TREE_CODE (t
))
1018 /* Don't say 'typedef class A' */
1019 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1021 if ((flags
& TFF_DECL_SPECIFIERS
)
1022 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1024 /* Say `class T' not just `T'. */
1025 pp_cxx_ws_string (pp
, "class");
1027 /* Emit the `...' for a parameter pack. */
1028 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1029 pp_cxx_ws_string (pp
, "...");
1032 dump_type (pp
, TREE_TYPE (t
), flags
);
1035 if (TYPE_DECL_ALIAS_P (t
)
1036 && (flags
& TFF_DECL_SPECIFIERS
1037 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1039 pp_cxx_ws_string (pp
, "using");
1040 dump_decl (pp
, DECL_NAME (t
), flags
);
1041 pp_cxx_whitespace (pp
);
1042 pp_cxx_ws_string (pp
, "=");
1043 pp_cxx_whitespace (pp
);
1044 dump_type (pp
, DECL_ORIGINAL_TYPE (t
), flags
);
1047 if ((flags
& TFF_DECL_SPECIFIERS
)
1048 && !DECL_SELF_REFERENCE_P (t
))
1049 pp_cxx_ws_string (pp
, "typedef");
1050 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1051 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1056 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1058 pp_string (pp
, M_("vtable for "));
1059 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1060 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1063 /* Else fall through. */
1066 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1068 /* Handle variable template specializations. */
1070 && DECL_LANG_SPECIFIC (t
)
1071 && DECL_TEMPLATE_INFO (t
)
1072 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1074 pp_cxx_begin_template_argument_list (pp
);
1075 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1076 dump_template_argument_list (pp
, args
, flags
);
1077 pp_cxx_end_template_argument_list (pp
);
1082 pp_string (pp
, M_("<return value> "));
1083 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1086 case NAMESPACE_DECL
:
1087 if (flags
& TFF_DECL_SPECIFIERS
)
1088 pp
->declaration (t
);
1091 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1092 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1093 flags
&= ~TFF_UNQUALIFIED_NAME
;
1094 if (DECL_NAME (t
) == NULL_TREE
)
1096 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1097 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1099 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1102 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1107 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1108 pp_colon_colon (pp
);
1109 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1113 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1114 pp_cxx_left_bracket (pp
);
1115 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1116 pp_cxx_right_bracket (pp
);
1119 case ARRAY_NOTATION_REF
:
1120 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1121 pp_cxx_left_bracket (pp
);
1122 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1124 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1126 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1127 pp_cxx_right_bracket (pp
);
1130 /* So that we can do dump_decl on an aggr type. */
1134 dump_type (pp
, t
, flags
);
1138 /* This is a pseudo destructor call which has not been folded into
1139 a PSEUDO_DTOR_EXPR yet. */
1140 pp_cxx_complement (pp
);
1141 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1148 /* These special cases are duplicated here so that other functions
1149 can feed identifiers to error and get them demangled properly. */
1150 case IDENTIFIER_NODE
:
1151 if (IDENTIFIER_TYPENAME_P (t
))
1153 pp_cxx_ws_string (pp
, "operator");
1154 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1155 dump_type (pp
, TREE_TYPE (t
), flags
);
1159 pp_cxx_tree_identifier (pp
, t
);
1165 t
= OVL_CURRENT (t
);
1166 if (DECL_CLASS_SCOPE_P (t
))
1168 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1169 pp_cxx_colon_colon (pp
);
1171 else if (!DECL_FILE_SCOPE_P (t
))
1173 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1174 pp_cxx_colon_colon (pp
);
1176 dump_decl (pp
, DECL_NAME (t
), flags
);
1180 /* If there's only one function, just treat it like an ordinary
1182 t
= OVL_CURRENT (t
);
1186 if (! DECL_LANG_SPECIFIC (t
))
1188 if (DECL_ABSTRACT_ORIGIN (t
))
1189 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1191 pp_string (pp
, M_("<built-in>"));
1193 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1194 dump_global_iord (pp
, t
);
1196 dump_function_decl (pp
, t
, flags
);
1200 dump_template_decl (pp
, t
, flags
);
1203 case TEMPLATE_ID_EXPR
:
1205 tree name
= TREE_OPERAND (t
, 0);
1206 tree args
= TREE_OPERAND (t
, 1);
1208 if (is_overloaded_fn (name
))
1209 name
= get_first_fn (name
);
1211 name
= DECL_NAME (name
);
1212 dump_decl (pp
, name
, flags
);
1213 pp_cxx_begin_template_argument_list (pp
);
1214 if (args
== error_mark_node
)
1215 pp_string (pp
, M_("<template arguments error>"));
1217 dump_template_argument_list
1218 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1219 pp_cxx_end_template_argument_list (pp
);
1224 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1228 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1229 || (DECL_INITIAL (t
) &&
1230 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1231 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1232 else if (DECL_NAME (t
))
1233 dump_decl (pp
, DECL_NAME (t
), flags
);
1234 else if (DECL_INITIAL (t
))
1235 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1237 pp_string (pp
, M_("<enumerator>"));
1241 pp_cxx_ws_string (pp
, "using");
1242 dump_type (pp
, USING_DECL_SCOPE (t
), flags
);
1243 pp_cxx_colon_colon (pp
);
1244 dump_decl (pp
, DECL_NAME (t
), flags
);
1248 pp
->declaration (t
);
1252 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1255 case NON_DEPENDENT_EXPR
:
1256 dump_expr (pp
, t
, flags
);
1259 case TEMPLATE_TYPE_PARM
:
1260 if (flags
& TFF_DECL_SPECIFIERS
)
1261 pp
->declaration (t
);
1266 case UNBOUND_CLASS_TEMPLATE
:
1267 case TYPE_PACK_EXPANSION
:
1269 dump_type (pp
, t
, flags
);
1273 pp_unsupported_tree (pp
, t
);
1274 /* Fall through to error. */
1277 pp_string (pp
, M_("<declaration error>"));
1282 /* Dump a template declaration T under control of FLAGS. This means the
1283 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1286 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1288 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1292 if (flags
& TFF_TEMPLATE_HEADER
)
1294 for (parms
= orig_parms
= nreverse (orig_parms
);
1296 parms
= TREE_CHAIN (parms
))
1298 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1299 int len
= TREE_VEC_LENGTH (inner_parms
);
1303 /* Skip over the dummy template levels of a template template
1305 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1309 pp_cxx_ws_string (pp
, "template");
1310 pp_cxx_begin_template_argument_list (pp
);
1312 /* If we've shown the template prefix, we'd better show the
1313 parameters' and decl's type too. */
1314 flags
|= TFF_DECL_SPECIFIERS
;
1316 for (i
= 0; i
< len
; i
++)
1319 pp_separate_with_comma (pp
);
1320 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1323 pp_cxx_end_template_argument_list (pp
);
1324 pp_cxx_whitespace (pp
);
1326 nreverse(orig_parms
);
1328 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1330 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1331 pp_cxx_ws_string (pp
, "class");
1333 /* If this is a parameter pack, print the ellipsis. */
1334 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1335 pp_cxx_ws_string (pp
, "...");
1340 if (tree ci
= get_constraints (t
))
1341 if (check_constraint_info (ci
))
1342 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1344 pp_cxx_requires_clause (pp
, reqs
);
1345 pp_cxx_whitespace (pp
);
1348 if (DECL_CLASS_TEMPLATE_P (t
))
1349 dump_type (pp
, TREE_TYPE (t
),
1350 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1351 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1352 else if (DECL_TEMPLATE_RESULT (t
)
1353 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1354 /* Alias template. */
1355 || DECL_TYPE_TEMPLATE_P (t
)))
1356 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1359 gcc_assert (TREE_TYPE (t
));
1360 switch (NEXT_CODE (t
))
1364 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1367 /* This case can occur with some invalid code. */
1368 dump_type (pp
, TREE_TYPE (t
),
1369 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1370 | (flags
& TFF_DECL_SPECIFIERS
1371 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1376 /* find_typenames looks through the type of the function template T
1377 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1380 struct find_typenames_t
1382 hash_set
<tree
> *p_set
;
1383 vec
<tree
, va_gc
> *typenames
;
1387 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1389 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1390 tree mv
= NULL_TREE
;
1392 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1393 /* Add the type of the typedef without any additional cv-quals. */
1394 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1395 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1396 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1397 /* Add the typename without any cv-qualifiers. */
1398 mv
= TYPE_MAIN_VARIANT (*tp
);
1400 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1402 /* Don't mess with parameter packs since we don't remember
1403 the pack expansion context for a particular typename. */
1404 *walk_subtrees
= false;
1408 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1409 vec_safe_push (d
->typenames
, mv
);
1411 /* Search into class template arguments, which cp_walk_subtrees
1413 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1414 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1420 static vec
<tree
, va_gc
> *
1421 find_typenames (tree t
)
1423 struct find_typenames_t ft
;
1424 ft
.p_set
= new hash_set
<tree
>;
1425 ft
.typenames
= NULL
;
1426 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1427 find_typenames_r
, &ft
, ft
.p_set
);
1429 return ft
.typenames
;
1432 /* Output the "[with ...]" clause for a template instantiation T iff
1433 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1434 formatting a deduction/substitution diagnostic rather than an
1438 dump_substitution (cxx_pretty_printer
*pp
,
1439 tree t
, tree template_parms
, tree template_args
,
1442 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1443 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1445 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1446 pp_cxx_whitespace (pp
);
1447 pp_cxx_left_bracket (pp
);
1448 pp
->translate_string ("with");
1449 pp_cxx_whitespace (pp
);
1450 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1451 pp_cxx_right_bracket (pp
);
1455 /* Dump the lambda function FN including its 'mutable' qualifier and any
1456 template bindings. */
1459 dump_lambda_function (cxx_pretty_printer
*pp
,
1460 tree fn
, tree template_parms
, tree template_args
,
1463 /* A lambda's signature is essentially its "type". */
1464 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1465 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1467 pp
->padding
= pp_before
;
1468 pp_c_ws_string (pp
, "mutable");
1470 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1473 /* Pretty print a function decl. There are several ways we want to print a
1474 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1475 As error can only apply the '#' flag once to give 0 and 1 for V, there
1476 is %D which doesn't print the throw specs, and %F which does. */
1479 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1483 tree cname
= NULL_TREE
;
1484 tree template_args
= NULL_TREE
;
1485 tree template_parms
= NULL_TREE
;
1486 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1487 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1490 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1491 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1492 t
= DECL_TEMPLATE_RESULT (t
);
1494 /* Save the exceptions, in case t is a specialization and we are
1495 emitting an error about incompatible specifications. */
1496 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1498 /* Pretty print template instantiations only. */
1499 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1500 && flag_pretty_templates
)
1504 template_args
= DECL_TI_ARGS (t
);
1505 tmpl
= most_general_template (t
);
1506 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1508 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1513 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1514 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1516 fntype
= TREE_TYPE (t
);
1517 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1519 if (DECL_CLASS_SCOPE_P (t
))
1520 cname
= DECL_CONTEXT (t
);
1521 /* This is for partially instantiated template methods. */
1522 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1523 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1525 if (flags
& TFF_DECL_SPECIFIERS
)
1527 if (DECL_STATIC_FUNCTION_P (t
))
1528 pp_cxx_ws_string (pp
, "static");
1529 else if (DECL_VIRTUAL_P (t
))
1530 pp_cxx_ws_string (pp
, "virtual");
1532 if (DECL_DECLARED_CONSTEXPR_P (t
))
1533 pp_cxx_ws_string (pp
, "constexpr");
1536 /* Print the return type? */
1538 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1539 && !DECL_DESTRUCTOR_P (t
);
1542 tree ret
= fndecl_declared_return_type (t
);
1543 dump_type_prefix (pp
, ret
, flags
);
1546 /* Print the function name. */
1547 if (!do_outer_scope
)
1551 dump_type (pp
, cname
, flags
);
1552 pp_cxx_colon_colon (pp
);
1555 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1557 dump_function_name (pp
, t
, flags
);
1559 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1561 dump_parameters (pp
, parmtypes
, flags
);
1563 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1565 pp
->padding
= pp_before
;
1566 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1567 dump_ref_qualifier (pp
, fntype
, flags
);
1570 if (tx_safe_fn_type_p (fntype
))
1572 pp
->padding
= pp_before
;
1573 pp_cxx_ws_string (pp
, "transaction_safe");
1576 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1578 pp
->padding
= pp_before
;
1579 dump_exception_spec (pp
, exceptions
, flags
);
1583 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1586 if (tree ci
= get_constraints (t
))
1587 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1588 pp_cxx_requires_clause (pp
, reqs
);
1590 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1592 else if (template_args
)
1594 bool need_comma
= false;
1596 pp_cxx_begin_template_argument_list (pp
);
1597 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1598 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1600 tree arg
= TREE_VEC_ELT (template_args
, i
);
1602 pp_separate_with_comma (pp
);
1603 if (ARGUMENT_PACK_P (arg
))
1604 pp_cxx_left_brace (pp
);
1605 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1606 if (ARGUMENT_PACK_P (arg
))
1607 pp_cxx_right_brace (pp
);
1610 pp_cxx_end_template_argument_list (pp
);
1614 /* Print a parameter list. If this is for a member function, the
1615 member object ptr (and any other hidden args) should have
1616 already been removed. */
1619 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1622 flags
&= ~TFF_SCOPE
;
1623 pp_cxx_left_paren (pp
);
1625 for (first
= 1; parmtypes
!= void_list_node
;
1626 parmtypes
= TREE_CHAIN (parmtypes
))
1629 pp_separate_with_comma (pp
);
1633 pp_cxx_ws_string (pp
, "...");
1637 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1639 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1641 pp_cxx_whitespace (pp
);
1643 pp_cxx_whitespace (pp
);
1644 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1648 pp_cxx_right_paren (pp
);
1651 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1654 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1656 if (FUNCTION_REF_QUALIFIED (t
))
1658 pp
->padding
= pp_before
;
1659 if (FUNCTION_RVALUE_QUALIFIED (t
))
1660 pp_cxx_ws_string (pp
, "&&");
1662 pp_cxx_ws_string (pp
, "&");
1666 /* Print an exception specification. T is the exception specification. */
1669 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1671 if (t
&& TREE_PURPOSE (t
))
1673 pp_cxx_ws_string (pp
, "noexcept");
1674 if (!integer_onep (TREE_PURPOSE (t
)))
1676 pp_cxx_whitespace (pp
);
1677 pp_cxx_left_paren (pp
);
1678 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1679 pp_cxx_ws_string (pp
, "<uninstantiated>");
1681 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1682 pp_cxx_right_paren (pp
);
1687 pp_cxx_ws_string (pp
, "throw");
1688 pp_cxx_whitespace (pp
);
1689 pp_cxx_left_paren (pp
);
1690 if (TREE_VALUE (t
) != NULL_TREE
)
1693 dump_type (pp
, TREE_VALUE (t
), flags
);
1697 pp_separate_with_comma (pp
);
1699 pp_cxx_right_paren (pp
);
1703 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1704 and destructors properly. */
1707 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1709 tree name
= DECL_NAME (t
);
1711 /* We can get here with a decl that was synthesized by language-
1712 independent machinery (e.g. coverage.c) in which case it won't
1713 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1714 will crash. In this case it is safe just to print out the
1716 if (!DECL_LANG_SPECIFIC (t
))
1718 pp_cxx_tree_identifier (pp
, name
);
1722 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1723 t
= DECL_TEMPLATE_RESULT (t
);
1725 /* Don't let the user see __comp_ctor et al. */
1726 if (DECL_CONSTRUCTOR_P (t
)
1727 || DECL_DESTRUCTOR_P (t
))
1729 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1730 name
= get_identifier ("<lambda>");
1731 else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t
)))
1732 name
= get_identifier ("<constructor>");
1734 name
= constructor_name (DECL_CONTEXT (t
));
1737 if (DECL_DESTRUCTOR_P (t
))
1739 pp_cxx_complement (pp
);
1740 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1742 else if (DECL_CONV_FN_P (t
))
1744 /* This cannot use the hack that the operator's return
1745 type is stashed off of its name because it may be
1746 used for error reporting. In the case of conflicting
1747 declarations, both will have the same name, yet
1748 the types will be different, hence the TREE_TYPE field
1749 of the first name will be clobbered by the second. */
1750 pp_cxx_ws_string (pp
, "operator");
1751 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1753 else if (name
&& IDENTIFIER_OPNAME_P (name
))
1754 pp_cxx_tree_identifier (pp
, name
);
1755 else if (name
&& UDLIT_OPER_P (name
))
1756 pp_cxx_tree_identifier (pp
, name
);
1758 dump_decl (pp
, name
, flags
);
1760 if (DECL_TEMPLATE_INFO (t
)
1761 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1762 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1763 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1764 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1768 /* Dump the template parameters from the template info INFO under control of
1769 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1770 specialization (partial or complete). For partial specializations we show
1771 the specialized parameter values. For a primary template we show no
1775 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1776 int primary
, int flags
)
1778 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1780 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1782 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1783 pp_cxx_begin_template_argument_list (pp
);
1785 /* Be careful only to print things when we have them, so as not
1786 to crash producing error messages. */
1787 if (args
&& !primary
)
1790 len
= get_non_default_template_args_count (args
, flags
);
1792 args
= INNERMOST_TEMPLATE_ARGS (args
);
1793 for (ix
= 0; ix
!= len
; ix
++)
1795 tree arg
= TREE_VEC_ELT (args
, ix
);
1797 /* Only print a comma if we know there is an argument coming. In
1798 the case of an empty template argument pack, no actual
1799 argument will be printed. */
1801 && (!ARGUMENT_PACK_P (arg
)
1802 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1803 pp_separate_with_comma (pp
);
1806 pp_string (pp
, M_("<template parameter error>"));
1808 dump_template_argument (pp
, arg
, flags
);
1813 tree tpl
= TI_TEMPLATE (info
);
1814 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1817 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1818 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1820 for (ix
= 0; ix
!= len
; ix
++)
1824 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1826 pp_string (pp
, M_("<template parameter error>"));
1830 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1833 pp_separate_with_comma (pp
);
1835 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1838 pp_cxx_end_template_argument_list (pp
);
1841 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1842 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1845 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1848 call_expr_arg_iterator iter
;
1850 pp_cxx_left_paren (pp
);
1851 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1857 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1858 if (more_call_expr_args_p (&iter
))
1859 pp_separate_with_comma (pp
);
1862 pp_cxx_right_paren (pp
);
1865 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1866 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1870 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1874 aggr_init_expr_arg_iterator iter
;
1876 pp_cxx_left_paren (pp
);
1877 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1883 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1884 if (more_aggr_init_expr_args_p (&iter
))
1885 pp_separate_with_comma (pp
);
1888 pp_cxx_right_paren (pp
);
1891 /* Print out a list of initializers (subr of dump_expr). */
1894 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1898 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1901 pp_separate_with_comma (pp
);
1905 /* Print out a vector of initializers (subr of dump_expr). */
1908 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1911 unsigned HOST_WIDE_INT idx
;
1914 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1916 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1917 if (idx
!= v
->length () - 1)
1918 pp_separate_with_comma (pp
);
1923 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1924 function. Resolve it to a close relative -- in the sense of static
1925 type -- variant being overridden. That is close to what was written in
1926 the source code. Subroutine of dump_expr. */
1929 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1931 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1932 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1933 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1936 fun
= TREE_CHAIN (fun
);
1937 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1938 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1944 /* Print out an expression E under control of FLAGS. */
1947 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
1954 if (STATEMENT_CLASS_P (t
))
1956 pp_cxx_ws_string (pp
, M_("<statement>"));
1960 switch (TREE_CODE (t
))
1968 case NAMESPACE_DECL
:
1972 case IDENTIFIER_NODE
:
1973 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
1974 |TFF_TEMPLATE_HEADER
))
1975 | TFF_NO_FUNCTION_ARGUMENTS
));
1979 if (SSA_NAME_VAR (t
)
1980 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
1981 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
1983 pp_cxx_ws_string (pp
, M_("<unknown>"));
1994 case USERDEF_LITERAL
:
1995 pp_cxx_userdef_literal (pp
, t
);
1999 /* While waiting for caret diagnostics, avoid printing
2000 __cxa_allocate_exception, __cxa_throw, and the like. */
2001 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2006 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2007 pp_cxx_colon_colon (pp
);
2008 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2012 pp_cxx_left_paren (pp
);
2013 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2014 pp_separate_with_comma (pp
);
2015 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2016 pp_cxx_right_paren (pp
);
2020 pp_cxx_left_paren (pp
);
2021 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2022 pp_string (pp
, " ? ");
2023 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2024 pp_string (pp
, " : ");
2025 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2026 pp_cxx_right_paren (pp
);
2030 if (TREE_HAS_CONSTRUCTOR (t
))
2032 pp_cxx_ws_string (pp
, "new");
2033 pp_cxx_whitespace (pp
);
2034 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2037 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2040 case AGGR_INIT_EXPR
:
2042 tree fn
= NULL_TREE
;
2044 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2045 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2047 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2049 if (DECL_CONSTRUCTOR_P (fn
))
2050 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2052 dump_decl (pp
, fn
, 0);
2055 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2057 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2062 tree fn
= CALL_EXPR_FN (t
);
2063 bool skipfirst
= false;
2065 /* Deal with internal functions. */
2066 if (fn
== NULL_TREE
)
2068 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2069 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2073 if (TREE_CODE (fn
) == ADDR_EXPR
)
2074 fn
= TREE_OPERAND (fn
, 0);
2076 /* Nobody is interested in seeing the guts of vcalls. */
2077 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2078 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2080 if (TREE_TYPE (fn
) != NULL_TREE
2081 && NEXT_CODE (fn
) == METHOD_TYPE
2082 && call_expr_nargs (t
))
2084 tree ob
= CALL_EXPR_ARG (t
, 0);
2085 if (TREE_CODE (ob
) == ADDR_EXPR
)
2087 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2088 flags
| TFF_EXPR_IN_PARENS
);
2091 else if (TREE_CODE (ob
) != PARM_DECL
2092 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2094 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2099 if (flag_sanitize
& SANITIZE_UNDEFINED
2100 && is_ubsan_builtin_p (fn
))
2102 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2105 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2106 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2111 /* Note that this only works for G++ target exprs. If somebody
2112 builds a general TARGET_EXPR, there's no way to represent that
2113 it initializes anything other that the parameter slot for the
2114 default argument. Note we may have cleared out the first
2115 operand in expand_expr, so don't go killing ourselves. */
2116 if (TREE_OPERAND (t
, 1))
2117 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2120 case POINTER_PLUS_EXPR
:
2121 dump_binary_op (pp
, "+", t
, flags
);
2126 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2133 case TRUNC_DIV_EXPR
:
2134 case TRUNC_MOD_EXPR
:
2142 case TRUTH_ANDIF_EXPR
:
2143 case TRUTH_ORIF_EXPR
:
2150 case EXACT_DIV_EXPR
:
2151 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2155 case FLOOR_DIV_EXPR
:
2156 case ROUND_DIV_EXPR
:
2158 dump_binary_op (pp
, "/", t
, flags
);
2162 case FLOOR_MOD_EXPR
:
2163 case ROUND_MOD_EXPR
:
2164 dump_binary_op (pp
, "%", t
, flags
);
2169 tree ob
= TREE_OPERAND (t
, 0);
2170 if (INDIRECT_REF_P (ob
))
2172 ob
= TREE_OPERAND (ob
, 0);
2173 if (TREE_CODE (ob
) != PARM_DECL
2175 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2177 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2178 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2186 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2189 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2194 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2195 pp_cxx_left_bracket (pp
);
2196 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2197 pp_cxx_right_bracket (pp
);
2200 case ARRAY_NOTATION_REF
:
2201 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2202 pp_cxx_left_bracket (pp
);
2203 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2205 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2207 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2208 pp_cxx_right_bracket (pp
);
2211 case UNARY_PLUS_EXPR
:
2212 dump_unary_op (pp
, "+", t
, flags
);
2216 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2217 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2218 /* An ADDR_EXPR can have reference type. In that case, we
2219 shouldn't print the `&' doing so indicates to the user
2220 that the expression has pointer type. */
2222 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2223 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2224 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2225 dump_unary_op (pp
, "&&", t
, flags
);
2227 dump_unary_op (pp
, "&", t
, flags
);
2231 if (TREE_HAS_CONSTRUCTOR (t
))
2233 t
= TREE_OPERAND (t
, 0);
2234 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2235 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2236 dump_call_expr_args (pp
, t
, flags
, true);
2240 if (TREE_OPERAND (t
,0) != NULL_TREE
2241 && TREE_TYPE (TREE_OPERAND (t
, 0))
2242 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2243 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2245 dump_unary_op (pp
, "*", t
, flags
);
2250 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2251 && integer_zerop (TREE_OPERAND (t
, 1)))
2252 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2256 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2258 pp_cxx_left_paren (pp
);
2259 if (!integer_onep (TYPE_SIZE_UNIT
2260 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2262 pp_cxx_left_paren (pp
);
2263 dump_type (pp
, ptr_type_node
, flags
);
2264 pp_cxx_right_paren (pp
);
2267 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2268 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2270 pp_cxx_ws_string (pp
, "+");
2271 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2273 pp_cxx_right_paren (pp
);
2280 case TRUTH_NOT_EXPR
:
2281 case PREDECREMENT_EXPR
:
2282 case PREINCREMENT_EXPR
:
2283 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2286 case POSTDECREMENT_EXPR
:
2287 case POSTINCREMENT_EXPR
:
2288 pp_cxx_left_paren (pp
);
2289 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2290 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2291 pp_cxx_right_paren (pp
);
2294 case NON_LVALUE_EXPR
:
2295 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2296 should be another level of INDIRECT_REF so that I don't have to do
2298 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2300 tree next
= TREE_TYPE (TREE_TYPE (t
));
2302 while (TYPE_PTR_P (next
))
2303 next
= TREE_TYPE (next
);
2305 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2307 if (flags
& TFF_EXPR_IN_PARENS
)
2308 pp_cxx_left_paren (pp
);
2310 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2311 if (flags
& TFF_EXPR_IN_PARENS
)
2312 pp_cxx_right_paren (pp
);
2315 /* Else fall through. */
2317 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2321 case IMPLICIT_CONV_EXPR
:
2322 case VIEW_CONVERT_EXPR
:
2324 tree op
= TREE_OPERAND (t
, 0);
2325 tree ttype
= TREE_TYPE (t
);
2326 tree optype
= TREE_TYPE (op
);
2328 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2329 && POINTER_TYPE_P (ttype
)
2330 && POINTER_TYPE_P (optype
)
2331 && same_type_p (TREE_TYPE (optype
),
2334 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2337 if (TREE_CODE (op
) == ADDR_EXPR
)
2338 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2340 dump_unary_op (pp
, "*", t
, flags
);
2343 dump_unary_op (pp
, "&", t
, flags
);
2345 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2347 /* It is a cast, but we cannot tell whether it is a
2348 reinterpret or static cast. Use the C style notation. */
2349 if (flags
& TFF_EXPR_IN_PARENS
)
2350 pp_cxx_left_paren (pp
);
2351 pp_cxx_left_paren (pp
);
2352 dump_type (pp
, TREE_TYPE (t
), flags
);
2353 pp_cxx_right_paren (pp
);
2354 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2355 if (flags
& TFF_EXPR_IN_PARENS
)
2356 pp_cxx_right_paren (pp
);
2359 dump_expr (pp
, op
, flags
);
2364 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2366 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2368 if (integer_zerop (idx
))
2370 /* A NULL pointer-to-member constant. */
2371 pp_cxx_left_paren (pp
);
2372 pp_cxx_left_paren (pp
);
2373 dump_type (pp
, TREE_TYPE (t
), flags
);
2374 pp_cxx_right_paren (pp
);
2375 pp_character (pp
, '0');
2376 pp_cxx_right_paren (pp
);
2379 else if (tree_fits_shwi_p (idx
))
2382 unsigned HOST_WIDE_INT n
;
2384 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2385 t
= TYPE_METHOD_BASETYPE (t
);
2386 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2388 n
= tree_to_shwi (idx
);
2390 /* Map vtable index back one, to allow for the null pointer to
2394 while (n
> 0 && virtuals
)
2397 virtuals
= TREE_CHAIN (virtuals
);
2401 dump_expr (pp
, BV_FN (virtuals
),
2402 flags
| TFF_EXPR_IN_PARENS
);
2407 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2408 pp_string (pp
, "<lambda closure object>");
2409 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2411 dump_type (pp
, TREE_TYPE (t
), 0);
2412 pp_cxx_left_paren (pp
);
2413 pp_cxx_right_paren (pp
);
2417 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2418 dump_type (pp
, TREE_TYPE (t
), 0);
2419 pp_cxx_left_brace (pp
);
2420 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2421 pp_cxx_right_brace (pp
);
2428 tree ob
= TREE_OPERAND (t
, 0);
2429 if (is_dummy_object (ob
))
2431 t
= TREE_OPERAND (t
, 1);
2432 if (TREE_CODE (t
) == FUNCTION_DECL
)
2434 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2435 else if (BASELINK_P (t
))
2436 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2437 flags
| TFF_EXPR_IN_PARENS
);
2439 dump_decl (pp
, t
, flags
);
2443 if (INDIRECT_REF_P (ob
))
2445 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2451 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2455 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2460 case TEMPLATE_PARM_INDEX
:
2461 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2465 if (TREE_OPERAND (t
, 0) == NULL_TREE
2466 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2468 dump_type (pp
, TREE_TYPE (t
), flags
);
2469 pp_cxx_left_paren (pp
);
2470 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2471 pp_cxx_right_paren (pp
);
2475 pp_cxx_left_paren (pp
);
2476 dump_type (pp
, TREE_TYPE (t
), flags
);
2477 pp_cxx_right_paren (pp
);
2478 pp_cxx_left_paren (pp
);
2479 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2480 pp_cxx_right_paren (pp
);
2484 case STATIC_CAST_EXPR
:
2485 pp_cxx_ws_string (pp
, "static_cast");
2487 case REINTERPRET_CAST_EXPR
:
2488 pp_cxx_ws_string (pp
, "reinterpret_cast");
2490 case CONST_CAST_EXPR
:
2491 pp_cxx_ws_string (pp
, "const_cast");
2493 case DYNAMIC_CAST_EXPR
:
2494 pp_cxx_ws_string (pp
, "dynamic_cast");
2496 pp_cxx_begin_template_argument_list (pp
);
2497 dump_type (pp
, TREE_TYPE (t
), flags
);
2498 pp_cxx_end_template_argument_list (pp
);
2499 pp_cxx_left_paren (pp
);
2500 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2501 pp_cxx_right_paren (pp
);
2505 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2511 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2512 pp_cxx_ws_string (pp
, "sizeof");
2515 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2516 pp_cxx_ws_string (pp
, "__alignof__");
2518 op
= TREE_OPERAND (t
, 0);
2519 if (PACK_EXPANSION_P (op
))
2521 pp_string (pp
, "...");
2522 op
= PACK_EXPANSION_PATTERN (op
);
2524 pp_cxx_whitespace (pp
);
2525 pp_cxx_left_paren (pp
);
2526 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2527 dump_type (pp
, TREE_TYPE (op
), flags
);
2528 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2529 dump_type (pp
, op
, flags
);
2531 dump_expr (pp
, op
, flags
);
2532 pp_cxx_right_paren (pp
);
2535 case AT_ENCODE_EXPR
:
2536 pp_cxx_ws_string (pp
, "@encode");
2537 pp_cxx_whitespace (pp
);
2538 pp_cxx_left_paren (pp
);
2539 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2540 pp_cxx_right_paren (pp
);
2544 pp_cxx_ws_string (pp
, "noexcept");
2545 pp_cxx_whitespace (pp
);
2546 pp_cxx_left_paren (pp
);
2547 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2548 pp_cxx_right_paren (pp
);
2553 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2554 pp_cxx_whitespace (pp
);
2555 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2559 pp_string (pp
, M_("<unparsed>"));
2562 case TRY_CATCH_EXPR
:
2563 case WITH_CLEANUP_EXPR
:
2564 case CLEANUP_POINT_EXPR
:
2565 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2568 case PSEUDO_DTOR_EXPR
:
2569 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2571 if (TREE_OPERAND (t
, 1))
2573 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2574 pp_cxx_colon_colon (pp
);
2576 pp_cxx_complement (pp
);
2577 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2580 case TEMPLATE_ID_EXPR
:
2581 dump_decl (pp
, t
, flags
);
2587 case STATEMENT_LIST
:
2588 /* We don't yet have a way of dumping statements in a
2589 human-readable format. */
2590 pp_string (pp
, "({...})");
2594 pp_string (pp
, "while (1) { ");
2595 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2596 pp_cxx_right_brace (pp
);
2600 pp_string (pp
, "if (");
2601 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2602 pp_string (pp
, ") break; ");
2606 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2609 case EMPTY_CLASS_EXPR
:
2610 dump_type (pp
, TREE_TYPE (t
), flags
);
2611 pp_cxx_left_paren (pp
);
2612 pp_cxx_right_paren (pp
);
2615 case NON_DEPENDENT_EXPR
:
2616 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2619 case ARGUMENT_PACK_SELECT
:
2620 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2632 pp_type_specifier_seq (pp
, t
);
2636 /* We get here when we want to print a dependent type as an
2637 id-expression, without any disambiguator decoration. */
2638 pp
->id_expression (t
);
2641 case TEMPLATE_TYPE_PARM
:
2642 case TEMPLATE_TEMPLATE_PARM
:
2643 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2644 dump_type (pp
, t
, flags
);
2648 pp_cxx_trait_expression (pp
, t
);
2652 pp_cxx_va_arg_expression (pp
, t
);
2656 pp_cxx_offsetof_expression (pp
, t
);
2660 dump_decl (pp
, t
, flags
);
2663 case EXPR_PACK_EXPANSION
:
2670 case VEC_DELETE_EXPR
:
2676 case UNORDERED_EXPR
:
2686 case FIX_TRUNC_EXPR
:
2691 case TRUTH_AND_EXPR
:
2693 case TRUTH_XOR_EXPR
:
2694 if (flags
& TFF_EXPR_IN_PARENS
)
2695 pp_cxx_left_paren (pp
);
2697 if (flags
& TFF_EXPR_IN_PARENS
)
2698 pp_cxx_right_paren (pp
);
2702 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2706 pp_string (pp
, M_("<lambda>"));
2710 pp_cxx_left_paren (pp
);
2711 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2712 pp_cxx_right_paren (pp
);
2716 pp_cxx_requires_expr (cxx_pp
, t
);
2720 pp_cxx_simple_requirement (cxx_pp
, t
);
2724 pp_cxx_type_requirement (cxx_pp
, t
);
2728 pp_cxx_compound_requirement (cxx_pp
, t
);
2732 pp_cxx_nested_requirement (cxx_pp
, t
);
2744 pp_cxx_constraint (cxx_pp
, t
);
2747 case PLACEHOLDER_EXPR
:
2748 pp_string (pp
, M_("*this"));
2751 /* This list is incomplete, but should suffice for now.
2752 It is very important that `sorry' does not call
2753 `report_error_function'. That could cause an infinite loop. */
2755 pp_unsupported_tree (pp
, t
);
2756 /* fall through to ERROR_MARK... */
2758 pp_string (pp
, M_("<expression error>"));
2764 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2767 pp_cxx_left_paren (pp
);
2768 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2769 pp_cxx_whitespace (pp
);
2771 pp_cxx_ws_string (pp
, opstring
);
2773 pp_string (pp
, M_("<unknown operator>"));
2774 pp_cxx_whitespace (pp
);
2775 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2776 pp_cxx_right_paren (pp
);
2780 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2782 if (flags
& TFF_EXPR_IN_PARENS
)
2783 pp_cxx_left_paren (pp
);
2784 pp_cxx_ws_string (pp
, opstring
);
2785 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2786 if (flags
& TFF_EXPR_IN_PARENS
)
2787 pp_cxx_right_paren (pp
);
2791 reinit_cxx_pp (void)
2793 pp_clear_output_area (cxx_pp
);
2794 cxx_pp
->padding
= pp_none
;
2795 pp_indentation (cxx_pp
) = 0;
2796 pp_needs_newline (cxx_pp
) = false;
2797 cxx_pp
->enclosing_scope
= current_function_decl
;
2800 /* Same as pp_formatted_text, except the return string is a separate
2801 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2804 pp_ggc_formatted_text (pretty_printer
*pp
)
2806 return ggc_strdup (pp_formatted_text (pp
));
2809 /* Exported interface to stringifying types, exprs and decls under TFF_*
2813 type_as_string (tree typ
, int flags
)
2816 pp_translate_identifiers (cxx_pp
) = false;
2817 dump_type (cxx_pp
, typ
, flags
);
2818 return pp_ggc_formatted_text (cxx_pp
);
2822 type_as_string_translate (tree typ
, int flags
)
2825 dump_type (cxx_pp
, typ
, flags
);
2826 return pp_ggc_formatted_text (cxx_pp
);
2830 expr_as_string (tree decl
, int flags
)
2833 pp_translate_identifiers (cxx_pp
) = false;
2834 dump_expr (cxx_pp
, decl
, flags
);
2835 return pp_ggc_formatted_text (cxx_pp
);
2838 /* Wrap decl_as_string with options appropriate for dwarf. */
2841 decl_as_dwarf_string (tree decl
, int flags
)
2844 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2845 here will be adequate to get the desired behavior. */
2846 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2847 name
= decl_as_string (decl
, flags
);
2848 /* Subsequent calls to the pretty printer shouldn't use this style. */
2849 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2854 decl_as_string (tree decl
, int flags
)
2857 pp_translate_identifiers (cxx_pp
) = false;
2858 dump_decl (cxx_pp
, decl
, flags
);
2859 return pp_ggc_formatted_text (cxx_pp
);
2863 decl_as_string_translate (tree decl
, int flags
)
2866 dump_decl (cxx_pp
, decl
, flags
);
2867 return pp_ggc_formatted_text (cxx_pp
);
2870 /* Wrap lang_decl_name with options appropriate for dwarf. */
2873 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2876 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2877 here will be adequate to get the desired behavior. */
2878 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2879 name
= lang_decl_name (decl
, v
, translate
);
2880 /* Subsequent calls to the pretty printer shouldn't use this style. */
2881 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2885 /* Generate the three forms of printable names for cxx_printable_name. */
2888 lang_decl_name (tree decl
, int v
, bool translate
)
2892 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2893 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2896 pp_translate_identifiers (cxx_pp
) = translate
;
2898 && (DECL_CLASS_SCOPE_P (decl
)
2899 || (DECL_NAMESPACE_SCOPE_P (decl
)
2900 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2902 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2903 pp_cxx_colon_colon (cxx_pp
);
2906 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2907 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2908 else if ((DECL_NAME (decl
) == NULL_TREE
)
2909 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2910 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2912 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2914 return pp_ggc_formatted_text (cxx_pp
);
2917 /* Return the location of a tree passed to %+ formats. */
2920 location_of (tree t
)
2924 t
= TYPE_MAIN_DECL (t
);
2926 return input_location
;
2928 else if (TREE_CODE (t
) == OVERLOAD
)
2929 t
= OVL_FUNCTION (t
);
2932 return DECL_SOURCE_LOCATION (t
);
2933 return EXPR_LOC_OR_LOC (t
, input_location
);
2936 /* Now the interfaces from error et al to dump_type et al. Each takes an
2937 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2941 decl_to_string (tree decl
, int verbose
)
2945 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2946 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2947 flags
= TFF_CLASS_KEY_OR_ENUM
;
2949 flags
|= TFF_DECL_SPECIFIERS
;
2950 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2951 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2952 flags
|= TFF_TEMPLATE_HEADER
;
2955 dump_decl (cxx_pp
, decl
, flags
);
2956 return pp_ggc_formatted_text (cxx_pp
);
2960 expr_to_string (tree decl
)
2963 dump_expr (cxx_pp
, decl
, 0);
2964 return pp_ggc_formatted_text (cxx_pp
);
2968 fndecl_to_string (tree fndecl
, int verbose
)
2972 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2973 | TFF_TEMPLATE_HEADER
;
2975 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2977 dump_decl (cxx_pp
, fndecl
, flags
);
2978 return pp_ggc_formatted_text (cxx_pp
);
2983 code_to_string (enum tree_code c
)
2985 return get_tree_code_name (c
);
2989 language_to_string (enum languages c
)
2996 case lang_cplusplus
:
3008 /* Return the proper printed version of a parameter to a C++ function. */
3011 parm_to_string (int p
)
3015 pp_string (cxx_pp
, "'this'");
3017 pp_decimal_int (cxx_pp
, p
+ 1);
3018 return pp_ggc_formatted_text (cxx_pp
);
3022 op_to_string (enum tree_code p
)
3024 tree id
= operator_name_info
[p
].identifier
;
3025 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3029 type_to_string (tree typ
, int verbose
)
3033 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3034 flags
|= TFF_TEMPLATE_HEADER
;
3037 dump_type (cxx_pp
, typ
, flags
);
3038 /* If we're printing a type that involves typedefs, also print the
3039 stripped version. But sometimes the stripped version looks
3040 exactly the same, so we don't want it after all. To avoid printing
3041 it in that case, we play ugly obstack games. */
3042 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3043 && !uses_template_parms (typ
))
3045 int aka_start
, aka_len
; char *p
;
3046 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3047 /* Remember the end of the initial dump. */
3048 int len
= obstack_object_size (ob
);
3049 tree aka
= strip_typedefs (typ
);
3050 pp_string (cxx_pp
, " {aka");
3051 pp_cxx_whitespace (cxx_pp
);
3052 /* And remember the start of the aka dump. */
3053 aka_start
= obstack_object_size (ob
);
3054 dump_type (cxx_pp
, aka
, flags
);
3055 aka_len
= obstack_object_size (ob
) - aka_start
;
3056 pp_right_brace (cxx_pp
);
3057 p
= (char*)obstack_base (ob
);
3058 /* If they are identical, cut off the aka with a NUL. */
3059 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3062 return pp_ggc_formatted_text (cxx_pp
);
3066 assop_to_string (enum tree_code p
)
3068 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3069 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3073 args_to_string (tree p
, int verbose
)
3077 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3082 if (TYPE_P (TREE_VALUE (p
)))
3083 return type_as_string_translate (p
, flags
);
3086 for (; p
; p
= TREE_CHAIN (p
))
3088 if (TREE_VALUE (p
) == null_node
)
3089 pp_cxx_ws_string (cxx_pp
, "NULL");
3091 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3093 pp_separate_with_comma (cxx_pp
);
3095 return pp_ggc_formatted_text (cxx_pp
);
3098 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3099 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3103 subst_to_string (tree p
)
3105 tree decl
= TREE_PURPOSE (p
);
3106 tree targs
= TREE_VALUE (p
);
3107 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3108 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3109 |TFF_NO_TEMPLATE_BINDINGS
);
3115 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3116 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3117 return pp_ggc_formatted_text (cxx_pp
);
3121 cv_to_string (tree p
, int v
)
3124 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3125 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3126 return pp_ggc_formatted_text (cxx_pp
);
3130 eh_spec_to_string (tree p
, int /*v*/)
3134 dump_exception_spec (cxx_pp
, p
, flags
);
3135 return pp_ggc_formatted_text (cxx_pp
);
3138 /* Langhook for print_error_function. */
3140 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3141 diagnostic_info
*diagnostic
)
3143 lhd_print_error_function (context
, file
, diagnostic
);
3144 pp_set_prefix (context
->printer
, file
);
3145 maybe_print_instantiation_context (context
);
3149 cp_diagnostic_starter (diagnostic_context
*context
,
3150 diagnostic_info
*diagnostic
)
3152 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3153 cp_print_error_function (context
, diagnostic
);
3154 maybe_print_instantiation_context (context
);
3155 maybe_print_constexpr_context (context
);
3156 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3160 /* Print current function onto BUFFER, in the process of reporting
3161 a diagnostic message. Called from cp_diagnostic_starter. */
3163 cp_print_error_function (diagnostic_context
*context
,
3164 diagnostic_info
*diagnostic
)
3166 /* If we are in an instantiation context, current_function_decl is likely
3167 to be wrong, so just rely on print_instantiation_full_context. */
3168 if (current_instantiation ())
3170 if (diagnostic_last_function_changed (context
, diagnostic
))
3172 const char *old_prefix
= context
->printer
->prefix
;
3173 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3174 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3175 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3176 ? file_name_as_prefix (context
, file
) : NULL
;
3178 pp_set_prefix (context
->printer
, new_prefix
);
3180 if (current_function_decl
== NULL
)
3181 pp_string (context
->printer
, _("At global scope:"));
3186 if (abstract_origin
)
3188 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3189 while (TREE_CODE (ao
) == BLOCK
3190 && BLOCK_ABSTRACT_ORIGIN (ao
)
3191 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3192 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3193 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3197 fndecl
= current_function_decl
;
3199 pp_printf (context
->printer
, function_category (fndecl
),
3200 cxx_printable_name_translate (fndecl
, 2));
3202 while (abstract_origin
)
3205 tree block
= abstract_origin
;
3207 locus
= &BLOCK_SOURCE_LOCATION (block
);
3209 block
= BLOCK_SUPERCONTEXT (block
);
3210 while (block
&& TREE_CODE (block
) == BLOCK
3211 && BLOCK_ABSTRACT_ORIGIN (block
))
3213 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3215 while (TREE_CODE (ao
) == BLOCK
3216 && BLOCK_ABSTRACT_ORIGIN (ao
)
3217 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3218 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3220 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3225 else if (TREE_CODE (ao
) != BLOCK
)
3228 block
= BLOCK_SUPERCONTEXT (block
);
3231 abstract_origin
= block
;
3234 while (block
&& TREE_CODE (block
) == BLOCK
)
3235 block
= BLOCK_SUPERCONTEXT (block
);
3237 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3239 abstract_origin
= NULL
;
3243 expanded_location s
= expand_location (*locus
);
3244 pp_character (context
->printer
, ',');
3245 pp_newline (context
->printer
);
3248 if (context
->show_column
&& s
.column
!= 0)
3249 pp_printf (context
->printer
,
3250 _(" inlined from %qs at %r%s:%d:%d%R"),
3251 cxx_printable_name_translate (fndecl
, 2),
3252 "locus", s
.file
, s
.line
, s
.column
);
3254 pp_printf (context
->printer
,
3255 _(" inlined from %qs at %r%s:%d%R"),
3256 cxx_printable_name_translate (fndecl
, 2),
3257 "locus", s
.file
, s
.line
);
3261 pp_printf (context
->printer
, _(" inlined from %qs"),
3262 cxx_printable_name_translate (fndecl
, 2));
3265 pp_character (context
->printer
, ':');
3267 pp_newline (context
->printer
);
3269 diagnostic_set_last_function (context
, diagnostic
);
3270 pp_destroy_prefix (context
->printer
);
3271 context
->printer
->prefix
= old_prefix
;
3275 /* Returns a description of FUNCTION using standard terminology. The
3276 result is a format string of the form "In CATEGORY %qs". */
3278 function_category (tree fn
)
3280 /* We can get called from the middle-end for diagnostics of function
3281 clones. Make sure we have language specific information before
3282 dereferencing it. */
3283 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3284 && DECL_FUNCTION_MEMBER_P (fn
))
3286 if (DECL_STATIC_FUNCTION_P (fn
))
3287 return _("In static member function %qs");
3288 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3289 return _("In copy constructor %qs");
3290 else if (DECL_CONSTRUCTOR_P (fn
))
3291 return _("In constructor %qs");
3292 else if (DECL_DESTRUCTOR_P (fn
))
3293 return _("In destructor %qs");
3294 else if (LAMBDA_FUNCTION_P (fn
))
3295 return _("In lambda function");
3297 return _("In member function %qs");
3300 return _("In function %qs");
3303 /* Report the full context of a current template instantiation,
3306 print_instantiation_full_context (diagnostic_context
*context
)
3308 struct tinst_level
*p
= current_instantiation ();
3309 location_t location
= input_location
;
3313 pp_verbatim (context
->printer
,
3314 TREE_CODE (p
->decl
) == TREE_LIST
3315 ? _("%s: In substitution of %qS:\n")
3316 : _("%s: In instantiation of %q#D:\n"),
3317 LOCATION_FILE (location
),
3320 location
= p
->locus
;
3324 print_instantiation_partial_context (context
, p
, location
);
3327 /* Helper function of print_instantiation_partial_context() that
3328 prints a single line of instantiation context. */
3331 print_instantiation_partial_context_line (diagnostic_context
*context
,
3332 const struct tinst_level
*t
,
3333 location_t loc
, bool recursive_p
)
3335 if (loc
== UNKNOWN_LOCATION
)
3338 expanded_location xloc
= expand_location (loc
);
3340 if (context
->show_column
)
3341 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3342 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3344 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3345 "locus", xloc
.file
, xloc
.line
);
3349 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3350 pp_verbatim (context
->printer
,
3352 ? _("recursively required by substitution of %qS\n")
3353 : _("required by substitution of %qS\n"),
3356 pp_verbatim (context
->printer
,
3358 ? _("recursively required from %q#D\n")
3359 : _("required from %q#D\n"),
3364 pp_verbatim (context
->printer
,
3366 ? _("recursively required from here\n")
3367 : _("required from here\n"));
3371 /* Same as print_instantiation_full_context but less verbose. */
3374 print_instantiation_partial_context (diagnostic_context
*context
,
3375 struct tinst_level
*t0
, location_t loc
)
3377 struct tinst_level
*t
;
3380 location_t prev_loc
= loc
;
3382 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3383 if (prev_loc
!= t
->locus
)
3385 prev_loc
= t
->locus
;
3391 if (template_backtrace_limit
3392 && n_total
> template_backtrace_limit
)
3394 int skip
= n_total
- template_backtrace_limit
;
3395 int head
= template_backtrace_limit
/ 2;
3397 /* Avoid skipping just 1. If so, skip 2. */
3401 head
= (template_backtrace_limit
- 1) / 2;
3404 for (n
= 0; n
< head
; n
++)
3406 gcc_assert (t
!= NULL
);
3407 if (loc
!= t
->locus
)
3408 print_instantiation_partial_context_line (context
, t
, loc
,
3409 /*recursive_p=*/false);
3413 if (t
!= NULL
&& skip
> 0)
3415 expanded_location xloc
;
3416 xloc
= expand_location (loc
);
3417 if (context
->show_column
)
3418 pp_verbatim (context
->printer
,
3419 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3420 "contexts, use -ftemplate-backtrace-limit=0 to "
3422 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3424 pp_verbatim (context
->printer
,
3425 _("%r%s:%d:%R [ skipping %d instantiation "
3426 "contexts, use -ftemplate-backtrace-limit=0 to "
3428 "locus", xloc
.file
, xloc
.line
, skip
);
3433 } while (t
!= NULL
&& --skip
> 0);
3439 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3444 print_instantiation_partial_context_line (context
, t
, loc
,
3449 print_instantiation_partial_context_line (context
, NULL
, loc
,
3450 /*recursive_p=*/false);
3453 /* Called from cp_thing to print the template context for an error. */
3455 maybe_print_instantiation_context (diagnostic_context
*context
)
3457 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3460 record_last_problematic_instantiation ();
3461 print_instantiation_full_context (context
);
3464 /* Report what constexpr call(s) we're trying to expand, if any. */
3467 maybe_print_constexpr_context (diagnostic_context
*context
)
3469 vec
<tree
> call_stack
= cx_error_context ();
3473 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3475 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3476 const char *s
= expr_as_string (t
, 0);
3477 if (context
->show_column
)
3478 pp_verbatim (context
->printer
,
3479 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3480 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3482 pp_verbatim (context
->printer
,
3483 _("%r%s:%d:%R in constexpr expansion of %qs"),
3484 "locus", xloc
.file
, xloc
.line
, s
);
3485 pp_newline (context
->printer
);
3489 /* Called from output_format -- during diagnostic message processing --
3490 to handle C++ specific format specifier with the following meanings:
3491 %A function argument-list.
3495 %F function declaration.
3496 %L language as used in extern "lang".
3498 %P function parameter whose position is indicated by an integer.
3499 %Q assignment operator.
3500 %S substitution (template + args)
3503 %X exception-specification. */
3505 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3506 int precision
, bool wide
, bool set_locus
, bool verbose
)
3510 #define next_tree (t = va_arg (*text->args_ptr, tree))
3511 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3512 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3513 #define next_int va_arg (*text->args_ptr, int)
3515 if (precision
!= 0 || wide
)
3520 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3521 case 'C': result
= code_to_string (next_tcode
); break;
3524 tree temp
= next_tree
;
3526 && DECL_HAS_DEBUG_EXPR_P (temp
))
3528 temp
= DECL_DEBUG_EXPR (temp
);
3531 result
= expr_to_string (temp
);
3535 result
= decl_to_string (temp
, verbose
);
3538 case 'E': result
= expr_to_string (next_tree
); break;
3539 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3540 case 'L': result
= language_to_string (next_lang
); break;
3541 case 'O': result
= op_to_string (next_tcode
); break;
3542 case 'P': result
= parm_to_string (next_int
); break;
3543 case 'Q': result
= assop_to_string (next_tcode
); break;
3544 case 'S': result
= subst_to_string (next_tree
); break;
3545 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3546 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3547 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3550 percent_K_format (text
);
3557 pp_string (pp
, result
);
3558 if (set_locus
&& t
!= NULL
)
3559 text
->set_location (0, location_of (t
), true);
3567 /* Warn about the use of C++0x features when appropriate. */
3569 maybe_warn_cpp0x (cpp0x_warn_str str
)
3571 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3572 /* We really want to suppress this warning in system headers,
3573 because libstdc++ uses variadic templates even when we aren't
3577 case CPP0X_INITIALIZER_LISTS
:
3578 pedwarn (input_location
, 0,
3579 "extended initializer lists "
3580 "only available with -std=c++11 or -std=gnu++11");
3582 case CPP0X_EXPLICIT_CONVERSION
:
3583 pedwarn (input_location
, 0,
3584 "explicit conversion operators "
3585 "only available with -std=c++11 or -std=gnu++11");
3587 case CPP0X_VARIADIC_TEMPLATES
:
3588 pedwarn (input_location
, 0,
3589 "variadic templates "
3590 "only available with -std=c++11 or -std=gnu++11");
3592 case CPP0X_LAMBDA_EXPR
:
3593 pedwarn (input_location
, 0,
3594 "lambda expressions "
3595 "only available with -std=c++11 or -std=gnu++11");
3598 pedwarn (input_location
, 0,
3599 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3601 case CPP0X_SCOPED_ENUMS
:
3602 pedwarn (input_location
, 0,
3603 "scoped enums only available with -std=c++11 or -std=gnu++11");
3605 case CPP0X_DEFAULTED_DELETED
:
3606 pedwarn (input_location
, 0,
3607 "defaulted and deleted functions "
3608 "only available with -std=c++11 or -std=gnu++11");
3610 case CPP0X_INLINE_NAMESPACES
:
3611 pedwarn (input_location
, OPT_Wpedantic
,
3612 "inline namespaces "
3613 "only available with -std=c++11 or -std=gnu++11");
3615 case CPP0X_OVERRIDE_CONTROLS
:
3616 pedwarn (input_location
, 0,
3617 "override controls (override/final) "
3618 "only available with -std=c++11 or -std=gnu++11");
3621 pedwarn (input_location
, 0,
3622 "non-static data member initializers "
3623 "only available with -std=c++11 or -std=gnu++11");
3625 case CPP0X_USER_DEFINED_LITERALS
:
3626 pedwarn (input_location
, 0,
3627 "user-defined literals "
3628 "only available with -std=c++11 or -std=gnu++11");
3630 case CPP0X_DELEGATING_CTORS
:
3631 pedwarn (input_location
, 0,
3632 "delegating constructors "
3633 "only available with -std=c++11 or -std=gnu++11");
3635 case CPP0X_INHERITING_CTORS
:
3636 pedwarn (input_location
, 0,
3637 "inheriting constructors "
3638 "only available with -std=c++11 or -std=gnu++11");
3640 case CPP0X_ATTRIBUTES
:
3641 pedwarn (input_location
, 0,
3643 "only available with -std=c++11 or -std=gnu++11");
3645 case CPP0X_REF_QUALIFIER
:
3646 pedwarn (input_location
, 0,
3648 "only available with -std=c++11 or -std=gnu++11");
3655 /* Warn about the use of variadic templates when appropriate. */
3657 maybe_warn_variadic_templates (void)
3659 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3663 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3664 option OPT with text GMSGID. Use this function to report
3665 diagnostics for constructs that are invalid C++98, but valid
3668 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3670 diagnostic_info diagnostic
;
3673 rich_location
richloc (line_table
, location
);
3675 va_start (ap
, gmsgid
);
3676 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
3677 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3678 diagnostic
.option_index
= opt
;
3679 ret
= report_diagnostic (&diagnostic
);
3684 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3685 we found when we tried to do the lookup. LOCATION is the location of
3686 the NAME identifier. */
3689 qualified_name_lookup_error (tree scope
, tree name
,
3690 tree decl
, location_t location
)
3692 if (scope
== error_mark_node
)
3693 ; /* We already complained. */
3694 else if (TYPE_P (scope
))
3696 if (!COMPLETE_TYPE_P (scope
))
3697 error_at (location
, "incomplete type %qT used in nested name specifier",
3699 else if (TREE_CODE (decl
) == TREE_LIST
)
3701 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3703 print_candidates (decl
);
3706 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3708 else if (scope
!= global_namespace
)
3710 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3711 suggest_alternatives_for (location
, name
);
3715 error_at (location
, "%<::%D%> has not been declared", name
);
3716 suggest_alternatives_for (location
, name
);