1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "stringpool.h"
25 #include "tree-diagnostic.h"
26 #include "langhooks-def.h"
28 #include "cxx-pretty-print.h"
29 #include "tree-pretty-print.h"
30 #include "c-family/c-objc.h"
32 #include "internal-fn.h"
34 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
35 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
37 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
38 dump C++ ASTs as strings. It is mostly used only by the various
39 tree -> string functions that are occasionally called from the
40 debugger or by the front-end for things like
41 __PRETTY_FUNCTION__. */
42 static cxx_pretty_printer actual_pretty_printer
;
43 static cxx_pretty_printer
* const cxx_pp
= &actual_pretty_printer
;
45 /* Translate if being used for diagnostics, but not for dump files or
47 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
49 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
51 static const char *args_to_string (tree
, int);
52 static const char *assop_to_string (enum tree_code
);
53 static const char *code_to_string (enum tree_code
);
54 static const char *cv_to_string (tree
, int);
55 static const char *decl_to_string (tree
, int);
56 static const char *expr_to_string (tree
);
57 static const char *fndecl_to_string (tree
, int);
58 static const char *op_to_string (enum tree_code
);
59 static const char *parm_to_string (int);
60 static const char *type_to_string (tree
, int);
62 static void dump_alias_template_specialization (cxx_pretty_printer
*, tree
, int);
63 static void dump_type (cxx_pretty_printer
*, tree
, int);
64 static void dump_typename (cxx_pretty_printer
*, tree
, int);
65 static void dump_simple_decl (cxx_pretty_printer
*, tree
, tree
, int);
66 static void dump_decl (cxx_pretty_printer
*, tree
, int);
67 static void dump_template_decl (cxx_pretty_printer
*, tree
, int);
68 static void dump_function_decl (cxx_pretty_printer
*, tree
, int);
69 static void dump_expr (cxx_pretty_printer
*, tree
, int);
70 static void dump_unary_op (cxx_pretty_printer
*, const char *, tree
, int);
71 static void dump_binary_op (cxx_pretty_printer
*, const char *, tree
, int);
72 static void dump_aggr_type (cxx_pretty_printer
*, tree
, int);
73 static void dump_type_prefix (cxx_pretty_printer
*, tree
, int);
74 static void dump_type_suffix (cxx_pretty_printer
*, tree
, int);
75 static void dump_function_name (cxx_pretty_printer
*, tree
, int);
76 static void dump_call_expr_args (cxx_pretty_printer
*, tree
, int, bool);
77 static void dump_aggr_init_expr_args (cxx_pretty_printer
*, tree
, int, bool);
78 static void dump_expr_list (cxx_pretty_printer
*, tree
, int);
79 static void dump_global_iord (cxx_pretty_printer
*, tree
);
80 static void dump_parameters (cxx_pretty_printer
*, tree
, int);
81 static void dump_ref_qualifier (cxx_pretty_printer
*, tree
, int);
82 static void dump_exception_spec (cxx_pretty_printer
*, tree
, int);
83 static void dump_template_argument (cxx_pretty_printer
*, tree
, int);
84 static void dump_template_argument_list (cxx_pretty_printer
*, tree
, int);
85 static void dump_template_parameter (cxx_pretty_printer
*, tree
, int);
86 static void dump_template_bindings (cxx_pretty_printer
*, tree
, tree
,
88 static void dump_scope (cxx_pretty_printer
*, tree
, int);
89 static void dump_template_parms (cxx_pretty_printer
*, tree
, int, int);
90 static int get_non_default_template_args_count (tree
, int);
91 static const char *function_category (tree
);
92 static void maybe_print_constexpr_context (diagnostic_context
*);
93 static void maybe_print_instantiation_context (diagnostic_context
*);
94 static void print_instantiation_full_context (diagnostic_context
*);
95 static void print_instantiation_partial_context (diagnostic_context
*,
98 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
99 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
101 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
102 int, bool, bool, bool);
104 /* CONTEXT->printer is a basic pretty printer that was constructed
105 presumably by diagnostic_initialize(), called early in the
106 compiler's initialization process (in general_init) Before the FE
107 is initialized. This (C++) FE-specific diagnostic initializer is
108 thus replacing the basic pretty printer with one that has C++-aware
112 cxx_initialize_diagnostics (diagnostic_context
*context
)
114 pretty_printer
*base
= context
->printer
;
115 cxx_pretty_printer
*pp
= XNEW (cxx_pretty_printer
);
116 context
->printer
= new (pp
) cxx_pretty_printer ();
118 /* It is safe to free this object because it was previously XNEW()'d. */
119 base
->~pretty_printer ();
122 c_common_diagnostics_set_defaults (context
);
123 diagnostic_starter (context
) = cp_diagnostic_starter
;
124 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
125 diagnostic_format_decoder (context
) = cp_printer
;
128 /* Dump a scope, if deemed necessary. */
131 dump_scope (cxx_pretty_printer
*pp
, tree scope
, int flags
)
133 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
135 if (scope
== NULL_TREE
)
138 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
140 if (scope
!= global_namespace
)
142 dump_decl (pp
, scope
, f
);
143 pp_cxx_colon_colon (pp
);
146 else if (AGGREGATE_TYPE_P (scope
))
148 dump_type (pp
, scope
, f
);
149 pp_cxx_colon_colon (pp
);
151 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
153 dump_function_decl (pp
, scope
, f
);
154 pp_cxx_colon_colon (pp
);
158 /* Dump the template ARGument under control of FLAGS. */
161 dump_template_argument (cxx_pretty_printer
*pp
, tree arg
, int flags
)
163 if (ARGUMENT_PACK_P (arg
))
164 dump_template_argument_list (pp
, ARGUMENT_PACK_ARGS (arg
),
165 /* No default args in argument packs. */
166 flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
167 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
168 dump_type (pp
, arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
171 if (TREE_CODE (arg
) == TREE_LIST
)
172 arg
= TREE_VALUE (arg
);
174 /* Strip implicit conversions. */
175 while (CONVERT_EXPR_P (arg
))
176 arg
= TREE_OPERAND (arg
, 0);
178 dump_expr (pp
, arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
182 /* Count the number of template arguments ARGS whose value does not
183 match the (optional) default template parameter in PARAMS */
186 get_non_default_template_args_count (tree args
, int flags
)
188 int n
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args
));
190 if (/* We use this flag when generating debug information. We don't
191 want to expand templates at this point, for this may generate
192 new decls, which gets decl counts out of sync, which may in
193 turn cause codegen differences between compilations with and
195 (flags
& TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
) != 0
196 || !flag_pretty_templates
)
199 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args
));
202 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
206 dump_template_argument_list (cxx_pretty_printer
*pp
, tree args
, int flags
)
208 int n
= get_non_default_template_args_count (args
, flags
);
212 for (i
= 0; i
< n
; ++i
)
214 tree arg
= TREE_VEC_ELT (args
, i
);
216 /* Only print a comma if we know there is an argument coming. In
217 the case of an empty template argument pack, no actual
218 argument will be printed. */
220 && (!ARGUMENT_PACK_P (arg
)
221 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
222 pp_separate_with_comma (pp
);
224 dump_template_argument (pp
, arg
, flags
);
229 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
232 dump_template_parameter (cxx_pretty_printer
*pp
, tree parm
, int flags
)
237 if (parm
== error_mark_node
)
240 p
= TREE_VALUE (parm
);
241 a
= TREE_PURPOSE (parm
);
243 if (TREE_CODE (p
) == TYPE_DECL
)
245 if (flags
& TFF_DECL_SPECIFIERS
)
247 pp_cxx_ws_string (pp
, "class");
248 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
249 pp_cxx_ws_string (pp
, "...");
251 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
253 else if (DECL_NAME (p
))
254 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
256 pp_cxx_canonical_template_parameter (pp
, TREE_TYPE (p
));
259 dump_decl (pp
, p
, flags
| TFF_DECL_SPECIFIERS
);
261 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
263 pp_cxx_whitespace (pp
);
265 pp_cxx_whitespace (pp
);
266 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
267 dump_type (pp
, a
, flags
& ~TFF_CHASE_TYPEDEF
);
269 dump_expr (pp
, a
, flags
| TFF_EXPR_IN_PARENS
);
273 /* Dump, under control of FLAGS, a template-parameter-list binding.
274 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
278 dump_template_bindings (cxx_pretty_printer
*pp
, tree parms
, tree args
,
279 vec
<tree
, va_gc
> *typenames
)
281 bool need_semicolon
= false;
287 tree p
= TREE_VALUE (parms
);
288 int lvl
= TMPL_PARMS_DEPTH (parms
);
291 tree lvl_args
= NULL_TREE
;
293 /* Don't crash if we had an invalid argument list. */
294 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
295 lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
297 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
299 tree arg
= NULL_TREE
;
301 /* Don't crash if we had an invalid argument list. */
302 if (lvl_args
&& NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
303 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
306 pp_separate_with_semicolon (pp
);
307 dump_template_parameter (pp
, TREE_VEC_ELT (p
, i
),
308 TFF_PLAIN_IDENTIFIER
);
309 pp_cxx_whitespace (pp
);
311 pp_cxx_whitespace (pp
);
314 if (ARGUMENT_PACK_P (arg
))
315 pp_cxx_left_brace (pp
);
316 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
317 if (ARGUMENT_PACK_P (arg
))
318 pp_cxx_right_brace (pp
);
321 pp_string (pp
, M_("<missing>"));
324 need_semicolon
= true;
327 parms
= TREE_CHAIN (parms
);
330 /* Don't bother with typenames for a partial instantiation. */
331 if (vec_safe_is_empty (typenames
) || uses_template_parms (args
))
334 /* Don't try to print typenames when we're processing a clone. */
335 if (current_function_decl
336 && !DECL_LANG_SPECIFIC (current_function_decl
))
339 /* Don't try to do this once cgraph starts throwing away front-end
344 FOR_EACH_VEC_SAFE_ELT (typenames
, i
, t
)
347 pp_separate_with_semicolon (pp
);
348 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
349 pp_cxx_whitespace (pp
);
351 pp_cxx_whitespace (pp
);
352 push_deferring_access_checks (dk_no_check
);
353 t
= tsubst (t
, args
, tf_none
, NULL_TREE
);
354 pop_deferring_access_checks ();
355 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
356 pp_simple_type_specifier doesn't know about it. */
357 t
= strip_typedefs (t
);
358 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
362 /* Dump a human-readable equivalent of the alias template
363 specialization of T. */
366 dump_alias_template_specialization (cxx_pretty_printer
*pp
, tree t
, int flags
)
368 gcc_assert (alias_template_specialization_p (t
));
370 tree decl
= TYPE_NAME (t
);
371 if (!(flags
& TFF_UNQUALIFIED_NAME
))
372 dump_scope (pp
, CP_DECL_CONTEXT (decl
), flags
);
373 pp_cxx_tree_identifier (pp
, DECL_NAME (decl
));
374 dump_template_parms (pp
, DECL_TEMPLATE_INFO (decl
),
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
);
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 (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
494 pp_cxx_constrained_type_spec (pp
, c
);
495 else if (TYPE_IDENTIFIER (t
))
496 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
498 pp_cxx_canonical_template_parameter
499 (pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
502 /* This is not always necessary for pointers and such, but doing this
503 reduces code size. */
512 dump_type_prefix (pp
, t
, flags
);
513 dump_type_suffix (pp
, t
, flags
);
517 if (! (flags
& TFF_CHASE_TYPEDEF
)
518 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
520 dump_decl (pp
, TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
523 pp_cxx_cv_qualifier_seq (pp
, t
);
524 pp_cxx_ws_string (pp
,
525 TYPENAME_IS_ENUM_P (t
) ? "enum"
526 : TYPENAME_IS_CLASS_P (t
) ? "class"
528 dump_typename (pp
, t
, flags
);
531 case UNBOUND_CLASS_TEMPLATE
:
532 if (! (flags
& TFF_UNQUALIFIED_NAME
))
534 dump_type (pp
, TYPE_CONTEXT (t
), flags
);
535 pp_cxx_colon_colon (pp
);
537 pp_cxx_ws_string (pp
, "template");
538 dump_type (pp
, TYPE_IDENTIFIER (t
), flags
);
542 pp_cxx_ws_string (pp
, "__typeof__");
543 pp_cxx_whitespace (pp
);
544 pp_cxx_left_paren (pp
);
545 dump_expr (pp
, TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
546 pp_cxx_right_paren (pp
);
549 case UNDERLYING_TYPE
:
550 pp_cxx_ws_string (pp
, "__underlying_type");
551 pp_cxx_whitespace (pp
);
552 pp_cxx_left_paren (pp
);
553 dump_expr (pp
, UNDERLYING_TYPE_TYPE (t
), flags
& ~TFF_EXPR_IN_PARENS
);
554 pp_cxx_right_paren (pp
);
557 case TYPE_PACK_EXPANSION
:
558 dump_type (pp
, PACK_EXPANSION_PATTERN (t
), flags
);
559 pp_cxx_ws_string (pp
, "...");
562 case TYPE_ARGUMENT_PACK
:
563 dump_template_argument (pp
, t
, flags
);
567 pp_cxx_ws_string (pp
, "decltype");
568 pp_cxx_whitespace (pp
);
569 pp_cxx_left_paren (pp
);
570 dump_expr (pp
, DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
571 pp_cxx_right_paren (pp
);
575 pp_string (pp
, "std::nullptr_t");
579 pp_unsupported_tree (pp
, t
);
583 pp_string (pp
, M_("<type error>"));
588 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
592 dump_typename (cxx_pretty_printer
*pp
, tree t
, int flags
)
594 tree ctx
= TYPE_CONTEXT (t
);
596 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
597 dump_typename (pp
, ctx
, flags
);
599 dump_type (pp
, ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
600 pp_cxx_colon_colon (pp
);
601 dump_decl (pp
, TYPENAME_TYPE_FULLNAME (t
), flags
);
604 /* Return the name of the supplied aggregate, or enumeral type. */
607 class_key_or_enum_as_string (tree t
)
609 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
611 if (SCOPED_ENUM_P (t
))
616 else if (TREE_CODE (t
) == UNION_TYPE
)
618 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
624 /* Print out a class declaration T under the control of FLAGS,
625 in the form `class foo'. */
628 dump_aggr_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
631 const char *variety
= class_key_or_enum_as_string (t
);
635 pp_cxx_cv_qualifier_seq (pp
, t
);
637 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
638 pp_cxx_ws_string (pp
, variety
);
640 name
= TYPE_NAME (t
);
644 typdef
= (!DECL_ARTIFICIAL (name
)
645 /* An alias specialization is not considered to be a
647 && !alias_template_specialization_p (t
));
650 && ((flags
& TFF_CHASE_TYPEDEF
)
651 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
652 && DECL_TEMPLATE_INFO (name
))))
653 || DECL_SELF_REFERENCE_P (name
))
655 t
= TYPE_MAIN_VARIANT (t
);
656 name
= TYPE_NAME (t
);
660 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
661 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
662 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
663 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
665 if (! (flags
& TFF_UNQUALIFIED_NAME
))
666 dump_scope (pp
, CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
667 flags
&= ~TFF_UNQUALIFIED_NAME
;
670 /* Because the template names are mangled, we have to locate
671 the most general template, and use that name. */
672 tree tpl
= TYPE_TI_TEMPLATE (t
);
674 while (DECL_TEMPLATE_INFO (tpl
))
675 tpl
= DECL_TI_TEMPLATE (tpl
);
678 name
= DECL_NAME (name
);
681 if (name
== 0 || anon_aggrname_p (name
))
683 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
684 pp_string (pp
, M_("<unnamed>"));
686 pp_printf (pp
, M_("<unnamed %s>"), variety
);
688 else if (LAMBDA_TYPE_P (t
))
690 /* A lambda's "type" is essentially its signature. */
691 pp_string (pp
, M_("<lambda"));
692 if (lambda_function (t
))
694 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
699 pp_cxx_tree_identifier (pp
, name
);
701 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
702 !CLASSTYPE_USE_TEMPLATE (t
),
703 flags
& ~TFF_TEMPLATE_HEADER
);
706 /* Dump into the obstack the initial part of the output for a given type.
707 This is necessary when dealing with things like functions returning
710 return type of `int (* fee ())()': pointer -> function -> int. Both
711 pointer (and reference and offset) and function (and member) types must
712 deal with prefix and suffix.
714 Arrays must also do this for DECL nodes, like int a[], and for things like
718 dump_type_prefix (cxx_pretty_printer
*pp
, tree t
, int flags
)
720 if (TYPE_PTRMEMFUNC_P (t
))
722 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
726 switch (TREE_CODE (t
))
731 tree sub
= TREE_TYPE (t
);
733 dump_type_prefix (pp
, sub
, flags
);
734 if (TREE_CODE (sub
) == ARRAY_TYPE
735 || TREE_CODE (sub
) == FUNCTION_TYPE
)
737 pp_cxx_whitespace (pp
);
738 pp_cxx_left_paren (pp
);
739 pp_c_attributes_display (pp
, TYPE_ATTRIBUTES (sub
));
743 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
745 if (TYPE_REF_IS_RVALUE (t
))
746 pp_ampersand_ampersand (pp
);
750 pp
->padding
= pp_before
;
751 pp_cxx_cv_qualifier_seq (pp
, t
);
757 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
758 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
761 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
762 pp_cxx_left_paren (pp
);
763 dump_type (pp
, TYPE_OFFSET_BASETYPE (t
), flags
);
764 pp_cxx_colon_colon (pp
);
767 pp_cxx_cv_qualifier_seq (pp
, t
);
768 pp
->padding
= pp_before
;
771 /* This can be reached without a pointer when dealing with
772 templates, e.g. std::is_function. */
774 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
778 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
780 pp_cxx_left_paren (pp
);
781 dump_aggr_type (pp
, TYPE_METHOD_BASETYPE (t
), flags
);
782 pp_cxx_colon_colon (pp
);
786 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
790 case IDENTIFIER_NODE
:
795 case TEMPLATE_TYPE_PARM
:
796 case TEMPLATE_TEMPLATE_PARM
:
797 case BOUND_TEMPLATE_TEMPLATE_PARM
:
808 case UNDERLYING_TYPE
:
810 case TYPE_PACK_EXPANSION
:
811 case FIXED_POINT_TYPE
:
813 dump_type (pp
, t
, flags
);
814 pp
->padding
= pp_before
;
818 pp_unsupported_tree (pp
, t
);
821 pp_string (pp
, M_("<typeprefixerror>"));
826 /* Dump the suffix of type T, under control of FLAGS. This is the part
827 which appears after the identifier (or function parms). */
830 dump_type_suffix (cxx_pretty_printer
*pp
, tree t
, int flags
)
832 if (TYPE_PTRMEMFUNC_P (t
))
833 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
835 switch (TREE_CODE (t
))
840 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
841 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
842 pp_cxx_right_paren (pp
);
843 if (TREE_CODE (t
) == POINTER_TYPE
)
844 flags
|= TFF_POINTER
;
845 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
852 if (TREE_CODE (t
) == METHOD_TYPE
)
853 /* Can only be reached through a pointer. */
854 pp_cxx_right_paren (pp
);
855 arg
= TYPE_ARG_TYPES (t
);
856 if (TREE_CODE (t
) == METHOD_TYPE
)
857 arg
= TREE_CHAIN (arg
);
859 /* Function pointers don't have default args. Not in standard C++,
860 anyway; they may in g++, but we'll just pretend otherwise. */
861 dump_parameters (pp
, arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
863 pp
->padding
= pp_before
;
864 pp_cxx_cv_qualifiers (pp
, type_memfn_quals (t
),
865 TREE_CODE (t
) == FUNCTION_TYPE
866 && (flags
& TFF_POINTER
));
867 dump_ref_qualifier (pp
, t
, flags
);
868 if (tx_safe_fn_type_p (t
))
869 pp_cxx_ws_string (pp
, "transaction_safe");
870 dump_exception_spec (pp
, TYPE_RAISES_EXCEPTIONS (t
), flags
);
871 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
877 pp_cxx_left_bracket (pp
);
878 if (tree dtype
= TYPE_DOMAIN (t
))
880 tree max
= TYPE_MAX_VALUE (dtype
);
881 /* Zero-length arrays have an upper bound of SIZE_MAX. */
882 if (integer_all_onesp (max
))
883 pp_character (pp
, '0');
884 else if (tree_fits_shwi_p (max
))
885 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
889 if (TREE_CODE (max
) == SAVE_EXPR
)
890 max
= TREE_OPERAND (max
, 0);
891 if (TREE_CODE (max
) == MINUS_EXPR
892 || TREE_CODE (max
) == PLUS_EXPR
)
894 max
= TREE_OPERAND (max
, 0);
895 while (CONVERT_EXPR_P (max
))
896 max
= TREE_OPERAND (max
, 0);
899 max
= fold_build2_loc (input_location
,
900 PLUS_EXPR
, dtype
, max
,
901 build_int_cst (dtype
, 1));
902 dump_expr (pp
, max
, flags
& ~TFF_EXPR_IN_PARENS
);
905 pp_cxx_right_bracket (pp
);
906 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
910 case IDENTIFIER_NODE
:
915 case TEMPLATE_TYPE_PARM
:
916 case TEMPLATE_TEMPLATE_PARM
:
917 case BOUND_TEMPLATE_TEMPLATE_PARM
:
928 case UNDERLYING_TYPE
:
930 case TYPE_PACK_EXPANSION
:
931 case FIXED_POINT_TYPE
:
936 pp_unsupported_tree (pp
, t
);
938 /* Don't mark it here, we should have already done in
945 dump_global_iord (cxx_pretty_printer
*pp
, tree t
)
947 const char *p
= NULL
;
949 if (DECL_GLOBAL_CTOR_P (t
))
950 p
= M_("(static initializers for %s)");
951 else if (DECL_GLOBAL_DTOR_P (t
))
952 p
= M_("(static destructors for %s)");
956 pp_printf (pp
, p
, DECL_SOURCE_FILE (t
));
960 dump_simple_decl (cxx_pretty_printer
*pp
, tree t
, tree type
, int flags
)
962 if (flags
& TFF_DECL_SPECIFIERS
)
964 if (VAR_P (t
) && DECL_DECLARED_CONSTEXPR_P (t
))
966 if (DECL_LANG_SPECIFIC (t
) && DECL_DECLARED_CONCEPT_P (t
))
967 pp_cxx_ws_string (pp
, "concept");
969 pp_cxx_ws_string (pp
, "constexpr");
971 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
974 if (! (flags
& TFF_UNQUALIFIED_NAME
)
975 && TREE_CODE (t
) != PARM_DECL
976 && (!DECL_INITIAL (t
)
977 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
978 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
979 flags
&= ~TFF_UNQUALIFIED_NAME
;
980 if ((flags
& TFF_DECL_SPECIFIERS
)
981 && DECL_TEMPLATE_PARM_P (t
)
982 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
983 pp_string (pp
, "...");
986 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
989 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
990 pp_string (pp
, " capture>");
993 dump_decl (pp
, DECL_NAME (t
), flags
);
996 pp_string (pp
, M_("<anonymous>"));
997 if (flags
& TFF_DECL_SPECIFIERS
)
998 dump_type_suffix (pp
, type
, flags
);
1001 /* Print an IDENTIFIER_NODE that is the name of a declaration. */
1004 dump_decl_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1006 /* These special cases are duplicated here so that other functions
1007 can feed identifiers to error and get them demangled properly. */
1008 if (IDENTIFIER_TYPENAME_P (t
))
1010 pp_cxx_ws_string (pp
, "operator");
1011 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1012 dump_type (pp
, TREE_TYPE (t
), flags
);
1015 if (dguide_name_p (t
))
1017 dump_decl (pp
, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t
)),
1018 TFF_UNQUALIFIED_NAME
);
1022 const char *str
= IDENTIFIER_POINTER (t
);
1023 if (!strncmp (str
, "_ZGR", 3))
1025 pp_cxx_ws_string (pp
, "<temporary>");
1029 pp_cxx_tree_identifier (pp
, t
);
1032 /* Dump a human readable string for the decl T under control of FLAGS. */
1035 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1040 /* If doing Objective-C++, give Objective-C a chance to demangle
1041 Objective-C method names. */
1042 if (c_dialect_objc ())
1044 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1047 pp_string (pp
, demangled
);
1052 switch (TREE_CODE (t
))
1055 /* Don't say 'typedef class A' */
1056 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1058 if ((flags
& TFF_DECL_SPECIFIERS
)
1059 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1061 /* Say `class T' not just `T'. */
1062 pp_cxx_ws_string (pp
, "class");
1064 /* Emit the `...' for a parameter pack. */
1065 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1066 pp_cxx_ws_string (pp
, "...");
1069 dump_type (pp
, TREE_TYPE (t
), flags
);
1072 if (TYPE_DECL_ALIAS_P (t
)
1073 && (flags
& TFF_DECL_SPECIFIERS
1074 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1076 pp_cxx_ws_string (pp
, "using");
1077 dump_decl (pp
, DECL_NAME (t
), flags
);
1078 pp_cxx_whitespace (pp
);
1079 pp_cxx_ws_string (pp
, "=");
1080 pp_cxx_whitespace (pp
);
1081 dump_type (pp
, (DECL_ORIGINAL_TYPE (t
)
1082 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
)),
1086 if ((flags
& TFF_DECL_SPECIFIERS
)
1087 && !DECL_SELF_REFERENCE_P (t
))
1088 pp_cxx_ws_string (pp
, "typedef");
1089 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1090 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1095 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1097 pp_string (pp
, M_("vtable for "));
1098 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1099 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1105 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1107 /* Handle variable template specializations. */
1109 && DECL_LANG_SPECIFIC (t
)
1110 && DECL_TEMPLATE_INFO (t
)
1111 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1113 pp_cxx_begin_template_argument_list (pp
);
1114 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1115 dump_template_argument_list (pp
, args
, flags
);
1116 pp_cxx_end_template_argument_list (pp
);
1121 pp_string (pp
, M_("<return value> "));
1122 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1125 case NAMESPACE_DECL
:
1126 if (flags
& TFF_DECL_SPECIFIERS
)
1127 pp
->declaration (t
);
1130 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1131 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1132 flags
&= ~TFF_UNQUALIFIED_NAME
;
1133 if (DECL_NAME (t
) == NULL_TREE
)
1135 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1136 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1138 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1141 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1146 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1147 pp_colon_colon (pp
);
1148 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1152 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1153 pp_cxx_left_bracket (pp
);
1154 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1155 pp_cxx_right_bracket (pp
);
1158 case ARRAY_NOTATION_REF
:
1159 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1160 pp_cxx_left_bracket (pp
);
1161 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1163 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1165 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1166 pp_cxx_right_bracket (pp
);
1169 /* So that we can do dump_decl on an aggr type. */
1173 dump_type (pp
, t
, flags
);
1177 /* This is a pseudo destructor call which has not been folded into
1178 a PSEUDO_DTOR_EXPR yet. */
1179 pp_cxx_complement (pp
);
1180 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1187 case IDENTIFIER_NODE
:
1188 dump_decl_name (pp
, t
, flags
);
1194 t
= OVL_CURRENT (t
);
1195 if (DECL_CLASS_SCOPE_P (t
))
1197 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1198 pp_cxx_colon_colon (pp
);
1200 else if (!DECL_FILE_SCOPE_P (t
))
1202 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1203 pp_cxx_colon_colon (pp
);
1205 dump_decl (pp
, DECL_NAME (t
), flags
);
1209 /* If there's only one function, just treat it like an ordinary
1211 t
= OVL_CURRENT (t
);
1215 if (! DECL_LANG_SPECIFIC (t
))
1217 if (DECL_ABSTRACT_ORIGIN (t
)
1218 && DECL_ABSTRACT_ORIGIN (t
) != t
)
1219 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1221 dump_function_name (pp
, t
, flags
);
1223 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1224 dump_global_iord (pp
, t
);
1226 dump_function_decl (pp
, t
, flags
);
1230 dump_template_decl (pp
, t
, flags
);
1233 case TEMPLATE_ID_EXPR
:
1235 tree name
= TREE_OPERAND (t
, 0);
1236 tree args
= TREE_OPERAND (t
, 1);
1238 if (is_overloaded_fn (name
))
1239 name
= get_first_fn (name
);
1241 name
= DECL_NAME (name
);
1242 dump_decl (pp
, name
, flags
);
1243 pp_cxx_begin_template_argument_list (pp
);
1244 if (args
== error_mark_node
)
1245 pp_string (pp
, M_("<template arguments error>"));
1247 dump_template_argument_list
1248 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1249 pp_cxx_end_template_argument_list (pp
);
1254 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1258 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1259 || (DECL_INITIAL (t
) &&
1260 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1261 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1262 else if (DECL_NAME (t
))
1263 dump_decl (pp
, DECL_NAME (t
), flags
);
1264 else if (DECL_INITIAL (t
))
1265 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1267 pp_string (pp
, M_("<enumerator>"));
1272 pp_cxx_ws_string (pp
, "using");
1273 tree scope
= USING_DECL_SCOPE (t
);
1274 bool variadic
= false;
1275 if (PACK_EXPANSION_P (scope
))
1277 scope
= PACK_EXPANSION_PATTERN (scope
);
1280 dump_type (pp
, scope
, flags
);
1281 pp_cxx_colon_colon (pp
);
1282 dump_decl (pp
, DECL_NAME (t
), flags
);
1284 pp_cxx_ws_string (pp
, "...");
1289 pp
->declaration (t
);
1293 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1296 case NON_DEPENDENT_EXPR
:
1297 dump_expr (pp
, t
, flags
);
1300 case TEMPLATE_TYPE_PARM
:
1301 if (flags
& TFF_DECL_SPECIFIERS
)
1302 pp
->declaration (t
);
1307 case UNBOUND_CLASS_TEMPLATE
:
1308 case TYPE_PACK_EXPANSION
:
1310 dump_type (pp
, t
, flags
);
1314 pp_unsupported_tree (pp
, t
);
1318 pp_string (pp
, M_("<declaration error>"));
1323 /* Dump a template declaration T under control of FLAGS. This means the
1324 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1327 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1329 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1333 if (flags
& TFF_TEMPLATE_HEADER
)
1335 for (parms
= orig_parms
= nreverse (orig_parms
);
1337 parms
= TREE_CHAIN (parms
))
1339 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1340 int len
= TREE_VEC_LENGTH (inner_parms
);
1344 /* Skip over the dummy template levels of a template template
1346 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1350 pp_cxx_ws_string (pp
, "template");
1351 pp_cxx_begin_template_argument_list (pp
);
1353 /* If we've shown the template prefix, we'd better show the
1354 parameters' and decl's type too. */
1355 flags
|= TFF_DECL_SPECIFIERS
;
1357 for (i
= 0; i
< len
; i
++)
1360 pp_separate_with_comma (pp
);
1361 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1364 pp_cxx_end_template_argument_list (pp
);
1365 pp_cxx_whitespace (pp
);
1367 nreverse(orig_parms
);
1369 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1371 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1372 pp_cxx_ws_string (pp
, "class");
1374 /* If this is a parameter pack, print the ellipsis. */
1375 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1376 pp_cxx_ws_string (pp
, "...");
1379 /* Only print the requirements if we're also printing
1380 the template header. */
1382 if (tree ci
= get_constraints (t
))
1383 if (check_constraint_info (ci
))
1384 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1386 pp_cxx_requires_clause (pp
, reqs
);
1387 pp_cxx_whitespace (pp
);
1392 if (DECL_CLASS_TEMPLATE_P (t
))
1393 dump_type (pp
, TREE_TYPE (t
),
1394 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1395 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1396 else if (DECL_TEMPLATE_RESULT (t
)
1397 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1398 /* Alias template. */
1399 || DECL_TYPE_TEMPLATE_P (t
)))
1400 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1403 gcc_assert (TREE_TYPE (t
));
1404 switch (NEXT_CODE (t
))
1408 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1411 /* This case can occur with some invalid code. */
1412 dump_type (pp
, TREE_TYPE (t
),
1413 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1414 | (flags
& TFF_DECL_SPECIFIERS
1415 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1420 /* find_typenames looks through the type of the function template T
1421 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1424 struct find_typenames_t
1426 hash_set
<tree
> *p_set
;
1427 vec
<tree
, va_gc
> *typenames
;
1431 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1433 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1434 tree mv
= NULL_TREE
;
1436 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1437 /* Add the type of the typedef without any additional cv-quals. */
1438 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1439 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1440 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1441 /* Add the typename without any cv-qualifiers. */
1442 mv
= TYPE_MAIN_VARIANT (*tp
);
1444 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1446 /* Don't mess with parameter packs since we don't remember
1447 the pack expansion context for a particular typename. */
1448 *walk_subtrees
= false;
1452 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1453 vec_safe_push (d
->typenames
, mv
);
1455 /* Search into class template arguments, which cp_walk_subtrees
1457 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1458 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1464 static vec
<tree
, va_gc
> *
1465 find_typenames (tree t
)
1467 struct find_typenames_t ft
;
1468 ft
.p_set
= new hash_set
<tree
>;
1469 ft
.typenames
= NULL
;
1470 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1471 find_typenames_r
, &ft
, ft
.p_set
);
1473 return ft
.typenames
;
1476 /* Output the "[with ...]" clause for a template instantiation T iff
1477 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1478 formatting a deduction/substitution diagnostic rather than an
1482 dump_substitution (cxx_pretty_printer
*pp
,
1483 tree t
, tree template_parms
, tree template_args
,
1486 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1487 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1489 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1490 pp_cxx_whitespace (pp
);
1491 pp_cxx_left_bracket (pp
);
1492 pp
->translate_string ("with");
1493 pp_cxx_whitespace (pp
);
1494 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1495 pp_cxx_right_bracket (pp
);
1499 /* Dump the lambda function FN including its 'mutable' qualifier and any
1500 template bindings. */
1503 dump_lambda_function (cxx_pretty_printer
*pp
,
1504 tree fn
, tree template_parms
, tree template_args
,
1507 /* A lambda's signature is essentially its "type". */
1508 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1509 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1511 pp
->padding
= pp_before
;
1512 pp_c_ws_string (pp
, "mutable");
1514 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1517 /* Pretty print a function decl. There are several ways we want to print a
1518 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1519 As error can only apply the '#' flag once to give 0 and 1 for V, there
1520 is %D which doesn't print the throw specs, and %F which does. */
1523 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1527 tree cname
= NULL_TREE
;
1528 tree template_args
= NULL_TREE
;
1529 tree template_parms
= NULL_TREE
;
1530 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1531 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1535 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1536 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1537 t
= DECL_TEMPLATE_RESULT (t
);
1539 /* Save the exceptions, in case t is a specialization and we are
1540 emitting an error about incompatible specifications. */
1541 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1543 /* Likewise for the constexpr specifier, in case t is a specialization. */
1544 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1546 /* Pretty print template instantiations only. */
1547 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1548 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1549 && flag_pretty_templates
)
1553 template_args
= DECL_TI_ARGS (t
);
1554 tmpl
= most_general_template (t
);
1555 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1557 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1562 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1563 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1565 fntype
= TREE_TYPE (t
);
1566 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1568 if (DECL_CLASS_SCOPE_P (t
))
1569 cname
= DECL_CONTEXT (t
);
1570 /* This is for partially instantiated template methods. */
1571 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1572 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1574 if (flags
& TFF_DECL_SPECIFIERS
)
1576 if (DECL_STATIC_FUNCTION_P (t
))
1577 pp_cxx_ws_string (pp
, "static");
1578 else if (DECL_VIRTUAL_P (t
))
1579 pp_cxx_ws_string (pp
, "virtual");
1583 if (DECL_DECLARED_CONCEPT_P (t
))
1584 pp_cxx_ws_string (pp
, "concept");
1586 pp_cxx_ws_string (pp
, "constexpr");
1590 /* Print the return type? */
1592 show_return
= (!DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1593 && !DECL_DESTRUCTOR_P (t
) && !deduction_guide_p (t
));
1596 tree ret
= fndecl_declared_return_type (t
);
1597 dump_type_prefix (pp
, ret
, flags
);
1600 /* Print the function name. */
1601 if (!do_outer_scope
)
1605 dump_type (pp
, cname
, flags
);
1606 pp_cxx_colon_colon (pp
);
1609 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1611 dump_function_name (pp
, t
, flags
);
1613 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1615 dump_parameters (pp
, parmtypes
, flags
);
1617 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1619 pp
->padding
= pp_before
;
1620 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1621 dump_ref_qualifier (pp
, fntype
, flags
);
1624 if (tx_safe_fn_type_p (fntype
))
1626 pp
->padding
= pp_before
;
1627 pp_cxx_ws_string (pp
, "transaction_safe");
1630 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1632 pp
->padding
= pp_before
;
1633 dump_exception_spec (pp
, exceptions
, flags
);
1637 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1638 else if (deduction_guide_p (t
))
1640 pp_cxx_ws_string (pp
, "->");
1641 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1645 if (tree ci
= get_constraints (t
))
1646 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1647 pp_cxx_requires_clause (pp
, reqs
);
1649 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1651 if (tree base
= DECL_INHERITED_CTOR_BASE (t
))
1653 pp_cxx_ws_string (pp
, "[inherited from");
1654 dump_type (pp
, base
, TFF_PLAIN_IDENTIFIER
);
1655 pp_character (pp
, ']');
1658 else if (template_args
)
1660 bool need_comma
= false;
1662 pp_cxx_begin_template_argument_list (pp
);
1663 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1664 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1666 tree arg
= TREE_VEC_ELT (template_args
, i
);
1668 pp_separate_with_comma (pp
);
1669 if (ARGUMENT_PACK_P (arg
))
1670 pp_cxx_left_brace (pp
);
1671 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1672 if (ARGUMENT_PACK_P (arg
))
1673 pp_cxx_right_brace (pp
);
1676 pp_cxx_end_template_argument_list (pp
);
1680 /* Print a parameter list. If this is for a member function, the
1681 member object ptr (and any other hidden args) should have
1682 already been removed. */
1685 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1688 flags
&= ~TFF_SCOPE
;
1689 pp_cxx_left_paren (pp
);
1691 for (first
= 1; parmtypes
!= void_list_node
;
1692 parmtypes
= TREE_CHAIN (parmtypes
))
1695 pp_separate_with_comma (pp
);
1699 pp_cxx_ws_string (pp
, "...");
1703 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1705 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1707 pp_cxx_whitespace (pp
);
1709 pp_cxx_whitespace (pp
);
1710 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1714 pp_cxx_right_paren (pp
);
1717 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1720 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1722 if (FUNCTION_REF_QUALIFIED (t
))
1724 pp
->padding
= pp_before
;
1725 if (FUNCTION_RVALUE_QUALIFIED (t
))
1726 pp_cxx_ws_string (pp
, "&&");
1728 pp_cxx_ws_string (pp
, "&");
1732 /* Print an exception specification. T is the exception specification. */
1735 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1737 if (t
&& TREE_PURPOSE (t
))
1739 pp_cxx_ws_string (pp
, "noexcept");
1740 if (!integer_onep (TREE_PURPOSE (t
)))
1742 pp_cxx_whitespace (pp
);
1743 pp_cxx_left_paren (pp
);
1744 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1745 pp_cxx_ws_string (pp
, "<uninstantiated>");
1747 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1748 pp_cxx_right_paren (pp
);
1753 pp_cxx_ws_string (pp
, "throw");
1754 pp_cxx_whitespace (pp
);
1755 pp_cxx_left_paren (pp
);
1756 if (TREE_VALUE (t
) != NULL_TREE
)
1759 dump_type (pp
, TREE_VALUE (t
), flags
);
1763 pp_separate_with_comma (pp
);
1765 pp_cxx_right_paren (pp
);
1769 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1770 and destructors properly. */
1773 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1775 tree name
= DECL_NAME (t
);
1777 /* We can get here with a decl that was synthesized by language-
1778 independent machinery (e.g. coverage.c) in which case it won't
1779 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1780 will crash. In this case it is safe just to print out the
1782 if (!DECL_LANG_SPECIFIC (t
))
1784 pp_cxx_tree_identifier (pp
, name
);
1788 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1789 t
= DECL_TEMPLATE_RESULT (t
);
1791 /* Don't let the user see __comp_ctor et al. */
1792 if (DECL_CONSTRUCTOR_P (t
)
1793 || DECL_DESTRUCTOR_P (t
))
1795 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1796 name
= get_identifier ("<lambda>");
1797 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1798 name
= get_identifier ("<constructor>");
1800 name
= constructor_name (DECL_CONTEXT (t
));
1803 if (DECL_DESTRUCTOR_P (t
))
1805 pp_cxx_complement (pp
);
1806 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1808 else if (DECL_CONV_FN_P (t
))
1810 /* This cannot use the hack that the operator's return
1811 type is stashed off of its name because it may be
1812 used for error reporting. In the case of conflicting
1813 declarations, both will have the same name, yet
1814 the types will be different, hence the TREE_TYPE field
1815 of the first name will be clobbered by the second. */
1816 pp_cxx_ws_string (pp
, "operator");
1817 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1820 dump_decl (pp
, name
, flags
);
1822 if (DECL_TEMPLATE_INFO (t
)
1823 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1824 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1825 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1826 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1830 /* Dump the template parameters from the template info INFO under control of
1831 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1832 specialization (partial or complete). For partial specializations we show
1833 the specialized parameter values. For a primary template we show no
1837 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1838 int primary
, int flags
)
1840 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1842 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1844 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1845 pp_cxx_begin_template_argument_list (pp
);
1847 /* Be careful only to print things when we have them, so as not
1848 to crash producing error messages. */
1849 if (args
&& !primary
)
1852 len
= get_non_default_template_args_count (args
, flags
);
1854 args
= INNERMOST_TEMPLATE_ARGS (args
);
1855 for (ix
= 0; ix
!= len
; ix
++)
1857 tree arg
= TREE_VEC_ELT (args
, ix
);
1859 /* Only print a comma if we know there is an argument coming. In
1860 the case of an empty template argument pack, no actual
1861 argument will be printed. */
1863 && (!ARGUMENT_PACK_P (arg
)
1864 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1865 pp_separate_with_comma (pp
);
1868 pp_string (pp
, M_("<template parameter error>"));
1870 dump_template_argument (pp
, arg
, flags
);
1875 tree tpl
= TI_TEMPLATE (info
);
1876 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1879 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1880 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1882 for (ix
= 0; ix
!= len
; ix
++)
1886 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1888 pp_string (pp
, M_("<template parameter error>"));
1892 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1895 pp_separate_with_comma (pp
);
1897 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1900 pp_cxx_end_template_argument_list (pp
);
1903 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1904 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1907 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1910 call_expr_arg_iterator iter
;
1912 pp_cxx_left_paren (pp
);
1913 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1919 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1920 if (more_call_expr_args_p (&iter
))
1921 pp_separate_with_comma (pp
);
1924 pp_cxx_right_paren (pp
);
1927 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1928 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1932 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1936 aggr_init_expr_arg_iterator iter
;
1938 pp_cxx_left_paren (pp
);
1939 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1945 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1946 if (more_aggr_init_expr_args_p (&iter
))
1947 pp_separate_with_comma (pp
);
1950 pp_cxx_right_paren (pp
);
1953 /* Print out a list of initializers (subr of dump_expr). */
1956 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1960 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1963 pp_separate_with_comma (pp
);
1967 /* Print out a vector of initializers (subr of dump_expr). */
1970 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1973 unsigned HOST_WIDE_INT idx
;
1976 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1978 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1979 if (idx
!= v
->length () - 1)
1980 pp_separate_with_comma (pp
);
1985 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1986 function. Resolve it to a close relative -- in the sense of static
1987 type -- variant being overridden. That is close to what was written in
1988 the source code. Subroutine of dump_expr. */
1991 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1993 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1994 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1995 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1998 fun
= TREE_CHAIN (fun
);
1999 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
2000 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
2006 /* Print out an expression E under control of FLAGS. */
2009 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
2016 if (STATEMENT_CLASS_P (t
))
2018 pp_cxx_ws_string (pp
, M_("<statement>"));
2022 switch (TREE_CODE (t
))
2030 case NAMESPACE_DECL
:
2034 case IDENTIFIER_NODE
:
2035 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
2036 |TFF_TEMPLATE_HEADER
))
2037 | TFF_NO_TEMPLATE_BINDINGS
2038 | TFF_NO_FUNCTION_ARGUMENTS
));
2042 if (SSA_NAME_VAR (t
)
2043 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
2044 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2046 pp_cxx_ws_string (pp
, M_("<unknown>"));
2057 case USERDEF_LITERAL
:
2058 pp_cxx_userdef_literal (pp
, t
);
2062 /* While waiting for caret diagnostics, avoid printing
2063 __cxa_allocate_exception, __cxa_throw, and the like. */
2064 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2069 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2070 pp_cxx_colon_colon (pp
);
2071 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2075 pp_cxx_left_paren (pp
);
2076 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2077 pp_separate_with_comma (pp
);
2078 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2079 pp_cxx_right_paren (pp
);
2084 pp_cxx_left_paren (pp
);
2085 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2086 pp_string (pp
, " ? ");
2087 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2088 pp_string (pp
, " : ");
2089 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2090 pp_cxx_right_paren (pp
);
2094 if (TREE_HAS_CONSTRUCTOR (t
))
2096 pp_cxx_ws_string (pp
, "new");
2097 pp_cxx_whitespace (pp
);
2098 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2101 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2104 case AGGR_INIT_EXPR
:
2106 tree fn
= NULL_TREE
;
2108 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2109 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2111 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2113 if (DECL_CONSTRUCTOR_P (fn
))
2114 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2116 dump_decl (pp
, fn
, 0);
2119 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2121 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2126 tree fn
= CALL_EXPR_FN (t
);
2127 bool skipfirst
= false;
2129 /* Deal with internal functions. */
2130 if (fn
== NULL_TREE
)
2132 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2133 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2137 if (TREE_CODE (fn
) == ADDR_EXPR
)
2138 fn
= TREE_OPERAND (fn
, 0);
2140 /* Nobody is interested in seeing the guts of vcalls. */
2141 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2142 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2144 if (TREE_TYPE (fn
) != NULL_TREE
2145 && NEXT_CODE (fn
) == METHOD_TYPE
2146 && call_expr_nargs (t
))
2148 tree ob
= CALL_EXPR_ARG (t
, 0);
2149 if (TREE_CODE (ob
) == ADDR_EXPR
)
2151 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2152 flags
| TFF_EXPR_IN_PARENS
);
2155 else if (TREE_CODE (ob
) != PARM_DECL
2156 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2158 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2163 if (flag_sanitize
& SANITIZE_UNDEFINED
2164 && is_ubsan_builtin_p (fn
))
2166 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2169 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2170 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2175 /* Note that this only works for G++ target exprs. If somebody
2176 builds a general TARGET_EXPR, there's no way to represent that
2177 it initializes anything other that the parameter slot for the
2178 default argument. Note we may have cleared out the first
2179 operand in expand_expr, so don't go killing ourselves. */
2180 if (TREE_OPERAND (t
, 1))
2181 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2184 case POINTER_PLUS_EXPR
:
2185 dump_binary_op (pp
, "+", t
, flags
);
2190 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2197 case TRUNC_DIV_EXPR
:
2198 case TRUNC_MOD_EXPR
:
2206 case TRUTH_ANDIF_EXPR
:
2207 case TRUTH_ORIF_EXPR
:
2214 case EXACT_DIV_EXPR
:
2215 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2219 case FLOOR_DIV_EXPR
:
2220 case ROUND_DIV_EXPR
:
2222 dump_binary_op (pp
, "/", t
, flags
);
2226 case FLOOR_MOD_EXPR
:
2227 case ROUND_MOD_EXPR
:
2228 dump_binary_op (pp
, "%", t
, flags
);
2233 tree ob
= TREE_OPERAND (t
, 0);
2234 if (INDIRECT_REF_P (ob
))
2236 ob
= TREE_OPERAND (ob
, 0);
2237 if (TREE_CODE (ob
) != PARM_DECL
2239 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2241 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2242 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2250 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2251 if (TREE_CODE (ob
) != ARROW_EXPR
)
2254 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2259 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2260 pp_cxx_left_bracket (pp
);
2261 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2262 pp_cxx_right_bracket (pp
);
2265 case ARRAY_NOTATION_REF
:
2266 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2267 pp_cxx_left_bracket (pp
);
2268 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2270 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2272 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2273 pp_cxx_right_bracket (pp
);
2276 case UNARY_PLUS_EXPR
:
2277 dump_unary_op (pp
, "+", t
, flags
);
2281 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2282 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2283 /* An ADDR_EXPR can have reference type. In that case, we
2284 shouldn't print the `&' doing so indicates to the user
2285 that the expression has pointer type. */
2287 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2288 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2289 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2290 dump_unary_op (pp
, "&&", t
, flags
);
2292 dump_unary_op (pp
, "&", t
, flags
);
2296 if (TREE_HAS_CONSTRUCTOR (t
))
2298 t
= TREE_OPERAND (t
, 0);
2299 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2300 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2301 dump_call_expr_args (pp
, t
, flags
, true);
2305 if (TREE_OPERAND (t
,0) != NULL_TREE
2306 && TREE_TYPE (TREE_OPERAND (t
, 0))
2307 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2308 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2310 dump_unary_op (pp
, "*", t
, flags
);
2315 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2316 && integer_zerop (TREE_OPERAND (t
, 1)))
2317 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2321 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2323 pp_cxx_left_paren (pp
);
2324 if (!integer_onep (TYPE_SIZE_UNIT
2325 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2327 pp_cxx_left_paren (pp
);
2328 dump_type (pp
, ptr_type_node
, flags
);
2329 pp_cxx_right_paren (pp
);
2332 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2333 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2335 pp_cxx_ws_string (pp
, "+");
2336 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2338 pp_cxx_right_paren (pp
);
2345 case TRUTH_NOT_EXPR
:
2346 case PREDECREMENT_EXPR
:
2347 case PREINCREMENT_EXPR
:
2348 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2351 case POSTDECREMENT_EXPR
:
2352 case POSTINCREMENT_EXPR
:
2353 pp_cxx_left_paren (pp
);
2354 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2355 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2356 pp_cxx_right_paren (pp
);
2359 case NON_LVALUE_EXPR
:
2360 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2361 should be another level of INDIRECT_REF so that I don't have to do
2363 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2365 tree next
= TREE_TYPE (TREE_TYPE (t
));
2367 while (TYPE_PTR_P (next
))
2368 next
= TREE_TYPE (next
);
2370 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2372 if (flags
& TFF_EXPR_IN_PARENS
)
2373 pp_cxx_left_paren (pp
);
2375 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2376 if (flags
& TFF_EXPR_IN_PARENS
)
2377 pp_cxx_right_paren (pp
);
2380 /* Else fall through. */
2382 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2386 case IMPLICIT_CONV_EXPR
:
2387 case VIEW_CONVERT_EXPR
:
2389 tree op
= TREE_OPERAND (t
, 0);
2390 tree ttype
= TREE_TYPE (t
);
2391 tree optype
= TREE_TYPE (op
);
2393 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2394 && POINTER_TYPE_P (ttype
)
2395 && POINTER_TYPE_P (optype
)
2396 && same_type_p (TREE_TYPE (optype
),
2399 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2402 if (TREE_CODE (op
) == ADDR_EXPR
)
2403 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2405 dump_unary_op (pp
, "*", t
, flags
);
2408 dump_unary_op (pp
, "&", t
, flags
);
2410 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2412 /* It is a cast, but we cannot tell whether it is a
2413 reinterpret or static cast. Use the C style notation. */
2414 if (flags
& TFF_EXPR_IN_PARENS
)
2415 pp_cxx_left_paren (pp
);
2416 pp_cxx_left_paren (pp
);
2417 dump_type (pp
, TREE_TYPE (t
), flags
);
2418 pp_cxx_right_paren (pp
);
2419 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2420 if (flags
& TFF_EXPR_IN_PARENS
)
2421 pp_cxx_right_paren (pp
);
2424 dump_expr (pp
, op
, flags
);
2429 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2431 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2433 if (integer_zerop (idx
))
2435 /* A NULL pointer-to-member constant. */
2436 pp_cxx_left_paren (pp
);
2437 pp_cxx_left_paren (pp
);
2438 dump_type (pp
, TREE_TYPE (t
), flags
);
2439 pp_cxx_right_paren (pp
);
2440 pp_character (pp
, '0');
2441 pp_cxx_right_paren (pp
);
2444 else if (tree_fits_shwi_p (idx
))
2447 unsigned HOST_WIDE_INT n
;
2449 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2450 t
= TYPE_METHOD_BASETYPE (t
);
2451 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2453 n
= tree_to_shwi (idx
);
2455 /* Map vtable index back one, to allow for the null pointer to
2459 while (n
> 0 && virtuals
)
2462 virtuals
= TREE_CHAIN (virtuals
);
2466 dump_expr (pp
, BV_FN (virtuals
),
2467 flags
| TFF_EXPR_IN_PARENS
);
2472 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2473 pp_string (pp
, "<lambda closure object>");
2474 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2476 dump_type (pp
, TREE_TYPE (t
), 0);
2477 pp_cxx_left_paren (pp
);
2478 pp_cxx_right_paren (pp
);
2482 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2483 dump_type (pp
, TREE_TYPE (t
), 0);
2484 pp_cxx_left_brace (pp
);
2485 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2486 pp_cxx_right_brace (pp
);
2493 tree ob
= TREE_OPERAND (t
, 0);
2494 if (is_dummy_object (ob
))
2496 t
= TREE_OPERAND (t
, 1);
2497 if (TREE_CODE (t
) == FUNCTION_DECL
)
2499 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2500 else if (BASELINK_P (t
))
2501 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2502 flags
| TFF_EXPR_IN_PARENS
);
2504 dump_decl (pp
, t
, flags
);
2508 if (INDIRECT_REF_P (ob
))
2510 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2516 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2520 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2525 case TEMPLATE_PARM_INDEX
:
2526 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2530 if (TREE_OPERAND (t
, 0) == NULL_TREE
2531 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2533 dump_type (pp
, TREE_TYPE (t
), flags
);
2534 pp_cxx_left_paren (pp
);
2535 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2536 pp_cxx_right_paren (pp
);
2540 pp_cxx_left_paren (pp
);
2541 dump_type (pp
, TREE_TYPE (t
), flags
);
2542 pp_cxx_right_paren (pp
);
2543 pp_cxx_left_paren (pp
);
2544 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2545 pp_cxx_right_paren (pp
);
2549 case STATIC_CAST_EXPR
:
2550 pp_cxx_ws_string (pp
, "static_cast");
2552 case REINTERPRET_CAST_EXPR
:
2553 pp_cxx_ws_string (pp
, "reinterpret_cast");
2555 case CONST_CAST_EXPR
:
2556 pp_cxx_ws_string (pp
, "const_cast");
2558 case DYNAMIC_CAST_EXPR
:
2559 pp_cxx_ws_string (pp
, "dynamic_cast");
2561 pp_cxx_begin_template_argument_list (pp
);
2562 dump_type (pp
, TREE_TYPE (t
), flags
);
2563 pp_cxx_end_template_argument_list (pp
);
2564 pp_cxx_left_paren (pp
);
2565 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2566 pp_cxx_right_paren (pp
);
2570 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2576 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2577 pp_cxx_ws_string (pp
, "sizeof");
2580 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2581 pp_cxx_ws_string (pp
, "__alignof__");
2583 op
= TREE_OPERAND (t
, 0);
2584 if (PACK_EXPANSION_P (op
))
2586 pp_string (pp
, "...");
2587 op
= PACK_EXPANSION_PATTERN (op
);
2589 pp_cxx_whitespace (pp
);
2590 pp_cxx_left_paren (pp
);
2591 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2592 dump_type (pp
, TREE_TYPE (op
), flags
);
2593 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2594 dump_type (pp
, op
, flags
);
2596 dump_expr (pp
, op
, flags
);
2597 pp_cxx_right_paren (pp
);
2600 case AT_ENCODE_EXPR
:
2601 pp_cxx_ws_string (pp
, "@encode");
2602 pp_cxx_whitespace (pp
);
2603 pp_cxx_left_paren (pp
);
2604 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2605 pp_cxx_right_paren (pp
);
2609 pp_cxx_ws_string (pp
, "noexcept");
2610 pp_cxx_whitespace (pp
);
2611 pp_cxx_left_paren (pp
);
2612 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2613 pp_cxx_right_paren (pp
);
2618 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2619 pp_cxx_whitespace (pp
);
2620 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2624 pp_string (pp
, M_("<unparsed>"));
2627 case TRY_CATCH_EXPR
:
2628 case WITH_CLEANUP_EXPR
:
2629 case CLEANUP_POINT_EXPR
:
2630 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2633 case PSEUDO_DTOR_EXPR
:
2634 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2636 if (TREE_OPERAND (t
, 1))
2638 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2639 pp_cxx_colon_colon (pp
);
2641 pp_cxx_complement (pp
);
2642 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2645 case TEMPLATE_ID_EXPR
:
2646 dump_decl (pp
, t
, flags
);
2652 case STATEMENT_LIST
:
2653 /* We don't yet have a way of dumping statements in a
2654 human-readable format. */
2655 pp_string (pp
, "({...})");
2659 pp_string (pp
, "while (1) { ");
2660 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2661 pp_cxx_right_brace (pp
);
2665 pp_string (pp
, "if (");
2666 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2667 pp_string (pp
, ") break; ");
2671 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2674 case EMPTY_CLASS_EXPR
:
2675 dump_type (pp
, TREE_TYPE (t
), flags
);
2676 pp_cxx_left_paren (pp
);
2677 pp_cxx_right_paren (pp
);
2680 case NON_DEPENDENT_EXPR
:
2681 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2684 case ARGUMENT_PACK_SELECT
:
2685 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2697 pp_type_specifier_seq (pp
, t
);
2701 /* We get here when we want to print a dependent type as an
2702 id-expression, without any disambiguator decoration. */
2703 pp
->id_expression (t
);
2706 case TEMPLATE_TYPE_PARM
:
2707 case TEMPLATE_TEMPLATE_PARM
:
2708 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2709 dump_type (pp
, t
, flags
);
2713 pp_cxx_trait_expression (pp
, t
);
2717 pp_cxx_va_arg_expression (pp
, t
);
2721 pp_cxx_offsetof_expression (pp
, t
);
2724 case ADDRESSOF_EXPR
:
2725 pp_cxx_addressof_expression (pp
, t
);
2729 dump_decl (pp
, t
, flags
);
2732 case EXPR_PACK_EXPANSION
:
2733 case UNARY_LEFT_FOLD_EXPR
:
2734 case UNARY_RIGHT_FOLD_EXPR
:
2735 case BINARY_LEFT_FOLD_EXPR
:
2736 case BINARY_RIGHT_FOLD_EXPR
:
2743 case VEC_DELETE_EXPR
:
2749 case UNORDERED_EXPR
:
2759 case FIX_TRUNC_EXPR
:
2764 case TRUTH_AND_EXPR
:
2766 case TRUTH_XOR_EXPR
:
2767 if (flags
& TFF_EXPR_IN_PARENS
)
2768 pp_cxx_left_paren (pp
);
2770 if (flags
& TFF_EXPR_IN_PARENS
)
2771 pp_cxx_right_paren (pp
);
2775 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2779 pp_string (pp
, M_("<lambda>"));
2783 pp_cxx_left_paren (pp
);
2784 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2785 pp_cxx_right_paren (pp
);
2789 pp_cxx_requires_expr (cxx_pp
, t
);
2793 pp_cxx_simple_requirement (cxx_pp
, t
);
2797 pp_cxx_type_requirement (cxx_pp
, t
);
2801 pp_cxx_compound_requirement (cxx_pp
, t
);
2805 pp_cxx_nested_requirement (cxx_pp
, t
);
2818 pp_cxx_constraint (cxx_pp
, t
);
2821 case PLACEHOLDER_EXPR
:
2822 pp_string (pp
, M_("*this"));
2826 dump_expr_list (pp
, t
, flags
);
2829 /* This list is incomplete, but should suffice for now.
2830 It is very important that `sorry' does not call
2831 `report_error_function'. That could cause an infinite loop. */
2833 pp_unsupported_tree (pp
, t
);
2836 pp_string (pp
, M_("<expression error>"));
2842 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2845 pp_cxx_left_paren (pp
);
2846 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2847 pp_cxx_whitespace (pp
);
2849 pp_cxx_ws_string (pp
, opstring
);
2851 pp_string (pp
, M_("<unknown operator>"));
2852 pp_cxx_whitespace (pp
);
2853 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2854 pp_cxx_right_paren (pp
);
2858 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2860 if (flags
& TFF_EXPR_IN_PARENS
)
2861 pp_cxx_left_paren (pp
);
2862 pp_cxx_ws_string (pp
, opstring
);
2863 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2864 if (flags
& TFF_EXPR_IN_PARENS
)
2865 pp_cxx_right_paren (pp
);
2869 reinit_cxx_pp (void)
2871 pp_clear_output_area (cxx_pp
);
2872 cxx_pp
->padding
= pp_none
;
2873 pp_indentation (cxx_pp
) = 0;
2874 pp_needs_newline (cxx_pp
) = false;
2875 cxx_pp
->enclosing_scope
= current_function_decl
;
2878 /* Same as pp_formatted_text, except the return string is a separate
2879 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2882 pp_ggc_formatted_text (pretty_printer
*pp
)
2884 return ggc_strdup (pp_formatted_text (pp
));
2887 /* Exported interface to stringifying types, exprs and decls under TFF_*
2891 type_as_string (tree typ
, int flags
)
2894 pp_translate_identifiers (cxx_pp
) = false;
2895 dump_type (cxx_pp
, typ
, flags
);
2896 return pp_ggc_formatted_text (cxx_pp
);
2900 type_as_string_translate (tree typ
, int flags
)
2903 dump_type (cxx_pp
, typ
, flags
);
2904 return pp_ggc_formatted_text (cxx_pp
);
2908 expr_as_string (tree decl
, int flags
)
2911 pp_translate_identifiers (cxx_pp
) = false;
2912 dump_expr (cxx_pp
, decl
, flags
);
2913 return pp_ggc_formatted_text (cxx_pp
);
2916 /* Wrap decl_as_string with options appropriate for dwarf. */
2919 decl_as_dwarf_string (tree decl
, int flags
)
2922 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2923 here will be adequate to get the desired behavior. */
2924 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2925 name
= decl_as_string (decl
, flags
);
2926 /* Subsequent calls to the pretty printer shouldn't use this style. */
2927 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2932 decl_as_string (tree decl
, int flags
)
2935 pp_translate_identifiers (cxx_pp
) = false;
2936 dump_decl (cxx_pp
, decl
, flags
);
2937 return pp_ggc_formatted_text (cxx_pp
);
2941 decl_as_string_translate (tree decl
, int flags
)
2944 dump_decl (cxx_pp
, decl
, flags
);
2945 return pp_ggc_formatted_text (cxx_pp
);
2948 /* Wrap lang_decl_name with options appropriate for dwarf. */
2951 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2954 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2955 here will be adequate to get the desired behavior. */
2956 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2957 name
= lang_decl_name (decl
, v
, translate
);
2958 /* Subsequent calls to the pretty printer shouldn't use this style. */
2959 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2963 /* Generate the three forms of printable names for cxx_printable_name. */
2966 lang_decl_name (tree decl
, int v
, bool translate
)
2970 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2971 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2974 pp_translate_identifiers (cxx_pp
) = translate
;
2976 && (DECL_CLASS_SCOPE_P (decl
)
2977 || (DECL_NAMESPACE_SCOPE_P (decl
)
2978 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2980 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2981 pp_cxx_colon_colon (cxx_pp
);
2984 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2985 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2986 else if ((DECL_NAME (decl
) == NULL_TREE
)
2987 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2988 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2990 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2992 return pp_ggc_formatted_text (cxx_pp
);
2995 /* Return the location of a tree passed to %+ formats. */
2998 location_of (tree t
)
3002 t
= TYPE_MAIN_DECL (t
);
3004 return input_location
;
3006 else if (TREE_CODE (t
) == OVERLOAD
)
3007 t
= OVL_FUNCTION (t
);
3010 return DECL_SOURCE_LOCATION (t
);
3011 return EXPR_LOC_OR_LOC (t
, input_location
);
3014 /* Now the interfaces from error et al to dump_type et al. Each takes an
3015 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
3019 decl_to_string (tree decl
, int verbose
)
3023 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
3024 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
3025 flags
= TFF_CLASS_KEY_OR_ENUM
;
3027 flags
|= TFF_DECL_SPECIFIERS
;
3028 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3029 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
3030 flags
|= TFF_TEMPLATE_HEADER
;
3033 dump_decl (cxx_pp
, decl
, flags
);
3034 return pp_ggc_formatted_text (cxx_pp
);
3038 expr_to_string (tree decl
)
3041 dump_expr (cxx_pp
, decl
, 0);
3042 return pp_ggc_formatted_text (cxx_pp
);
3046 fndecl_to_string (tree fndecl
, int verbose
)
3050 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
3051 | TFF_TEMPLATE_HEADER
;
3053 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3055 dump_decl (cxx_pp
, fndecl
, flags
);
3056 return pp_ggc_formatted_text (cxx_pp
);
3061 code_to_string (enum tree_code c
)
3063 return get_tree_code_name (c
);
3067 language_to_string (enum languages c
)
3074 case lang_cplusplus
:
3083 /* Return the proper printed version of a parameter to a C++ function. */
3086 parm_to_string (int p
)
3090 pp_string (cxx_pp
, "'this'");
3092 pp_decimal_int (cxx_pp
, p
+ 1);
3093 return pp_ggc_formatted_text (cxx_pp
);
3097 op_to_string (enum tree_code p
)
3099 tree id
= operator_name_info
[p
].identifier
;
3100 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3104 type_to_string (tree typ
, int verbose
)
3108 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3109 flags
|= TFF_TEMPLATE_HEADER
;
3112 dump_type (cxx_pp
, typ
, flags
);
3113 /* If we're printing a type that involves typedefs, also print the
3114 stripped version. But sometimes the stripped version looks
3115 exactly the same, so we don't want it after all. To avoid printing
3116 it in that case, we play ugly obstack games. */
3117 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3118 && !uses_template_parms (typ
))
3120 int aka_start
, aka_len
; char *p
;
3121 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3122 /* Remember the end of the initial dump. */
3123 int len
= obstack_object_size (ob
);
3124 tree aka
= strip_typedefs (typ
);
3125 pp_string (cxx_pp
, " {aka");
3126 pp_cxx_whitespace (cxx_pp
);
3127 /* And remember the start of the aka dump. */
3128 aka_start
= obstack_object_size (ob
);
3129 dump_type (cxx_pp
, aka
, flags
);
3130 aka_len
= obstack_object_size (ob
) - aka_start
;
3131 pp_right_brace (cxx_pp
);
3132 p
= (char*)obstack_base (ob
);
3133 /* If they are identical, cut off the aka with a NUL. */
3134 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3138 if (typ
&& TYPE_P (typ
) && TREE_CODE (typ
) == ENUMERAL_TYPE
)
3139 pp_string (cxx_pp
, M_(" {enum}"));
3141 return pp_ggc_formatted_text (cxx_pp
);
3145 assop_to_string (enum tree_code p
)
3147 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3148 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3152 args_to_string (tree p
, int verbose
)
3156 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3161 if (TYPE_P (TREE_VALUE (p
)))
3162 return type_as_string_translate (p
, flags
);
3165 for (; p
; p
= TREE_CHAIN (p
))
3167 if (TREE_VALUE (p
) == null_node
)
3168 pp_cxx_ws_string (cxx_pp
, "NULL");
3170 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3172 pp_separate_with_comma (cxx_pp
);
3174 return pp_ggc_formatted_text (cxx_pp
);
3177 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3178 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3182 subst_to_string (tree p
)
3184 tree decl
= TREE_PURPOSE (p
);
3185 tree targs
= TREE_VALUE (p
);
3186 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3187 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3188 |TFF_NO_TEMPLATE_BINDINGS
);
3194 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3195 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3196 return pp_ggc_formatted_text (cxx_pp
);
3200 cv_to_string (tree p
, int v
)
3203 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3204 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3205 return pp_ggc_formatted_text (cxx_pp
);
3209 eh_spec_to_string (tree p
, int /*v*/)
3213 dump_exception_spec (cxx_pp
, p
, flags
);
3214 return pp_ggc_formatted_text (cxx_pp
);
3217 /* Langhook for print_error_function. */
3219 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3220 diagnostic_info
*diagnostic
)
3222 lhd_print_error_function (context
, file
, diagnostic
);
3223 pp_set_prefix (context
->printer
, file
);
3224 maybe_print_instantiation_context (context
);
3228 cp_diagnostic_starter (diagnostic_context
*context
,
3229 diagnostic_info
*diagnostic
)
3231 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3232 cp_print_error_function (context
, diagnostic
);
3233 maybe_print_instantiation_context (context
);
3234 maybe_print_constexpr_context (context
);
3235 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3239 /* Print current function onto BUFFER, in the process of reporting
3240 a diagnostic message. Called from cp_diagnostic_starter. */
3242 cp_print_error_function (diagnostic_context
*context
,
3243 diagnostic_info
*diagnostic
)
3245 /* If we are in an instantiation context, current_function_decl is likely
3246 to be wrong, so just rely on print_instantiation_full_context. */
3247 if (current_instantiation ())
3249 if (diagnostic_last_function_changed (context
, diagnostic
))
3251 const char *old_prefix
= context
->printer
->prefix
;
3252 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3253 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3254 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3255 ? file_name_as_prefix (context
, file
) : NULL
;
3257 pp_set_prefix (context
->printer
, new_prefix
);
3259 if (current_function_decl
== NULL
)
3260 pp_string (context
->printer
, _("At global scope:"));
3265 if (abstract_origin
)
3267 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3268 while (TREE_CODE (ao
) == BLOCK
3269 && BLOCK_ABSTRACT_ORIGIN (ao
)
3270 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3271 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3272 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3276 fndecl
= current_function_decl
;
3278 pp_printf (context
->printer
, function_category (fndecl
),
3279 cxx_printable_name_translate (fndecl
, 2));
3281 while (abstract_origin
)
3284 tree block
= abstract_origin
;
3286 locus
= &BLOCK_SOURCE_LOCATION (block
);
3288 block
= BLOCK_SUPERCONTEXT (block
);
3289 while (block
&& TREE_CODE (block
) == BLOCK
3290 && BLOCK_ABSTRACT_ORIGIN (block
))
3292 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3294 while (TREE_CODE (ao
) == BLOCK
3295 && BLOCK_ABSTRACT_ORIGIN (ao
)
3296 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3297 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3299 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3304 else if (TREE_CODE (ao
) != BLOCK
)
3307 block
= BLOCK_SUPERCONTEXT (block
);
3310 abstract_origin
= block
;
3313 while (block
&& TREE_CODE (block
) == BLOCK
)
3314 block
= BLOCK_SUPERCONTEXT (block
);
3316 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3318 abstract_origin
= NULL
;
3322 expanded_location s
= expand_location (*locus
);
3323 pp_character (context
->printer
, ',');
3324 pp_newline (context
->printer
);
3327 if (context
->show_column
&& s
.column
!= 0)
3328 pp_printf (context
->printer
,
3329 _(" inlined from %qs at %r%s:%d:%d%R"),
3330 cxx_printable_name_translate (fndecl
, 2),
3331 "locus", s
.file
, s
.line
, s
.column
);
3333 pp_printf (context
->printer
,
3334 _(" inlined from %qs at %r%s:%d%R"),
3335 cxx_printable_name_translate (fndecl
, 2),
3336 "locus", s
.file
, s
.line
);
3340 pp_printf (context
->printer
, _(" inlined from %qs"),
3341 cxx_printable_name_translate (fndecl
, 2));
3344 pp_character (context
->printer
, ':');
3346 pp_newline (context
->printer
);
3348 diagnostic_set_last_function (context
, diagnostic
);
3349 pp_destroy_prefix (context
->printer
);
3350 context
->printer
->prefix
= old_prefix
;
3354 /* Returns a description of FUNCTION using standard terminology. The
3355 result is a format string of the form "In CATEGORY %qs". */
3357 function_category (tree fn
)
3359 /* We can get called from the middle-end for diagnostics of function
3360 clones. Make sure we have language specific information before
3361 dereferencing it. */
3362 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3363 && DECL_FUNCTION_MEMBER_P (fn
))
3365 if (DECL_STATIC_FUNCTION_P (fn
))
3366 return _("In static member function %qs");
3367 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3368 return _("In copy constructor %qs");
3369 else if (DECL_CONSTRUCTOR_P (fn
))
3370 return _("In constructor %qs");
3371 else if (DECL_DESTRUCTOR_P (fn
))
3372 return _("In destructor %qs");
3373 else if (LAMBDA_FUNCTION_P (fn
))
3374 return _("In lambda function");
3376 return _("In member function %qs");
3379 return _("In function %qs");
3382 /* Report the full context of a current template instantiation,
3385 print_instantiation_full_context (diagnostic_context
*context
)
3387 struct tinst_level
*p
= current_instantiation ();
3388 location_t location
= input_location
;
3392 pp_verbatim (context
->printer
,
3393 TREE_CODE (p
->decl
) == TREE_LIST
3394 ? _("%s: In substitution of %qS:\n")
3395 : _("%s: In instantiation of %q#D:\n"),
3396 LOCATION_FILE (location
),
3399 location
= p
->locus
;
3403 print_instantiation_partial_context (context
, p
, location
);
3406 /* Helper function of print_instantiation_partial_context() that
3407 prints a single line of instantiation context. */
3410 print_instantiation_partial_context_line (diagnostic_context
*context
,
3411 const struct tinst_level
*t
,
3412 location_t loc
, bool recursive_p
)
3414 if (loc
== UNKNOWN_LOCATION
)
3417 expanded_location xloc
= expand_location (loc
);
3419 if (context
->show_column
)
3420 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3421 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3423 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3424 "locus", xloc
.file
, xloc
.line
);
3428 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3429 pp_verbatim (context
->printer
,
3431 ? _("recursively required by substitution of %qS\n")
3432 : _("required by substitution of %qS\n"),
3435 pp_verbatim (context
->printer
,
3437 ? _("recursively required from %q#D\n")
3438 : _("required from %q#D\n"),
3443 pp_verbatim (context
->printer
,
3445 ? _("recursively required from here\n")
3446 : _("required from here\n"));
3450 /* Same as print_instantiation_full_context but less verbose. */
3453 print_instantiation_partial_context (diagnostic_context
*context
,
3454 struct tinst_level
*t0
, location_t loc
)
3456 struct tinst_level
*t
;
3459 location_t prev_loc
= loc
;
3461 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3462 if (prev_loc
!= t
->locus
)
3464 prev_loc
= t
->locus
;
3470 if (template_backtrace_limit
3471 && n_total
> template_backtrace_limit
)
3473 int skip
= n_total
- template_backtrace_limit
;
3474 int head
= template_backtrace_limit
/ 2;
3476 /* Avoid skipping just 1. If so, skip 2. */
3480 head
= (template_backtrace_limit
- 1) / 2;
3483 for (n
= 0; n
< head
; n
++)
3485 gcc_assert (t
!= NULL
);
3486 if (loc
!= t
->locus
)
3487 print_instantiation_partial_context_line (context
, t
, loc
,
3488 /*recursive_p=*/false);
3492 if (t
!= NULL
&& skip
> 0)
3494 expanded_location xloc
;
3495 xloc
= expand_location (loc
);
3496 if (context
->show_column
)
3497 pp_verbatim (context
->printer
,
3498 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3499 "contexts, use -ftemplate-backtrace-limit=0 to "
3501 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3503 pp_verbatim (context
->printer
,
3504 _("%r%s:%d:%R [ skipping %d instantiation "
3505 "contexts, use -ftemplate-backtrace-limit=0 to "
3507 "locus", xloc
.file
, xloc
.line
, skip
);
3512 } while (t
!= NULL
&& --skip
> 0);
3518 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3523 print_instantiation_partial_context_line (context
, t
, loc
,
3528 print_instantiation_partial_context_line (context
, NULL
, loc
,
3529 /*recursive_p=*/false);
3532 /* Called from cp_thing to print the template context for an error. */
3534 maybe_print_instantiation_context (diagnostic_context
*context
)
3536 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3539 record_last_problematic_instantiation ();
3540 print_instantiation_full_context (context
);
3543 /* Report what constexpr call(s) we're trying to expand, if any. */
3546 maybe_print_constexpr_context (diagnostic_context
*context
)
3548 vec
<tree
> call_stack
= cx_error_context ();
3552 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3554 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3555 const char *s
= expr_as_string (t
, 0);
3556 if (context
->show_column
)
3557 pp_verbatim (context
->printer
,
3558 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3559 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3561 pp_verbatim (context
->printer
,
3562 _("%r%s:%d:%R in constexpr expansion of %qs"),
3563 "locus", xloc
.file
, xloc
.line
, s
);
3564 pp_newline (context
->printer
);
3568 /* Called from output_format -- during diagnostic message processing --
3569 to handle C++ specific format specifier with the following meanings:
3570 %A function argument-list.
3574 %F function declaration.
3575 %L language as used in extern "lang".
3577 %P function parameter whose position is indicated by an integer.
3578 %Q assignment operator.
3579 %S substitution (template + args)
3582 %X exception-specification. */
3584 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3585 int precision
, bool wide
, bool set_locus
, bool verbose
)
3589 #define next_tree (t = va_arg (*text->args_ptr, tree))
3590 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3591 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3592 #define next_int va_arg (*text->args_ptr, int)
3594 if (precision
!= 0 || wide
)
3599 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3600 case 'C': result
= code_to_string (next_tcode
); break;
3603 tree temp
= next_tree
;
3605 && DECL_HAS_DEBUG_EXPR_P (temp
))
3607 temp
= DECL_DEBUG_EXPR (temp
);
3610 result
= expr_to_string (temp
);
3614 result
= decl_to_string (temp
, verbose
);
3617 case 'E': result
= expr_to_string (next_tree
); break;
3618 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3619 case 'L': result
= language_to_string (next_lang
); break;
3620 case 'O': result
= op_to_string (next_tcode
); break;
3621 case 'P': result
= parm_to_string (next_int
); break;
3622 case 'Q': result
= assop_to_string (next_tcode
); break;
3623 case 'S': result
= subst_to_string (next_tree
); break;
3624 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3625 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3626 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3629 percent_K_format (text
);
3636 pp_string (pp
, result
);
3637 if (set_locus
&& t
!= NULL
)
3638 text
->set_location (0, location_of (t
), true);
3646 /* Warn about the use of C++0x features when appropriate. */
3648 maybe_warn_cpp0x (cpp0x_warn_str str
)
3650 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3651 /* We really want to suppress this warning in system headers,
3652 because libstdc++ uses variadic templates even when we aren't
3656 case CPP0X_INITIALIZER_LISTS
:
3657 pedwarn (input_location
, 0,
3658 "extended initializer lists "
3659 "only available with -std=c++11 or -std=gnu++11");
3661 case CPP0X_EXPLICIT_CONVERSION
:
3662 pedwarn (input_location
, 0,
3663 "explicit conversion operators "
3664 "only available with -std=c++11 or -std=gnu++11");
3666 case CPP0X_VARIADIC_TEMPLATES
:
3667 pedwarn (input_location
, 0,
3668 "variadic templates "
3669 "only available with -std=c++11 or -std=gnu++11");
3671 case CPP0X_LAMBDA_EXPR
:
3672 pedwarn (input_location
, 0,
3673 "lambda expressions "
3674 "only available with -std=c++11 or -std=gnu++11");
3677 pedwarn (input_location
, 0,
3678 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3680 case CPP0X_SCOPED_ENUMS
:
3681 pedwarn (input_location
, 0,
3682 "scoped enums only available with -std=c++11 or -std=gnu++11");
3684 case CPP0X_DEFAULTED_DELETED
:
3685 pedwarn (input_location
, 0,
3686 "defaulted and deleted functions "
3687 "only available with -std=c++11 or -std=gnu++11");
3689 case CPP0X_INLINE_NAMESPACES
:
3690 pedwarn (input_location
, OPT_Wpedantic
,
3691 "inline namespaces "
3692 "only available with -std=c++11 or -std=gnu++11");
3694 case CPP0X_OVERRIDE_CONTROLS
:
3695 pedwarn (input_location
, 0,
3696 "override controls (override/final) "
3697 "only available with -std=c++11 or -std=gnu++11");
3700 pedwarn (input_location
, 0,
3701 "non-static data member initializers "
3702 "only available with -std=c++11 or -std=gnu++11");
3704 case CPP0X_USER_DEFINED_LITERALS
:
3705 pedwarn (input_location
, 0,
3706 "user-defined literals "
3707 "only available with -std=c++11 or -std=gnu++11");
3709 case CPP0X_DELEGATING_CTORS
:
3710 pedwarn (input_location
, 0,
3711 "delegating constructors "
3712 "only available with -std=c++11 or -std=gnu++11");
3714 case CPP0X_INHERITING_CTORS
:
3715 pedwarn (input_location
, 0,
3716 "inheriting constructors "
3717 "only available with -std=c++11 or -std=gnu++11");
3719 case CPP0X_ATTRIBUTES
:
3720 pedwarn (input_location
, 0,
3722 "only available with -std=c++11 or -std=gnu++11");
3724 case CPP0X_REF_QUALIFIER
:
3725 pedwarn (input_location
, 0,
3727 "only available with -std=c++11 or -std=gnu++11");
3734 /* Warn about the use of variadic templates when appropriate. */
3736 maybe_warn_variadic_templates (void)
3738 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3742 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3743 option OPT with text GMSGID. Use this function to report
3744 diagnostics for constructs that are invalid C++98, but valid
3747 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3749 diagnostic_info diagnostic
;
3752 rich_location
richloc (line_table
, location
);
3754 va_start (ap
, gmsgid
);
3755 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
3756 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3757 diagnostic
.option_index
= opt
;
3758 ret
= report_diagnostic (&diagnostic
);
3763 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3764 we found when we tried to do the lookup. LOCATION is the location of
3765 the NAME identifier. */
3768 qualified_name_lookup_error (tree scope
, tree name
,
3769 tree decl
, location_t location
)
3771 if (scope
== error_mark_node
)
3772 ; /* We already complained. */
3773 else if (TYPE_P (scope
))
3775 if (!COMPLETE_TYPE_P (scope
))
3776 error_at (location
, "incomplete type %qT used in nested name specifier",
3778 else if (TREE_CODE (decl
) == TREE_LIST
)
3780 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3782 print_candidates (decl
);
3785 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3787 else if (scope
!= global_namespace
)
3789 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3790 if (!suggest_alternative_in_explicit_scope (location
, name
, scope
))
3791 suggest_alternatives_for (location
, name
, false);
3795 error_at (location
, "%<::%D%> has not been declared", name
);
3796 suggest_alternatives_for (location
, name
, true);