1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2015 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"
27 #include "double-int.h"
34 #include "stringpool.h"
37 #include "diagnostic.h"
38 #include "tree-diagnostic.h"
39 #include "langhooks-def.h"
41 #include "cxx-pretty-print.h"
42 #include "tree-pretty-print.h"
43 #include "c-family/c-objc.h"
45 #include "internal-fn.h"
47 #include <new> // For placement-new.
49 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
50 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
52 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
53 dump C++ ASTs as strings. It is mostly used only by the various
54 tree -> string functions that are occasionally called from the
55 debugger or by the front-end for things like
56 __PRETTY_FUNCTION__. */
57 static cxx_pretty_printer scratch_pretty_printer
;
58 static cxx_pretty_printer
* cxx_pp
= &scratch_pretty_printer
;
60 /* Translate if being used for diagnostics, but not for dump files or
62 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
64 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
66 static const char *args_to_string (tree
, int);
67 static const char *assop_to_string (enum tree_code
);
68 static const char *code_to_string (enum tree_code
);
69 static const char *cv_to_string (tree
, int);
70 static const char *decl_to_string (tree
, int);
71 static const char *expr_to_string (tree
);
72 static const char *fndecl_to_string (tree
, int);
73 static const char *op_to_string (enum tree_code
);
74 static const char *parm_to_string (int);
75 static const char *type_to_string (tree
, int);
77 static void dump_alias_template_specialization (cxx_pretty_printer
*, tree
, int);
78 static void dump_type (cxx_pretty_printer
*, tree
, int);
79 static void dump_typename (cxx_pretty_printer
*, tree
, int);
80 static void dump_simple_decl (cxx_pretty_printer
*, tree
, tree
, int);
81 static void dump_decl (cxx_pretty_printer
*, tree
, int);
82 static void dump_template_decl (cxx_pretty_printer
*, tree
, int);
83 static void dump_function_decl (cxx_pretty_printer
*, tree
, int);
84 static void dump_expr (cxx_pretty_printer
*, tree
, int);
85 static void dump_unary_op (cxx_pretty_printer
*, const char *, tree
, int);
86 static void dump_binary_op (cxx_pretty_printer
*, const char *, tree
, int);
87 static void dump_aggr_type (cxx_pretty_printer
*, tree
, int);
88 static void dump_type_prefix (cxx_pretty_printer
*, tree
, int);
89 static void dump_type_suffix (cxx_pretty_printer
*, tree
, int);
90 static void dump_function_name (cxx_pretty_printer
*, tree
, int);
91 static void dump_call_expr_args (cxx_pretty_printer
*, tree
, int, bool);
92 static void dump_aggr_init_expr_args (cxx_pretty_printer
*, tree
, int, bool);
93 static void dump_expr_list (cxx_pretty_printer
*, tree
, int);
94 static void dump_global_iord (cxx_pretty_printer
*, tree
);
95 static void dump_parameters (cxx_pretty_printer
*, tree
, int);
96 static void dump_ref_qualifier (cxx_pretty_printer
*, tree
, int);
97 static void dump_exception_spec (cxx_pretty_printer
*, tree
, int);
98 static void dump_template_argument (cxx_pretty_printer
*, tree
, int);
99 static void dump_template_argument_list (cxx_pretty_printer
*, tree
, int);
100 static void dump_template_parameter (cxx_pretty_printer
*, tree
, int);
101 static void dump_template_bindings (cxx_pretty_printer
*, tree
, tree
,
103 static void dump_scope (cxx_pretty_printer
*, tree
, int);
104 static void dump_template_parms (cxx_pretty_printer
*, tree
, int, int);
105 static int get_non_default_template_args_count (tree
, int);
106 static const char *function_category (tree
);
107 static void maybe_print_constexpr_context (diagnostic_context
*);
108 static void maybe_print_instantiation_context (diagnostic_context
*);
109 static void print_instantiation_full_context (diagnostic_context
*);
110 static void print_instantiation_partial_context (diagnostic_context
*,
111 struct tinst_level
*,
113 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
114 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
116 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
117 int, bool, bool, bool);
119 /* CONTEXT->printer is a basic pretty printer that was constructed
120 presumably by diagnostic_initialize(), called early in the
121 compiler's initialization process (in general_init) Before the FE
122 is initialized. This (C++) FE-specific diagnostic initializer is
123 thus replacing the basic pretty printer with one that has C++-aware
127 cxx_initialize_diagnostics (diagnostic_context
*context
)
129 pretty_printer
*base
= context
->printer
;
130 cxx_pretty_printer
*pp
= XNEW (cxx_pretty_printer
);
131 context
->printer
= new (pp
) cxx_pretty_printer ();
133 /* It is safe to free this object because it was previously XNEW()'d. */
134 base
->~pretty_printer ();
137 c_common_diagnostics_set_defaults (context
);
138 diagnostic_starter (context
) = cp_diagnostic_starter
;
139 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
140 diagnostic_format_decoder (context
) = cp_printer
;
143 /* Initialize the global cxx_pp that is used as the memory store for
144 the string representation of C++ AST. See the description of
150 new (cxx_pp
) cxx_pretty_printer ();
153 /* Dump a scope, if deemed necessary. */
156 dump_scope (cxx_pretty_printer
*pp
, tree scope
, int flags
)
158 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
160 if (scope
== NULL_TREE
)
163 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
165 if (scope
!= global_namespace
)
167 dump_decl (pp
, scope
, f
);
168 pp_cxx_colon_colon (pp
);
171 else if (AGGREGATE_TYPE_P (scope
))
173 dump_type (pp
, scope
, f
);
174 pp_cxx_colon_colon (pp
);
176 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
178 dump_function_decl (pp
, scope
, f
);
179 pp_cxx_colon_colon (pp
);
183 /* Dump the template ARGument under control of FLAGS. */
186 dump_template_argument (cxx_pretty_printer
*pp
, tree arg
, int flags
)
188 if (ARGUMENT_PACK_P (arg
))
189 dump_template_argument_list (pp
, ARGUMENT_PACK_ARGS (arg
),
190 /* No default args in argument packs. */
191 flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
192 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
193 dump_type (pp
, arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
196 if (TREE_CODE (arg
) == TREE_LIST
)
197 arg
= TREE_VALUE (arg
);
199 dump_expr (pp
, arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
203 /* Count the number of template arguments ARGS whose value does not
204 match the (optional) default template parameter in PARAMS */
207 get_non_default_template_args_count (tree args
, int flags
)
209 int n
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args
));
211 if (/* We use this flag when generating debug information. We don't
212 want to expand templates at this point, for this may generate
213 new decls, which gets decl counts out of sync, which may in
214 turn cause codegen differences between compilations with and
216 (flags
& TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
) != 0
217 || !flag_pretty_templates
)
220 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args
));
223 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
227 dump_template_argument_list (cxx_pretty_printer
*pp
, tree args
, int flags
)
229 int n
= get_non_default_template_args_count (args
, flags
);
233 for (i
= 0; i
< n
; ++i
)
235 tree arg
= TREE_VEC_ELT (args
, i
);
237 /* Only print a comma if we know there is an argument coming. In
238 the case of an empty template argument pack, no actual
239 argument will be printed. */
241 && (!ARGUMENT_PACK_P (arg
)
242 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
243 pp_separate_with_comma (pp
);
245 dump_template_argument (pp
, arg
, flags
);
250 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
253 dump_template_parameter (cxx_pretty_printer
*pp
, tree parm
, int flags
)
258 if (parm
== error_mark_node
)
261 p
= TREE_VALUE (parm
);
262 a
= TREE_PURPOSE (parm
);
264 if (TREE_CODE (p
) == TYPE_DECL
)
266 if (flags
& TFF_DECL_SPECIFIERS
)
268 pp_cxx_ws_string (pp
, "class");
269 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
270 pp_cxx_ws_string (pp
, "...");
272 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
274 else if (DECL_NAME (p
))
275 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
277 pp_cxx_canonical_template_parameter (pp
, TREE_TYPE (p
));
280 dump_decl (pp
, p
, flags
| TFF_DECL_SPECIFIERS
);
282 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
284 pp_cxx_whitespace (pp
);
286 pp_cxx_whitespace (pp
);
287 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
288 dump_type (pp
, a
, flags
& ~TFF_CHASE_TYPEDEF
);
290 dump_expr (pp
, a
, flags
| TFF_EXPR_IN_PARENS
);
294 /* Dump, under control of FLAGS, a template-parameter-list binding.
295 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
299 dump_template_bindings (cxx_pretty_printer
*pp
, tree parms
, tree args
,
300 vec
<tree
, va_gc
> *typenames
)
302 bool need_semicolon
= false;
308 tree p
= TREE_VALUE (parms
);
309 int lvl
= TMPL_PARMS_DEPTH (parms
);
312 tree lvl_args
= NULL_TREE
;
314 /* Don't crash if we had an invalid argument list. */
315 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
316 lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
318 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
320 tree arg
= NULL_TREE
;
322 /* Don't crash if we had an invalid argument list. */
323 if (lvl_args
&& NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
324 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
327 pp_separate_with_semicolon (pp
);
328 dump_template_parameter (pp
, TREE_VEC_ELT (p
, i
),
329 TFF_PLAIN_IDENTIFIER
);
330 pp_cxx_whitespace (pp
);
332 pp_cxx_whitespace (pp
);
335 if (ARGUMENT_PACK_P (arg
))
336 pp_cxx_left_brace (pp
);
337 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
338 if (ARGUMENT_PACK_P (arg
))
339 pp_cxx_right_brace (pp
);
342 pp_string (pp
, M_("<missing>"));
345 need_semicolon
= true;
348 parms
= TREE_CHAIN (parms
);
351 /* Don't bother with typenames for a partial instantiation. */
352 if (vec_safe_is_empty (typenames
) || uses_template_parms (args
))
355 /* Don't try to print typenames when we're processing a clone. */
356 if (current_function_decl
357 && !DECL_LANG_SPECIFIC (current_function_decl
))
360 FOR_EACH_VEC_SAFE_ELT (typenames
, i
, t
)
363 pp_separate_with_semicolon (pp
);
364 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
365 pp_cxx_whitespace (pp
);
367 pp_cxx_whitespace (pp
);
368 push_deferring_access_checks (dk_no_check
);
369 t
= tsubst (t
, args
, tf_none
, NULL_TREE
);
370 pop_deferring_access_checks ();
371 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
372 pp_simple_type_specifier doesn't know about it. */
373 t
= strip_typedefs (t
);
374 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
378 /* Dump a human-readable equivalent of the alias template
379 specialization of T. */
382 dump_alias_template_specialization (cxx_pretty_printer
*pp
, tree t
, int flags
)
386 gcc_assert (alias_template_specialization_p (t
));
388 if (!(flags
& TFF_UNQUALIFIED_NAME
))
389 dump_scope (pp
, CP_DECL_CONTEXT (TYPE_NAME (t
)), flags
);
390 name
= TYPE_IDENTIFIER (t
);
391 pp_cxx_tree_identifier (pp
, name
);
392 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
394 flags
& ~TFF_TEMPLATE_HEADER
);
397 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
401 dump_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
406 /* Don't print e.g. "struct mytypedef". */
407 if (TYPE_P (t
) && typedef_variant_p (t
))
409 tree decl
= TYPE_NAME (t
);
410 if ((flags
& TFF_CHASE_TYPEDEF
)
411 || DECL_SELF_REFERENCE_P (decl
)
412 || (!flag_pretty_templates
413 && DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)))
414 t
= strip_typedefs (t
);
415 else if (alias_template_specialization_p (t
))
417 dump_alias_template_specialization (pp
, t
, flags
);
420 else if (same_type_p (t
, TREE_TYPE (decl
)))
424 pp_cxx_cv_qualifier_seq (pp
, t
);
425 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
430 if (TYPE_PTRMEMFUNC_P (t
))
433 switch (TREE_CODE (t
))
436 if (t
== init_list_type_node
)
437 pp_string (pp
, M_("<brace-enclosed initializer list>"));
438 else if (t
== unknown_type_node
)
439 pp_string (pp
, M_("<unresolved overloaded function type>"));
442 pp_cxx_cv_qualifier_seq (pp
, t
);
443 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
448 /* A list of function parms. */
449 dump_parameters (pp
, t
, flags
);
452 case IDENTIFIER_NODE
:
453 pp_cxx_tree_identifier (pp
, t
);
457 dump_type (pp
, BINFO_TYPE (t
), flags
);
463 dump_aggr_type (pp
, t
, flags
);
467 if (flags
& TFF_CHASE_TYPEDEF
)
469 dump_type (pp
, DECL_ORIGINAL_TYPE (t
)
470 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
473 /* Else fall through. */
477 dump_decl (pp
, t
, flags
& ~TFF_DECL_SPECIFIERS
);
486 case FIXED_POINT_TYPE
:
487 pp_type_specifier_seq (pp
, t
);
490 case TEMPLATE_TEMPLATE_PARM
:
491 /* For parameters inside template signature. */
492 if (TYPE_IDENTIFIER (t
))
493 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
495 pp_cxx_canonical_template_parameter (pp
, t
);
498 case BOUND_TEMPLATE_TEMPLATE_PARM
:
500 tree args
= TYPE_TI_ARGS (t
);
501 pp_cxx_cv_qualifier_seq (pp
, t
);
502 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
503 pp_cxx_begin_template_argument_list (pp
);
504 dump_template_argument_list (pp
, args
, flags
);
505 pp_cxx_end_template_argument_list (pp
);
509 case TEMPLATE_TYPE_PARM
:
510 pp_cxx_cv_qualifier_seq (pp
, t
);
511 if (TYPE_IDENTIFIER (t
))
512 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
514 pp_cxx_canonical_template_parameter
515 (pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
518 /* This is not always necessary for pointers and such, but doing this
519 reduces code size. */
528 dump_type_prefix (pp
, t
, flags
);
529 dump_type_suffix (pp
, t
, flags
);
533 if (! (flags
& TFF_CHASE_TYPEDEF
)
534 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
536 dump_decl (pp
, TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
539 pp_cxx_cv_qualifier_seq (pp
, t
);
540 pp_cxx_ws_string (pp
,
541 TYPENAME_IS_ENUM_P (t
) ? "enum"
542 : TYPENAME_IS_CLASS_P (t
) ? "class"
544 dump_typename (pp
, t
, flags
);
547 case UNBOUND_CLASS_TEMPLATE
:
548 if (! (flags
& TFF_UNQUALIFIED_NAME
))
550 dump_type (pp
, TYPE_CONTEXT (t
), flags
);
551 pp_cxx_colon_colon (pp
);
553 pp_cxx_ws_string (pp
, "template");
554 dump_type (pp
, TYPE_IDENTIFIER (t
), flags
);
558 pp_cxx_ws_string (pp
, "__typeof__");
559 pp_cxx_whitespace (pp
);
560 pp_cxx_left_paren (pp
);
561 dump_expr (pp
, TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
562 pp_cxx_right_paren (pp
);
565 case UNDERLYING_TYPE
:
566 pp_cxx_ws_string (pp
, "__underlying_type");
567 pp_cxx_whitespace (pp
);
568 pp_cxx_left_paren (pp
);
569 dump_expr (pp
, UNDERLYING_TYPE_TYPE (t
), flags
& ~TFF_EXPR_IN_PARENS
);
570 pp_cxx_right_paren (pp
);
573 case TYPE_PACK_EXPANSION
:
574 dump_type (pp
, PACK_EXPANSION_PATTERN (t
), flags
);
575 pp_cxx_ws_string (pp
, "...");
578 case TYPE_ARGUMENT_PACK
:
579 dump_template_argument (pp
, t
, flags
);
583 pp_cxx_ws_string (pp
, "decltype");
584 pp_cxx_whitespace (pp
);
585 pp_cxx_left_paren (pp
);
586 dump_expr (pp
, DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
587 pp_cxx_right_paren (pp
);
591 pp_string (pp
, "std::nullptr_t");
595 pp_unsupported_tree (pp
, t
);
596 /* Fall through to error. */
599 pp_string (pp
, M_("<type error>"));
604 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
608 dump_typename (cxx_pretty_printer
*pp
, tree t
, int flags
)
610 tree ctx
= TYPE_CONTEXT (t
);
612 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
613 dump_typename (pp
, ctx
, flags
);
615 dump_type (pp
, ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
616 pp_cxx_colon_colon (pp
);
617 dump_decl (pp
, TYPENAME_TYPE_FULLNAME (t
), flags
);
620 /* Return the name of the supplied aggregate, or enumeral type. */
623 class_key_or_enum_as_string (tree t
)
625 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
627 if (SCOPED_ENUM_P (t
))
632 else if (TREE_CODE (t
) == UNION_TYPE
)
634 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
640 /* Print out a class declaration T under the control of FLAGS,
641 in the form `class foo'. */
644 dump_aggr_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
647 const char *variety
= class_key_or_enum_as_string (t
);
651 pp_cxx_cv_qualifier_seq (pp
, t
);
653 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
654 pp_cxx_ws_string (pp
, variety
);
656 name
= TYPE_NAME (t
);
660 typdef
= (!DECL_ARTIFICIAL (name
)
661 /* An alias specialization is not considered to be a
663 && !alias_template_specialization_p (t
));
666 && ((flags
& TFF_CHASE_TYPEDEF
)
667 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
668 && DECL_TEMPLATE_INFO (name
))))
669 || DECL_SELF_REFERENCE_P (name
))
671 t
= TYPE_MAIN_VARIANT (t
);
672 name
= TYPE_NAME (t
);
676 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
677 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
678 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
679 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
681 if (! (flags
& TFF_UNQUALIFIED_NAME
))
682 dump_scope (pp
, CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
683 flags
&= ~TFF_UNQUALIFIED_NAME
;
686 /* Because the template names are mangled, we have to locate
687 the most general template, and use that name. */
688 tree tpl
= TYPE_TI_TEMPLATE (t
);
690 while (DECL_TEMPLATE_INFO (tpl
))
691 tpl
= DECL_TI_TEMPLATE (tpl
);
694 name
= DECL_NAME (name
);
697 if (name
== 0 || ANON_AGGRNAME_P (name
))
699 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
700 pp_string (pp
, M_("<anonymous>"));
702 pp_printf (pp
, M_("<anonymous %s>"), variety
);
704 else if (LAMBDA_TYPE_P (t
))
706 /* A lambda's "type" is essentially its signature. */
707 pp_string (pp
, M_("<lambda"));
708 if (lambda_function (t
))
710 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
715 pp_cxx_tree_identifier (pp
, name
);
717 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
718 !CLASSTYPE_USE_TEMPLATE (t
),
719 flags
& ~TFF_TEMPLATE_HEADER
);
722 /* Dump into the obstack the initial part of the output for a given type.
723 This is necessary when dealing with things like functions returning
726 return type of `int (* fee ())()': pointer -> function -> int. Both
727 pointer (and reference and offset) and function (and member) types must
728 deal with prefix and suffix.
730 Arrays must also do this for DECL nodes, like int a[], and for things like
734 dump_type_prefix (cxx_pretty_printer
*pp
, tree t
, int flags
)
736 if (TYPE_PTRMEMFUNC_P (t
))
738 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
742 switch (TREE_CODE (t
))
747 tree sub
= TREE_TYPE (t
);
749 dump_type_prefix (pp
, sub
, flags
);
750 if (TREE_CODE (sub
) == ARRAY_TYPE
751 || TREE_CODE (sub
) == FUNCTION_TYPE
)
753 pp_cxx_whitespace (pp
);
754 pp_cxx_left_paren (pp
);
755 pp_c_attributes_display (pp
, TYPE_ATTRIBUTES (sub
));
759 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
761 if (TYPE_REF_IS_RVALUE (t
))
762 pp_ampersand_ampersand (pp
);
766 pp
->padding
= pp_before
;
767 pp_cxx_cv_qualifier_seq (pp
, t
);
773 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
774 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
777 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
778 pp_cxx_left_paren (pp
);
779 dump_type (pp
, TYPE_OFFSET_BASETYPE (t
), flags
);
780 pp_cxx_colon_colon (pp
);
783 pp_cxx_cv_qualifier_seq (pp
, t
);
784 pp
->padding
= pp_before
;
787 /* This can be reached without a pointer when dealing with
788 templates, e.g. std::is_function. */
790 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
794 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
796 pp_cxx_left_paren (pp
);
797 dump_aggr_type (pp
, TYPE_METHOD_BASETYPE (t
), flags
);
798 pp_cxx_colon_colon (pp
);
802 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
806 case IDENTIFIER_NODE
:
811 case TEMPLATE_TYPE_PARM
:
812 case TEMPLATE_TEMPLATE_PARM
:
813 case BOUND_TEMPLATE_TEMPLATE_PARM
:
824 case UNDERLYING_TYPE
:
826 case TYPE_PACK_EXPANSION
:
827 case FIXED_POINT_TYPE
:
829 dump_type (pp
, t
, flags
);
830 pp
->padding
= pp_before
;
834 pp_unsupported_tree (pp
, t
);
837 pp_string (pp
, M_("<typeprefixerror>"));
842 /* Dump the suffix of type T, under control of FLAGS. This is the part
843 which appears after the identifier (or function parms). */
846 dump_type_suffix (cxx_pretty_printer
*pp
, tree t
, int flags
)
848 if (TYPE_PTRMEMFUNC_P (t
))
849 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
851 switch (TREE_CODE (t
))
856 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
857 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
858 pp_cxx_right_paren (pp
);
859 if (TREE_CODE (t
) == POINTER_TYPE
)
860 flags
|= TFF_POINTER
;
861 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
868 if (TREE_CODE (t
) == METHOD_TYPE
)
869 /* Can only be reached through a pointer. */
870 pp_cxx_right_paren (pp
);
871 arg
= TYPE_ARG_TYPES (t
);
872 if (TREE_CODE (t
) == METHOD_TYPE
)
873 arg
= TREE_CHAIN (arg
);
875 /* Function pointers don't have default args. Not in standard C++,
876 anyway; they may in g++, but we'll just pretend otherwise. */
877 dump_parameters (pp
, arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
879 pp
->padding
= pp_before
;
880 pp_cxx_cv_qualifiers (pp
, type_memfn_quals (t
),
881 TREE_CODE (t
) == FUNCTION_TYPE
882 && (flags
& TFF_POINTER
));
883 dump_ref_qualifier (pp
, t
, flags
);
884 dump_exception_spec (pp
, TYPE_RAISES_EXCEPTIONS (t
), flags
);
885 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
891 pp_cxx_left_bracket (pp
);
894 tree dtype
= TYPE_DOMAIN (t
);
895 tree max
= TYPE_MAX_VALUE (dtype
);
896 if (integer_all_onesp (max
))
897 pp_character (pp
, '0');
898 else if (tree_fits_shwi_p (max
))
899 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
903 if (TREE_CODE (max
) == SAVE_EXPR
)
904 max
= TREE_OPERAND (max
, 0);
905 if (TREE_CODE (max
) == MINUS_EXPR
906 || TREE_CODE (max
) == PLUS_EXPR
)
908 max
= TREE_OPERAND (max
, 0);
909 while (CONVERT_EXPR_P (max
))
910 max
= TREE_OPERAND (max
, 0);
913 max
= fold_build2_loc (input_location
,
914 PLUS_EXPR
, dtype
, max
,
915 build_int_cst (dtype
, 1));
916 dump_expr (pp
, max
, flags
& ~TFF_EXPR_IN_PARENS
);
919 pp_cxx_right_bracket (pp
);
920 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
924 case IDENTIFIER_NODE
:
929 case TEMPLATE_TYPE_PARM
:
930 case TEMPLATE_TEMPLATE_PARM
:
931 case BOUND_TEMPLATE_TEMPLATE_PARM
:
942 case UNDERLYING_TYPE
:
944 case TYPE_PACK_EXPANSION
:
945 case FIXED_POINT_TYPE
:
950 pp_unsupported_tree (pp
, t
);
952 /* Don't mark it here, we should have already done in
959 dump_global_iord (cxx_pretty_printer
*pp
, tree t
)
961 const char *p
= NULL
;
963 if (DECL_GLOBAL_CTOR_P (t
))
964 p
= M_("(static initializers for %s)");
965 else if (DECL_GLOBAL_DTOR_P (t
))
966 p
= M_("(static destructors for %s)");
970 pp_printf (pp
, p
, LOCATION_FILE (input_location
));
974 dump_simple_decl (cxx_pretty_printer
*pp
, tree t
, tree type
, int flags
)
976 if (flags
& TFF_DECL_SPECIFIERS
)
979 && DECL_DECLARED_CONSTEXPR_P (t
))
980 pp_cxx_ws_string (pp
, "constexpr");
981 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
984 if (! (flags
& TFF_UNQUALIFIED_NAME
)
985 && TREE_CODE (t
) != PARM_DECL
986 && (!DECL_INITIAL (t
)
987 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
988 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
989 flags
&= ~TFF_UNQUALIFIED_NAME
;
990 if ((flags
& TFF_DECL_SPECIFIERS
)
991 && DECL_TEMPLATE_PARM_P (t
)
992 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
993 pp_string (pp
, "...");
996 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
999 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
1000 pp_string (pp
, " capture>");
1003 dump_decl (pp
, DECL_NAME (t
), flags
);
1006 pp_string (pp
, M_("<anonymous>"));
1007 if (flags
& TFF_DECL_SPECIFIERS
)
1008 dump_type_suffix (pp
, type
, flags
);
1011 /* Dump a human readable string for the decl T under control of FLAGS. */
1014 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1019 /* If doing Objective-C++, give Objective-C a chance to demangle
1020 Objective-C method names. */
1021 if (c_dialect_objc ())
1023 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1026 pp_string (pp
, demangled
);
1031 switch (TREE_CODE (t
))
1034 /* Don't say 'typedef class A' */
1035 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1037 if ((flags
& TFF_DECL_SPECIFIERS
)
1038 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1040 /* Say `class T' not just `T'. */
1041 pp_cxx_ws_string (pp
, "class");
1043 /* Emit the `...' for a parameter pack. */
1044 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1045 pp_cxx_ws_string (pp
, "...");
1048 dump_type (pp
, TREE_TYPE (t
), flags
);
1051 if (TYPE_DECL_ALIAS_P (t
)
1052 && (flags
& TFF_DECL_SPECIFIERS
1053 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1055 pp_cxx_ws_string (pp
, "using");
1056 dump_decl (pp
, DECL_NAME (t
), flags
);
1057 pp_cxx_whitespace (pp
);
1058 pp_cxx_ws_string (pp
, "=");
1059 pp_cxx_whitespace (pp
);
1060 dump_type (pp
, DECL_ORIGINAL_TYPE (t
), flags
);
1063 if ((flags
& TFF_DECL_SPECIFIERS
)
1064 && !DECL_SELF_REFERENCE_P (t
))
1065 pp_cxx_ws_string (pp
, "typedef");
1066 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1067 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1072 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1074 pp_string (pp
, M_("vtable for "));
1075 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1076 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1079 /* Else fall through. */
1082 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1084 /* Handle variable template specializations. */
1085 if (TREE_CODE (t
) == VAR_DECL
1086 && DECL_LANG_SPECIFIC (t
)
1087 && DECL_TEMPLATE_INFO (t
)
1088 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1090 pp_cxx_begin_template_argument_list (pp
);
1091 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1092 dump_template_argument_list (pp
, args
, flags
);
1093 pp_cxx_end_template_argument_list (pp
);
1098 pp_string (pp
, M_("<return value> "));
1099 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1102 case NAMESPACE_DECL
:
1103 if (flags
& TFF_DECL_SPECIFIERS
)
1104 pp
->declaration (t
);
1107 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1108 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1109 flags
&= ~TFF_UNQUALIFIED_NAME
;
1110 if (DECL_NAME (t
) == NULL_TREE
)
1112 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1113 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1115 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1118 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1123 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1124 pp_colon_colon (pp
);
1125 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1129 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1130 pp_cxx_left_bracket (pp
);
1131 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1132 pp_cxx_right_bracket (pp
);
1135 case ARRAY_NOTATION_REF
:
1136 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1137 pp_cxx_left_bracket (pp
);
1138 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1140 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1142 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1143 pp_cxx_right_bracket (pp
);
1146 /* So that we can do dump_decl on an aggr type. */
1150 dump_type (pp
, t
, flags
);
1154 /* This is a pseudo destructor call which has not been folded into
1155 a PSEUDO_DTOR_EXPR yet. */
1156 pp_cxx_complement (pp
);
1157 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1164 /* These special cases are duplicated here so that other functions
1165 can feed identifiers to error and get them demangled properly. */
1166 case IDENTIFIER_NODE
:
1167 if (IDENTIFIER_TYPENAME_P (t
))
1169 pp_cxx_ws_string (pp
, "operator");
1170 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1171 dump_type (pp
, TREE_TYPE (t
), flags
);
1175 pp_cxx_tree_identifier (pp
, t
);
1181 t
= OVL_CURRENT (t
);
1182 if (DECL_CLASS_SCOPE_P (t
))
1184 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1185 pp_cxx_colon_colon (pp
);
1187 else if (!DECL_FILE_SCOPE_P (t
))
1189 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1190 pp_cxx_colon_colon (pp
);
1192 dump_decl (pp
, DECL_NAME (t
), flags
);
1196 /* If there's only one function, just treat it like an ordinary
1198 t
= OVL_CURRENT (t
);
1202 if (! DECL_LANG_SPECIFIC (t
))
1204 if (DECL_ABSTRACT_ORIGIN (t
))
1205 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1207 pp_string (pp
, M_("<built-in>"));
1209 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1210 dump_global_iord (pp
, t
);
1212 dump_function_decl (pp
, t
, flags
);
1216 dump_template_decl (pp
, t
, flags
);
1219 case TEMPLATE_ID_EXPR
:
1221 tree name
= TREE_OPERAND (t
, 0);
1222 tree args
= TREE_OPERAND (t
, 1);
1224 if (is_overloaded_fn (name
))
1225 name
= get_first_fn (name
);
1227 name
= DECL_NAME (name
);
1228 dump_decl (pp
, name
, flags
);
1229 pp_cxx_begin_template_argument_list (pp
);
1230 if (args
== error_mark_node
)
1231 pp_string (pp
, M_("<template arguments error>"));
1233 dump_template_argument_list (pp
, args
, flags
);
1234 pp_cxx_end_template_argument_list (pp
);
1239 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1243 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1244 || (DECL_INITIAL (t
) &&
1245 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1246 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1247 else if (DECL_NAME (t
))
1248 dump_decl (pp
, DECL_NAME (t
), flags
);
1249 else if (DECL_INITIAL (t
))
1250 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1252 pp_string (pp
, M_("<enumerator>"));
1256 pp_cxx_ws_string (pp
, "using");
1257 dump_type (pp
, USING_DECL_SCOPE (t
), flags
);
1258 pp_cxx_colon_colon (pp
);
1259 dump_decl (pp
, DECL_NAME (t
), flags
);
1263 pp
->declaration (t
);
1267 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1270 case NON_DEPENDENT_EXPR
:
1271 dump_expr (pp
, t
, flags
);
1274 case TEMPLATE_TYPE_PARM
:
1275 if (flags
& TFF_DECL_SPECIFIERS
)
1276 pp
->declaration (t
);
1281 case UNBOUND_CLASS_TEMPLATE
:
1282 case TYPE_PACK_EXPANSION
:
1284 dump_type (pp
, t
, flags
);
1288 pp_unsupported_tree (pp
, t
);
1289 /* Fall through to error. */
1292 pp_string (pp
, M_("<declaration error>"));
1297 /* Dump a template declaration T under control of FLAGS. This means the
1298 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1301 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1303 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1307 if (flags
& TFF_TEMPLATE_HEADER
)
1309 for (parms
= orig_parms
= nreverse (orig_parms
);
1311 parms
= TREE_CHAIN (parms
))
1313 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1314 int len
= TREE_VEC_LENGTH (inner_parms
);
1316 pp_cxx_ws_string (pp
, "template");
1317 pp_cxx_begin_template_argument_list (pp
);
1319 /* If we've shown the template prefix, we'd better show the
1320 parameters' and decl's type too. */
1321 flags
|= TFF_DECL_SPECIFIERS
;
1323 for (i
= 0; i
< len
; i
++)
1326 pp_separate_with_comma (pp
);
1327 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1330 pp_cxx_end_template_argument_list (pp
);
1331 pp_cxx_whitespace (pp
);
1333 nreverse(orig_parms
);
1335 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1337 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1338 pp_cxx_ws_string (pp
, "class");
1340 /* If this is a parameter pack, print the ellipsis. */
1341 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1342 pp_cxx_ws_string (pp
, "...");
1346 if (DECL_CLASS_TEMPLATE_P (t
))
1347 dump_type (pp
, TREE_TYPE (t
),
1348 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1349 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1350 else if (DECL_TEMPLATE_RESULT (t
)
1351 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1352 /* Alias template. */
1353 || DECL_TYPE_TEMPLATE_P (t
)))
1354 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1357 gcc_assert (TREE_TYPE (t
));
1358 switch (NEXT_CODE (t
))
1362 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1365 /* This case can occur with some invalid code. */
1366 dump_type (pp
, TREE_TYPE (t
),
1367 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1368 | (flags
& TFF_DECL_SPECIFIERS
1369 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1374 /* find_typenames looks through the type of the function template T
1375 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1378 struct find_typenames_t
1380 hash_set
<tree
> *p_set
;
1381 vec
<tree
, va_gc
> *typenames
;
1385 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1387 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1388 tree mv
= NULL_TREE
;
1390 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1391 /* Add the type of the typedef without any additional cv-quals. */
1392 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1393 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1394 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1395 /* Add the typename without any cv-qualifiers. */
1396 mv
= TYPE_MAIN_VARIANT (*tp
);
1398 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1400 /* Don't mess with parameter packs since we don't remember
1401 the pack expansion context for a particular typename. */
1402 *walk_subtrees
= false;
1406 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1407 vec_safe_push (d
->typenames
, mv
);
1409 /* Search into class template arguments, which cp_walk_subtrees
1411 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1412 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1418 static vec
<tree
, va_gc
> *
1419 find_typenames (tree t
)
1421 struct find_typenames_t ft
;
1422 ft
.p_set
= new hash_set
<tree
>;
1423 ft
.typenames
= NULL
;
1424 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1425 find_typenames_r
, &ft
, ft
.p_set
);
1427 return ft
.typenames
;
1430 /* Output the "[with ...]" clause for a template instantiation T iff
1431 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1432 formatting a deduction/substitution diagnostic rather than an
1436 dump_substitution (cxx_pretty_printer
*pp
,
1437 tree t
, tree template_parms
, tree template_args
,
1440 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1441 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1443 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1444 pp_cxx_whitespace (pp
);
1445 pp_cxx_left_bracket (pp
);
1446 pp
->translate_string ("with");
1447 pp_cxx_whitespace (pp
);
1448 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1449 pp_cxx_right_bracket (pp
);
1453 /* Dump the lambda function FN including its 'mutable' qualifier and any
1454 template bindings. */
1457 dump_lambda_function (cxx_pretty_printer
*pp
,
1458 tree fn
, tree template_parms
, tree template_args
,
1461 /* A lambda's signature is essentially its "type". */
1462 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1463 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1465 pp
->padding
= pp_before
;
1466 pp_c_ws_string (pp
, "mutable");
1468 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1471 /* Pretty print a function decl. There are several ways we want to print a
1472 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1473 As error can only apply the '#' flag once to give 0 and 1 for V, there
1474 is %D which doesn't print the throw specs, and %F which does. */
1477 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1481 tree cname
= NULL_TREE
;
1482 tree template_args
= NULL_TREE
;
1483 tree template_parms
= NULL_TREE
;
1484 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1485 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1488 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1489 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1490 t
= DECL_TEMPLATE_RESULT (t
);
1492 /* Save the exceptions, in case t is a specialization and we are
1493 emitting an error about incompatible specifications. */
1494 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1496 /* Pretty print template instantiations only. */
1497 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1498 && flag_pretty_templates
)
1502 template_args
= DECL_TI_ARGS (t
);
1503 tmpl
= most_general_template (t
);
1504 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1506 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1511 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1512 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1514 fntype
= TREE_TYPE (t
);
1515 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1517 if (DECL_CLASS_SCOPE_P (t
))
1518 cname
= DECL_CONTEXT (t
);
1519 /* This is for partially instantiated template methods. */
1520 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1521 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1523 if (flags
& TFF_DECL_SPECIFIERS
)
1525 if (DECL_STATIC_FUNCTION_P (t
))
1526 pp_cxx_ws_string (pp
, "static");
1527 else if (DECL_VIRTUAL_P (t
))
1528 pp_cxx_ws_string (pp
, "virtual");
1530 if (DECL_DECLARED_CONSTEXPR_P (t
))
1531 pp_cxx_ws_string (pp
, "constexpr");
1534 /* Print the return type? */
1536 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1537 && !DECL_DESTRUCTOR_P (t
);
1540 tree ret
= fndecl_declared_return_type (t
);
1541 dump_type_prefix (pp
, ret
, flags
);
1544 /* Print the function name. */
1545 if (!do_outer_scope
)
1549 dump_type (pp
, cname
, flags
);
1550 pp_cxx_colon_colon (pp
);
1553 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1555 dump_function_name (pp
, t
, flags
);
1557 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1559 dump_parameters (pp
, parmtypes
, flags
);
1561 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1563 pp
->padding
= pp_before
;
1564 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1565 dump_ref_qualifier (pp
, fntype
, flags
);
1568 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1570 pp
->padding
= pp_before
;
1571 dump_exception_spec (pp
, exceptions
, flags
);
1575 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1577 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1579 else if (template_args
)
1581 bool need_comma
= false;
1583 pp_cxx_begin_template_argument_list (pp
);
1584 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1585 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1587 tree arg
= TREE_VEC_ELT (template_args
, i
);
1589 pp_separate_with_comma (pp
);
1590 if (ARGUMENT_PACK_P (arg
))
1591 pp_cxx_left_brace (pp
);
1592 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1593 if (ARGUMENT_PACK_P (arg
))
1594 pp_cxx_right_brace (pp
);
1597 pp_cxx_end_template_argument_list (pp
);
1601 /* Print a parameter list. If this is for a member function, the
1602 member object ptr (and any other hidden args) should have
1603 already been removed. */
1606 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1609 flags
&= ~TFF_SCOPE
;
1610 pp_cxx_left_paren (pp
);
1612 for (first
= 1; parmtypes
!= void_list_node
;
1613 parmtypes
= TREE_CHAIN (parmtypes
))
1616 pp_separate_with_comma (pp
);
1620 pp_cxx_ws_string (pp
, "...");
1624 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1626 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1628 pp_cxx_whitespace (pp
);
1630 pp_cxx_whitespace (pp
);
1631 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1635 pp_cxx_right_paren (pp
);
1638 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1641 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1643 if (FUNCTION_REF_QUALIFIED (t
))
1645 pp
->padding
= pp_before
;
1646 if (FUNCTION_RVALUE_QUALIFIED (t
))
1647 pp_cxx_ws_string (pp
, "&&");
1649 pp_cxx_ws_string (pp
, "&");
1653 /* Print an exception specification. T is the exception specification. */
1656 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1658 if (t
&& TREE_PURPOSE (t
))
1660 pp_cxx_ws_string (pp
, "noexcept");
1661 if (!integer_onep (TREE_PURPOSE (t
)))
1663 pp_cxx_whitespace (pp
);
1664 pp_cxx_left_paren (pp
);
1665 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1666 pp_cxx_ws_string (pp
, "<uninstantiated>");
1668 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1669 pp_cxx_right_paren (pp
);
1674 pp_cxx_ws_string (pp
, "throw");
1675 pp_cxx_whitespace (pp
);
1676 pp_cxx_left_paren (pp
);
1677 if (TREE_VALUE (t
) != NULL_TREE
)
1680 dump_type (pp
, TREE_VALUE (t
), flags
);
1684 pp_separate_with_comma (pp
);
1686 pp_cxx_right_paren (pp
);
1690 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1691 and destructors properly. */
1694 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1696 tree name
= DECL_NAME (t
);
1698 /* We can get here with a decl that was synthesized by language-
1699 independent machinery (e.g. coverage.c) in which case it won't
1700 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1701 will crash. In this case it is safe just to print out the
1703 if (!DECL_LANG_SPECIFIC (t
))
1705 pp_cxx_tree_identifier (pp
, name
);
1709 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1710 t
= DECL_TEMPLATE_RESULT (t
);
1712 /* Don't let the user see __comp_ctor et al. */
1713 if (DECL_CONSTRUCTOR_P (t
)
1714 || DECL_DESTRUCTOR_P (t
))
1716 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1717 name
= get_identifier ("<lambda>");
1718 else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t
)))
1719 name
= get_identifier ("<constructor>");
1721 name
= constructor_name (DECL_CONTEXT (t
));
1724 if (DECL_DESTRUCTOR_P (t
))
1726 pp_cxx_complement (pp
);
1727 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1729 else if (DECL_CONV_FN_P (t
))
1731 /* This cannot use the hack that the operator's return
1732 type is stashed off of its name because it may be
1733 used for error reporting. In the case of conflicting
1734 declarations, both will have the same name, yet
1735 the types will be different, hence the TREE_TYPE field
1736 of the first name will be clobbered by the second. */
1737 pp_cxx_ws_string (pp
, "operator");
1738 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1740 else if (name
&& IDENTIFIER_OPNAME_P (name
))
1741 pp_cxx_tree_identifier (pp
, name
);
1742 else if (name
&& UDLIT_OPER_P (name
))
1743 pp_cxx_tree_identifier (pp
, name
);
1745 dump_decl (pp
, name
, flags
);
1747 if (DECL_TEMPLATE_INFO (t
)
1748 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1749 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1750 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1751 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1755 /* Dump the template parameters from the template info INFO under control of
1756 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1757 specialization (partial or complete). For partial specializations we show
1758 the specialized parameter values. For a primary template we show no
1762 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1763 int primary
, int flags
)
1765 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1767 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1769 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1770 pp_cxx_begin_template_argument_list (pp
);
1772 /* Be careful only to print things when we have them, so as not
1773 to crash producing error messages. */
1774 if (args
&& !primary
)
1777 len
= get_non_default_template_args_count (args
, flags
);
1779 args
= INNERMOST_TEMPLATE_ARGS (args
);
1780 for (ix
= 0; ix
!= len
; ix
++)
1782 tree arg
= TREE_VEC_ELT (args
, ix
);
1784 /* Only print a comma if we know there is an argument coming. In
1785 the case of an empty template argument pack, no actual
1786 argument will be printed. */
1788 && (!ARGUMENT_PACK_P (arg
)
1789 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1790 pp_separate_with_comma (pp
);
1793 pp_string (pp
, M_("<template parameter error>"));
1795 dump_template_argument (pp
, arg
, flags
);
1800 tree tpl
= TI_TEMPLATE (info
);
1801 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1804 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1805 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1807 for (ix
= 0; ix
!= len
; ix
++)
1811 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1813 pp_string (pp
, M_("<template parameter error>"));
1817 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1820 pp_separate_with_comma (pp
);
1822 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1825 pp_cxx_end_template_argument_list (pp
);
1828 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1829 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1832 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1835 call_expr_arg_iterator iter
;
1837 pp_cxx_left_paren (pp
);
1838 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1844 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1845 if (more_call_expr_args_p (&iter
))
1846 pp_separate_with_comma (pp
);
1849 pp_cxx_right_paren (pp
);
1852 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1853 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1857 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1861 aggr_init_expr_arg_iterator iter
;
1863 pp_cxx_left_paren (pp
);
1864 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1870 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1871 if (more_aggr_init_expr_args_p (&iter
))
1872 pp_separate_with_comma (pp
);
1875 pp_cxx_right_paren (pp
);
1878 /* Print out a list of initializers (subr of dump_expr). */
1881 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1885 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1888 pp_separate_with_comma (pp
);
1892 /* Print out a vector of initializers (subr of dump_expr). */
1895 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1898 unsigned HOST_WIDE_INT idx
;
1901 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1903 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1904 if (idx
!= v
->length () - 1)
1905 pp_separate_with_comma (pp
);
1910 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1911 function. Resolve it to a close relative -- in the sense of static
1912 type -- variant being overridden. That is close to what was written in
1913 the source code. Subroutine of dump_expr. */
1916 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1918 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1919 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1920 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1923 fun
= TREE_CHAIN (fun
);
1924 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1925 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1931 /* Print out an expression E under control of FLAGS. */
1934 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
1941 if (STATEMENT_CLASS_P (t
))
1943 pp_cxx_ws_string (pp
, M_("<statement>"));
1947 switch (TREE_CODE (t
))
1955 case NAMESPACE_DECL
:
1959 case IDENTIFIER_NODE
:
1960 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
1961 |TFF_TEMPLATE_HEADER
))
1962 | TFF_NO_FUNCTION_ARGUMENTS
));
1966 if (SSA_NAME_VAR (t
)
1967 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
1968 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
1970 pp_cxx_ws_string (pp
, M_("<unknown>"));
1981 case USERDEF_LITERAL
:
1982 pp_cxx_userdef_literal (pp
, t
);
1986 /* While waiting for caret diagnostics, avoid printing
1987 __cxa_allocate_exception, __cxa_throw, and the like. */
1988 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
1993 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
1994 pp_cxx_colon_colon (pp
);
1995 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1999 pp_cxx_left_paren (pp
);
2000 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2001 pp_separate_with_comma (pp
);
2002 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2003 pp_cxx_right_paren (pp
);
2007 pp_cxx_left_paren (pp
);
2008 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2009 pp_string (pp
, " ? ");
2010 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2011 pp_string (pp
, " : ");
2012 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2013 pp_cxx_right_paren (pp
);
2017 if (TREE_HAS_CONSTRUCTOR (t
))
2019 pp_cxx_ws_string (pp
, "new");
2020 pp_cxx_whitespace (pp
);
2021 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2024 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2027 case AGGR_INIT_EXPR
:
2029 tree fn
= NULL_TREE
;
2031 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2032 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2034 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2036 if (DECL_CONSTRUCTOR_P (fn
))
2037 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2039 dump_decl (pp
, fn
, 0);
2042 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2044 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2049 tree fn
= CALL_EXPR_FN (t
);
2050 bool skipfirst
= false;
2052 /* Deal with internal functions. */
2053 if (fn
== NULL_TREE
)
2055 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2056 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2060 if (TREE_CODE (fn
) == ADDR_EXPR
)
2061 fn
= TREE_OPERAND (fn
, 0);
2063 /* Nobody is interested in seeing the guts of vcalls. */
2064 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2065 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2067 if (TREE_TYPE (fn
) != NULL_TREE
2068 && NEXT_CODE (fn
) == METHOD_TYPE
2069 && call_expr_nargs (t
))
2071 tree ob
= CALL_EXPR_ARG (t
, 0);
2072 if (TREE_CODE (ob
) == ADDR_EXPR
)
2074 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2075 flags
| TFF_EXPR_IN_PARENS
);
2078 else if (TREE_CODE (ob
) != PARM_DECL
2079 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2081 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2086 if (flag_sanitize
& SANITIZE_UNDEFINED
2087 && is_ubsan_builtin_p (fn
))
2089 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2092 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2093 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2098 /* Note that this only works for G++ target exprs. If somebody
2099 builds a general TARGET_EXPR, there's no way to represent that
2100 it initializes anything other that the parameter slot for the
2101 default argument. Note we may have cleared out the first
2102 operand in expand_expr, so don't go killing ourselves. */
2103 if (TREE_OPERAND (t
, 1))
2104 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2107 case POINTER_PLUS_EXPR
:
2108 dump_binary_op (pp
, "+", t
, flags
);
2113 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2120 case TRUNC_DIV_EXPR
:
2121 case TRUNC_MOD_EXPR
:
2129 case TRUTH_ANDIF_EXPR
:
2130 case TRUTH_ORIF_EXPR
:
2137 case EXACT_DIV_EXPR
:
2138 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2142 case FLOOR_DIV_EXPR
:
2143 case ROUND_DIV_EXPR
:
2145 dump_binary_op (pp
, "/", t
, flags
);
2149 case FLOOR_MOD_EXPR
:
2150 case ROUND_MOD_EXPR
:
2151 dump_binary_op (pp
, "%", t
, flags
);
2156 tree ob
= TREE_OPERAND (t
, 0);
2157 if (INDIRECT_REF_P (ob
))
2159 ob
= TREE_OPERAND (ob
, 0);
2160 if (TREE_CODE (ob
) != PARM_DECL
2162 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2164 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2165 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2173 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2176 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2181 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2182 pp_cxx_left_bracket (pp
);
2183 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2184 pp_cxx_right_bracket (pp
);
2187 case ARRAY_NOTATION_REF
:
2188 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2189 pp_cxx_left_bracket (pp
);
2190 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2192 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2194 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2195 pp_cxx_right_bracket (pp
);
2198 case UNARY_PLUS_EXPR
:
2199 dump_unary_op (pp
, "+", t
, flags
);
2203 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2204 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2205 /* An ADDR_EXPR can have reference type. In that case, we
2206 shouldn't print the `&' doing so indicates to the user
2207 that the expression has pointer type. */
2209 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2210 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2211 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2212 dump_unary_op (pp
, "&&", t
, flags
);
2214 dump_unary_op (pp
, "&", t
, flags
);
2218 if (TREE_HAS_CONSTRUCTOR (t
))
2220 t
= TREE_OPERAND (t
, 0);
2221 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2222 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2223 dump_call_expr_args (pp
, t
, flags
, true);
2227 if (TREE_OPERAND (t
,0) != NULL_TREE
2228 && TREE_TYPE (TREE_OPERAND (t
, 0))
2229 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2230 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2232 dump_unary_op (pp
, "*", t
, flags
);
2237 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2238 && integer_zerop (TREE_OPERAND (t
, 1)))
2239 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2243 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2245 pp_cxx_left_paren (pp
);
2246 if (!integer_onep (TYPE_SIZE_UNIT
2247 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2249 pp_cxx_left_paren (pp
);
2250 dump_type (pp
, ptr_type_node
, flags
);
2251 pp_cxx_right_paren (pp
);
2254 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2255 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2257 pp_cxx_ws_string (pp
, "+");
2258 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2260 pp_cxx_right_paren (pp
);
2267 case TRUTH_NOT_EXPR
:
2268 case PREDECREMENT_EXPR
:
2269 case PREINCREMENT_EXPR
:
2270 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2273 case POSTDECREMENT_EXPR
:
2274 case POSTINCREMENT_EXPR
:
2275 pp_cxx_left_paren (pp
);
2276 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2277 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2278 pp_cxx_right_paren (pp
);
2281 case NON_LVALUE_EXPR
:
2282 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2283 should be another level of INDIRECT_REF so that I don't have to do
2285 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2287 tree next
= TREE_TYPE (TREE_TYPE (t
));
2289 while (TYPE_PTR_P (next
))
2290 next
= TREE_TYPE (next
);
2292 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2294 if (flags
& TFF_EXPR_IN_PARENS
)
2295 pp_cxx_left_paren (pp
);
2297 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2298 if (flags
& TFF_EXPR_IN_PARENS
)
2299 pp_cxx_right_paren (pp
);
2302 /* Else fall through. */
2304 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2308 case IMPLICIT_CONV_EXPR
:
2309 case VIEW_CONVERT_EXPR
:
2311 tree op
= TREE_OPERAND (t
, 0);
2312 tree ttype
= TREE_TYPE (t
);
2313 tree optype
= TREE_TYPE (op
);
2315 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2316 && POINTER_TYPE_P (ttype
)
2317 && POINTER_TYPE_P (optype
)
2318 && same_type_p (TREE_TYPE (optype
),
2321 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2324 if (TREE_CODE (op
) == ADDR_EXPR
)
2325 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2327 dump_unary_op (pp
, "*", t
, flags
);
2330 dump_unary_op (pp
, "&", t
, flags
);
2332 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2334 /* It is a cast, but we cannot tell whether it is a
2335 reinterpret or static cast. Use the C style notation. */
2336 if (flags
& TFF_EXPR_IN_PARENS
)
2337 pp_cxx_left_paren (pp
);
2338 pp_cxx_left_paren (pp
);
2339 dump_type (pp
, TREE_TYPE (t
), flags
);
2340 pp_cxx_right_paren (pp
);
2341 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2342 if (flags
& TFF_EXPR_IN_PARENS
)
2343 pp_cxx_right_paren (pp
);
2346 dump_expr (pp
, op
, flags
);
2351 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2353 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2355 if (integer_zerop (idx
))
2357 /* A NULL pointer-to-member constant. */
2358 pp_cxx_left_paren (pp
);
2359 pp_cxx_left_paren (pp
);
2360 dump_type (pp
, TREE_TYPE (t
), flags
);
2361 pp_cxx_right_paren (pp
);
2362 pp_character (pp
, '0');
2363 pp_cxx_right_paren (pp
);
2366 else if (tree_fits_shwi_p (idx
))
2369 unsigned HOST_WIDE_INT n
;
2371 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2372 t
= TYPE_METHOD_BASETYPE (t
);
2373 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2375 n
= tree_to_shwi (idx
);
2377 /* Map vtable index back one, to allow for the null pointer to
2381 while (n
> 0 && virtuals
)
2384 virtuals
= TREE_CHAIN (virtuals
);
2388 dump_expr (pp
, BV_FN (virtuals
),
2389 flags
| TFF_EXPR_IN_PARENS
);
2394 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2395 pp_string (pp
, "<lambda closure object>");
2396 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2398 dump_type (pp
, TREE_TYPE (t
), 0);
2399 pp_cxx_left_paren (pp
);
2400 pp_cxx_right_paren (pp
);
2404 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2405 dump_type (pp
, TREE_TYPE (t
), 0);
2406 pp_cxx_left_brace (pp
);
2407 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2408 pp_cxx_right_brace (pp
);
2415 tree ob
= TREE_OPERAND (t
, 0);
2416 if (is_dummy_object (ob
))
2418 t
= TREE_OPERAND (t
, 1);
2419 if (TREE_CODE (t
) == FUNCTION_DECL
)
2421 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2422 else if (BASELINK_P (t
))
2423 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2424 flags
| TFF_EXPR_IN_PARENS
);
2426 dump_decl (pp
, t
, flags
);
2430 if (INDIRECT_REF_P (ob
))
2432 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2438 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2442 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2447 case TEMPLATE_PARM_INDEX
:
2448 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2452 if (TREE_OPERAND (t
, 0) == NULL_TREE
2453 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2455 dump_type (pp
, TREE_TYPE (t
), flags
);
2456 pp_cxx_left_paren (pp
);
2457 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2458 pp_cxx_right_paren (pp
);
2462 pp_cxx_left_paren (pp
);
2463 dump_type (pp
, TREE_TYPE (t
), flags
);
2464 pp_cxx_right_paren (pp
);
2465 pp_cxx_left_paren (pp
);
2466 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2467 pp_cxx_right_paren (pp
);
2471 case STATIC_CAST_EXPR
:
2472 pp_cxx_ws_string (pp
, "static_cast");
2474 case REINTERPRET_CAST_EXPR
:
2475 pp_cxx_ws_string (pp
, "reinterpret_cast");
2477 case CONST_CAST_EXPR
:
2478 pp_cxx_ws_string (pp
, "const_cast");
2480 case DYNAMIC_CAST_EXPR
:
2481 pp_cxx_ws_string (pp
, "dynamic_cast");
2483 pp_cxx_begin_template_argument_list (pp
);
2484 dump_type (pp
, TREE_TYPE (t
), flags
);
2485 pp_cxx_end_template_argument_list (pp
);
2486 pp_cxx_left_paren (pp
);
2487 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2488 pp_cxx_right_paren (pp
);
2492 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2498 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2499 pp_cxx_ws_string (pp
, "sizeof");
2502 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2503 pp_cxx_ws_string (pp
, "__alignof__");
2505 op
= TREE_OPERAND (t
, 0);
2506 if (PACK_EXPANSION_P (op
))
2508 pp_string (pp
, "...");
2509 op
= PACK_EXPANSION_PATTERN (op
);
2511 pp_cxx_whitespace (pp
);
2512 pp_cxx_left_paren (pp
);
2513 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2514 dump_type (pp
, TREE_TYPE (op
), flags
);
2515 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2516 dump_type (pp
, op
, flags
);
2518 dump_expr (pp
, op
, flags
);
2519 pp_cxx_right_paren (pp
);
2522 case AT_ENCODE_EXPR
:
2523 pp_cxx_ws_string (pp
, "@encode");
2524 pp_cxx_whitespace (pp
);
2525 pp_cxx_left_paren (pp
);
2526 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2527 pp_cxx_right_paren (pp
);
2531 pp_cxx_ws_string (pp
, "noexcept");
2532 pp_cxx_whitespace (pp
);
2533 pp_cxx_left_paren (pp
);
2534 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2535 pp_cxx_right_paren (pp
);
2540 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2541 pp_cxx_whitespace (pp
);
2542 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2546 pp_string (pp
, M_("<unparsed>"));
2549 case TRY_CATCH_EXPR
:
2550 case WITH_CLEANUP_EXPR
:
2551 case CLEANUP_POINT_EXPR
:
2552 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2555 case PSEUDO_DTOR_EXPR
:
2556 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2558 if (TREE_OPERAND (t
, 1))
2560 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2561 pp_cxx_colon_colon (pp
);
2563 pp_cxx_complement (pp
);
2564 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2567 case TEMPLATE_ID_EXPR
:
2568 dump_decl (pp
, t
, flags
);
2574 case STATEMENT_LIST
:
2575 /* We don't yet have a way of dumping statements in a
2576 human-readable format. */
2577 pp_string (pp
, "({...})");
2581 pp_string (pp
, "while (1) { ");
2582 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2583 pp_cxx_right_brace (pp
);
2587 pp_string (pp
, "if (");
2588 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2589 pp_string (pp
, ") break; ");
2593 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2596 case EMPTY_CLASS_EXPR
:
2597 dump_type (pp
, TREE_TYPE (t
), flags
);
2598 pp_cxx_left_paren (pp
);
2599 pp_cxx_right_paren (pp
);
2602 case NON_DEPENDENT_EXPR
:
2603 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2606 case ARGUMENT_PACK_SELECT
:
2607 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2619 pp_type_specifier_seq (pp
, t
);
2623 /* We get here when we want to print a dependent type as an
2624 id-expression, without any disambiguator decoration. */
2625 pp
->id_expression (t
);
2628 case TEMPLATE_TYPE_PARM
:
2629 case TEMPLATE_TEMPLATE_PARM
:
2630 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2631 dump_type (pp
, t
, flags
);
2635 pp_cxx_trait_expression (pp
, t
);
2639 pp_cxx_va_arg_expression (pp
, t
);
2643 pp_cxx_offsetof_expression (pp
, t
);
2647 dump_decl (pp
, t
, flags
);
2650 case EXPR_PACK_EXPANSION
:
2657 case VEC_DELETE_EXPR
:
2663 case UNORDERED_EXPR
:
2673 case FIX_TRUNC_EXPR
:
2678 case TRUTH_AND_EXPR
:
2680 case TRUTH_XOR_EXPR
:
2681 if (flags
& TFF_EXPR_IN_PARENS
)
2682 pp_cxx_left_paren (pp
);
2684 if (flags
& TFF_EXPR_IN_PARENS
)
2685 pp_cxx_right_paren (pp
);
2689 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2693 pp_string (pp
, M_("<lambda>"));
2697 pp_cxx_left_paren (pp
);
2698 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2699 pp_cxx_right_paren (pp
);
2702 case PLACEHOLDER_EXPR
:
2703 pp_string (pp
, M_("*this"));
2706 /* This list is incomplete, but should suffice for now.
2707 It is very important that `sorry' does not call
2708 `report_error_function'. That could cause an infinite loop. */
2710 pp_unsupported_tree (pp
, t
);
2711 /* fall through to ERROR_MARK... */
2713 pp_string (pp
, M_("<expression error>"));
2719 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2722 pp_cxx_left_paren (pp
);
2723 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2724 pp_cxx_whitespace (pp
);
2726 pp_cxx_ws_string (pp
, opstring
);
2728 pp_string (pp
, M_("<unknown operator>"));
2729 pp_cxx_whitespace (pp
);
2730 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2731 pp_cxx_right_paren (pp
);
2735 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2737 if (flags
& TFF_EXPR_IN_PARENS
)
2738 pp_cxx_left_paren (pp
);
2739 pp_cxx_ws_string (pp
, opstring
);
2740 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2741 if (flags
& TFF_EXPR_IN_PARENS
)
2742 pp_cxx_right_paren (pp
);
2746 reinit_cxx_pp (void)
2748 pp_clear_output_area (cxx_pp
);
2749 cxx_pp
->padding
= pp_none
;
2750 pp_indentation (cxx_pp
) = 0;
2751 pp_needs_newline (cxx_pp
) = false;
2752 cxx_pp
->enclosing_scope
= current_function_decl
;
2755 /* Same as pp_formatted_text, except the return string is a separate
2756 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2759 pp_ggc_formatted_text (pretty_printer
*pp
)
2761 return ggc_strdup (pp_formatted_text (pp
));
2764 /* Exported interface to stringifying types, exprs and decls under TFF_*
2768 type_as_string (tree typ
, int flags
)
2771 pp_translate_identifiers (cxx_pp
) = false;
2772 dump_type (cxx_pp
, typ
, flags
);
2773 return pp_ggc_formatted_text (cxx_pp
);
2777 type_as_string_translate (tree typ
, int flags
)
2780 dump_type (cxx_pp
, typ
, flags
);
2781 return pp_ggc_formatted_text (cxx_pp
);
2785 expr_as_string (tree decl
, int flags
)
2788 pp_translate_identifiers (cxx_pp
) = false;
2789 dump_expr (cxx_pp
, decl
, flags
);
2790 return pp_ggc_formatted_text (cxx_pp
);
2793 /* Wrap decl_as_string with options appropriate for dwarf. */
2796 decl_as_dwarf_string (tree decl
, int flags
)
2799 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2800 here will be adequate to get the desired behaviour. */
2801 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2802 name
= decl_as_string (decl
, flags
);
2803 /* Subsequent calls to the pretty printer shouldn't use this style. */
2804 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2809 decl_as_string (tree decl
, int flags
)
2812 pp_translate_identifiers (cxx_pp
) = false;
2813 dump_decl (cxx_pp
, decl
, flags
);
2814 return pp_ggc_formatted_text (cxx_pp
);
2818 decl_as_string_translate (tree decl
, int flags
)
2821 dump_decl (cxx_pp
, decl
, flags
);
2822 return pp_ggc_formatted_text (cxx_pp
);
2825 /* Wrap lang_decl_name with options appropriate for dwarf. */
2828 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2831 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2832 here will be adequate to get the desired behaviour. */
2833 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2834 name
= lang_decl_name (decl
, v
, translate
);
2835 /* Subsequent calls to the pretty printer shouldn't use this style. */
2836 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2840 /* Generate the three forms of printable names for cxx_printable_name. */
2843 lang_decl_name (tree decl
, int v
, bool translate
)
2847 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2848 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2851 pp_translate_identifiers (cxx_pp
) = translate
;
2853 && (DECL_CLASS_SCOPE_P (decl
)
2854 || (DECL_NAMESPACE_SCOPE_P (decl
)
2855 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2857 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2858 pp_cxx_colon_colon (cxx_pp
);
2861 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2862 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2863 else if ((DECL_NAME (decl
) == NULL_TREE
)
2864 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2865 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2867 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2869 return pp_ggc_formatted_text (cxx_pp
);
2872 /* Return the location of a tree passed to %+ formats. */
2875 location_of (tree t
)
2879 t
= TYPE_MAIN_DECL (t
);
2881 return input_location
;
2883 else if (TREE_CODE (t
) == OVERLOAD
)
2884 t
= OVL_FUNCTION (t
);
2887 return DECL_SOURCE_LOCATION (t
);
2888 return EXPR_LOC_OR_LOC (t
, input_location
);
2891 /* Now the interfaces from error et al to dump_type et al. Each takes an
2892 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2896 decl_to_string (tree decl
, int verbose
)
2900 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2901 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2902 flags
= TFF_CLASS_KEY_OR_ENUM
;
2904 flags
|= TFF_DECL_SPECIFIERS
;
2905 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2906 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2907 flags
|= TFF_TEMPLATE_HEADER
;
2910 dump_decl (cxx_pp
, decl
, flags
);
2911 return pp_ggc_formatted_text (cxx_pp
);
2915 expr_to_string (tree decl
)
2918 dump_expr (cxx_pp
, decl
, 0);
2919 return pp_ggc_formatted_text (cxx_pp
);
2923 fndecl_to_string (tree fndecl
, int verbose
)
2927 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2928 | TFF_TEMPLATE_HEADER
;
2930 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2932 dump_decl (cxx_pp
, fndecl
, flags
);
2933 return pp_ggc_formatted_text (cxx_pp
);
2938 code_to_string (enum tree_code c
)
2940 return get_tree_code_name (c
);
2944 language_to_string (enum languages c
)
2951 case lang_cplusplus
:
2963 /* Return the proper printed version of a parameter to a C++ function. */
2966 parm_to_string (int p
)
2970 pp_string (cxx_pp
, "'this'");
2972 pp_decimal_int (cxx_pp
, p
+ 1);
2973 return pp_ggc_formatted_text (cxx_pp
);
2977 op_to_string (enum tree_code p
)
2979 tree id
= operator_name_info
[p
].identifier
;
2980 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
2984 type_to_string (tree typ
, int verbose
)
2988 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2989 flags
|= TFF_TEMPLATE_HEADER
;
2992 dump_type (cxx_pp
, typ
, flags
);
2993 /* If we're printing a type that involves typedefs, also print the
2994 stripped version. But sometimes the stripped version looks
2995 exactly the same, so we don't want it after all. To avoid printing
2996 it in that case, we play ugly obstack games. */
2997 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
2998 && !uses_template_parms (typ
))
3000 int aka_start
, aka_len
; char *p
;
3001 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3002 /* Remember the end of the initial dump. */
3003 int len
= obstack_object_size (ob
);
3004 tree aka
= strip_typedefs (typ
);
3005 pp_string (cxx_pp
, " {aka");
3006 pp_cxx_whitespace (cxx_pp
);
3007 /* And remember the start of the aka dump. */
3008 aka_start
= obstack_object_size (ob
);
3009 dump_type (cxx_pp
, aka
, flags
);
3010 aka_len
= obstack_object_size (ob
) - aka_start
;
3011 pp_right_brace (cxx_pp
);
3012 p
= (char*)obstack_base (ob
);
3013 /* If they are identical, cut off the aka with a NUL. */
3014 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3017 return pp_ggc_formatted_text (cxx_pp
);
3021 assop_to_string (enum tree_code p
)
3023 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3024 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3028 args_to_string (tree p
, int verbose
)
3032 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3037 if (TYPE_P (TREE_VALUE (p
)))
3038 return type_as_string_translate (p
, flags
);
3041 for (; p
; p
= TREE_CHAIN (p
))
3043 if (TREE_VALUE (p
) == null_node
)
3044 pp_cxx_ws_string (cxx_pp
, "NULL");
3046 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3048 pp_separate_with_comma (cxx_pp
);
3050 return pp_ggc_formatted_text (cxx_pp
);
3053 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3054 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3058 subst_to_string (tree p
)
3060 tree decl
= TREE_PURPOSE (p
);
3061 tree targs
= TREE_VALUE (p
);
3062 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3063 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3064 |TFF_NO_TEMPLATE_BINDINGS
);
3070 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3071 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3072 return pp_ggc_formatted_text (cxx_pp
);
3076 cv_to_string (tree p
, int v
)
3079 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3080 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3081 return pp_ggc_formatted_text (cxx_pp
);
3085 eh_spec_to_string (tree p
, int /*v*/)
3089 dump_exception_spec (cxx_pp
, p
, flags
);
3090 return pp_ggc_formatted_text (cxx_pp
);
3093 /* Langhook for print_error_function. */
3095 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3096 diagnostic_info
*diagnostic
)
3098 lhd_print_error_function (context
, file
, diagnostic
);
3099 pp_set_prefix (context
->printer
, file
);
3100 maybe_print_instantiation_context (context
);
3104 cp_diagnostic_starter (diagnostic_context
*context
,
3105 diagnostic_info
*diagnostic
)
3107 diagnostic_report_current_module (context
, diagnostic
->location
);
3108 cp_print_error_function (context
, diagnostic
);
3109 maybe_print_instantiation_context (context
);
3110 maybe_print_constexpr_context (context
);
3111 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3115 /* Print current function onto BUFFER, in the process of reporting
3116 a diagnostic message. Called from cp_diagnostic_starter. */
3118 cp_print_error_function (diagnostic_context
*context
,
3119 diagnostic_info
*diagnostic
)
3121 /* If we are in an instantiation context, current_function_decl is likely
3122 to be wrong, so just rely on print_instantiation_full_context. */
3123 if (current_instantiation ())
3125 if (diagnostic_last_function_changed (context
, diagnostic
))
3127 const char *old_prefix
= context
->printer
->prefix
;
3128 const char *file
= LOCATION_FILE (diagnostic
->location
);
3129 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3130 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3131 ? file_name_as_prefix (context
, file
) : NULL
;
3133 pp_set_prefix (context
->printer
, new_prefix
);
3135 if (current_function_decl
== NULL
)
3136 pp_string (context
->printer
, _("At global scope:"));
3141 if (abstract_origin
)
3143 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3144 while (TREE_CODE (ao
) == BLOCK
3145 && BLOCK_ABSTRACT_ORIGIN (ao
)
3146 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3147 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3148 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3152 fndecl
= current_function_decl
;
3154 pp_printf (context
->printer
, function_category (fndecl
),
3155 cxx_printable_name_translate (fndecl
, 2));
3157 while (abstract_origin
)
3160 tree block
= abstract_origin
;
3162 locus
= &BLOCK_SOURCE_LOCATION (block
);
3164 block
= BLOCK_SUPERCONTEXT (block
);
3165 while (block
&& TREE_CODE (block
) == BLOCK
3166 && BLOCK_ABSTRACT_ORIGIN (block
))
3168 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3170 while (TREE_CODE (ao
) == BLOCK
3171 && BLOCK_ABSTRACT_ORIGIN (ao
)
3172 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3173 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3175 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3180 else if (TREE_CODE (ao
) != BLOCK
)
3183 block
= BLOCK_SUPERCONTEXT (block
);
3186 abstract_origin
= block
;
3189 while (block
&& TREE_CODE (block
) == BLOCK
)
3190 block
= BLOCK_SUPERCONTEXT (block
);
3192 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3194 abstract_origin
= NULL
;
3198 expanded_location s
= expand_location (*locus
);
3199 pp_character (context
->printer
, ',');
3200 pp_newline (context
->printer
);
3203 if (context
->show_column
&& s
.column
!= 0)
3204 pp_printf (context
->printer
,
3205 _(" inlined from %qs at %r%s:%d:%d%R"),
3206 cxx_printable_name_translate (fndecl
, 2),
3207 "locus", s
.file
, s
.line
, s
.column
);
3209 pp_printf (context
->printer
,
3210 _(" inlined from %qs at %r%s:%d%R"),
3211 cxx_printable_name_translate (fndecl
, 2),
3212 "locus", s
.file
, s
.line
);
3216 pp_printf (context
->printer
, _(" inlined from %qs"),
3217 cxx_printable_name_translate (fndecl
, 2));
3220 pp_character (context
->printer
, ':');
3222 pp_newline (context
->printer
);
3224 diagnostic_set_last_function (context
, diagnostic
);
3225 pp_destroy_prefix (context
->printer
);
3226 context
->printer
->prefix
= old_prefix
;
3230 /* Returns a description of FUNCTION using standard terminology. The
3231 result is a format string of the form "In CATEGORY %qs". */
3233 function_category (tree fn
)
3235 /* We can get called from the middle-end for diagnostics of function
3236 clones. Make sure we have language specific information before
3237 dereferencing it. */
3238 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3239 && DECL_FUNCTION_MEMBER_P (fn
))
3241 if (DECL_STATIC_FUNCTION_P (fn
))
3242 return _("In static member function %qs");
3243 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3244 return _("In copy constructor %qs");
3245 else if (DECL_CONSTRUCTOR_P (fn
))
3246 return _("In constructor %qs");
3247 else if (DECL_DESTRUCTOR_P (fn
))
3248 return _("In destructor %qs");
3249 else if (LAMBDA_FUNCTION_P (fn
))
3250 return _("In lambda function");
3252 return _("In member function %qs");
3255 return _("In function %qs");
3258 /* Report the full context of a current template instantiation,
3261 print_instantiation_full_context (diagnostic_context
*context
)
3263 struct tinst_level
*p
= current_instantiation ();
3264 location_t location
= input_location
;
3268 pp_verbatim (context
->printer
,
3269 TREE_CODE (p
->decl
) == TREE_LIST
3270 ? _("%s: In substitution of %qS:\n")
3271 : _("%s: In instantiation of %q#D:\n"),
3272 LOCATION_FILE (location
),
3275 location
= p
->locus
;
3279 print_instantiation_partial_context (context
, p
, location
);
3282 /* Helper function of print_instantiation_partial_context() that
3283 prints a single line of instantiation context. */
3286 print_instantiation_partial_context_line (diagnostic_context
*context
,
3287 const struct tinst_level
*t
,
3288 location_t loc
, bool recursive_p
)
3290 if (loc
== UNKNOWN_LOCATION
)
3293 expanded_location xloc
= expand_location (loc
);
3295 if (context
->show_column
)
3296 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3297 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3299 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3300 "locus", xloc
.file
, xloc
.line
);
3304 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3305 pp_verbatim (context
->printer
,
3307 ? _("recursively required by substitution of %qS\n")
3308 : _("required by substitution of %qS\n"),
3311 pp_verbatim (context
->printer
,
3313 ? _("recursively required from %q#D\n")
3314 : _("required from %q#D\n"),
3319 pp_verbatim (context
->printer
,
3321 ? _("recursively required from here")
3322 : _("required from here"));
3326 /* Same as print_instantiation_full_context but less verbose. */
3329 print_instantiation_partial_context (diagnostic_context
*context
,
3330 struct tinst_level
*t0
, location_t loc
)
3332 struct tinst_level
*t
;
3335 location_t prev_loc
= loc
;
3337 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3338 if (prev_loc
!= t
->locus
)
3340 prev_loc
= t
->locus
;
3346 if (template_backtrace_limit
3347 && n_total
> template_backtrace_limit
)
3349 int skip
= n_total
- template_backtrace_limit
;
3350 int head
= template_backtrace_limit
/ 2;
3352 /* Avoid skipping just 1. If so, skip 2. */
3356 head
= (template_backtrace_limit
- 1) / 2;
3359 for (n
= 0; n
< head
; n
++)
3361 gcc_assert (t
!= NULL
);
3362 if (loc
!= t
->locus
)
3363 print_instantiation_partial_context_line (context
, t
, loc
,
3364 /*recursive_p=*/false);
3368 if (t
!= NULL
&& skip
> 0)
3370 expanded_location xloc
;
3371 xloc
= expand_location (loc
);
3372 if (context
->show_column
)
3373 pp_verbatim (context
->printer
,
3374 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3375 "contexts, use -ftemplate-backtrace-limit=0 to "
3377 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3379 pp_verbatim (context
->printer
,
3380 _("%r%s:%d:%R [ skipping %d instantiation "
3381 "contexts, use -ftemplate-backtrace-limit=0 to "
3383 "locus", xloc
.file
, xloc
.line
, skip
);
3388 } while (t
!= NULL
&& --skip
> 0);
3394 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3399 print_instantiation_partial_context_line (context
, t
, loc
,
3404 print_instantiation_partial_context_line (context
, NULL
, loc
,
3405 /*recursive_p=*/false);
3406 pp_newline (context
->printer
);
3409 /* Called from cp_thing to print the template context for an error. */
3411 maybe_print_instantiation_context (diagnostic_context
*context
)
3413 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3416 record_last_problematic_instantiation ();
3417 print_instantiation_full_context (context
);
3420 /* Report what constexpr call(s) we're trying to expand, if any. */
3423 maybe_print_constexpr_context (diagnostic_context
*context
)
3425 vec
<tree
> call_stack
= cx_error_context ();
3429 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3431 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3432 const char *s
= expr_as_string (t
, 0);
3433 if (context
->show_column
)
3434 pp_verbatim (context
->printer
,
3435 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3436 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3438 pp_verbatim (context
->printer
,
3439 _("%r%s:%d:%R in constexpr expansion of %qs"),
3440 "locus", xloc
.file
, xloc
.line
, s
);
3441 pp_newline (context
->printer
);
3445 /* Called from output_format -- during diagnostic message processing --
3446 to handle C++ specific format specifier with the following meanings:
3447 %A function argument-list.
3451 %F function declaration.
3452 %L language as used in extern "lang".
3454 %P function parameter whose position is indicated by an integer.
3455 %Q assignment operator.
3456 %S substitution (template + args)
3459 %X exception-specification. */
3461 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3462 int precision
, bool wide
, bool set_locus
, bool verbose
)
3466 #define next_tree (t = va_arg (*text->args_ptr, tree))
3467 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3468 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3469 #define next_int va_arg (*text->args_ptr, int)
3471 if (precision
!= 0 || wide
)
3474 if (text
->locus
== NULL
)
3479 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3480 case 'C': result
= code_to_string (next_tcode
); break;
3483 tree temp
= next_tree
;
3485 && DECL_HAS_DEBUG_EXPR_P (temp
))
3487 temp
= DECL_DEBUG_EXPR (temp
);
3490 result
= expr_to_string (temp
);
3494 result
= decl_to_string (temp
, verbose
);
3497 case 'E': result
= expr_to_string (next_tree
); break;
3498 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3499 case 'L': result
= language_to_string (next_lang
); break;
3500 case 'O': result
= op_to_string (next_tcode
); break;
3501 case 'P': result
= parm_to_string (next_int
); break;
3502 case 'Q': result
= assop_to_string (next_tcode
); break;
3503 case 'S': result
= subst_to_string (next_tree
); break;
3504 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3505 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3506 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3509 percent_K_format (text
);
3516 pp_string (pp
, result
);
3517 if (set_locus
&& t
!= NULL
)
3518 *text
->locus
= location_of (t
);
3526 /* Warn about the use of C++0x features when appropriate. */
3528 maybe_warn_cpp0x (cpp0x_warn_str str
)
3530 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3531 /* We really want to suppress this warning in system headers,
3532 because libstdc++ uses variadic templates even when we aren't
3536 case CPP0X_INITIALIZER_LISTS
:
3537 pedwarn (input_location
, 0,
3538 "extended initializer lists "
3539 "only available with -std=c++11 or -std=gnu++11");
3541 case CPP0X_EXPLICIT_CONVERSION
:
3542 pedwarn (input_location
, 0,
3543 "explicit conversion operators "
3544 "only available with -std=c++11 or -std=gnu++11");
3546 case CPP0X_VARIADIC_TEMPLATES
:
3547 pedwarn (input_location
, 0,
3548 "variadic templates "
3549 "only available with -std=c++11 or -std=gnu++11");
3551 case CPP0X_LAMBDA_EXPR
:
3552 pedwarn (input_location
, 0,
3553 "lambda expressions "
3554 "only available with -std=c++11 or -std=gnu++11");
3557 pedwarn (input_location
, 0,
3558 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3560 case CPP0X_SCOPED_ENUMS
:
3561 pedwarn (input_location
, 0,
3562 "scoped enums only available with -std=c++11 or -std=gnu++11");
3564 case CPP0X_DEFAULTED_DELETED
:
3565 pedwarn (input_location
, 0,
3566 "defaulted and deleted functions "
3567 "only available with -std=c++11 or -std=gnu++11");
3569 case CPP0X_INLINE_NAMESPACES
:
3570 pedwarn (input_location
, OPT_Wpedantic
,
3571 "inline namespaces "
3572 "only available with -std=c++11 or -std=gnu++11");
3574 case CPP0X_OVERRIDE_CONTROLS
:
3575 pedwarn (input_location
, 0,
3576 "override controls (override/final) "
3577 "only available with -std=c++11 or -std=gnu++11");
3580 pedwarn (input_location
, 0,
3581 "non-static data member initializers "
3582 "only available with -std=c++11 or -std=gnu++11");
3584 case CPP0X_USER_DEFINED_LITERALS
:
3585 pedwarn (input_location
, 0,
3586 "user-defined literals "
3587 "only available with -std=c++11 or -std=gnu++11");
3589 case CPP0X_DELEGATING_CTORS
:
3590 pedwarn (input_location
, 0,
3591 "delegating constructors "
3592 "only available with -std=c++11 or -std=gnu++11");
3594 case CPP0X_INHERITING_CTORS
:
3595 pedwarn (input_location
, 0,
3596 "inheriting constructors "
3597 "only available with -std=c++11 or -std=gnu++11");
3599 case CPP0X_ATTRIBUTES
:
3600 pedwarn (input_location
, 0,
3602 "only available with -std=c++11 or -std=gnu++11");
3604 case CPP0X_REF_QUALIFIER
:
3605 pedwarn (input_location
, 0,
3607 "only available with -std=c++11 or -std=gnu++11");
3614 /* Warn about the use of variadic templates when appropriate. */
3616 maybe_warn_variadic_templates (void)
3618 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3622 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3623 option OPT with text GMSGID. Use this function to report
3624 diagnostics for constructs that are invalid C++98, but valid
3627 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3629 diagnostic_info diagnostic
;
3633 va_start (ap
, gmsgid
);
3634 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, location
,
3635 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3636 diagnostic
.option_index
= opt
;
3637 ret
= report_diagnostic (&diagnostic
);
3642 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3643 we found when we tried to do the lookup. LOCATION is the location of
3644 the NAME identifier. */
3647 qualified_name_lookup_error (tree scope
, tree name
,
3648 tree decl
, location_t location
)
3650 if (scope
== error_mark_node
)
3651 ; /* We already complained. */
3652 else if (TYPE_P (scope
))
3654 if (!COMPLETE_TYPE_P (scope
))
3655 error_at (location
, "incomplete type %qT used in nested name specifier",
3657 else if (TREE_CODE (decl
) == TREE_LIST
)
3659 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3661 print_candidates (decl
);
3664 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3666 else if (scope
!= global_namespace
)
3668 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3669 suggest_alternatives_for (location
, name
);
3673 error_at (location
, "%<::%D%> has not been declared", name
);
3674 suggest_alternatives_for (location
, name
);