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_("<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
)
963 && DECL_DECLARED_CONSTEXPR_P (t
))
965 if (DECL_DECLARED_CONCEPT_P (t
))
966 pp_cxx_ws_string (pp
, "concept");
968 pp_cxx_ws_string (pp
, "constexpr");
970 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
973 if (! (flags
& TFF_UNQUALIFIED_NAME
)
974 && TREE_CODE (t
) != PARM_DECL
975 && (!DECL_INITIAL (t
)
976 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
977 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
978 flags
&= ~TFF_UNQUALIFIED_NAME
;
979 if ((flags
& TFF_DECL_SPECIFIERS
)
980 && DECL_TEMPLATE_PARM_P (t
)
981 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
982 pp_string (pp
, "...");
985 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
988 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
989 pp_string (pp
, " capture>");
992 dump_decl (pp
, DECL_NAME (t
), flags
);
995 pp_string (pp
, M_("<anonymous>"));
996 if (flags
& TFF_DECL_SPECIFIERS
)
997 dump_type_suffix (pp
, type
, flags
);
1000 /* Dump a human readable string for the decl T under control of FLAGS. */
1003 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1008 /* If doing Objective-C++, give Objective-C a chance to demangle
1009 Objective-C method names. */
1010 if (c_dialect_objc ())
1012 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1015 pp_string (pp
, demangled
);
1020 switch (TREE_CODE (t
))
1023 /* Don't say 'typedef class A' */
1024 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1026 if ((flags
& TFF_DECL_SPECIFIERS
)
1027 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1029 /* Say `class T' not just `T'. */
1030 pp_cxx_ws_string (pp
, "class");
1032 /* Emit the `...' for a parameter pack. */
1033 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1034 pp_cxx_ws_string (pp
, "...");
1037 dump_type (pp
, TREE_TYPE (t
), flags
);
1040 if (TYPE_DECL_ALIAS_P (t
)
1041 && (flags
& TFF_DECL_SPECIFIERS
1042 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1044 pp_cxx_ws_string (pp
, "using");
1045 dump_decl (pp
, DECL_NAME (t
), flags
);
1046 pp_cxx_whitespace (pp
);
1047 pp_cxx_ws_string (pp
, "=");
1048 pp_cxx_whitespace (pp
);
1049 dump_type (pp
, DECL_ORIGINAL_TYPE (t
), flags
);
1052 if ((flags
& TFF_DECL_SPECIFIERS
)
1053 && !DECL_SELF_REFERENCE_P (t
))
1054 pp_cxx_ws_string (pp
, "typedef");
1055 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1056 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1061 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1063 pp_string (pp
, M_("vtable for "));
1064 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1065 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1068 /* Else fall through. */
1071 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1073 /* Handle variable template specializations. */
1075 && DECL_LANG_SPECIFIC (t
)
1076 && DECL_TEMPLATE_INFO (t
)
1077 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1079 pp_cxx_begin_template_argument_list (pp
);
1080 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1081 dump_template_argument_list (pp
, args
, flags
);
1082 pp_cxx_end_template_argument_list (pp
);
1087 pp_string (pp
, M_("<return value> "));
1088 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1091 case NAMESPACE_DECL
:
1092 if (flags
& TFF_DECL_SPECIFIERS
)
1093 pp
->declaration (t
);
1096 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1097 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1098 flags
&= ~TFF_UNQUALIFIED_NAME
;
1099 if (DECL_NAME (t
) == NULL_TREE
)
1101 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1102 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1104 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1107 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1112 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1113 pp_colon_colon (pp
);
1114 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1118 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1119 pp_cxx_left_bracket (pp
);
1120 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1121 pp_cxx_right_bracket (pp
);
1124 case ARRAY_NOTATION_REF
:
1125 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1126 pp_cxx_left_bracket (pp
);
1127 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1129 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1131 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1132 pp_cxx_right_bracket (pp
);
1135 /* So that we can do dump_decl on an aggr type. */
1139 dump_type (pp
, t
, flags
);
1143 /* This is a pseudo destructor call which has not been folded into
1144 a PSEUDO_DTOR_EXPR yet. */
1145 pp_cxx_complement (pp
);
1146 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1153 /* These special cases are duplicated here so that other functions
1154 can feed identifiers to error and get them demangled properly. */
1155 case IDENTIFIER_NODE
:
1156 if (IDENTIFIER_TYPENAME_P (t
))
1158 pp_cxx_ws_string (pp
, "operator");
1159 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1160 dump_type (pp
, TREE_TYPE (t
), flags
);
1164 pp_cxx_tree_identifier (pp
, t
);
1170 t
= OVL_CURRENT (t
);
1171 if (DECL_CLASS_SCOPE_P (t
))
1173 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1174 pp_cxx_colon_colon (pp
);
1176 else if (!DECL_FILE_SCOPE_P (t
))
1178 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1179 pp_cxx_colon_colon (pp
);
1181 dump_decl (pp
, DECL_NAME (t
), flags
);
1185 /* If there's only one function, just treat it like an ordinary
1187 t
= OVL_CURRENT (t
);
1191 if (! DECL_LANG_SPECIFIC (t
))
1193 if (DECL_ABSTRACT_ORIGIN (t
))
1194 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1196 pp_string (pp
, M_("<built-in>"));
1198 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1199 dump_global_iord (pp
, t
);
1201 dump_function_decl (pp
, t
, flags
);
1205 dump_template_decl (pp
, t
, flags
);
1208 case TEMPLATE_ID_EXPR
:
1210 tree name
= TREE_OPERAND (t
, 0);
1211 tree args
= TREE_OPERAND (t
, 1);
1213 if (is_overloaded_fn (name
))
1214 name
= get_first_fn (name
);
1216 name
= DECL_NAME (name
);
1217 dump_decl (pp
, name
, flags
);
1218 pp_cxx_begin_template_argument_list (pp
);
1219 if (args
== error_mark_node
)
1220 pp_string (pp
, M_("<template arguments error>"));
1222 dump_template_argument_list
1223 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1224 pp_cxx_end_template_argument_list (pp
);
1229 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1233 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1234 || (DECL_INITIAL (t
) &&
1235 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1236 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1237 else if (DECL_NAME (t
))
1238 dump_decl (pp
, DECL_NAME (t
), flags
);
1239 else if (DECL_INITIAL (t
))
1240 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1242 pp_string (pp
, M_("<enumerator>"));
1246 pp_cxx_ws_string (pp
, "using");
1247 dump_type (pp
, USING_DECL_SCOPE (t
), flags
);
1248 pp_cxx_colon_colon (pp
);
1249 dump_decl (pp
, DECL_NAME (t
), flags
);
1253 pp
->declaration (t
);
1257 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1260 case NON_DEPENDENT_EXPR
:
1261 dump_expr (pp
, t
, flags
);
1264 case TEMPLATE_TYPE_PARM
:
1265 if (flags
& TFF_DECL_SPECIFIERS
)
1266 pp
->declaration (t
);
1271 case UNBOUND_CLASS_TEMPLATE
:
1272 case TYPE_PACK_EXPANSION
:
1274 dump_type (pp
, t
, flags
);
1278 pp_unsupported_tree (pp
, t
);
1279 /* Fall through to error. */
1282 pp_string (pp
, M_("<declaration error>"));
1287 /* Dump a template declaration T under control of FLAGS. This means the
1288 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1291 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1293 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1297 if (flags
& TFF_TEMPLATE_HEADER
)
1299 for (parms
= orig_parms
= nreverse (orig_parms
);
1301 parms
= TREE_CHAIN (parms
))
1303 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1304 int len
= TREE_VEC_LENGTH (inner_parms
);
1308 /* Skip over the dummy template levels of a template template
1310 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1314 pp_cxx_ws_string (pp
, "template");
1315 pp_cxx_begin_template_argument_list (pp
);
1317 /* If we've shown the template prefix, we'd better show the
1318 parameters' and decl's type too. */
1319 flags
|= TFF_DECL_SPECIFIERS
;
1321 for (i
= 0; i
< len
; i
++)
1324 pp_separate_with_comma (pp
);
1325 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1328 pp_cxx_end_template_argument_list (pp
);
1329 pp_cxx_whitespace (pp
);
1331 nreverse(orig_parms
);
1333 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1335 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1336 pp_cxx_ws_string (pp
, "class");
1338 /* If this is a parameter pack, print the ellipsis. */
1339 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1340 pp_cxx_ws_string (pp
, "...");
1343 /* Only print the requirements if we're also printing
1344 the template header. */
1346 if (tree ci
= get_constraints (t
))
1347 if (check_constraint_info (ci
))
1348 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1350 pp_cxx_requires_clause (pp
, reqs
);
1351 pp_cxx_whitespace (pp
);
1356 if (DECL_CLASS_TEMPLATE_P (t
))
1357 dump_type (pp
, TREE_TYPE (t
),
1358 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1359 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1360 else if (DECL_TEMPLATE_RESULT (t
)
1361 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1362 /* Alias template. */
1363 || DECL_TYPE_TEMPLATE_P (t
)))
1364 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1367 gcc_assert (TREE_TYPE (t
));
1368 switch (NEXT_CODE (t
))
1372 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1375 /* This case can occur with some invalid code. */
1376 dump_type (pp
, TREE_TYPE (t
),
1377 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1378 | (flags
& TFF_DECL_SPECIFIERS
1379 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1384 /* find_typenames looks through the type of the function template T
1385 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1388 struct find_typenames_t
1390 hash_set
<tree
> *p_set
;
1391 vec
<tree
, va_gc
> *typenames
;
1395 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1397 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1398 tree mv
= NULL_TREE
;
1400 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1401 /* Add the type of the typedef without any additional cv-quals. */
1402 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1403 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1404 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1405 /* Add the typename without any cv-qualifiers. */
1406 mv
= TYPE_MAIN_VARIANT (*tp
);
1408 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1410 /* Don't mess with parameter packs since we don't remember
1411 the pack expansion context for a particular typename. */
1412 *walk_subtrees
= false;
1416 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1417 vec_safe_push (d
->typenames
, mv
);
1419 /* Search into class template arguments, which cp_walk_subtrees
1421 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1422 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1428 static vec
<tree
, va_gc
> *
1429 find_typenames (tree t
)
1431 struct find_typenames_t ft
;
1432 ft
.p_set
= new hash_set
<tree
>;
1433 ft
.typenames
= NULL
;
1434 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1435 find_typenames_r
, &ft
, ft
.p_set
);
1437 return ft
.typenames
;
1440 /* Output the "[with ...]" clause for a template instantiation T iff
1441 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1442 formatting a deduction/substitution diagnostic rather than an
1446 dump_substitution (cxx_pretty_printer
*pp
,
1447 tree t
, tree template_parms
, tree template_args
,
1450 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1451 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1453 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1454 pp_cxx_whitespace (pp
);
1455 pp_cxx_left_bracket (pp
);
1456 pp
->translate_string ("with");
1457 pp_cxx_whitespace (pp
);
1458 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1459 pp_cxx_right_bracket (pp
);
1463 /* Dump the lambda function FN including its 'mutable' qualifier and any
1464 template bindings. */
1467 dump_lambda_function (cxx_pretty_printer
*pp
,
1468 tree fn
, tree template_parms
, tree template_args
,
1471 /* A lambda's signature is essentially its "type". */
1472 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1473 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1475 pp
->padding
= pp_before
;
1476 pp_c_ws_string (pp
, "mutable");
1478 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1481 /* Pretty print a function decl. There are several ways we want to print a
1482 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1483 As error can only apply the '#' flag once to give 0 and 1 for V, there
1484 is %D which doesn't print the throw specs, and %F which does. */
1487 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1491 tree cname
= NULL_TREE
;
1492 tree template_args
= NULL_TREE
;
1493 tree template_parms
= NULL_TREE
;
1494 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1495 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1499 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1500 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1501 t
= DECL_TEMPLATE_RESULT (t
);
1503 /* Save the exceptions, in case t is a specialization and we are
1504 emitting an error about incompatible specifications. */
1505 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1507 /* Likewise for the constexpr specifier, in case t is a specialization. */
1508 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1510 /* Pretty print template instantiations only. */
1511 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1512 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1513 && flag_pretty_templates
)
1517 template_args
= DECL_TI_ARGS (t
);
1518 tmpl
= most_general_template (t
);
1519 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1521 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1526 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1527 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1529 fntype
= TREE_TYPE (t
);
1530 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1532 if (DECL_CLASS_SCOPE_P (t
))
1533 cname
= DECL_CONTEXT (t
);
1534 /* This is for partially instantiated template methods. */
1535 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1536 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1538 if (flags
& TFF_DECL_SPECIFIERS
)
1540 if (DECL_STATIC_FUNCTION_P (t
))
1541 pp_cxx_ws_string (pp
, "static");
1542 else if (DECL_VIRTUAL_P (t
))
1543 pp_cxx_ws_string (pp
, "virtual");
1547 if (DECL_DECLARED_CONCEPT_P (t
))
1548 pp_cxx_ws_string (pp
, "concept");
1550 pp_cxx_ws_string (pp
, "constexpr");
1554 /* Print the return type? */
1556 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1557 && !DECL_DESTRUCTOR_P (t
);
1560 tree ret
= fndecl_declared_return_type (t
);
1561 dump_type_prefix (pp
, ret
, flags
);
1564 /* Print the function name. */
1565 if (!do_outer_scope
)
1569 dump_type (pp
, cname
, flags
);
1570 pp_cxx_colon_colon (pp
);
1573 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1575 dump_function_name (pp
, t
, flags
);
1577 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1579 dump_parameters (pp
, parmtypes
, flags
);
1581 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1583 pp
->padding
= pp_before
;
1584 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1585 dump_ref_qualifier (pp
, fntype
, flags
);
1588 if (tx_safe_fn_type_p (fntype
))
1590 pp
->padding
= pp_before
;
1591 pp_cxx_ws_string (pp
, "transaction_safe");
1594 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1596 pp
->padding
= pp_before
;
1597 dump_exception_spec (pp
, exceptions
, flags
);
1601 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1604 if (tree ci
= get_constraints (t
))
1605 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1606 pp_cxx_requires_clause (pp
, reqs
);
1608 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1610 else if (template_args
)
1612 bool need_comma
= false;
1614 pp_cxx_begin_template_argument_list (pp
);
1615 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1616 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1618 tree arg
= TREE_VEC_ELT (template_args
, i
);
1620 pp_separate_with_comma (pp
);
1621 if (ARGUMENT_PACK_P (arg
))
1622 pp_cxx_left_brace (pp
);
1623 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1624 if (ARGUMENT_PACK_P (arg
))
1625 pp_cxx_right_brace (pp
);
1628 pp_cxx_end_template_argument_list (pp
);
1632 /* Print a parameter list. If this is for a member function, the
1633 member object ptr (and any other hidden args) should have
1634 already been removed. */
1637 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1640 flags
&= ~TFF_SCOPE
;
1641 pp_cxx_left_paren (pp
);
1643 for (first
= 1; parmtypes
!= void_list_node
;
1644 parmtypes
= TREE_CHAIN (parmtypes
))
1647 pp_separate_with_comma (pp
);
1651 pp_cxx_ws_string (pp
, "...");
1655 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1657 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1659 pp_cxx_whitespace (pp
);
1661 pp_cxx_whitespace (pp
);
1662 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1666 pp_cxx_right_paren (pp
);
1669 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1672 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1674 if (FUNCTION_REF_QUALIFIED (t
))
1676 pp
->padding
= pp_before
;
1677 if (FUNCTION_RVALUE_QUALIFIED (t
))
1678 pp_cxx_ws_string (pp
, "&&");
1680 pp_cxx_ws_string (pp
, "&");
1684 /* Print an exception specification. T is the exception specification. */
1687 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1689 if (t
&& TREE_PURPOSE (t
))
1691 pp_cxx_ws_string (pp
, "noexcept");
1692 if (!integer_onep (TREE_PURPOSE (t
)))
1694 pp_cxx_whitespace (pp
);
1695 pp_cxx_left_paren (pp
);
1696 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1697 pp_cxx_ws_string (pp
, "<uninstantiated>");
1699 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1700 pp_cxx_right_paren (pp
);
1705 pp_cxx_ws_string (pp
, "throw");
1706 pp_cxx_whitespace (pp
);
1707 pp_cxx_left_paren (pp
);
1708 if (TREE_VALUE (t
) != NULL_TREE
)
1711 dump_type (pp
, TREE_VALUE (t
), flags
);
1715 pp_separate_with_comma (pp
);
1717 pp_cxx_right_paren (pp
);
1721 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1722 and destructors properly. */
1725 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1727 tree name
= DECL_NAME (t
);
1729 /* We can get here with a decl that was synthesized by language-
1730 independent machinery (e.g. coverage.c) in which case it won't
1731 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1732 will crash. In this case it is safe just to print out the
1734 if (!DECL_LANG_SPECIFIC (t
))
1736 pp_cxx_tree_identifier (pp
, name
);
1740 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1741 t
= DECL_TEMPLATE_RESULT (t
);
1743 /* Don't let the user see __comp_ctor et al. */
1744 if (DECL_CONSTRUCTOR_P (t
)
1745 || DECL_DESTRUCTOR_P (t
))
1747 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1748 name
= get_identifier ("<lambda>");
1749 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1750 name
= get_identifier ("<constructor>");
1752 name
= constructor_name (DECL_CONTEXT (t
));
1755 if (DECL_DESTRUCTOR_P (t
))
1757 pp_cxx_complement (pp
);
1758 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1760 else if (DECL_CONV_FN_P (t
))
1762 /* This cannot use the hack that the operator's return
1763 type is stashed off of its name because it may be
1764 used for error reporting. In the case of conflicting
1765 declarations, both will have the same name, yet
1766 the types will be different, hence the TREE_TYPE field
1767 of the first name will be clobbered by the second. */
1768 pp_cxx_ws_string (pp
, "operator");
1769 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1771 else if (name
&& IDENTIFIER_OPNAME_P (name
))
1772 pp_cxx_tree_identifier (pp
, name
);
1773 else if (name
&& UDLIT_OPER_P (name
))
1774 pp_cxx_tree_identifier (pp
, name
);
1776 dump_decl (pp
, name
, flags
);
1778 if (DECL_TEMPLATE_INFO (t
)
1779 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1780 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1781 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1782 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1786 /* Dump the template parameters from the template info INFO under control of
1787 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1788 specialization (partial or complete). For partial specializations we show
1789 the specialized parameter values. For a primary template we show no
1793 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1794 int primary
, int flags
)
1796 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1798 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1800 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1801 pp_cxx_begin_template_argument_list (pp
);
1803 /* Be careful only to print things when we have them, so as not
1804 to crash producing error messages. */
1805 if (args
&& !primary
)
1808 len
= get_non_default_template_args_count (args
, flags
);
1810 args
= INNERMOST_TEMPLATE_ARGS (args
);
1811 for (ix
= 0; ix
!= len
; ix
++)
1813 tree arg
= TREE_VEC_ELT (args
, ix
);
1815 /* Only print a comma if we know there is an argument coming. In
1816 the case of an empty template argument pack, no actual
1817 argument will be printed. */
1819 && (!ARGUMENT_PACK_P (arg
)
1820 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1821 pp_separate_with_comma (pp
);
1824 pp_string (pp
, M_("<template parameter error>"));
1826 dump_template_argument (pp
, arg
, flags
);
1831 tree tpl
= TI_TEMPLATE (info
);
1832 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1835 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1836 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1838 for (ix
= 0; ix
!= len
; ix
++)
1842 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1844 pp_string (pp
, M_("<template parameter error>"));
1848 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1851 pp_separate_with_comma (pp
);
1853 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1856 pp_cxx_end_template_argument_list (pp
);
1859 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1860 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1863 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1866 call_expr_arg_iterator iter
;
1868 pp_cxx_left_paren (pp
);
1869 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1875 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1876 if (more_call_expr_args_p (&iter
))
1877 pp_separate_with_comma (pp
);
1880 pp_cxx_right_paren (pp
);
1883 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1884 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1888 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1892 aggr_init_expr_arg_iterator iter
;
1894 pp_cxx_left_paren (pp
);
1895 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1901 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1902 if (more_aggr_init_expr_args_p (&iter
))
1903 pp_separate_with_comma (pp
);
1906 pp_cxx_right_paren (pp
);
1909 /* Print out a list of initializers (subr of dump_expr). */
1912 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1916 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1919 pp_separate_with_comma (pp
);
1923 /* Print out a vector of initializers (subr of dump_expr). */
1926 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1929 unsigned HOST_WIDE_INT idx
;
1932 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1934 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1935 if (idx
!= v
->length () - 1)
1936 pp_separate_with_comma (pp
);
1941 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1942 function. Resolve it to a close relative -- in the sense of static
1943 type -- variant being overridden. That is close to what was written in
1944 the source code. Subroutine of dump_expr. */
1947 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1949 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1950 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1951 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1954 fun
= TREE_CHAIN (fun
);
1955 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1956 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1962 /* Print out an expression E under control of FLAGS. */
1965 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
1972 if (STATEMENT_CLASS_P (t
))
1974 pp_cxx_ws_string (pp
, M_("<statement>"));
1978 switch (TREE_CODE (t
))
1986 case NAMESPACE_DECL
:
1990 case IDENTIFIER_NODE
:
1991 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
1992 |TFF_TEMPLATE_HEADER
))
1993 | TFF_NO_TEMPLATE_BINDINGS
1994 | TFF_NO_FUNCTION_ARGUMENTS
));
1998 if (SSA_NAME_VAR (t
)
1999 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
2000 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2002 pp_cxx_ws_string (pp
, M_("<unknown>"));
2013 case USERDEF_LITERAL
:
2014 pp_cxx_userdef_literal (pp
, t
);
2018 /* While waiting for caret diagnostics, avoid printing
2019 __cxa_allocate_exception, __cxa_throw, and the like. */
2020 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2025 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2026 pp_cxx_colon_colon (pp
);
2027 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2031 pp_cxx_left_paren (pp
);
2032 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2033 pp_separate_with_comma (pp
);
2034 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2035 pp_cxx_right_paren (pp
);
2039 pp_cxx_left_paren (pp
);
2040 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2041 pp_string (pp
, " ? ");
2042 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2043 pp_string (pp
, " : ");
2044 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2045 pp_cxx_right_paren (pp
);
2049 if (TREE_HAS_CONSTRUCTOR (t
))
2051 pp_cxx_ws_string (pp
, "new");
2052 pp_cxx_whitespace (pp
);
2053 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2056 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2059 case AGGR_INIT_EXPR
:
2061 tree fn
= NULL_TREE
;
2063 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2064 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2066 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2068 if (DECL_CONSTRUCTOR_P (fn
))
2069 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2071 dump_decl (pp
, fn
, 0);
2074 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2076 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2081 tree fn
= CALL_EXPR_FN (t
);
2082 bool skipfirst
= false;
2084 /* Deal with internal functions. */
2085 if (fn
== NULL_TREE
)
2087 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2088 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2092 if (TREE_CODE (fn
) == ADDR_EXPR
)
2093 fn
= TREE_OPERAND (fn
, 0);
2095 /* Nobody is interested in seeing the guts of vcalls. */
2096 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2097 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2099 if (TREE_TYPE (fn
) != NULL_TREE
2100 && NEXT_CODE (fn
) == METHOD_TYPE
2101 && call_expr_nargs (t
))
2103 tree ob
= CALL_EXPR_ARG (t
, 0);
2104 if (TREE_CODE (ob
) == ADDR_EXPR
)
2106 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2107 flags
| TFF_EXPR_IN_PARENS
);
2110 else if (TREE_CODE (ob
) != PARM_DECL
2111 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2113 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2118 if (flag_sanitize
& SANITIZE_UNDEFINED
2119 && is_ubsan_builtin_p (fn
))
2121 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2124 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2125 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2130 /* Note that this only works for G++ target exprs. If somebody
2131 builds a general TARGET_EXPR, there's no way to represent that
2132 it initializes anything other that the parameter slot for the
2133 default argument. Note we may have cleared out the first
2134 operand in expand_expr, so don't go killing ourselves. */
2135 if (TREE_OPERAND (t
, 1))
2136 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2139 case POINTER_PLUS_EXPR
:
2140 dump_binary_op (pp
, "+", t
, flags
);
2145 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2152 case TRUNC_DIV_EXPR
:
2153 case TRUNC_MOD_EXPR
:
2161 case TRUTH_ANDIF_EXPR
:
2162 case TRUTH_ORIF_EXPR
:
2169 case EXACT_DIV_EXPR
:
2170 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2174 case FLOOR_DIV_EXPR
:
2175 case ROUND_DIV_EXPR
:
2177 dump_binary_op (pp
, "/", t
, flags
);
2181 case FLOOR_MOD_EXPR
:
2182 case ROUND_MOD_EXPR
:
2183 dump_binary_op (pp
, "%", t
, flags
);
2188 tree ob
= TREE_OPERAND (t
, 0);
2189 if (INDIRECT_REF_P (ob
))
2191 ob
= TREE_OPERAND (ob
, 0);
2192 if (TREE_CODE (ob
) != PARM_DECL
2194 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2196 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2197 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2205 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2208 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2213 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2214 pp_cxx_left_bracket (pp
);
2215 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2216 pp_cxx_right_bracket (pp
);
2219 case ARRAY_NOTATION_REF
:
2220 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2221 pp_cxx_left_bracket (pp
);
2222 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2224 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2226 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2227 pp_cxx_right_bracket (pp
);
2230 case UNARY_PLUS_EXPR
:
2231 dump_unary_op (pp
, "+", t
, flags
);
2235 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2236 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2237 /* An ADDR_EXPR can have reference type. In that case, we
2238 shouldn't print the `&' doing so indicates to the user
2239 that the expression has pointer type. */
2241 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2242 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2243 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2244 dump_unary_op (pp
, "&&", t
, flags
);
2246 dump_unary_op (pp
, "&", t
, flags
);
2250 if (TREE_HAS_CONSTRUCTOR (t
))
2252 t
= TREE_OPERAND (t
, 0);
2253 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2254 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2255 dump_call_expr_args (pp
, t
, flags
, true);
2259 if (TREE_OPERAND (t
,0) != NULL_TREE
2260 && TREE_TYPE (TREE_OPERAND (t
, 0))
2261 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2262 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2264 dump_unary_op (pp
, "*", t
, flags
);
2269 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2270 && integer_zerop (TREE_OPERAND (t
, 1)))
2271 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2275 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2277 pp_cxx_left_paren (pp
);
2278 if (!integer_onep (TYPE_SIZE_UNIT
2279 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2281 pp_cxx_left_paren (pp
);
2282 dump_type (pp
, ptr_type_node
, flags
);
2283 pp_cxx_right_paren (pp
);
2286 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2287 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2289 pp_cxx_ws_string (pp
, "+");
2290 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2292 pp_cxx_right_paren (pp
);
2299 case TRUTH_NOT_EXPR
:
2300 case PREDECREMENT_EXPR
:
2301 case PREINCREMENT_EXPR
:
2302 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2305 case POSTDECREMENT_EXPR
:
2306 case POSTINCREMENT_EXPR
:
2307 pp_cxx_left_paren (pp
);
2308 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2309 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2310 pp_cxx_right_paren (pp
);
2313 case NON_LVALUE_EXPR
:
2314 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2315 should be another level of INDIRECT_REF so that I don't have to do
2317 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2319 tree next
= TREE_TYPE (TREE_TYPE (t
));
2321 while (TYPE_PTR_P (next
))
2322 next
= TREE_TYPE (next
);
2324 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2326 if (flags
& TFF_EXPR_IN_PARENS
)
2327 pp_cxx_left_paren (pp
);
2329 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2330 if (flags
& TFF_EXPR_IN_PARENS
)
2331 pp_cxx_right_paren (pp
);
2334 /* Else fall through. */
2336 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2340 case IMPLICIT_CONV_EXPR
:
2341 case VIEW_CONVERT_EXPR
:
2343 tree op
= TREE_OPERAND (t
, 0);
2344 tree ttype
= TREE_TYPE (t
);
2345 tree optype
= TREE_TYPE (op
);
2347 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2348 && POINTER_TYPE_P (ttype
)
2349 && POINTER_TYPE_P (optype
)
2350 && same_type_p (TREE_TYPE (optype
),
2353 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2356 if (TREE_CODE (op
) == ADDR_EXPR
)
2357 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2359 dump_unary_op (pp
, "*", t
, flags
);
2362 dump_unary_op (pp
, "&", t
, flags
);
2364 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2366 /* It is a cast, but we cannot tell whether it is a
2367 reinterpret or static cast. Use the C style notation. */
2368 if (flags
& TFF_EXPR_IN_PARENS
)
2369 pp_cxx_left_paren (pp
);
2370 pp_cxx_left_paren (pp
);
2371 dump_type (pp
, TREE_TYPE (t
), flags
);
2372 pp_cxx_right_paren (pp
);
2373 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2374 if (flags
& TFF_EXPR_IN_PARENS
)
2375 pp_cxx_right_paren (pp
);
2378 dump_expr (pp
, op
, flags
);
2383 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2385 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2387 if (integer_zerop (idx
))
2389 /* A NULL pointer-to-member constant. */
2390 pp_cxx_left_paren (pp
);
2391 pp_cxx_left_paren (pp
);
2392 dump_type (pp
, TREE_TYPE (t
), flags
);
2393 pp_cxx_right_paren (pp
);
2394 pp_character (pp
, '0');
2395 pp_cxx_right_paren (pp
);
2398 else if (tree_fits_shwi_p (idx
))
2401 unsigned HOST_WIDE_INT n
;
2403 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2404 t
= TYPE_METHOD_BASETYPE (t
);
2405 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2407 n
= tree_to_shwi (idx
);
2409 /* Map vtable index back one, to allow for the null pointer to
2413 while (n
> 0 && virtuals
)
2416 virtuals
= TREE_CHAIN (virtuals
);
2420 dump_expr (pp
, BV_FN (virtuals
),
2421 flags
| TFF_EXPR_IN_PARENS
);
2426 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2427 pp_string (pp
, "<lambda closure object>");
2428 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2430 dump_type (pp
, TREE_TYPE (t
), 0);
2431 pp_cxx_left_paren (pp
);
2432 pp_cxx_right_paren (pp
);
2436 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2437 dump_type (pp
, TREE_TYPE (t
), 0);
2438 pp_cxx_left_brace (pp
);
2439 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2440 pp_cxx_right_brace (pp
);
2447 tree ob
= TREE_OPERAND (t
, 0);
2448 if (is_dummy_object (ob
))
2450 t
= TREE_OPERAND (t
, 1);
2451 if (TREE_CODE (t
) == FUNCTION_DECL
)
2453 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2454 else if (BASELINK_P (t
))
2455 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2456 flags
| TFF_EXPR_IN_PARENS
);
2458 dump_decl (pp
, t
, flags
);
2462 if (INDIRECT_REF_P (ob
))
2464 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2470 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2474 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2479 case TEMPLATE_PARM_INDEX
:
2480 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2484 if (TREE_OPERAND (t
, 0) == NULL_TREE
2485 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2487 dump_type (pp
, TREE_TYPE (t
), flags
);
2488 pp_cxx_left_paren (pp
);
2489 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2490 pp_cxx_right_paren (pp
);
2494 pp_cxx_left_paren (pp
);
2495 dump_type (pp
, TREE_TYPE (t
), flags
);
2496 pp_cxx_right_paren (pp
);
2497 pp_cxx_left_paren (pp
);
2498 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2499 pp_cxx_right_paren (pp
);
2503 case STATIC_CAST_EXPR
:
2504 pp_cxx_ws_string (pp
, "static_cast");
2506 case REINTERPRET_CAST_EXPR
:
2507 pp_cxx_ws_string (pp
, "reinterpret_cast");
2509 case CONST_CAST_EXPR
:
2510 pp_cxx_ws_string (pp
, "const_cast");
2512 case DYNAMIC_CAST_EXPR
:
2513 pp_cxx_ws_string (pp
, "dynamic_cast");
2515 pp_cxx_begin_template_argument_list (pp
);
2516 dump_type (pp
, TREE_TYPE (t
), flags
);
2517 pp_cxx_end_template_argument_list (pp
);
2518 pp_cxx_left_paren (pp
);
2519 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2520 pp_cxx_right_paren (pp
);
2524 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2530 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2531 pp_cxx_ws_string (pp
, "sizeof");
2534 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2535 pp_cxx_ws_string (pp
, "__alignof__");
2537 op
= TREE_OPERAND (t
, 0);
2538 if (PACK_EXPANSION_P (op
))
2540 pp_string (pp
, "...");
2541 op
= PACK_EXPANSION_PATTERN (op
);
2543 pp_cxx_whitespace (pp
);
2544 pp_cxx_left_paren (pp
);
2545 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2546 dump_type (pp
, TREE_TYPE (op
), flags
);
2547 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2548 dump_type (pp
, op
, flags
);
2550 dump_expr (pp
, op
, flags
);
2551 pp_cxx_right_paren (pp
);
2554 case AT_ENCODE_EXPR
:
2555 pp_cxx_ws_string (pp
, "@encode");
2556 pp_cxx_whitespace (pp
);
2557 pp_cxx_left_paren (pp
);
2558 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2559 pp_cxx_right_paren (pp
);
2563 pp_cxx_ws_string (pp
, "noexcept");
2564 pp_cxx_whitespace (pp
);
2565 pp_cxx_left_paren (pp
);
2566 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2567 pp_cxx_right_paren (pp
);
2572 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2573 pp_cxx_whitespace (pp
);
2574 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2578 pp_string (pp
, M_("<unparsed>"));
2581 case TRY_CATCH_EXPR
:
2582 case WITH_CLEANUP_EXPR
:
2583 case CLEANUP_POINT_EXPR
:
2584 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2587 case PSEUDO_DTOR_EXPR
:
2588 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2590 if (TREE_OPERAND (t
, 1))
2592 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2593 pp_cxx_colon_colon (pp
);
2595 pp_cxx_complement (pp
);
2596 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2599 case TEMPLATE_ID_EXPR
:
2600 dump_decl (pp
, t
, flags
);
2606 case STATEMENT_LIST
:
2607 /* We don't yet have a way of dumping statements in a
2608 human-readable format. */
2609 pp_string (pp
, "({...})");
2613 pp_string (pp
, "while (1) { ");
2614 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2615 pp_cxx_right_brace (pp
);
2619 pp_string (pp
, "if (");
2620 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2621 pp_string (pp
, ") break; ");
2625 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2628 case EMPTY_CLASS_EXPR
:
2629 dump_type (pp
, TREE_TYPE (t
), flags
);
2630 pp_cxx_left_paren (pp
);
2631 pp_cxx_right_paren (pp
);
2634 case NON_DEPENDENT_EXPR
:
2635 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2638 case ARGUMENT_PACK_SELECT
:
2639 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2651 pp_type_specifier_seq (pp
, t
);
2655 /* We get here when we want to print a dependent type as an
2656 id-expression, without any disambiguator decoration. */
2657 pp
->id_expression (t
);
2660 case TEMPLATE_TYPE_PARM
:
2661 case TEMPLATE_TEMPLATE_PARM
:
2662 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2663 dump_type (pp
, t
, flags
);
2667 pp_cxx_trait_expression (pp
, t
);
2671 pp_cxx_va_arg_expression (pp
, t
);
2675 pp_cxx_offsetof_expression (pp
, t
);
2679 dump_decl (pp
, t
, flags
);
2682 case EXPR_PACK_EXPANSION
:
2683 case UNARY_LEFT_FOLD_EXPR
:
2684 case UNARY_RIGHT_FOLD_EXPR
:
2685 case BINARY_LEFT_FOLD_EXPR
:
2686 case BINARY_RIGHT_FOLD_EXPR
:
2693 case VEC_DELETE_EXPR
:
2699 case UNORDERED_EXPR
:
2709 case FIX_TRUNC_EXPR
:
2714 case TRUTH_AND_EXPR
:
2716 case TRUTH_XOR_EXPR
:
2717 if (flags
& TFF_EXPR_IN_PARENS
)
2718 pp_cxx_left_paren (pp
);
2720 if (flags
& TFF_EXPR_IN_PARENS
)
2721 pp_cxx_right_paren (pp
);
2725 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2729 pp_string (pp
, M_("<lambda>"));
2733 pp_cxx_left_paren (pp
);
2734 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2735 pp_cxx_right_paren (pp
);
2739 pp_cxx_requires_expr (cxx_pp
, t
);
2743 pp_cxx_simple_requirement (cxx_pp
, t
);
2747 pp_cxx_type_requirement (cxx_pp
, t
);
2751 pp_cxx_compound_requirement (cxx_pp
, t
);
2755 pp_cxx_nested_requirement (cxx_pp
, t
);
2768 pp_cxx_constraint (cxx_pp
, t
);
2771 case PLACEHOLDER_EXPR
:
2772 pp_string (pp
, M_("*this"));
2775 /* This list is incomplete, but should suffice for now.
2776 It is very important that `sorry' does not call
2777 `report_error_function'. That could cause an infinite loop. */
2779 pp_unsupported_tree (pp
, t
);
2780 /* fall through to ERROR_MARK... */
2782 pp_string (pp
, M_("<expression error>"));
2788 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2791 pp_cxx_left_paren (pp
);
2792 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2793 pp_cxx_whitespace (pp
);
2795 pp_cxx_ws_string (pp
, opstring
);
2797 pp_string (pp
, M_("<unknown operator>"));
2798 pp_cxx_whitespace (pp
);
2799 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2800 pp_cxx_right_paren (pp
);
2804 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2806 if (flags
& TFF_EXPR_IN_PARENS
)
2807 pp_cxx_left_paren (pp
);
2808 pp_cxx_ws_string (pp
, opstring
);
2809 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2810 if (flags
& TFF_EXPR_IN_PARENS
)
2811 pp_cxx_right_paren (pp
);
2815 reinit_cxx_pp (void)
2817 pp_clear_output_area (cxx_pp
);
2818 cxx_pp
->padding
= pp_none
;
2819 pp_indentation (cxx_pp
) = 0;
2820 pp_needs_newline (cxx_pp
) = false;
2821 cxx_pp
->enclosing_scope
= current_function_decl
;
2824 /* Same as pp_formatted_text, except the return string is a separate
2825 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2828 pp_ggc_formatted_text (pretty_printer
*pp
)
2830 return ggc_strdup (pp_formatted_text (pp
));
2833 /* Exported interface to stringifying types, exprs and decls under TFF_*
2837 type_as_string (tree typ
, int flags
)
2840 pp_translate_identifiers (cxx_pp
) = false;
2841 dump_type (cxx_pp
, typ
, flags
);
2842 return pp_ggc_formatted_text (cxx_pp
);
2846 type_as_string_translate (tree typ
, int flags
)
2849 dump_type (cxx_pp
, typ
, flags
);
2850 return pp_ggc_formatted_text (cxx_pp
);
2854 expr_as_string (tree decl
, int flags
)
2857 pp_translate_identifiers (cxx_pp
) = false;
2858 dump_expr (cxx_pp
, decl
, flags
);
2859 return pp_ggc_formatted_text (cxx_pp
);
2862 /* Wrap decl_as_string with options appropriate for dwarf. */
2865 decl_as_dwarf_string (tree decl
, int flags
)
2868 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2869 here will be adequate to get the desired behavior. */
2870 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2871 name
= decl_as_string (decl
, flags
);
2872 /* Subsequent calls to the pretty printer shouldn't use this style. */
2873 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2878 decl_as_string (tree decl
, int flags
)
2881 pp_translate_identifiers (cxx_pp
) = false;
2882 dump_decl (cxx_pp
, decl
, flags
);
2883 return pp_ggc_formatted_text (cxx_pp
);
2887 decl_as_string_translate (tree decl
, int flags
)
2890 dump_decl (cxx_pp
, decl
, flags
);
2891 return pp_ggc_formatted_text (cxx_pp
);
2894 /* Wrap lang_decl_name with options appropriate for dwarf. */
2897 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2900 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2901 here will be adequate to get the desired behavior. */
2902 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2903 name
= lang_decl_name (decl
, v
, translate
);
2904 /* Subsequent calls to the pretty printer shouldn't use this style. */
2905 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2909 /* Generate the three forms of printable names for cxx_printable_name. */
2912 lang_decl_name (tree decl
, int v
, bool translate
)
2916 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2917 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2920 pp_translate_identifiers (cxx_pp
) = translate
;
2922 && (DECL_CLASS_SCOPE_P (decl
)
2923 || (DECL_NAMESPACE_SCOPE_P (decl
)
2924 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2926 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2927 pp_cxx_colon_colon (cxx_pp
);
2930 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2931 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2932 else if ((DECL_NAME (decl
) == NULL_TREE
)
2933 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2934 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2936 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2938 return pp_ggc_formatted_text (cxx_pp
);
2941 /* Return the location of a tree passed to %+ formats. */
2944 location_of (tree t
)
2948 t
= TYPE_MAIN_DECL (t
);
2950 return input_location
;
2952 else if (TREE_CODE (t
) == OVERLOAD
)
2953 t
= OVL_FUNCTION (t
);
2956 return DECL_SOURCE_LOCATION (t
);
2957 return EXPR_LOC_OR_LOC (t
, input_location
);
2960 /* Now the interfaces from error et al to dump_type et al. Each takes an
2961 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2965 decl_to_string (tree decl
, int verbose
)
2969 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2970 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2971 flags
= TFF_CLASS_KEY_OR_ENUM
;
2973 flags
|= TFF_DECL_SPECIFIERS
;
2974 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2975 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2976 flags
|= TFF_TEMPLATE_HEADER
;
2979 dump_decl (cxx_pp
, decl
, flags
);
2980 return pp_ggc_formatted_text (cxx_pp
);
2984 expr_to_string (tree decl
)
2987 dump_expr (cxx_pp
, decl
, 0);
2988 return pp_ggc_formatted_text (cxx_pp
);
2992 fndecl_to_string (tree fndecl
, int verbose
)
2996 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2997 | TFF_TEMPLATE_HEADER
;
2999 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3001 dump_decl (cxx_pp
, fndecl
, flags
);
3002 return pp_ggc_formatted_text (cxx_pp
);
3007 code_to_string (enum tree_code c
)
3009 return get_tree_code_name (c
);
3013 language_to_string (enum languages c
)
3020 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
);