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"
26 #include "stringpool.h"
29 #include "diagnostic.h"
30 #include "tree-diagnostic.h"
31 #include "langhooks-def.h"
33 #include "cxx-pretty-print.h"
34 #include "tree-pretty-print.h"
35 #include "c-family/c-objc.h"
37 #include "internal-fn.h"
39 #include <new> // For placement-new.
41 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
42 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
44 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
45 dump C++ ASTs as strings. It is mostly used only by the various
46 tree -> string functions that are occasionally called from the
47 debugger or by the front-end for things like
48 __PRETTY_FUNCTION__. */
49 static cxx_pretty_printer actual_pretty_printer
;
50 static cxx_pretty_printer
* const cxx_pp
= &actual_pretty_printer
;
52 /* Translate if being used for diagnostics, but not for dump files or
54 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
56 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
58 static const char *args_to_string (tree
, int);
59 static const char *assop_to_string (enum tree_code
);
60 static const char *code_to_string (enum tree_code
);
61 static const char *cv_to_string (tree
, int);
62 static const char *decl_to_string (tree
, int);
63 static const char *expr_to_string (tree
);
64 static const char *fndecl_to_string (tree
, int);
65 static const char *op_to_string (enum tree_code
);
66 static const char *parm_to_string (int);
67 static const char *type_to_string (tree
, int);
69 static void dump_alias_template_specialization (cxx_pretty_printer
*, tree
, int);
70 static void dump_type (cxx_pretty_printer
*, tree
, int);
71 static void dump_typename (cxx_pretty_printer
*, tree
, int);
72 static void dump_simple_decl (cxx_pretty_printer
*, tree
, tree
, int);
73 static void dump_decl (cxx_pretty_printer
*, tree
, int);
74 static void dump_template_decl (cxx_pretty_printer
*, tree
, int);
75 static void dump_function_decl (cxx_pretty_printer
*, tree
, int);
76 static void dump_expr (cxx_pretty_printer
*, tree
, int);
77 static void dump_unary_op (cxx_pretty_printer
*, const char *, tree
, int);
78 static void dump_binary_op (cxx_pretty_printer
*, const char *, tree
, int);
79 static void dump_aggr_type (cxx_pretty_printer
*, tree
, int);
80 static void dump_type_prefix (cxx_pretty_printer
*, tree
, int);
81 static void dump_type_suffix (cxx_pretty_printer
*, tree
, int);
82 static void dump_function_name (cxx_pretty_printer
*, tree
, int);
83 static void dump_call_expr_args (cxx_pretty_printer
*, tree
, int, bool);
84 static void dump_aggr_init_expr_args (cxx_pretty_printer
*, tree
, int, bool);
85 static void dump_expr_list (cxx_pretty_printer
*, tree
, int);
86 static void dump_global_iord (cxx_pretty_printer
*, tree
);
87 static void dump_parameters (cxx_pretty_printer
*, tree
, int);
88 static void dump_ref_qualifier (cxx_pretty_printer
*, tree
, int);
89 static void dump_exception_spec (cxx_pretty_printer
*, tree
, int);
90 static void dump_template_argument (cxx_pretty_printer
*, tree
, int);
91 static void dump_template_argument_list (cxx_pretty_printer
*, tree
, int);
92 static void dump_template_parameter (cxx_pretty_printer
*, tree
, int);
93 static void dump_template_bindings (cxx_pretty_printer
*, tree
, tree
,
95 static void dump_scope (cxx_pretty_printer
*, tree
, int);
96 static void dump_template_parms (cxx_pretty_printer
*, tree
, int, int);
97 static int get_non_default_template_args_count (tree
, int);
98 static const char *function_category (tree
);
99 static void maybe_print_constexpr_context (diagnostic_context
*);
100 static void maybe_print_instantiation_context (diagnostic_context
*);
101 static void print_instantiation_full_context (diagnostic_context
*);
102 static void print_instantiation_partial_context (diagnostic_context
*,
103 struct tinst_level
*,
105 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
106 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
108 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
109 int, bool, bool, bool);
111 /* CONTEXT->printer is a basic pretty printer that was constructed
112 presumably by diagnostic_initialize(), called early in the
113 compiler's initialization process (in general_init) Before the FE
114 is initialized. This (C++) FE-specific diagnostic initializer is
115 thus replacing the basic pretty printer with one that has C++-aware
119 cxx_initialize_diagnostics (diagnostic_context
*context
)
121 pretty_printer
*base
= context
->printer
;
122 cxx_pretty_printer
*pp
= XNEW (cxx_pretty_printer
);
123 context
->printer
= new (pp
) cxx_pretty_printer ();
125 /* It is safe to free this object because it was previously XNEW()'d. */
126 base
->~pretty_printer ();
129 c_common_diagnostics_set_defaults (context
);
130 diagnostic_starter (context
) = cp_diagnostic_starter
;
131 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
132 diagnostic_format_decoder (context
) = cp_printer
;
135 /* Dump a scope, if deemed necessary. */
138 dump_scope (cxx_pretty_printer
*pp
, tree scope
, int flags
)
140 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
142 if (scope
== NULL_TREE
)
145 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
147 if (scope
!= global_namespace
)
149 dump_decl (pp
, scope
, f
);
150 pp_cxx_colon_colon (pp
);
153 else if (AGGREGATE_TYPE_P (scope
))
155 dump_type (pp
, scope
, f
);
156 pp_cxx_colon_colon (pp
);
158 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
160 dump_function_decl (pp
, scope
, f
);
161 pp_cxx_colon_colon (pp
);
165 /* Dump the template ARGument under control of FLAGS. */
168 dump_template_argument (cxx_pretty_printer
*pp
, tree arg
, int flags
)
170 if (ARGUMENT_PACK_P (arg
))
171 dump_template_argument_list (pp
, ARGUMENT_PACK_ARGS (arg
),
172 /* No default args in argument packs. */
173 flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
174 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
175 dump_type (pp
, arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
178 if (TREE_CODE (arg
) == TREE_LIST
)
179 arg
= TREE_VALUE (arg
);
181 dump_expr (pp
, arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
185 /* Count the number of template arguments ARGS whose value does not
186 match the (optional) default template parameter in PARAMS */
189 get_non_default_template_args_count (tree args
, int flags
)
191 int n
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args
));
193 if (/* We use this flag when generating debug information. We don't
194 want to expand templates at this point, for this may generate
195 new decls, which gets decl counts out of sync, which may in
196 turn cause codegen differences between compilations with and
198 (flags
& TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
) != 0
199 || !flag_pretty_templates
)
202 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args
));
205 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
209 dump_template_argument_list (cxx_pretty_printer
*pp
, tree args
, int flags
)
211 int n
= get_non_default_template_args_count (args
, flags
);
215 for (i
= 0; i
< n
; ++i
)
217 tree arg
= TREE_VEC_ELT (args
, i
);
219 /* Only print a comma if we know there is an argument coming. In
220 the case of an empty template argument pack, no actual
221 argument will be printed. */
223 && (!ARGUMENT_PACK_P (arg
)
224 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
225 pp_separate_with_comma (pp
);
227 dump_template_argument (pp
, arg
, flags
);
232 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
235 dump_template_parameter (cxx_pretty_printer
*pp
, tree parm
, int flags
)
240 if (parm
== error_mark_node
)
243 p
= TREE_VALUE (parm
);
244 a
= TREE_PURPOSE (parm
);
246 if (TREE_CODE (p
) == TYPE_DECL
)
248 if (flags
& TFF_DECL_SPECIFIERS
)
250 pp_cxx_ws_string (pp
, "class");
251 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
252 pp_cxx_ws_string (pp
, "...");
254 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
256 else if (DECL_NAME (p
))
257 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
259 pp_cxx_canonical_template_parameter (pp
, TREE_TYPE (p
));
262 dump_decl (pp
, p
, flags
| TFF_DECL_SPECIFIERS
);
264 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
266 pp_cxx_whitespace (pp
);
268 pp_cxx_whitespace (pp
);
269 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
270 dump_type (pp
, a
, flags
& ~TFF_CHASE_TYPEDEF
);
272 dump_expr (pp
, a
, flags
| TFF_EXPR_IN_PARENS
);
276 /* Dump, under control of FLAGS, a template-parameter-list binding.
277 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
281 dump_template_bindings (cxx_pretty_printer
*pp
, tree parms
, tree args
,
282 vec
<tree
, va_gc
> *typenames
)
284 bool need_semicolon
= false;
290 tree p
= TREE_VALUE (parms
);
291 int lvl
= TMPL_PARMS_DEPTH (parms
);
294 tree lvl_args
= NULL_TREE
;
296 /* Don't crash if we had an invalid argument list. */
297 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
298 lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
300 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
302 tree arg
= NULL_TREE
;
304 /* Don't crash if we had an invalid argument list. */
305 if (lvl_args
&& NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
306 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
309 pp_separate_with_semicolon (pp
);
310 dump_template_parameter (pp
, TREE_VEC_ELT (p
, i
),
311 TFF_PLAIN_IDENTIFIER
);
312 pp_cxx_whitespace (pp
);
314 pp_cxx_whitespace (pp
);
317 if (ARGUMENT_PACK_P (arg
))
318 pp_cxx_left_brace (pp
);
319 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
320 if (ARGUMENT_PACK_P (arg
))
321 pp_cxx_right_brace (pp
);
324 pp_string (pp
, M_("<missing>"));
327 need_semicolon
= true;
330 parms
= TREE_CHAIN (parms
);
333 /* Don't bother with typenames for a partial instantiation. */
334 if (vec_safe_is_empty (typenames
) || uses_template_parms (args
))
337 /* Don't try to print typenames when we're processing a clone. */
338 if (current_function_decl
339 && !DECL_LANG_SPECIFIC (current_function_decl
))
342 FOR_EACH_VEC_SAFE_ELT (typenames
, i
, t
)
345 pp_separate_with_semicolon (pp
);
346 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
347 pp_cxx_whitespace (pp
);
349 pp_cxx_whitespace (pp
);
350 push_deferring_access_checks (dk_no_check
);
351 t
= tsubst (t
, args
, tf_none
, NULL_TREE
);
352 pop_deferring_access_checks ();
353 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
354 pp_simple_type_specifier doesn't know about it. */
355 t
= strip_typedefs (t
);
356 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
360 /* Dump a human-readable equivalent of the alias template
361 specialization of T. */
364 dump_alias_template_specialization (cxx_pretty_printer
*pp
, tree t
, int flags
)
368 gcc_assert (alias_template_specialization_p (t
));
370 if (!(flags
& TFF_UNQUALIFIED_NAME
))
371 dump_scope (pp
, CP_DECL_CONTEXT (TYPE_NAME (t
)), flags
);
372 name
= TYPE_IDENTIFIER (t
);
373 pp_cxx_tree_identifier (pp
, name
);
374 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
376 flags
& ~TFF_TEMPLATE_HEADER
);
379 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
383 dump_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
388 /* Don't print e.g. "struct mytypedef". */
389 if (TYPE_P (t
) && typedef_variant_p (t
))
391 tree decl
= TYPE_NAME (t
);
392 if ((flags
& TFF_CHASE_TYPEDEF
)
393 || DECL_SELF_REFERENCE_P (decl
)
394 || (!flag_pretty_templates
395 && DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)))
396 t
= strip_typedefs (t
);
397 else if (alias_template_specialization_p (t
))
399 dump_alias_template_specialization (pp
, t
, flags
);
402 else if (same_type_p (t
, TREE_TYPE (decl
)))
406 pp_cxx_cv_qualifier_seq (pp
, t
);
407 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
412 if (TYPE_PTRMEMFUNC_P (t
))
415 switch (TREE_CODE (t
))
418 if (t
== init_list_type_node
)
419 pp_string (pp
, M_("<brace-enclosed initializer list>"));
420 else if (t
== unknown_type_node
)
421 pp_string (pp
, M_("<unresolved overloaded function type>"));
424 pp_cxx_cv_qualifier_seq (pp
, t
);
425 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
430 /* A list of function parms. */
431 dump_parameters (pp
, t
, flags
);
434 case IDENTIFIER_NODE
:
435 pp_cxx_tree_identifier (pp
, t
);
439 dump_type (pp
, BINFO_TYPE (t
), flags
);
445 dump_aggr_type (pp
, t
, flags
);
449 if (flags
& TFF_CHASE_TYPEDEF
)
451 dump_type (pp
, DECL_ORIGINAL_TYPE (t
)
452 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
455 /* Else fall through. */
459 dump_decl (pp
, t
, flags
& ~TFF_DECL_SPECIFIERS
);
468 case FIXED_POINT_TYPE
:
469 pp_type_specifier_seq (pp
, t
);
472 case TEMPLATE_TEMPLATE_PARM
:
473 /* For parameters inside template signature. */
474 if (TYPE_IDENTIFIER (t
))
475 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
477 pp_cxx_canonical_template_parameter (pp
, t
);
480 case BOUND_TEMPLATE_TEMPLATE_PARM
:
482 tree args
= TYPE_TI_ARGS (t
);
483 pp_cxx_cv_qualifier_seq (pp
, t
);
484 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
485 pp_cxx_begin_template_argument_list (pp
);
486 dump_template_argument_list (pp
, args
, flags
);
487 pp_cxx_end_template_argument_list (pp
);
491 case TEMPLATE_TYPE_PARM
:
492 pp_cxx_cv_qualifier_seq (pp
, t
);
493 if (TYPE_IDENTIFIER (t
))
494 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
496 pp_cxx_canonical_template_parameter
497 (pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
500 /* This is not always necessary for pointers and such, but doing this
501 reduces code size. */
510 dump_type_prefix (pp
, t
, flags
);
511 dump_type_suffix (pp
, t
, flags
);
515 if (! (flags
& TFF_CHASE_TYPEDEF
)
516 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
518 dump_decl (pp
, TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
521 pp_cxx_cv_qualifier_seq (pp
, t
);
522 pp_cxx_ws_string (pp
,
523 TYPENAME_IS_ENUM_P (t
) ? "enum"
524 : TYPENAME_IS_CLASS_P (t
) ? "class"
526 dump_typename (pp
, t
, flags
);
529 case UNBOUND_CLASS_TEMPLATE
:
530 if (! (flags
& TFF_UNQUALIFIED_NAME
))
532 dump_type (pp
, TYPE_CONTEXT (t
), flags
);
533 pp_cxx_colon_colon (pp
);
535 pp_cxx_ws_string (pp
, "template");
536 dump_type (pp
, TYPE_IDENTIFIER (t
), flags
);
540 pp_cxx_ws_string (pp
, "__typeof__");
541 pp_cxx_whitespace (pp
);
542 pp_cxx_left_paren (pp
);
543 dump_expr (pp
, TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
544 pp_cxx_right_paren (pp
);
547 case UNDERLYING_TYPE
:
548 pp_cxx_ws_string (pp
, "__underlying_type");
549 pp_cxx_whitespace (pp
);
550 pp_cxx_left_paren (pp
);
551 dump_expr (pp
, UNDERLYING_TYPE_TYPE (t
), flags
& ~TFF_EXPR_IN_PARENS
);
552 pp_cxx_right_paren (pp
);
555 case TYPE_PACK_EXPANSION
:
556 dump_type (pp
, PACK_EXPANSION_PATTERN (t
), flags
);
557 pp_cxx_ws_string (pp
, "...");
560 case TYPE_ARGUMENT_PACK
:
561 dump_template_argument (pp
, t
, flags
);
565 pp_cxx_ws_string (pp
, "decltype");
566 pp_cxx_whitespace (pp
);
567 pp_cxx_left_paren (pp
);
568 dump_expr (pp
, DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
569 pp_cxx_right_paren (pp
);
573 pp_string (pp
, "std::nullptr_t");
577 pp_unsupported_tree (pp
, t
);
578 /* Fall through to error. */
581 pp_string (pp
, M_("<type error>"));
586 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
590 dump_typename (cxx_pretty_printer
*pp
, tree t
, int flags
)
592 tree ctx
= TYPE_CONTEXT (t
);
594 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
595 dump_typename (pp
, ctx
, flags
);
597 dump_type (pp
, ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
598 pp_cxx_colon_colon (pp
);
599 dump_decl (pp
, TYPENAME_TYPE_FULLNAME (t
), flags
);
602 /* Return the name of the supplied aggregate, or enumeral type. */
605 class_key_or_enum_as_string (tree t
)
607 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
609 if (SCOPED_ENUM_P (t
))
614 else if (TREE_CODE (t
) == UNION_TYPE
)
616 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
622 /* Print out a class declaration T under the control of FLAGS,
623 in the form `class foo'. */
626 dump_aggr_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
629 const char *variety
= class_key_or_enum_as_string (t
);
633 pp_cxx_cv_qualifier_seq (pp
, t
);
635 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
636 pp_cxx_ws_string (pp
, variety
);
638 name
= TYPE_NAME (t
);
642 typdef
= (!DECL_ARTIFICIAL (name
)
643 /* An alias specialization is not considered to be a
645 && !alias_template_specialization_p (t
));
648 && ((flags
& TFF_CHASE_TYPEDEF
)
649 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
650 && DECL_TEMPLATE_INFO (name
))))
651 || DECL_SELF_REFERENCE_P (name
))
653 t
= TYPE_MAIN_VARIANT (t
);
654 name
= TYPE_NAME (t
);
658 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
659 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
660 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
661 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
663 if (! (flags
& TFF_UNQUALIFIED_NAME
))
664 dump_scope (pp
, CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
665 flags
&= ~TFF_UNQUALIFIED_NAME
;
668 /* Because the template names are mangled, we have to locate
669 the most general template, and use that name. */
670 tree tpl
= TYPE_TI_TEMPLATE (t
);
672 while (DECL_TEMPLATE_INFO (tpl
))
673 tpl
= DECL_TI_TEMPLATE (tpl
);
676 name
= DECL_NAME (name
);
679 if (name
== 0 || anon_aggrname_p (name
))
681 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
682 pp_string (pp
, M_("<anonymous>"));
684 pp_printf (pp
, M_("<anonymous %s>"), variety
);
686 else if (LAMBDA_TYPE_P (t
))
688 /* A lambda's "type" is essentially its signature. */
689 pp_string (pp
, M_("<lambda"));
690 if (lambda_function (t
))
692 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
697 pp_cxx_tree_identifier (pp
, name
);
699 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
700 !CLASSTYPE_USE_TEMPLATE (t
),
701 flags
& ~TFF_TEMPLATE_HEADER
);
704 /* Dump into the obstack the initial part of the output for a given type.
705 This is necessary when dealing with things like functions returning
708 return type of `int (* fee ())()': pointer -> function -> int. Both
709 pointer (and reference and offset) and function (and member) types must
710 deal with prefix and suffix.
712 Arrays must also do this for DECL nodes, like int a[], and for things like
716 dump_type_prefix (cxx_pretty_printer
*pp
, tree t
, int flags
)
718 if (TYPE_PTRMEMFUNC_P (t
))
720 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
724 switch (TREE_CODE (t
))
729 tree sub
= TREE_TYPE (t
);
731 dump_type_prefix (pp
, sub
, flags
);
732 if (TREE_CODE (sub
) == ARRAY_TYPE
733 || TREE_CODE (sub
) == FUNCTION_TYPE
)
735 pp_cxx_whitespace (pp
);
736 pp_cxx_left_paren (pp
);
737 pp_c_attributes_display (pp
, TYPE_ATTRIBUTES (sub
));
741 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
743 if (TYPE_REF_IS_RVALUE (t
))
744 pp_ampersand_ampersand (pp
);
748 pp
->padding
= pp_before
;
749 pp_cxx_cv_qualifier_seq (pp
, t
);
755 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
756 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
759 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
760 pp_cxx_left_paren (pp
);
761 dump_type (pp
, TYPE_OFFSET_BASETYPE (t
), flags
);
762 pp_cxx_colon_colon (pp
);
765 pp_cxx_cv_qualifier_seq (pp
, t
);
766 pp
->padding
= pp_before
;
769 /* This can be reached without a pointer when dealing with
770 templates, e.g. std::is_function. */
772 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
776 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
778 pp_cxx_left_paren (pp
);
779 dump_aggr_type (pp
, TYPE_METHOD_BASETYPE (t
), flags
);
780 pp_cxx_colon_colon (pp
);
784 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
788 case IDENTIFIER_NODE
:
793 case TEMPLATE_TYPE_PARM
:
794 case TEMPLATE_TEMPLATE_PARM
:
795 case BOUND_TEMPLATE_TEMPLATE_PARM
:
806 case UNDERLYING_TYPE
:
808 case TYPE_PACK_EXPANSION
:
809 case FIXED_POINT_TYPE
:
811 dump_type (pp
, t
, flags
);
812 pp
->padding
= pp_before
;
816 pp_unsupported_tree (pp
, t
);
819 pp_string (pp
, M_("<typeprefixerror>"));
824 /* Dump the suffix of type T, under control of FLAGS. This is the part
825 which appears after the identifier (or function parms). */
828 dump_type_suffix (cxx_pretty_printer
*pp
, tree t
, int flags
)
830 if (TYPE_PTRMEMFUNC_P (t
))
831 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
833 switch (TREE_CODE (t
))
838 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
839 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
840 pp_cxx_right_paren (pp
);
841 if (TREE_CODE (t
) == POINTER_TYPE
)
842 flags
|= TFF_POINTER
;
843 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
850 if (TREE_CODE (t
) == METHOD_TYPE
)
851 /* Can only be reached through a pointer. */
852 pp_cxx_right_paren (pp
);
853 arg
= TYPE_ARG_TYPES (t
);
854 if (TREE_CODE (t
) == METHOD_TYPE
)
855 arg
= TREE_CHAIN (arg
);
857 /* Function pointers don't have default args. Not in standard C++,
858 anyway; they may in g++, but we'll just pretend otherwise. */
859 dump_parameters (pp
, arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
861 pp
->padding
= pp_before
;
862 pp_cxx_cv_qualifiers (pp
, type_memfn_quals (t
),
863 TREE_CODE (t
) == FUNCTION_TYPE
864 && (flags
& TFF_POINTER
));
865 dump_ref_qualifier (pp
, t
, flags
);
866 dump_exception_spec (pp
, TYPE_RAISES_EXCEPTIONS (t
), flags
);
867 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
873 pp_cxx_left_bracket (pp
);
876 tree dtype
= TYPE_DOMAIN (t
);
877 tree max
= TYPE_MAX_VALUE (dtype
);
878 if (integer_all_onesp (max
))
879 pp_character (pp
, '0');
880 else if (tree_fits_shwi_p (max
))
881 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
885 if (TREE_CODE (max
) == SAVE_EXPR
)
886 max
= TREE_OPERAND (max
, 0);
887 if (TREE_CODE (max
) == MINUS_EXPR
888 || TREE_CODE (max
) == PLUS_EXPR
)
890 max
= TREE_OPERAND (max
, 0);
891 while (CONVERT_EXPR_P (max
))
892 max
= TREE_OPERAND (max
, 0);
895 max
= fold_build2_loc (input_location
,
896 PLUS_EXPR
, dtype
, max
,
897 build_int_cst (dtype
, 1));
898 dump_expr (pp
, max
, flags
& ~TFF_EXPR_IN_PARENS
);
901 pp_cxx_right_bracket (pp
);
902 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
906 case IDENTIFIER_NODE
:
911 case TEMPLATE_TYPE_PARM
:
912 case TEMPLATE_TEMPLATE_PARM
:
913 case BOUND_TEMPLATE_TEMPLATE_PARM
:
924 case UNDERLYING_TYPE
:
926 case TYPE_PACK_EXPANSION
:
927 case FIXED_POINT_TYPE
:
932 pp_unsupported_tree (pp
, t
);
934 /* Don't mark it here, we should have already done in
941 dump_global_iord (cxx_pretty_printer
*pp
, tree t
)
943 const char *p
= NULL
;
945 if (DECL_GLOBAL_CTOR_P (t
))
946 p
= M_("(static initializers for %s)");
947 else if (DECL_GLOBAL_DTOR_P (t
))
948 p
= M_("(static destructors for %s)");
952 pp_printf (pp
, p
, LOCATION_FILE (input_location
));
956 dump_simple_decl (cxx_pretty_printer
*pp
, tree t
, tree type
, int flags
)
958 if (flags
& TFF_DECL_SPECIFIERS
)
961 && DECL_DECLARED_CONSTEXPR_P (t
))
962 pp_cxx_ws_string (pp
, "constexpr");
963 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
966 if (! (flags
& TFF_UNQUALIFIED_NAME
)
967 && TREE_CODE (t
) != PARM_DECL
968 && (!DECL_INITIAL (t
)
969 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
970 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
971 flags
&= ~TFF_UNQUALIFIED_NAME
;
972 if ((flags
& TFF_DECL_SPECIFIERS
)
973 && DECL_TEMPLATE_PARM_P (t
)
974 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
975 pp_string (pp
, "...");
978 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
981 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
982 pp_string (pp
, " capture>");
985 dump_decl (pp
, DECL_NAME (t
), flags
);
988 pp_string (pp
, M_("<anonymous>"));
989 if (flags
& TFF_DECL_SPECIFIERS
)
990 dump_type_suffix (pp
, type
, flags
);
993 /* Dump a human readable string for the decl T under control of FLAGS. */
996 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1001 /* If doing Objective-C++, give Objective-C a chance to demangle
1002 Objective-C method names. */
1003 if (c_dialect_objc ())
1005 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1008 pp_string (pp
, demangled
);
1013 switch (TREE_CODE (t
))
1016 /* Don't say 'typedef class A' */
1017 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1019 if ((flags
& TFF_DECL_SPECIFIERS
)
1020 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1022 /* Say `class T' not just `T'. */
1023 pp_cxx_ws_string (pp
, "class");
1025 /* Emit the `...' for a parameter pack. */
1026 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1027 pp_cxx_ws_string (pp
, "...");
1030 dump_type (pp
, TREE_TYPE (t
), flags
);
1033 if (TYPE_DECL_ALIAS_P (t
)
1034 && (flags
& TFF_DECL_SPECIFIERS
1035 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1037 pp_cxx_ws_string (pp
, "using");
1038 dump_decl (pp
, DECL_NAME (t
), flags
);
1039 pp_cxx_whitespace (pp
);
1040 pp_cxx_ws_string (pp
, "=");
1041 pp_cxx_whitespace (pp
);
1042 dump_type (pp
, DECL_ORIGINAL_TYPE (t
), flags
);
1045 if ((flags
& TFF_DECL_SPECIFIERS
)
1046 && !DECL_SELF_REFERENCE_P (t
))
1047 pp_cxx_ws_string (pp
, "typedef");
1048 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1049 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1054 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1056 pp_string (pp
, M_("vtable for "));
1057 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1058 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1061 /* Else fall through. */
1064 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1066 /* Handle variable template specializations. */
1068 && DECL_LANG_SPECIFIC (t
)
1069 && DECL_TEMPLATE_INFO (t
)
1070 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1072 pp_cxx_begin_template_argument_list (pp
);
1073 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1074 dump_template_argument_list (pp
, args
, flags
);
1075 pp_cxx_end_template_argument_list (pp
);
1080 pp_string (pp
, M_("<return value> "));
1081 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1084 case NAMESPACE_DECL
:
1085 if (flags
& TFF_DECL_SPECIFIERS
)
1086 pp
->declaration (t
);
1089 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1090 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1091 flags
&= ~TFF_UNQUALIFIED_NAME
;
1092 if (DECL_NAME (t
) == NULL_TREE
)
1094 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1095 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1097 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1100 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1105 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1106 pp_colon_colon (pp
);
1107 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1111 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1112 pp_cxx_left_bracket (pp
);
1113 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1114 pp_cxx_right_bracket (pp
);
1117 case ARRAY_NOTATION_REF
:
1118 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1119 pp_cxx_left_bracket (pp
);
1120 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1122 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1124 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1125 pp_cxx_right_bracket (pp
);
1128 /* So that we can do dump_decl on an aggr type. */
1132 dump_type (pp
, t
, flags
);
1136 /* This is a pseudo destructor call which has not been folded into
1137 a PSEUDO_DTOR_EXPR yet. */
1138 pp_cxx_complement (pp
);
1139 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1146 /* These special cases are duplicated here so that other functions
1147 can feed identifiers to error and get them demangled properly. */
1148 case IDENTIFIER_NODE
:
1149 if (IDENTIFIER_TYPENAME_P (t
))
1151 pp_cxx_ws_string (pp
, "operator");
1152 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1153 dump_type (pp
, TREE_TYPE (t
), flags
);
1157 pp_cxx_tree_identifier (pp
, t
);
1163 t
= OVL_CURRENT (t
);
1164 if (DECL_CLASS_SCOPE_P (t
))
1166 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1167 pp_cxx_colon_colon (pp
);
1169 else if (!DECL_FILE_SCOPE_P (t
))
1171 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1172 pp_cxx_colon_colon (pp
);
1174 dump_decl (pp
, DECL_NAME (t
), flags
);
1178 /* If there's only one function, just treat it like an ordinary
1180 t
= OVL_CURRENT (t
);
1184 if (! DECL_LANG_SPECIFIC (t
))
1186 if (DECL_ABSTRACT_ORIGIN (t
))
1187 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1189 pp_string (pp
, M_("<built-in>"));
1191 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1192 dump_global_iord (pp
, t
);
1194 dump_function_decl (pp
, t
, flags
);
1198 dump_template_decl (pp
, t
, flags
);
1201 case TEMPLATE_ID_EXPR
:
1203 tree name
= TREE_OPERAND (t
, 0);
1204 tree args
= TREE_OPERAND (t
, 1);
1206 if (is_overloaded_fn (name
))
1207 name
= get_first_fn (name
);
1209 name
= DECL_NAME (name
);
1210 dump_decl (pp
, name
, flags
);
1211 pp_cxx_begin_template_argument_list (pp
);
1212 if (args
== error_mark_node
)
1213 pp_string (pp
, M_("<template arguments error>"));
1215 dump_template_argument_list (pp
, args
, flags
);
1216 pp_cxx_end_template_argument_list (pp
);
1221 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1225 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1226 || (DECL_INITIAL (t
) &&
1227 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1228 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1229 else if (DECL_NAME (t
))
1230 dump_decl (pp
, DECL_NAME (t
), flags
);
1231 else if (DECL_INITIAL (t
))
1232 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1234 pp_string (pp
, M_("<enumerator>"));
1238 pp_cxx_ws_string (pp
, "using");
1239 dump_type (pp
, USING_DECL_SCOPE (t
), flags
);
1240 pp_cxx_colon_colon (pp
);
1241 dump_decl (pp
, DECL_NAME (t
), flags
);
1245 pp
->declaration (t
);
1249 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1252 case NON_DEPENDENT_EXPR
:
1253 dump_expr (pp
, t
, flags
);
1256 case TEMPLATE_TYPE_PARM
:
1257 if (flags
& TFF_DECL_SPECIFIERS
)
1258 pp
->declaration (t
);
1263 case UNBOUND_CLASS_TEMPLATE
:
1264 case TYPE_PACK_EXPANSION
:
1266 dump_type (pp
, t
, flags
);
1270 pp_unsupported_tree (pp
, t
);
1271 /* Fall through to error. */
1274 pp_string (pp
, M_("<declaration error>"));
1279 /* Dump a template declaration T under control of FLAGS. This means the
1280 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1283 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1285 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1289 if (flags
& TFF_TEMPLATE_HEADER
)
1291 for (parms
= orig_parms
= nreverse (orig_parms
);
1293 parms
= TREE_CHAIN (parms
))
1295 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1296 int len
= TREE_VEC_LENGTH (inner_parms
);
1298 pp_cxx_ws_string (pp
, "template");
1299 pp_cxx_begin_template_argument_list (pp
);
1301 /* If we've shown the template prefix, we'd better show the
1302 parameters' and decl's type too. */
1303 flags
|= TFF_DECL_SPECIFIERS
;
1305 for (i
= 0; i
< len
; i
++)
1308 pp_separate_with_comma (pp
);
1309 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1312 pp_cxx_end_template_argument_list (pp
);
1313 pp_cxx_whitespace (pp
);
1315 nreverse(orig_parms
);
1317 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1319 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1320 pp_cxx_ws_string (pp
, "class");
1322 /* If this is a parameter pack, print the ellipsis. */
1323 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1324 pp_cxx_ws_string (pp
, "...");
1328 if (DECL_CLASS_TEMPLATE_P (t
))
1329 dump_type (pp
, TREE_TYPE (t
),
1330 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1331 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1332 else if (DECL_TEMPLATE_RESULT (t
)
1333 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1334 /* Alias template. */
1335 || DECL_TYPE_TEMPLATE_P (t
)))
1336 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1339 gcc_assert (TREE_TYPE (t
));
1340 switch (NEXT_CODE (t
))
1344 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1347 /* This case can occur with some invalid code. */
1348 dump_type (pp
, TREE_TYPE (t
),
1349 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1350 | (flags
& TFF_DECL_SPECIFIERS
1351 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1356 /* find_typenames looks through the type of the function template T
1357 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1360 struct find_typenames_t
1362 hash_set
<tree
> *p_set
;
1363 vec
<tree
, va_gc
> *typenames
;
1367 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1369 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1370 tree mv
= NULL_TREE
;
1372 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1373 /* Add the type of the typedef without any additional cv-quals. */
1374 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1375 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1376 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1377 /* Add the typename without any cv-qualifiers. */
1378 mv
= TYPE_MAIN_VARIANT (*tp
);
1380 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1382 /* Don't mess with parameter packs since we don't remember
1383 the pack expansion context for a particular typename. */
1384 *walk_subtrees
= false;
1388 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1389 vec_safe_push (d
->typenames
, mv
);
1391 /* Search into class template arguments, which cp_walk_subtrees
1393 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1394 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1400 static vec
<tree
, va_gc
> *
1401 find_typenames (tree t
)
1403 struct find_typenames_t ft
;
1404 ft
.p_set
= new hash_set
<tree
>;
1405 ft
.typenames
= NULL
;
1406 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1407 find_typenames_r
, &ft
, ft
.p_set
);
1409 return ft
.typenames
;
1412 /* Output the "[with ...]" clause for a template instantiation T iff
1413 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1414 formatting a deduction/substitution diagnostic rather than an
1418 dump_substitution (cxx_pretty_printer
*pp
,
1419 tree t
, tree template_parms
, tree template_args
,
1422 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1423 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1425 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1426 pp_cxx_whitespace (pp
);
1427 pp_cxx_left_bracket (pp
);
1428 pp
->translate_string ("with");
1429 pp_cxx_whitespace (pp
);
1430 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1431 pp_cxx_right_bracket (pp
);
1435 /* Dump the lambda function FN including its 'mutable' qualifier and any
1436 template bindings. */
1439 dump_lambda_function (cxx_pretty_printer
*pp
,
1440 tree fn
, tree template_parms
, tree template_args
,
1443 /* A lambda's signature is essentially its "type". */
1444 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1445 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1447 pp
->padding
= pp_before
;
1448 pp_c_ws_string (pp
, "mutable");
1450 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1453 /* Pretty print a function decl. There are several ways we want to print a
1454 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1455 As error can only apply the '#' flag once to give 0 and 1 for V, there
1456 is %D which doesn't print the throw specs, and %F which does. */
1459 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1463 tree cname
= NULL_TREE
;
1464 tree template_args
= NULL_TREE
;
1465 tree template_parms
= NULL_TREE
;
1466 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1467 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1470 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1471 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1472 t
= DECL_TEMPLATE_RESULT (t
);
1474 /* Save the exceptions, in case t is a specialization and we are
1475 emitting an error about incompatible specifications. */
1476 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1478 /* Pretty print template instantiations only. */
1479 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1480 && flag_pretty_templates
)
1484 template_args
= DECL_TI_ARGS (t
);
1485 tmpl
= most_general_template (t
);
1486 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1488 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1493 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1494 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1496 fntype
= TREE_TYPE (t
);
1497 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1499 if (DECL_CLASS_SCOPE_P (t
))
1500 cname
= DECL_CONTEXT (t
);
1501 /* This is for partially instantiated template methods. */
1502 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1503 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1505 if (flags
& TFF_DECL_SPECIFIERS
)
1507 if (DECL_STATIC_FUNCTION_P (t
))
1508 pp_cxx_ws_string (pp
, "static");
1509 else if (DECL_VIRTUAL_P (t
))
1510 pp_cxx_ws_string (pp
, "virtual");
1512 if (DECL_DECLARED_CONSTEXPR_P (t
))
1513 pp_cxx_ws_string (pp
, "constexpr");
1516 /* Print the return type? */
1518 show_return
= !DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1519 && !DECL_DESTRUCTOR_P (t
);
1522 tree ret
= fndecl_declared_return_type (t
);
1523 dump_type_prefix (pp
, ret
, flags
);
1526 /* Print the function name. */
1527 if (!do_outer_scope
)
1531 dump_type (pp
, cname
, flags
);
1532 pp_cxx_colon_colon (pp
);
1535 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1537 dump_function_name (pp
, t
, flags
);
1539 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1541 dump_parameters (pp
, parmtypes
, flags
);
1543 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1545 pp
->padding
= pp_before
;
1546 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1547 dump_ref_qualifier (pp
, fntype
, flags
);
1550 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1552 pp
->padding
= pp_before
;
1553 dump_exception_spec (pp
, exceptions
, flags
);
1557 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1559 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1561 else if (template_args
)
1563 bool need_comma
= false;
1565 pp_cxx_begin_template_argument_list (pp
);
1566 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1567 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1569 tree arg
= TREE_VEC_ELT (template_args
, i
);
1571 pp_separate_with_comma (pp
);
1572 if (ARGUMENT_PACK_P (arg
))
1573 pp_cxx_left_brace (pp
);
1574 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1575 if (ARGUMENT_PACK_P (arg
))
1576 pp_cxx_right_brace (pp
);
1579 pp_cxx_end_template_argument_list (pp
);
1583 /* Print a parameter list. If this is for a member function, the
1584 member object ptr (and any other hidden args) should have
1585 already been removed. */
1588 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1591 flags
&= ~TFF_SCOPE
;
1592 pp_cxx_left_paren (pp
);
1594 for (first
= 1; parmtypes
!= void_list_node
;
1595 parmtypes
= TREE_CHAIN (parmtypes
))
1598 pp_separate_with_comma (pp
);
1602 pp_cxx_ws_string (pp
, "...");
1606 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1608 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1610 pp_cxx_whitespace (pp
);
1612 pp_cxx_whitespace (pp
);
1613 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1617 pp_cxx_right_paren (pp
);
1620 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1623 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1625 if (FUNCTION_REF_QUALIFIED (t
))
1627 pp
->padding
= pp_before
;
1628 if (FUNCTION_RVALUE_QUALIFIED (t
))
1629 pp_cxx_ws_string (pp
, "&&");
1631 pp_cxx_ws_string (pp
, "&");
1635 /* Print an exception specification. T is the exception specification. */
1638 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1640 if (t
&& TREE_PURPOSE (t
))
1642 pp_cxx_ws_string (pp
, "noexcept");
1643 if (!integer_onep (TREE_PURPOSE (t
)))
1645 pp_cxx_whitespace (pp
);
1646 pp_cxx_left_paren (pp
);
1647 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1648 pp_cxx_ws_string (pp
, "<uninstantiated>");
1650 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1651 pp_cxx_right_paren (pp
);
1656 pp_cxx_ws_string (pp
, "throw");
1657 pp_cxx_whitespace (pp
);
1658 pp_cxx_left_paren (pp
);
1659 if (TREE_VALUE (t
) != NULL_TREE
)
1662 dump_type (pp
, TREE_VALUE (t
), flags
);
1666 pp_separate_with_comma (pp
);
1668 pp_cxx_right_paren (pp
);
1672 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1673 and destructors properly. */
1676 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1678 tree name
= DECL_NAME (t
);
1680 /* We can get here with a decl that was synthesized by language-
1681 independent machinery (e.g. coverage.c) in which case it won't
1682 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1683 will crash. In this case it is safe just to print out the
1685 if (!DECL_LANG_SPECIFIC (t
))
1687 pp_cxx_tree_identifier (pp
, name
);
1691 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1692 t
= DECL_TEMPLATE_RESULT (t
);
1694 /* Don't let the user see __comp_ctor et al. */
1695 if (DECL_CONSTRUCTOR_P (t
)
1696 || DECL_DESTRUCTOR_P (t
))
1698 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1699 name
= get_identifier ("<lambda>");
1700 else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t
)))
1701 name
= get_identifier ("<constructor>");
1703 name
= constructor_name (DECL_CONTEXT (t
));
1706 if (DECL_DESTRUCTOR_P (t
))
1708 pp_cxx_complement (pp
);
1709 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1711 else if (DECL_CONV_FN_P (t
))
1713 /* This cannot use the hack that the operator's return
1714 type is stashed off of its name because it may be
1715 used for error reporting. In the case of conflicting
1716 declarations, both will have the same name, yet
1717 the types will be different, hence the TREE_TYPE field
1718 of the first name will be clobbered by the second. */
1719 pp_cxx_ws_string (pp
, "operator");
1720 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1722 else if (name
&& IDENTIFIER_OPNAME_P (name
))
1723 pp_cxx_tree_identifier (pp
, name
);
1724 else if (name
&& UDLIT_OPER_P (name
))
1725 pp_cxx_tree_identifier (pp
, name
);
1727 dump_decl (pp
, name
, flags
);
1729 if (DECL_TEMPLATE_INFO (t
)
1730 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1731 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1732 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1733 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1737 /* Dump the template parameters from the template info INFO under control of
1738 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1739 specialization (partial or complete). For partial specializations we show
1740 the specialized parameter values. For a primary template we show no
1744 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1745 int primary
, int flags
)
1747 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1749 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1751 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1752 pp_cxx_begin_template_argument_list (pp
);
1754 /* Be careful only to print things when we have them, so as not
1755 to crash producing error messages. */
1756 if (args
&& !primary
)
1759 len
= get_non_default_template_args_count (args
, flags
);
1761 args
= INNERMOST_TEMPLATE_ARGS (args
);
1762 for (ix
= 0; ix
!= len
; ix
++)
1764 tree arg
= TREE_VEC_ELT (args
, ix
);
1766 /* Only print a comma if we know there is an argument coming. In
1767 the case of an empty template argument pack, no actual
1768 argument will be printed. */
1770 && (!ARGUMENT_PACK_P (arg
)
1771 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1772 pp_separate_with_comma (pp
);
1775 pp_string (pp
, M_("<template parameter error>"));
1777 dump_template_argument (pp
, arg
, flags
);
1782 tree tpl
= TI_TEMPLATE (info
);
1783 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1786 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1787 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1789 for (ix
= 0; ix
!= len
; ix
++)
1793 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1795 pp_string (pp
, M_("<template parameter error>"));
1799 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1802 pp_separate_with_comma (pp
);
1804 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1807 pp_cxx_end_template_argument_list (pp
);
1810 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1811 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1814 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1817 call_expr_arg_iterator iter
;
1819 pp_cxx_left_paren (pp
);
1820 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1826 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1827 if (more_call_expr_args_p (&iter
))
1828 pp_separate_with_comma (pp
);
1831 pp_cxx_right_paren (pp
);
1834 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1835 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1839 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1843 aggr_init_expr_arg_iterator iter
;
1845 pp_cxx_left_paren (pp
);
1846 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1852 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1853 if (more_aggr_init_expr_args_p (&iter
))
1854 pp_separate_with_comma (pp
);
1857 pp_cxx_right_paren (pp
);
1860 /* Print out a list of initializers (subr of dump_expr). */
1863 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1867 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1870 pp_separate_with_comma (pp
);
1874 /* Print out a vector of initializers (subr of dump_expr). */
1877 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1880 unsigned HOST_WIDE_INT idx
;
1883 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1885 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1886 if (idx
!= v
->length () - 1)
1887 pp_separate_with_comma (pp
);
1892 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1893 function. Resolve it to a close relative -- in the sense of static
1894 type -- variant being overridden. That is close to what was written in
1895 the source code. Subroutine of dump_expr. */
1898 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1900 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1901 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1902 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1905 fun
= TREE_CHAIN (fun
);
1906 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1907 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1913 /* Print out an expression E under control of FLAGS. */
1916 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
1923 if (STATEMENT_CLASS_P (t
))
1925 pp_cxx_ws_string (pp
, M_("<statement>"));
1929 switch (TREE_CODE (t
))
1937 case NAMESPACE_DECL
:
1941 case IDENTIFIER_NODE
:
1942 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
1943 |TFF_TEMPLATE_HEADER
))
1944 | TFF_NO_FUNCTION_ARGUMENTS
));
1948 if (SSA_NAME_VAR (t
)
1949 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
1950 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
1952 pp_cxx_ws_string (pp
, M_("<unknown>"));
1963 case USERDEF_LITERAL
:
1964 pp_cxx_userdef_literal (pp
, t
);
1968 /* While waiting for caret diagnostics, avoid printing
1969 __cxa_allocate_exception, __cxa_throw, and the like. */
1970 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
1975 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
1976 pp_cxx_colon_colon (pp
);
1977 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
1981 pp_cxx_left_paren (pp
);
1982 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1983 pp_separate_with_comma (pp
);
1984 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1985 pp_cxx_right_paren (pp
);
1989 pp_cxx_left_paren (pp
);
1990 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
1991 pp_string (pp
, " ? ");
1992 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
1993 pp_string (pp
, " : ");
1994 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
1995 pp_cxx_right_paren (pp
);
1999 if (TREE_HAS_CONSTRUCTOR (t
))
2001 pp_cxx_ws_string (pp
, "new");
2002 pp_cxx_whitespace (pp
);
2003 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2006 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2009 case AGGR_INIT_EXPR
:
2011 tree fn
= NULL_TREE
;
2013 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2014 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2016 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2018 if (DECL_CONSTRUCTOR_P (fn
))
2019 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2021 dump_decl (pp
, fn
, 0);
2024 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2026 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2031 tree fn
= CALL_EXPR_FN (t
);
2032 bool skipfirst
= false;
2034 /* Deal with internal functions. */
2035 if (fn
== NULL_TREE
)
2037 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2038 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2042 if (TREE_CODE (fn
) == ADDR_EXPR
)
2043 fn
= TREE_OPERAND (fn
, 0);
2045 /* Nobody is interested in seeing the guts of vcalls. */
2046 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2047 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2049 if (TREE_TYPE (fn
) != NULL_TREE
2050 && NEXT_CODE (fn
) == METHOD_TYPE
2051 && call_expr_nargs (t
))
2053 tree ob
= CALL_EXPR_ARG (t
, 0);
2054 if (TREE_CODE (ob
) == ADDR_EXPR
)
2056 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2057 flags
| TFF_EXPR_IN_PARENS
);
2060 else if (TREE_CODE (ob
) != PARM_DECL
2061 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2063 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2068 if (flag_sanitize
& SANITIZE_UNDEFINED
2069 && is_ubsan_builtin_p (fn
))
2071 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2074 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2075 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2080 /* Note that this only works for G++ target exprs. If somebody
2081 builds a general TARGET_EXPR, there's no way to represent that
2082 it initializes anything other that the parameter slot for the
2083 default argument. Note we may have cleared out the first
2084 operand in expand_expr, so don't go killing ourselves. */
2085 if (TREE_OPERAND (t
, 1))
2086 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2089 case POINTER_PLUS_EXPR
:
2090 dump_binary_op (pp
, "+", t
, flags
);
2095 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2102 case TRUNC_DIV_EXPR
:
2103 case TRUNC_MOD_EXPR
:
2111 case TRUTH_ANDIF_EXPR
:
2112 case TRUTH_ORIF_EXPR
:
2119 case EXACT_DIV_EXPR
:
2120 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2124 case FLOOR_DIV_EXPR
:
2125 case ROUND_DIV_EXPR
:
2127 dump_binary_op (pp
, "/", t
, flags
);
2131 case FLOOR_MOD_EXPR
:
2132 case ROUND_MOD_EXPR
:
2133 dump_binary_op (pp
, "%", t
, flags
);
2138 tree ob
= TREE_OPERAND (t
, 0);
2139 if (INDIRECT_REF_P (ob
))
2141 ob
= TREE_OPERAND (ob
, 0);
2142 if (TREE_CODE (ob
) != PARM_DECL
2144 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2146 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2147 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2155 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2158 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2163 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2164 pp_cxx_left_bracket (pp
);
2165 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2166 pp_cxx_right_bracket (pp
);
2169 case ARRAY_NOTATION_REF
:
2170 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2171 pp_cxx_left_bracket (pp
);
2172 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2174 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2176 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2177 pp_cxx_right_bracket (pp
);
2180 case UNARY_PLUS_EXPR
:
2181 dump_unary_op (pp
, "+", t
, flags
);
2185 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2186 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2187 /* An ADDR_EXPR can have reference type. In that case, we
2188 shouldn't print the `&' doing so indicates to the user
2189 that the expression has pointer type. */
2191 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2192 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2193 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2194 dump_unary_op (pp
, "&&", t
, flags
);
2196 dump_unary_op (pp
, "&", t
, flags
);
2200 if (TREE_HAS_CONSTRUCTOR (t
))
2202 t
= TREE_OPERAND (t
, 0);
2203 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2204 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2205 dump_call_expr_args (pp
, t
, flags
, true);
2209 if (TREE_OPERAND (t
,0) != NULL_TREE
2210 && TREE_TYPE (TREE_OPERAND (t
, 0))
2211 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2212 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2214 dump_unary_op (pp
, "*", t
, flags
);
2219 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2220 && integer_zerop (TREE_OPERAND (t
, 1)))
2221 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2225 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2227 pp_cxx_left_paren (pp
);
2228 if (!integer_onep (TYPE_SIZE_UNIT
2229 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2231 pp_cxx_left_paren (pp
);
2232 dump_type (pp
, ptr_type_node
, flags
);
2233 pp_cxx_right_paren (pp
);
2236 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2237 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2239 pp_cxx_ws_string (pp
, "+");
2240 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2242 pp_cxx_right_paren (pp
);
2249 case TRUTH_NOT_EXPR
:
2250 case PREDECREMENT_EXPR
:
2251 case PREINCREMENT_EXPR
:
2252 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2255 case POSTDECREMENT_EXPR
:
2256 case POSTINCREMENT_EXPR
:
2257 pp_cxx_left_paren (pp
);
2258 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2259 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2260 pp_cxx_right_paren (pp
);
2263 case NON_LVALUE_EXPR
:
2264 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2265 should be another level of INDIRECT_REF so that I don't have to do
2267 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2269 tree next
= TREE_TYPE (TREE_TYPE (t
));
2271 while (TYPE_PTR_P (next
))
2272 next
= TREE_TYPE (next
);
2274 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2276 if (flags
& TFF_EXPR_IN_PARENS
)
2277 pp_cxx_left_paren (pp
);
2279 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2280 if (flags
& TFF_EXPR_IN_PARENS
)
2281 pp_cxx_right_paren (pp
);
2284 /* Else fall through. */
2286 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2290 case IMPLICIT_CONV_EXPR
:
2291 case VIEW_CONVERT_EXPR
:
2293 tree op
= TREE_OPERAND (t
, 0);
2294 tree ttype
= TREE_TYPE (t
);
2295 tree optype
= TREE_TYPE (op
);
2297 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2298 && POINTER_TYPE_P (ttype
)
2299 && POINTER_TYPE_P (optype
)
2300 && same_type_p (TREE_TYPE (optype
),
2303 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2306 if (TREE_CODE (op
) == ADDR_EXPR
)
2307 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2309 dump_unary_op (pp
, "*", t
, flags
);
2312 dump_unary_op (pp
, "&", t
, flags
);
2314 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2316 /* It is a cast, but we cannot tell whether it is a
2317 reinterpret or static cast. Use the C style notation. */
2318 if (flags
& TFF_EXPR_IN_PARENS
)
2319 pp_cxx_left_paren (pp
);
2320 pp_cxx_left_paren (pp
);
2321 dump_type (pp
, TREE_TYPE (t
), flags
);
2322 pp_cxx_right_paren (pp
);
2323 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2324 if (flags
& TFF_EXPR_IN_PARENS
)
2325 pp_cxx_right_paren (pp
);
2328 dump_expr (pp
, op
, flags
);
2333 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2335 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2337 if (integer_zerop (idx
))
2339 /* A NULL pointer-to-member constant. */
2340 pp_cxx_left_paren (pp
);
2341 pp_cxx_left_paren (pp
);
2342 dump_type (pp
, TREE_TYPE (t
), flags
);
2343 pp_cxx_right_paren (pp
);
2344 pp_character (pp
, '0');
2345 pp_cxx_right_paren (pp
);
2348 else if (tree_fits_shwi_p (idx
))
2351 unsigned HOST_WIDE_INT n
;
2353 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2354 t
= TYPE_METHOD_BASETYPE (t
);
2355 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2357 n
= tree_to_shwi (idx
);
2359 /* Map vtable index back one, to allow for the null pointer to
2363 while (n
> 0 && virtuals
)
2366 virtuals
= TREE_CHAIN (virtuals
);
2370 dump_expr (pp
, BV_FN (virtuals
),
2371 flags
| TFF_EXPR_IN_PARENS
);
2376 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2377 pp_string (pp
, "<lambda closure object>");
2378 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2380 dump_type (pp
, TREE_TYPE (t
), 0);
2381 pp_cxx_left_paren (pp
);
2382 pp_cxx_right_paren (pp
);
2386 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2387 dump_type (pp
, TREE_TYPE (t
), 0);
2388 pp_cxx_left_brace (pp
);
2389 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2390 pp_cxx_right_brace (pp
);
2397 tree ob
= TREE_OPERAND (t
, 0);
2398 if (is_dummy_object (ob
))
2400 t
= TREE_OPERAND (t
, 1);
2401 if (TREE_CODE (t
) == FUNCTION_DECL
)
2403 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2404 else if (BASELINK_P (t
))
2405 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2406 flags
| TFF_EXPR_IN_PARENS
);
2408 dump_decl (pp
, t
, flags
);
2412 if (INDIRECT_REF_P (ob
))
2414 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2420 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2424 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2429 case TEMPLATE_PARM_INDEX
:
2430 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2434 if (TREE_OPERAND (t
, 0) == NULL_TREE
2435 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2437 dump_type (pp
, TREE_TYPE (t
), flags
);
2438 pp_cxx_left_paren (pp
);
2439 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2440 pp_cxx_right_paren (pp
);
2444 pp_cxx_left_paren (pp
);
2445 dump_type (pp
, TREE_TYPE (t
), flags
);
2446 pp_cxx_right_paren (pp
);
2447 pp_cxx_left_paren (pp
);
2448 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2449 pp_cxx_right_paren (pp
);
2453 case STATIC_CAST_EXPR
:
2454 pp_cxx_ws_string (pp
, "static_cast");
2456 case REINTERPRET_CAST_EXPR
:
2457 pp_cxx_ws_string (pp
, "reinterpret_cast");
2459 case CONST_CAST_EXPR
:
2460 pp_cxx_ws_string (pp
, "const_cast");
2462 case DYNAMIC_CAST_EXPR
:
2463 pp_cxx_ws_string (pp
, "dynamic_cast");
2465 pp_cxx_begin_template_argument_list (pp
);
2466 dump_type (pp
, TREE_TYPE (t
), flags
);
2467 pp_cxx_end_template_argument_list (pp
);
2468 pp_cxx_left_paren (pp
);
2469 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2470 pp_cxx_right_paren (pp
);
2474 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2480 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2481 pp_cxx_ws_string (pp
, "sizeof");
2484 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2485 pp_cxx_ws_string (pp
, "__alignof__");
2487 op
= TREE_OPERAND (t
, 0);
2488 if (PACK_EXPANSION_P (op
))
2490 pp_string (pp
, "...");
2491 op
= PACK_EXPANSION_PATTERN (op
);
2493 pp_cxx_whitespace (pp
);
2494 pp_cxx_left_paren (pp
);
2495 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2496 dump_type (pp
, TREE_TYPE (op
), flags
);
2497 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2498 dump_type (pp
, op
, flags
);
2500 dump_expr (pp
, op
, flags
);
2501 pp_cxx_right_paren (pp
);
2504 case AT_ENCODE_EXPR
:
2505 pp_cxx_ws_string (pp
, "@encode");
2506 pp_cxx_whitespace (pp
);
2507 pp_cxx_left_paren (pp
);
2508 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2509 pp_cxx_right_paren (pp
);
2513 pp_cxx_ws_string (pp
, "noexcept");
2514 pp_cxx_whitespace (pp
);
2515 pp_cxx_left_paren (pp
);
2516 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2517 pp_cxx_right_paren (pp
);
2522 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2523 pp_cxx_whitespace (pp
);
2524 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2528 pp_string (pp
, M_("<unparsed>"));
2531 case TRY_CATCH_EXPR
:
2532 case WITH_CLEANUP_EXPR
:
2533 case CLEANUP_POINT_EXPR
:
2534 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2537 case PSEUDO_DTOR_EXPR
:
2538 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2540 if (TREE_OPERAND (t
, 1))
2542 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2543 pp_cxx_colon_colon (pp
);
2545 pp_cxx_complement (pp
);
2546 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2549 case TEMPLATE_ID_EXPR
:
2550 dump_decl (pp
, t
, flags
);
2556 case STATEMENT_LIST
:
2557 /* We don't yet have a way of dumping statements in a
2558 human-readable format. */
2559 pp_string (pp
, "({...})");
2563 pp_string (pp
, "while (1) { ");
2564 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2565 pp_cxx_right_brace (pp
);
2569 pp_string (pp
, "if (");
2570 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2571 pp_string (pp
, ") break; ");
2575 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2578 case EMPTY_CLASS_EXPR
:
2579 dump_type (pp
, TREE_TYPE (t
), flags
);
2580 pp_cxx_left_paren (pp
);
2581 pp_cxx_right_paren (pp
);
2584 case NON_DEPENDENT_EXPR
:
2585 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2588 case ARGUMENT_PACK_SELECT
:
2589 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2601 pp_type_specifier_seq (pp
, t
);
2605 /* We get here when we want to print a dependent type as an
2606 id-expression, without any disambiguator decoration. */
2607 pp
->id_expression (t
);
2610 case TEMPLATE_TYPE_PARM
:
2611 case TEMPLATE_TEMPLATE_PARM
:
2612 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2613 dump_type (pp
, t
, flags
);
2617 pp_cxx_trait_expression (pp
, t
);
2621 pp_cxx_va_arg_expression (pp
, t
);
2625 pp_cxx_offsetof_expression (pp
, t
);
2629 dump_decl (pp
, t
, flags
);
2632 case EXPR_PACK_EXPANSION
:
2639 case VEC_DELETE_EXPR
:
2645 case UNORDERED_EXPR
:
2655 case FIX_TRUNC_EXPR
:
2660 case TRUTH_AND_EXPR
:
2662 case TRUTH_XOR_EXPR
:
2663 if (flags
& TFF_EXPR_IN_PARENS
)
2664 pp_cxx_left_paren (pp
);
2666 if (flags
& TFF_EXPR_IN_PARENS
)
2667 pp_cxx_right_paren (pp
);
2671 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2675 pp_string (pp
, M_("<lambda>"));
2679 pp_cxx_left_paren (pp
);
2680 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2681 pp_cxx_right_paren (pp
);
2684 case PLACEHOLDER_EXPR
:
2685 pp_string (pp
, M_("*this"));
2688 /* This list is incomplete, but should suffice for now.
2689 It is very important that `sorry' does not call
2690 `report_error_function'. That could cause an infinite loop. */
2692 pp_unsupported_tree (pp
, t
);
2693 /* fall through to ERROR_MARK... */
2695 pp_string (pp
, M_("<expression error>"));
2701 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2704 pp_cxx_left_paren (pp
);
2705 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2706 pp_cxx_whitespace (pp
);
2708 pp_cxx_ws_string (pp
, opstring
);
2710 pp_string (pp
, M_("<unknown operator>"));
2711 pp_cxx_whitespace (pp
);
2712 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2713 pp_cxx_right_paren (pp
);
2717 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2719 if (flags
& TFF_EXPR_IN_PARENS
)
2720 pp_cxx_left_paren (pp
);
2721 pp_cxx_ws_string (pp
, opstring
);
2722 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2723 if (flags
& TFF_EXPR_IN_PARENS
)
2724 pp_cxx_right_paren (pp
);
2728 reinit_cxx_pp (void)
2730 pp_clear_output_area (cxx_pp
);
2731 cxx_pp
->padding
= pp_none
;
2732 pp_indentation (cxx_pp
) = 0;
2733 pp_needs_newline (cxx_pp
) = false;
2734 cxx_pp
->enclosing_scope
= current_function_decl
;
2737 /* Same as pp_formatted_text, except the return string is a separate
2738 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2741 pp_ggc_formatted_text (pretty_printer
*pp
)
2743 return ggc_strdup (pp_formatted_text (pp
));
2746 /* Exported interface to stringifying types, exprs and decls under TFF_*
2750 type_as_string (tree typ
, int flags
)
2753 pp_translate_identifiers (cxx_pp
) = false;
2754 dump_type (cxx_pp
, typ
, flags
);
2755 return pp_ggc_formatted_text (cxx_pp
);
2759 type_as_string_translate (tree typ
, int flags
)
2762 dump_type (cxx_pp
, typ
, flags
);
2763 return pp_ggc_formatted_text (cxx_pp
);
2767 expr_as_string (tree decl
, int flags
)
2770 pp_translate_identifiers (cxx_pp
) = false;
2771 dump_expr (cxx_pp
, decl
, flags
);
2772 return pp_ggc_formatted_text (cxx_pp
);
2775 /* Wrap decl_as_string with options appropriate for dwarf. */
2778 decl_as_dwarf_string (tree decl
, int flags
)
2781 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2782 here will be adequate to get the desired behaviour. */
2783 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2784 name
= decl_as_string (decl
, flags
);
2785 /* Subsequent calls to the pretty printer shouldn't use this style. */
2786 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2791 decl_as_string (tree decl
, int flags
)
2794 pp_translate_identifiers (cxx_pp
) = false;
2795 dump_decl (cxx_pp
, decl
, flags
);
2796 return pp_ggc_formatted_text (cxx_pp
);
2800 decl_as_string_translate (tree decl
, int flags
)
2803 dump_decl (cxx_pp
, decl
, flags
);
2804 return pp_ggc_formatted_text (cxx_pp
);
2807 /* Wrap lang_decl_name with options appropriate for dwarf. */
2810 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2813 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2814 here will be adequate to get the desired behaviour. */
2815 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2816 name
= lang_decl_name (decl
, v
, translate
);
2817 /* Subsequent calls to the pretty printer shouldn't use this style. */
2818 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2822 /* Generate the three forms of printable names for cxx_printable_name. */
2825 lang_decl_name (tree decl
, int v
, bool translate
)
2829 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2830 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2833 pp_translate_identifiers (cxx_pp
) = translate
;
2835 && (DECL_CLASS_SCOPE_P (decl
)
2836 || (DECL_NAMESPACE_SCOPE_P (decl
)
2837 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2839 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2840 pp_cxx_colon_colon (cxx_pp
);
2843 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2844 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2845 else if ((DECL_NAME (decl
) == NULL_TREE
)
2846 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2847 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2849 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2851 return pp_ggc_formatted_text (cxx_pp
);
2854 /* Return the location of a tree passed to %+ formats. */
2857 location_of (tree t
)
2861 t
= TYPE_MAIN_DECL (t
);
2863 return input_location
;
2865 else if (TREE_CODE (t
) == OVERLOAD
)
2866 t
= OVL_FUNCTION (t
);
2869 return DECL_SOURCE_LOCATION (t
);
2870 return EXPR_LOC_OR_LOC (t
, input_location
);
2873 /* Now the interfaces from error et al to dump_type et al. Each takes an
2874 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2878 decl_to_string (tree decl
, int verbose
)
2882 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2883 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2884 flags
= TFF_CLASS_KEY_OR_ENUM
;
2886 flags
|= TFF_DECL_SPECIFIERS
;
2887 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2888 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2889 flags
|= TFF_TEMPLATE_HEADER
;
2892 dump_decl (cxx_pp
, decl
, flags
);
2893 return pp_ggc_formatted_text (cxx_pp
);
2897 expr_to_string (tree decl
)
2900 dump_expr (cxx_pp
, decl
, 0);
2901 return pp_ggc_formatted_text (cxx_pp
);
2905 fndecl_to_string (tree fndecl
, int verbose
)
2909 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
2910 | TFF_TEMPLATE_HEADER
;
2912 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
2914 dump_decl (cxx_pp
, fndecl
, flags
);
2915 return pp_ggc_formatted_text (cxx_pp
);
2920 code_to_string (enum tree_code c
)
2922 return get_tree_code_name (c
);
2926 language_to_string (enum languages c
)
2933 case lang_cplusplus
:
2945 /* Return the proper printed version of a parameter to a C++ function. */
2948 parm_to_string (int p
)
2952 pp_string (cxx_pp
, "'this'");
2954 pp_decimal_int (cxx_pp
, p
+ 1);
2955 return pp_ggc_formatted_text (cxx_pp
);
2959 op_to_string (enum tree_code p
)
2961 tree id
= operator_name_info
[p
].identifier
;
2962 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
2966 type_to_string (tree typ
, int verbose
)
2970 flags
|= TFF_CLASS_KEY_OR_ENUM
;
2971 flags
|= TFF_TEMPLATE_HEADER
;
2974 dump_type (cxx_pp
, typ
, flags
);
2975 /* If we're printing a type that involves typedefs, also print the
2976 stripped version. But sometimes the stripped version looks
2977 exactly the same, so we don't want it after all. To avoid printing
2978 it in that case, we play ugly obstack games. */
2979 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
2980 && !uses_template_parms (typ
))
2982 int aka_start
, aka_len
; char *p
;
2983 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
2984 /* Remember the end of the initial dump. */
2985 int len
= obstack_object_size (ob
);
2986 tree aka
= strip_typedefs (typ
);
2987 pp_string (cxx_pp
, " {aka");
2988 pp_cxx_whitespace (cxx_pp
);
2989 /* And remember the start of the aka dump. */
2990 aka_start
= obstack_object_size (ob
);
2991 dump_type (cxx_pp
, aka
, flags
);
2992 aka_len
= obstack_object_size (ob
) - aka_start
;
2993 pp_right_brace (cxx_pp
);
2994 p
= (char*)obstack_base (ob
);
2995 /* If they are identical, cut off the aka with a NUL. */
2996 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
2999 return pp_ggc_formatted_text (cxx_pp
);
3003 assop_to_string (enum tree_code p
)
3005 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3006 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3010 args_to_string (tree p
, int verbose
)
3014 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3019 if (TYPE_P (TREE_VALUE (p
)))
3020 return type_as_string_translate (p
, flags
);
3023 for (; p
; p
= TREE_CHAIN (p
))
3025 if (TREE_VALUE (p
) == null_node
)
3026 pp_cxx_ws_string (cxx_pp
, "NULL");
3028 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3030 pp_separate_with_comma (cxx_pp
);
3032 return pp_ggc_formatted_text (cxx_pp
);
3035 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3036 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3040 subst_to_string (tree p
)
3042 tree decl
= TREE_PURPOSE (p
);
3043 tree targs
= TREE_VALUE (p
);
3044 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3045 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3046 |TFF_NO_TEMPLATE_BINDINGS
);
3052 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3053 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3054 return pp_ggc_formatted_text (cxx_pp
);
3058 cv_to_string (tree p
, int v
)
3061 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3062 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3063 return pp_ggc_formatted_text (cxx_pp
);
3067 eh_spec_to_string (tree p
, int /*v*/)
3071 dump_exception_spec (cxx_pp
, p
, flags
);
3072 return pp_ggc_formatted_text (cxx_pp
);
3075 /* Langhook for print_error_function. */
3077 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3078 diagnostic_info
*diagnostic
)
3080 lhd_print_error_function (context
, file
, diagnostic
);
3081 pp_set_prefix (context
->printer
, file
);
3082 maybe_print_instantiation_context (context
);
3086 cp_diagnostic_starter (diagnostic_context
*context
,
3087 diagnostic_info
*diagnostic
)
3089 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3090 cp_print_error_function (context
, diagnostic
);
3091 maybe_print_instantiation_context (context
);
3092 maybe_print_constexpr_context (context
);
3093 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3097 /* Print current function onto BUFFER, in the process of reporting
3098 a diagnostic message. Called from cp_diagnostic_starter. */
3100 cp_print_error_function (diagnostic_context
*context
,
3101 diagnostic_info
*diagnostic
)
3103 /* If we are in an instantiation context, current_function_decl is likely
3104 to be wrong, so just rely on print_instantiation_full_context. */
3105 if (current_instantiation ())
3107 if (diagnostic_last_function_changed (context
, diagnostic
))
3109 const char *old_prefix
= context
->printer
->prefix
;
3110 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3111 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3112 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3113 ? file_name_as_prefix (context
, file
) : NULL
;
3115 pp_set_prefix (context
->printer
, new_prefix
);
3117 if (current_function_decl
== NULL
)
3118 pp_string (context
->printer
, _("At global scope:"));
3123 if (abstract_origin
)
3125 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3126 while (TREE_CODE (ao
) == BLOCK
3127 && BLOCK_ABSTRACT_ORIGIN (ao
)
3128 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3129 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3130 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3134 fndecl
= current_function_decl
;
3136 pp_printf (context
->printer
, function_category (fndecl
),
3137 cxx_printable_name_translate (fndecl
, 2));
3139 while (abstract_origin
)
3142 tree block
= abstract_origin
;
3144 locus
= &BLOCK_SOURCE_LOCATION (block
);
3146 block
= BLOCK_SUPERCONTEXT (block
);
3147 while (block
&& TREE_CODE (block
) == BLOCK
3148 && BLOCK_ABSTRACT_ORIGIN (block
))
3150 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3152 while (TREE_CODE (ao
) == BLOCK
3153 && BLOCK_ABSTRACT_ORIGIN (ao
)
3154 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3155 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3157 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3162 else if (TREE_CODE (ao
) != BLOCK
)
3165 block
= BLOCK_SUPERCONTEXT (block
);
3168 abstract_origin
= block
;
3171 while (block
&& TREE_CODE (block
) == BLOCK
)
3172 block
= BLOCK_SUPERCONTEXT (block
);
3174 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3176 abstract_origin
= NULL
;
3180 expanded_location s
= expand_location (*locus
);
3181 pp_character (context
->printer
, ',');
3182 pp_newline (context
->printer
);
3185 if (context
->show_column
&& s
.column
!= 0)
3186 pp_printf (context
->printer
,
3187 _(" inlined from %qs at %r%s:%d:%d%R"),
3188 cxx_printable_name_translate (fndecl
, 2),
3189 "locus", s
.file
, s
.line
, s
.column
);
3191 pp_printf (context
->printer
,
3192 _(" inlined from %qs at %r%s:%d%R"),
3193 cxx_printable_name_translate (fndecl
, 2),
3194 "locus", s
.file
, s
.line
);
3198 pp_printf (context
->printer
, _(" inlined from %qs"),
3199 cxx_printable_name_translate (fndecl
, 2));
3202 pp_character (context
->printer
, ':');
3204 pp_newline (context
->printer
);
3206 diagnostic_set_last_function (context
, diagnostic
);
3207 pp_destroy_prefix (context
->printer
);
3208 context
->printer
->prefix
= old_prefix
;
3212 /* Returns a description of FUNCTION using standard terminology. The
3213 result is a format string of the form "In CATEGORY %qs". */
3215 function_category (tree fn
)
3217 /* We can get called from the middle-end for diagnostics of function
3218 clones. Make sure we have language specific information before
3219 dereferencing it. */
3220 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3221 && DECL_FUNCTION_MEMBER_P (fn
))
3223 if (DECL_STATIC_FUNCTION_P (fn
))
3224 return _("In static member function %qs");
3225 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3226 return _("In copy constructor %qs");
3227 else if (DECL_CONSTRUCTOR_P (fn
))
3228 return _("In constructor %qs");
3229 else if (DECL_DESTRUCTOR_P (fn
))
3230 return _("In destructor %qs");
3231 else if (LAMBDA_FUNCTION_P (fn
))
3232 return _("In lambda function");
3234 return _("In member function %qs");
3237 return _("In function %qs");
3240 /* Report the full context of a current template instantiation,
3243 print_instantiation_full_context (diagnostic_context
*context
)
3245 struct tinst_level
*p
= current_instantiation ();
3246 location_t location
= input_location
;
3250 pp_verbatim (context
->printer
,
3251 TREE_CODE (p
->decl
) == TREE_LIST
3252 ? _("%s: In substitution of %qS:\n")
3253 : _("%s: In instantiation of %q#D:\n"),
3254 LOCATION_FILE (location
),
3257 location
= p
->locus
;
3261 print_instantiation_partial_context (context
, p
, location
);
3264 /* Helper function of print_instantiation_partial_context() that
3265 prints a single line of instantiation context. */
3268 print_instantiation_partial_context_line (diagnostic_context
*context
,
3269 const struct tinst_level
*t
,
3270 location_t loc
, bool recursive_p
)
3272 if (loc
== UNKNOWN_LOCATION
)
3275 expanded_location xloc
= expand_location (loc
);
3277 if (context
->show_column
)
3278 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3279 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3281 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3282 "locus", xloc
.file
, xloc
.line
);
3286 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3287 pp_verbatim (context
->printer
,
3289 ? _("recursively required by substitution of %qS\n")
3290 : _("required by substitution of %qS\n"),
3293 pp_verbatim (context
->printer
,
3295 ? _("recursively required from %q#D\n")
3296 : _("required from %q#D\n"),
3301 pp_verbatim (context
->printer
,
3303 ? _("recursively required from here")
3304 : _("required from here"));
3308 /* Same as print_instantiation_full_context but less verbose. */
3311 print_instantiation_partial_context (diagnostic_context
*context
,
3312 struct tinst_level
*t0
, location_t loc
)
3314 struct tinst_level
*t
;
3317 location_t prev_loc
= loc
;
3319 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3320 if (prev_loc
!= t
->locus
)
3322 prev_loc
= t
->locus
;
3328 if (template_backtrace_limit
3329 && n_total
> template_backtrace_limit
)
3331 int skip
= n_total
- template_backtrace_limit
;
3332 int head
= template_backtrace_limit
/ 2;
3334 /* Avoid skipping just 1. If so, skip 2. */
3338 head
= (template_backtrace_limit
- 1) / 2;
3341 for (n
= 0; n
< head
; n
++)
3343 gcc_assert (t
!= NULL
);
3344 if (loc
!= t
->locus
)
3345 print_instantiation_partial_context_line (context
, t
, loc
,
3346 /*recursive_p=*/false);
3350 if (t
!= NULL
&& skip
> 0)
3352 expanded_location xloc
;
3353 xloc
= expand_location (loc
);
3354 if (context
->show_column
)
3355 pp_verbatim (context
->printer
,
3356 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3357 "contexts, use -ftemplate-backtrace-limit=0 to "
3359 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3361 pp_verbatim (context
->printer
,
3362 _("%r%s:%d:%R [ skipping %d instantiation "
3363 "contexts, use -ftemplate-backtrace-limit=0 to "
3365 "locus", xloc
.file
, xloc
.line
, skip
);
3370 } while (t
!= NULL
&& --skip
> 0);
3376 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3381 print_instantiation_partial_context_line (context
, t
, loc
,
3386 print_instantiation_partial_context_line (context
, NULL
, loc
,
3387 /*recursive_p=*/false);
3388 pp_newline (context
->printer
);
3391 /* Called from cp_thing to print the template context for an error. */
3393 maybe_print_instantiation_context (diagnostic_context
*context
)
3395 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3398 record_last_problematic_instantiation ();
3399 print_instantiation_full_context (context
);
3402 /* Report what constexpr call(s) we're trying to expand, if any. */
3405 maybe_print_constexpr_context (diagnostic_context
*context
)
3407 vec
<tree
> call_stack
= cx_error_context ();
3411 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3413 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3414 const char *s
= expr_as_string (t
, 0);
3415 if (context
->show_column
)
3416 pp_verbatim (context
->printer
,
3417 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3418 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3420 pp_verbatim (context
->printer
,
3421 _("%r%s:%d:%R in constexpr expansion of %qs"),
3422 "locus", xloc
.file
, xloc
.line
, s
);
3423 pp_newline (context
->printer
);
3427 /* Called from output_format -- during diagnostic message processing --
3428 to handle C++ specific format specifier with the following meanings:
3429 %A function argument-list.
3433 %F function declaration.
3434 %L language as used in extern "lang".
3436 %P function parameter whose position is indicated by an integer.
3437 %Q assignment operator.
3438 %S substitution (template + args)
3441 %X exception-specification. */
3443 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3444 int precision
, bool wide
, bool set_locus
, bool verbose
)
3448 #define next_tree (t = va_arg (*text->args_ptr, tree))
3449 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3450 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3451 #define next_int va_arg (*text->args_ptr, int)
3453 if (precision
!= 0 || wide
)
3458 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3459 case 'C': result
= code_to_string (next_tcode
); break;
3462 tree temp
= next_tree
;
3464 && DECL_HAS_DEBUG_EXPR_P (temp
))
3466 temp
= DECL_DEBUG_EXPR (temp
);
3469 result
= expr_to_string (temp
);
3473 result
= decl_to_string (temp
, verbose
);
3476 case 'E': result
= expr_to_string (next_tree
); break;
3477 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3478 case 'L': result
= language_to_string (next_lang
); break;
3479 case 'O': result
= op_to_string (next_tcode
); break;
3480 case 'P': result
= parm_to_string (next_int
); break;
3481 case 'Q': result
= assop_to_string (next_tcode
); break;
3482 case 'S': result
= subst_to_string (next_tree
); break;
3483 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3484 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3485 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3488 percent_K_format (text
);
3495 pp_string (pp
, result
);
3496 if (set_locus
&& t
!= NULL
)
3497 text
->set_location (0, location_of (t
));
3505 /* Warn about the use of C++0x features when appropriate. */
3507 maybe_warn_cpp0x (cpp0x_warn_str str
)
3509 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3510 /* We really want to suppress this warning in system headers,
3511 because libstdc++ uses variadic templates even when we aren't
3515 case CPP0X_INITIALIZER_LISTS
:
3516 pedwarn (input_location
, 0,
3517 "extended initializer lists "
3518 "only available with -std=c++11 or -std=gnu++11");
3520 case CPP0X_EXPLICIT_CONVERSION
:
3521 pedwarn (input_location
, 0,
3522 "explicit conversion operators "
3523 "only available with -std=c++11 or -std=gnu++11");
3525 case CPP0X_VARIADIC_TEMPLATES
:
3526 pedwarn (input_location
, 0,
3527 "variadic templates "
3528 "only available with -std=c++11 or -std=gnu++11");
3530 case CPP0X_LAMBDA_EXPR
:
3531 pedwarn (input_location
, 0,
3532 "lambda expressions "
3533 "only available with -std=c++11 or -std=gnu++11");
3536 pedwarn (input_location
, 0,
3537 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3539 case CPP0X_SCOPED_ENUMS
:
3540 pedwarn (input_location
, 0,
3541 "scoped enums only available with -std=c++11 or -std=gnu++11");
3543 case CPP0X_DEFAULTED_DELETED
:
3544 pedwarn (input_location
, 0,
3545 "defaulted and deleted functions "
3546 "only available with -std=c++11 or -std=gnu++11");
3548 case CPP0X_INLINE_NAMESPACES
:
3549 pedwarn (input_location
, OPT_Wpedantic
,
3550 "inline namespaces "
3551 "only available with -std=c++11 or -std=gnu++11");
3553 case CPP0X_OVERRIDE_CONTROLS
:
3554 pedwarn (input_location
, 0,
3555 "override controls (override/final) "
3556 "only available with -std=c++11 or -std=gnu++11");
3559 pedwarn (input_location
, 0,
3560 "non-static data member initializers "
3561 "only available with -std=c++11 or -std=gnu++11");
3563 case CPP0X_USER_DEFINED_LITERALS
:
3564 pedwarn (input_location
, 0,
3565 "user-defined literals "
3566 "only available with -std=c++11 or -std=gnu++11");
3568 case CPP0X_DELEGATING_CTORS
:
3569 pedwarn (input_location
, 0,
3570 "delegating constructors "
3571 "only available with -std=c++11 or -std=gnu++11");
3573 case CPP0X_INHERITING_CTORS
:
3574 pedwarn (input_location
, 0,
3575 "inheriting constructors "
3576 "only available with -std=c++11 or -std=gnu++11");
3578 case CPP0X_ATTRIBUTES
:
3579 pedwarn (input_location
, 0,
3581 "only available with -std=c++11 or -std=gnu++11");
3583 case CPP0X_REF_QUALIFIER
:
3584 pedwarn (input_location
, 0,
3586 "only available with -std=c++11 or -std=gnu++11");
3593 /* Warn about the use of variadic templates when appropriate. */
3595 maybe_warn_variadic_templates (void)
3597 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3601 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3602 option OPT with text GMSGID. Use this function to report
3603 diagnostics for constructs that are invalid C++98, but valid
3606 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3608 diagnostic_info diagnostic
;
3612 va_start (ap
, gmsgid
);
3613 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, location
,
3614 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3615 diagnostic
.option_index
= opt
;
3616 ret
= report_diagnostic (&diagnostic
);
3621 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3622 we found when we tried to do the lookup. LOCATION is the location of
3623 the NAME identifier. */
3626 qualified_name_lookup_error (tree scope
, tree name
,
3627 tree decl
, location_t location
)
3629 if (scope
== error_mark_node
)
3630 ; /* We already complained. */
3631 else if (TYPE_P (scope
))
3633 if (!COMPLETE_TYPE_P (scope
))
3634 error_at (location
, "incomplete type %qT used in nested name specifier",
3636 else if (TREE_CODE (decl
) == TREE_LIST
)
3638 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3640 print_candidates (decl
);
3643 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3645 else if (scope
!= global_namespace
)
3647 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3648 suggest_alternatives_for (location
, name
);
3652 error_at (location
, "%<::%D%> has not been declared", name
);
3653 suggest_alternatives_for (location
, name
);