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
);
1192 if (!OVL_SINGLE_P (t
))
1195 tree ctx
= CP_DECL_CONTEXT (t
);
1196 if (ctx
!= global_namespace
)
1199 dump_type (pp
, ctx
, flags
);
1201 dump_decl (pp
, ctx
, flags
);
1202 pp_cxx_colon_colon (pp
);
1204 dump_decl (pp
, DECL_NAME (t
), flags
);
1208 /* If there's only one function, just treat it like an ordinary
1214 if (! DECL_LANG_SPECIFIC (t
))
1216 if (DECL_ABSTRACT_ORIGIN (t
)
1217 && DECL_ABSTRACT_ORIGIN (t
) != t
)
1218 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1220 dump_function_name (pp
, t
, flags
);
1222 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1223 dump_global_iord (pp
, t
);
1225 dump_function_decl (pp
, t
, flags
);
1229 dump_template_decl (pp
, t
, flags
);
1232 case TEMPLATE_ID_EXPR
:
1234 tree name
= TREE_OPERAND (t
, 0);
1235 tree args
= TREE_OPERAND (t
, 1);
1237 if (!identifier_p (name
))
1238 name
= OVL_NAME (name
);
1239 dump_decl (pp
, name
, flags
);
1240 pp_cxx_begin_template_argument_list (pp
);
1241 if (args
== error_mark_node
)
1242 pp_string (pp
, M_("<template arguments error>"));
1244 dump_template_argument_list
1245 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1246 pp_cxx_end_template_argument_list (pp
);
1251 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1255 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1256 || (DECL_INITIAL (t
) &&
1257 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1258 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1259 else if (DECL_NAME (t
))
1260 dump_decl (pp
, DECL_NAME (t
), flags
);
1261 else if (DECL_INITIAL (t
))
1262 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1264 pp_string (pp
, M_("<enumerator>"));
1269 pp_cxx_ws_string (pp
, "using");
1270 tree scope
= USING_DECL_SCOPE (t
);
1271 bool variadic
= false;
1272 if (PACK_EXPANSION_P (scope
))
1274 scope
= PACK_EXPANSION_PATTERN (scope
);
1277 dump_type (pp
, scope
, flags
);
1278 pp_cxx_colon_colon (pp
);
1279 dump_decl (pp
, DECL_NAME (t
), flags
);
1281 pp_cxx_ws_string (pp
, "...");
1286 pp
->declaration (t
);
1290 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1293 case NON_DEPENDENT_EXPR
:
1294 dump_expr (pp
, t
, flags
);
1297 case TEMPLATE_TYPE_PARM
:
1298 if (flags
& TFF_DECL_SPECIFIERS
)
1299 pp
->declaration (t
);
1304 case UNBOUND_CLASS_TEMPLATE
:
1305 case TYPE_PACK_EXPANSION
:
1307 dump_type (pp
, t
, flags
);
1311 pp_unsupported_tree (pp
, t
);
1315 pp_string (pp
, M_("<declaration error>"));
1320 /* Dump a template declaration T under control of FLAGS. This means the
1321 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1324 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1326 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1330 if (flags
& TFF_TEMPLATE_HEADER
)
1332 for (parms
= orig_parms
= nreverse (orig_parms
);
1334 parms
= TREE_CHAIN (parms
))
1336 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1337 int len
= TREE_VEC_LENGTH (inner_parms
);
1341 /* Skip over the dummy template levels of a template template
1343 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1347 pp_cxx_ws_string (pp
, "template");
1348 pp_cxx_begin_template_argument_list (pp
);
1350 /* If we've shown the template prefix, we'd better show the
1351 parameters' and decl's type too. */
1352 flags
|= TFF_DECL_SPECIFIERS
;
1354 for (i
= 0; i
< len
; i
++)
1357 pp_separate_with_comma (pp
);
1358 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1361 pp_cxx_end_template_argument_list (pp
);
1362 pp_cxx_whitespace (pp
);
1364 nreverse(orig_parms
);
1366 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1368 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1369 pp_cxx_ws_string (pp
, "class");
1371 /* If this is a parameter pack, print the ellipsis. */
1372 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1373 pp_cxx_ws_string (pp
, "...");
1376 /* Only print the requirements if we're also printing
1377 the template header. */
1379 if (tree ci
= get_constraints (t
))
1380 if (check_constraint_info (ci
))
1381 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1383 pp_cxx_requires_clause (pp
, reqs
);
1384 pp_cxx_whitespace (pp
);
1389 if (DECL_CLASS_TEMPLATE_P (t
))
1390 dump_type (pp
, TREE_TYPE (t
),
1391 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1392 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1393 else if (DECL_TEMPLATE_RESULT (t
)
1394 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1395 /* Alias template. */
1396 || DECL_TYPE_TEMPLATE_P (t
)))
1397 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1400 gcc_assert (TREE_TYPE (t
));
1401 switch (NEXT_CODE (t
))
1405 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1408 /* This case can occur with some invalid code. */
1409 dump_type (pp
, TREE_TYPE (t
),
1410 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1411 | (flags
& TFF_DECL_SPECIFIERS
1412 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1417 /* find_typenames looks through the type of the function template T
1418 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1421 struct find_typenames_t
1423 hash_set
<tree
> *p_set
;
1424 vec
<tree
, va_gc
> *typenames
;
1428 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1430 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1431 tree mv
= NULL_TREE
;
1433 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1434 /* Add the type of the typedef without any additional cv-quals. */
1435 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1436 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1437 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1438 /* Add the typename without any cv-qualifiers. */
1439 mv
= TYPE_MAIN_VARIANT (*tp
);
1441 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1443 /* Don't mess with parameter packs since we don't remember
1444 the pack expansion context for a particular typename. */
1445 *walk_subtrees
= false;
1449 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1450 vec_safe_push (d
->typenames
, mv
);
1452 /* Search into class template arguments, which cp_walk_subtrees
1454 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1455 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1461 static vec
<tree
, va_gc
> *
1462 find_typenames (tree t
)
1464 struct find_typenames_t ft
;
1465 ft
.p_set
= new hash_set
<tree
>;
1466 ft
.typenames
= NULL
;
1467 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1468 find_typenames_r
, &ft
, ft
.p_set
);
1470 return ft
.typenames
;
1473 /* Output the "[with ...]" clause for a template instantiation T iff
1474 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1475 formatting a deduction/substitution diagnostic rather than an
1479 dump_substitution (cxx_pretty_printer
*pp
,
1480 tree t
, tree template_parms
, tree template_args
,
1483 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1484 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1486 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1487 pp_cxx_whitespace (pp
);
1488 pp_cxx_left_bracket (pp
);
1489 pp
->translate_string ("with");
1490 pp_cxx_whitespace (pp
);
1491 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1492 pp_cxx_right_bracket (pp
);
1496 /* Dump the lambda function FN including its 'mutable' qualifier and any
1497 template bindings. */
1500 dump_lambda_function (cxx_pretty_printer
*pp
,
1501 tree fn
, tree template_parms
, tree template_args
,
1504 /* A lambda's signature is essentially its "type". */
1505 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1506 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1508 pp
->padding
= pp_before
;
1509 pp_c_ws_string (pp
, "mutable");
1511 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1514 /* Pretty print a function decl. There are several ways we want to print a
1515 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1516 As error can only apply the '#' flag once to give 0 and 1 for V, there
1517 is %D which doesn't print the throw specs, and %F which does. */
1520 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1524 tree cname
= NULL_TREE
;
1525 tree template_args
= NULL_TREE
;
1526 tree template_parms
= NULL_TREE
;
1527 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1528 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1532 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1533 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1534 t
= DECL_TEMPLATE_RESULT (t
);
1536 /* Save the exceptions, in case t is a specialization and we are
1537 emitting an error about incompatible specifications. */
1538 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1540 /* Likewise for the constexpr specifier, in case t is a specialization. */
1541 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1543 /* Pretty print template instantiations only. */
1544 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1545 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1546 && flag_pretty_templates
)
1550 template_args
= DECL_TI_ARGS (t
);
1551 tmpl
= most_general_template (t
);
1552 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1554 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1559 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1560 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1562 fntype
= TREE_TYPE (t
);
1563 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1565 if (DECL_CLASS_SCOPE_P (t
))
1566 cname
= DECL_CONTEXT (t
);
1567 /* This is for partially instantiated template methods. */
1568 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1569 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1571 if (flags
& TFF_DECL_SPECIFIERS
)
1573 if (DECL_STATIC_FUNCTION_P (t
))
1574 pp_cxx_ws_string (pp
, "static");
1575 else if (DECL_VIRTUAL_P (t
))
1576 pp_cxx_ws_string (pp
, "virtual");
1580 if (DECL_DECLARED_CONCEPT_P (t
))
1581 pp_cxx_ws_string (pp
, "concept");
1583 pp_cxx_ws_string (pp
, "constexpr");
1587 /* Print the return type? */
1589 show_return
= (!DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1590 && !DECL_DESTRUCTOR_P (t
) && !deduction_guide_p (t
));
1593 tree ret
= fndecl_declared_return_type (t
);
1594 dump_type_prefix (pp
, ret
, flags
);
1597 /* Print the function name. */
1598 if (!do_outer_scope
)
1602 dump_type (pp
, cname
, flags
);
1603 pp_cxx_colon_colon (pp
);
1606 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1608 dump_function_name (pp
, t
, flags
);
1610 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1612 dump_parameters (pp
, parmtypes
, flags
);
1614 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1616 pp
->padding
= pp_before
;
1617 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1618 dump_ref_qualifier (pp
, fntype
, flags
);
1621 if (tx_safe_fn_type_p (fntype
))
1623 pp
->padding
= pp_before
;
1624 pp_cxx_ws_string (pp
, "transaction_safe");
1627 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1629 pp
->padding
= pp_before
;
1630 dump_exception_spec (pp
, exceptions
, flags
);
1634 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1635 else if (deduction_guide_p (t
))
1637 pp_cxx_ws_string (pp
, "->");
1638 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1642 if (tree ci
= get_constraints (t
))
1643 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1644 pp_cxx_requires_clause (pp
, reqs
);
1646 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1648 if (tree base
= DECL_INHERITED_CTOR_BASE (t
))
1650 pp_cxx_ws_string (pp
, "[inherited from");
1651 dump_type (pp
, base
, TFF_PLAIN_IDENTIFIER
);
1652 pp_character (pp
, ']');
1655 else if (template_args
)
1657 bool need_comma
= false;
1659 pp_cxx_begin_template_argument_list (pp
);
1660 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1661 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1663 tree arg
= TREE_VEC_ELT (template_args
, i
);
1665 pp_separate_with_comma (pp
);
1666 if (ARGUMENT_PACK_P (arg
))
1667 pp_cxx_left_brace (pp
);
1668 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1669 if (ARGUMENT_PACK_P (arg
))
1670 pp_cxx_right_brace (pp
);
1673 pp_cxx_end_template_argument_list (pp
);
1677 /* Print a parameter list. If this is for a member function, the
1678 member object ptr (and any other hidden args) should have
1679 already been removed. */
1682 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1685 flags
&= ~TFF_SCOPE
;
1686 pp_cxx_left_paren (pp
);
1688 for (first
= 1; parmtypes
!= void_list_node
;
1689 parmtypes
= TREE_CHAIN (parmtypes
))
1692 pp_separate_with_comma (pp
);
1696 pp_cxx_ws_string (pp
, "...");
1700 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1702 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1704 pp_cxx_whitespace (pp
);
1706 pp_cxx_whitespace (pp
);
1707 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1711 pp_cxx_right_paren (pp
);
1714 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1717 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1719 if (FUNCTION_REF_QUALIFIED (t
))
1721 pp
->padding
= pp_before
;
1722 if (FUNCTION_RVALUE_QUALIFIED (t
))
1723 pp_cxx_ws_string (pp
, "&&");
1725 pp_cxx_ws_string (pp
, "&");
1729 /* Print an exception specification. T is the exception specification. */
1732 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1734 if (t
&& TREE_PURPOSE (t
))
1736 pp_cxx_ws_string (pp
, "noexcept");
1737 if (!integer_onep (TREE_PURPOSE (t
)))
1739 pp_cxx_whitespace (pp
);
1740 pp_cxx_left_paren (pp
);
1741 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1742 pp_cxx_ws_string (pp
, "<uninstantiated>");
1744 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1745 pp_cxx_right_paren (pp
);
1750 pp_cxx_ws_string (pp
, "throw");
1751 pp_cxx_whitespace (pp
);
1752 pp_cxx_left_paren (pp
);
1753 if (TREE_VALUE (t
) != NULL_TREE
)
1756 dump_type (pp
, TREE_VALUE (t
), flags
);
1760 pp_separate_with_comma (pp
);
1762 pp_cxx_right_paren (pp
);
1766 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1767 and destructors properly. */
1770 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1772 tree name
= DECL_NAME (t
);
1774 /* We can get here with a decl that was synthesized by language-
1775 independent machinery (e.g. coverage.c) in which case it won't
1776 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1777 will crash. In this case it is safe just to print out the
1779 if (!DECL_LANG_SPECIFIC (t
))
1781 pp_cxx_tree_identifier (pp
, name
);
1785 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1786 t
= DECL_TEMPLATE_RESULT (t
);
1788 /* Don't let the user see __comp_ctor et al. */
1789 if (DECL_CONSTRUCTOR_P (t
)
1790 || DECL_DESTRUCTOR_P (t
))
1792 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1793 name
= get_identifier ("<lambda>");
1794 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1795 name
= get_identifier ("<constructor>");
1797 name
= constructor_name (DECL_CONTEXT (t
));
1800 if (DECL_DESTRUCTOR_P (t
))
1802 pp_cxx_complement (pp
);
1803 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1805 else if (DECL_CONV_FN_P (t
))
1807 /* This cannot use the hack that the operator's return
1808 type is stashed off of its name because it may be
1809 used for error reporting. In the case of conflicting
1810 declarations, both will have the same name, yet
1811 the types will be different, hence the TREE_TYPE field
1812 of the first name will be clobbered by the second. */
1813 pp_cxx_ws_string (pp
, "operator");
1814 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1817 dump_decl (pp
, name
, flags
);
1819 if (DECL_TEMPLATE_INFO (t
)
1820 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1821 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1822 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1823 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1827 /* Dump the template parameters from the template info INFO under control of
1828 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1829 specialization (partial or complete). For partial specializations we show
1830 the specialized parameter values. For a primary template we show no
1834 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1835 int primary
, int flags
)
1837 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1839 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1841 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1842 pp_cxx_begin_template_argument_list (pp
);
1844 /* Be careful only to print things when we have them, so as not
1845 to crash producing error messages. */
1846 if (args
&& !primary
)
1849 len
= get_non_default_template_args_count (args
, flags
);
1851 args
= INNERMOST_TEMPLATE_ARGS (args
);
1852 for (ix
= 0; ix
!= len
; ix
++)
1854 tree arg
= TREE_VEC_ELT (args
, ix
);
1856 /* Only print a comma if we know there is an argument coming. In
1857 the case of an empty template argument pack, no actual
1858 argument will be printed. */
1860 && (!ARGUMENT_PACK_P (arg
)
1861 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1862 pp_separate_with_comma (pp
);
1865 pp_string (pp
, M_("<template parameter error>"));
1867 dump_template_argument (pp
, arg
, flags
);
1872 tree tpl
= TI_TEMPLATE (info
);
1873 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1876 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1877 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1879 for (ix
= 0; ix
!= len
; ix
++)
1883 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1885 pp_string (pp
, M_("<template parameter error>"));
1889 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1892 pp_separate_with_comma (pp
);
1894 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1897 pp_cxx_end_template_argument_list (pp
);
1900 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1901 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1904 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1907 call_expr_arg_iterator iter
;
1909 pp_cxx_left_paren (pp
);
1910 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1916 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1917 if (more_call_expr_args_p (&iter
))
1918 pp_separate_with_comma (pp
);
1921 pp_cxx_right_paren (pp
);
1924 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1925 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1929 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1933 aggr_init_expr_arg_iterator iter
;
1935 pp_cxx_left_paren (pp
);
1936 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1942 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1943 if (more_aggr_init_expr_args_p (&iter
))
1944 pp_separate_with_comma (pp
);
1947 pp_cxx_right_paren (pp
);
1950 /* Print out a list of initializers (subr of dump_expr). */
1953 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1957 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1960 pp_separate_with_comma (pp
);
1964 /* Print out a vector of initializers (subr of dump_expr). */
1967 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1970 unsigned HOST_WIDE_INT idx
;
1973 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1975 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1976 if (idx
!= v
->length () - 1)
1977 pp_separate_with_comma (pp
);
1982 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1983 function. Resolve it to a close relative -- in the sense of static
1984 type -- variant being overridden. That is close to what was written in
1985 the source code. Subroutine of dump_expr. */
1988 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1990 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1991 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1992 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1995 fun
= TREE_CHAIN (fun
);
1996 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1997 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
2003 /* Print out an expression E under control of FLAGS. */
2006 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
2013 if (STATEMENT_CLASS_P (t
))
2015 pp_cxx_ws_string (pp
, M_("<statement>"));
2019 switch (TREE_CODE (t
))
2027 case NAMESPACE_DECL
:
2031 case IDENTIFIER_NODE
:
2032 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
2033 |TFF_TEMPLATE_HEADER
))
2034 | TFF_NO_TEMPLATE_BINDINGS
2035 | TFF_NO_FUNCTION_ARGUMENTS
));
2039 if (SSA_NAME_VAR (t
)
2040 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
2041 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2043 pp_cxx_ws_string (pp
, M_("<unknown>"));
2054 case USERDEF_LITERAL
:
2055 pp_cxx_userdef_literal (pp
, t
);
2059 /* While waiting for caret diagnostics, avoid printing
2060 __cxa_allocate_exception, __cxa_throw, and the like. */
2061 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2066 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2067 pp_cxx_colon_colon (pp
);
2068 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2072 pp_cxx_left_paren (pp
);
2073 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2074 pp_separate_with_comma (pp
);
2075 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2076 pp_cxx_right_paren (pp
);
2081 pp_cxx_left_paren (pp
);
2082 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2083 pp_string (pp
, " ? ");
2084 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2085 pp_string (pp
, " : ");
2086 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2087 pp_cxx_right_paren (pp
);
2091 if (TREE_HAS_CONSTRUCTOR (t
))
2093 pp_cxx_ws_string (pp
, "new");
2094 pp_cxx_whitespace (pp
);
2095 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2098 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2101 case AGGR_INIT_EXPR
:
2103 tree fn
= NULL_TREE
;
2105 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2106 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2108 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2110 if (DECL_CONSTRUCTOR_P (fn
))
2111 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2113 dump_decl (pp
, fn
, 0);
2116 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2118 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2123 tree fn
= CALL_EXPR_FN (t
);
2124 bool skipfirst
= false;
2126 /* Deal with internal functions. */
2127 if (fn
== NULL_TREE
)
2129 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2130 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2134 if (TREE_CODE (fn
) == ADDR_EXPR
)
2135 fn
= TREE_OPERAND (fn
, 0);
2137 /* Nobody is interested in seeing the guts of vcalls. */
2138 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2139 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2141 if (TREE_TYPE (fn
) != NULL_TREE
2142 && NEXT_CODE (fn
) == METHOD_TYPE
2143 && call_expr_nargs (t
))
2145 tree ob
= CALL_EXPR_ARG (t
, 0);
2146 if (TREE_CODE (ob
) == ADDR_EXPR
)
2148 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2149 flags
| TFF_EXPR_IN_PARENS
);
2152 else if (TREE_CODE (ob
) != PARM_DECL
2153 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2155 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2160 if (flag_sanitize
& SANITIZE_UNDEFINED
2161 && is_ubsan_builtin_p (fn
))
2163 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2166 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2167 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2172 /* Note that this only works for G++ target exprs. If somebody
2173 builds a general TARGET_EXPR, there's no way to represent that
2174 it initializes anything other that the parameter slot for the
2175 default argument. Note we may have cleared out the first
2176 operand in expand_expr, so don't go killing ourselves. */
2177 if (TREE_OPERAND (t
, 1))
2178 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2181 case POINTER_PLUS_EXPR
:
2182 dump_binary_op (pp
, "+", t
, flags
);
2187 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2194 case TRUNC_DIV_EXPR
:
2195 case TRUNC_MOD_EXPR
:
2203 case TRUTH_ANDIF_EXPR
:
2204 case TRUTH_ORIF_EXPR
:
2211 case EXACT_DIV_EXPR
:
2212 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2216 case FLOOR_DIV_EXPR
:
2217 case ROUND_DIV_EXPR
:
2219 dump_binary_op (pp
, "/", t
, flags
);
2223 case FLOOR_MOD_EXPR
:
2224 case ROUND_MOD_EXPR
:
2225 dump_binary_op (pp
, "%", t
, flags
);
2230 tree ob
= TREE_OPERAND (t
, 0);
2231 if (INDIRECT_REF_P (ob
))
2233 ob
= TREE_OPERAND (ob
, 0);
2234 if (TREE_CODE (ob
) != PARM_DECL
2236 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2238 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2239 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2247 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2248 if (TREE_CODE (ob
) != ARROW_EXPR
)
2251 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2256 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2257 pp_cxx_left_bracket (pp
);
2258 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2259 pp_cxx_right_bracket (pp
);
2262 case ARRAY_NOTATION_REF
:
2263 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2264 pp_cxx_left_bracket (pp
);
2265 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2267 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2269 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2270 pp_cxx_right_bracket (pp
);
2273 case UNARY_PLUS_EXPR
:
2274 dump_unary_op (pp
, "+", t
, flags
);
2278 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2279 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2280 /* An ADDR_EXPR can have reference type. In that case, we
2281 shouldn't print the `&' doing so indicates to the user
2282 that the expression has pointer type. */
2284 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2285 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2286 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2287 dump_unary_op (pp
, "&&", t
, flags
);
2289 dump_unary_op (pp
, "&", t
, flags
);
2293 if (TREE_HAS_CONSTRUCTOR (t
))
2295 t
= TREE_OPERAND (t
, 0);
2296 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2297 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2298 dump_call_expr_args (pp
, t
, flags
, true);
2302 if (TREE_OPERAND (t
,0) != NULL_TREE
2303 && TREE_TYPE (TREE_OPERAND (t
, 0))
2304 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2305 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2307 dump_unary_op (pp
, "*", t
, flags
);
2312 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2313 && integer_zerop (TREE_OPERAND (t
, 1)))
2314 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2318 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2320 pp_cxx_left_paren (pp
);
2321 if (!integer_onep (TYPE_SIZE_UNIT
2322 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2324 pp_cxx_left_paren (pp
);
2325 dump_type (pp
, ptr_type_node
, flags
);
2326 pp_cxx_right_paren (pp
);
2329 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2330 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2332 pp_cxx_ws_string (pp
, "+");
2333 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2335 pp_cxx_right_paren (pp
);
2342 case TRUTH_NOT_EXPR
:
2343 case PREDECREMENT_EXPR
:
2344 case PREINCREMENT_EXPR
:
2345 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2348 case POSTDECREMENT_EXPR
:
2349 case POSTINCREMENT_EXPR
:
2350 pp_cxx_left_paren (pp
);
2351 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2352 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2353 pp_cxx_right_paren (pp
);
2356 case NON_LVALUE_EXPR
:
2357 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2358 should be another level of INDIRECT_REF so that I don't have to do
2360 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2362 tree next
= TREE_TYPE (TREE_TYPE (t
));
2364 while (TYPE_PTR_P (next
))
2365 next
= TREE_TYPE (next
);
2367 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2369 if (flags
& TFF_EXPR_IN_PARENS
)
2370 pp_cxx_left_paren (pp
);
2372 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2373 if (flags
& TFF_EXPR_IN_PARENS
)
2374 pp_cxx_right_paren (pp
);
2377 /* Else fall through. */
2379 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2383 case IMPLICIT_CONV_EXPR
:
2384 case VIEW_CONVERT_EXPR
:
2386 tree op
= TREE_OPERAND (t
, 0);
2387 tree ttype
= TREE_TYPE (t
);
2388 tree optype
= TREE_TYPE (op
);
2390 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2391 && POINTER_TYPE_P (ttype
)
2392 && POINTER_TYPE_P (optype
)
2393 && same_type_p (TREE_TYPE (optype
),
2396 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2399 if (TREE_CODE (op
) == ADDR_EXPR
)
2400 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2402 dump_unary_op (pp
, "*", t
, flags
);
2405 dump_unary_op (pp
, "&", t
, flags
);
2407 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2409 /* It is a cast, but we cannot tell whether it is a
2410 reinterpret or static cast. Use the C style notation. */
2411 if (flags
& TFF_EXPR_IN_PARENS
)
2412 pp_cxx_left_paren (pp
);
2413 pp_cxx_left_paren (pp
);
2414 dump_type (pp
, TREE_TYPE (t
), flags
);
2415 pp_cxx_right_paren (pp
);
2416 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2417 if (flags
& TFF_EXPR_IN_PARENS
)
2418 pp_cxx_right_paren (pp
);
2421 dump_expr (pp
, op
, flags
);
2426 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2428 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2430 if (integer_zerop (idx
))
2432 /* A NULL pointer-to-member constant. */
2433 pp_cxx_left_paren (pp
);
2434 pp_cxx_left_paren (pp
);
2435 dump_type (pp
, TREE_TYPE (t
), flags
);
2436 pp_cxx_right_paren (pp
);
2437 pp_character (pp
, '0');
2438 pp_cxx_right_paren (pp
);
2441 else if (tree_fits_shwi_p (idx
))
2444 unsigned HOST_WIDE_INT n
;
2446 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2447 t
= TYPE_METHOD_BASETYPE (t
);
2448 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2450 n
= tree_to_shwi (idx
);
2452 /* Map vtable index back one, to allow for the null pointer to
2456 while (n
> 0 && virtuals
)
2459 virtuals
= TREE_CHAIN (virtuals
);
2463 dump_expr (pp
, BV_FN (virtuals
),
2464 flags
| TFF_EXPR_IN_PARENS
);
2469 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2470 pp_string (pp
, "<lambda closure object>");
2471 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2473 dump_type (pp
, TREE_TYPE (t
), 0);
2474 pp_cxx_left_paren (pp
);
2475 pp_cxx_right_paren (pp
);
2479 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2480 dump_type (pp
, TREE_TYPE (t
), 0);
2481 pp_cxx_left_brace (pp
);
2482 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2483 pp_cxx_right_brace (pp
);
2490 tree ob
= TREE_OPERAND (t
, 0);
2491 if (is_dummy_object (ob
))
2493 t
= TREE_OPERAND (t
, 1);
2494 if (TREE_CODE (t
) == FUNCTION_DECL
)
2496 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2497 else if (BASELINK_P (t
))
2498 dump_expr (pp
, OVL_FIRST (BASELINK_FUNCTIONS (t
)),
2499 flags
| TFF_EXPR_IN_PARENS
);
2501 dump_decl (pp
, t
, flags
);
2505 if (INDIRECT_REF_P (ob
))
2507 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2513 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2517 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2522 case TEMPLATE_PARM_INDEX
:
2523 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2527 if (TREE_OPERAND (t
, 0) == NULL_TREE
2528 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2530 dump_type (pp
, TREE_TYPE (t
), flags
);
2531 pp_cxx_left_paren (pp
);
2532 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2533 pp_cxx_right_paren (pp
);
2537 pp_cxx_left_paren (pp
);
2538 dump_type (pp
, TREE_TYPE (t
), flags
);
2539 pp_cxx_right_paren (pp
);
2540 pp_cxx_left_paren (pp
);
2541 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2542 pp_cxx_right_paren (pp
);
2546 case STATIC_CAST_EXPR
:
2547 pp_cxx_ws_string (pp
, "static_cast");
2549 case REINTERPRET_CAST_EXPR
:
2550 pp_cxx_ws_string (pp
, "reinterpret_cast");
2552 case CONST_CAST_EXPR
:
2553 pp_cxx_ws_string (pp
, "const_cast");
2555 case DYNAMIC_CAST_EXPR
:
2556 pp_cxx_ws_string (pp
, "dynamic_cast");
2558 pp_cxx_begin_template_argument_list (pp
);
2559 dump_type (pp
, TREE_TYPE (t
), flags
);
2560 pp_cxx_end_template_argument_list (pp
);
2561 pp_cxx_left_paren (pp
);
2562 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2563 pp_cxx_right_paren (pp
);
2567 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2573 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2574 pp_cxx_ws_string (pp
, "sizeof");
2577 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2578 pp_cxx_ws_string (pp
, "__alignof__");
2580 op
= TREE_OPERAND (t
, 0);
2581 if (PACK_EXPANSION_P (op
))
2583 pp_string (pp
, "...");
2584 op
= PACK_EXPANSION_PATTERN (op
);
2586 pp_cxx_whitespace (pp
);
2587 pp_cxx_left_paren (pp
);
2588 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2589 dump_type (pp
, TREE_TYPE (op
), flags
);
2590 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2591 dump_type (pp
, op
, flags
);
2593 dump_expr (pp
, op
, flags
);
2594 pp_cxx_right_paren (pp
);
2597 case AT_ENCODE_EXPR
:
2598 pp_cxx_ws_string (pp
, "@encode");
2599 pp_cxx_whitespace (pp
);
2600 pp_cxx_left_paren (pp
);
2601 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2602 pp_cxx_right_paren (pp
);
2606 pp_cxx_ws_string (pp
, "noexcept");
2607 pp_cxx_whitespace (pp
);
2608 pp_cxx_left_paren (pp
);
2609 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2610 pp_cxx_right_paren (pp
);
2615 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2616 pp_cxx_whitespace (pp
);
2617 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2621 pp_string (pp
, M_("<unparsed>"));
2624 case TRY_CATCH_EXPR
:
2625 case WITH_CLEANUP_EXPR
:
2626 case CLEANUP_POINT_EXPR
:
2627 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2630 case PSEUDO_DTOR_EXPR
:
2631 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2633 if (TREE_OPERAND (t
, 1))
2635 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2636 pp_cxx_colon_colon (pp
);
2638 pp_cxx_complement (pp
);
2639 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2642 case TEMPLATE_ID_EXPR
:
2643 dump_decl (pp
, t
, flags
);
2649 case STATEMENT_LIST
:
2650 /* We don't yet have a way of dumping statements in a
2651 human-readable format. */
2652 pp_string (pp
, "({...})");
2656 pp_string (pp
, "while (1) { ");
2657 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2658 pp_cxx_right_brace (pp
);
2662 pp_string (pp
, "if (");
2663 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2664 pp_string (pp
, ") break; ");
2668 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2671 case EMPTY_CLASS_EXPR
:
2672 dump_type (pp
, TREE_TYPE (t
), flags
);
2673 pp_cxx_left_paren (pp
);
2674 pp_cxx_right_paren (pp
);
2677 case NON_DEPENDENT_EXPR
:
2678 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2681 case ARGUMENT_PACK_SELECT
:
2682 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2694 pp_type_specifier_seq (pp
, t
);
2698 /* We get here when we want to print a dependent type as an
2699 id-expression, without any disambiguator decoration. */
2700 pp
->id_expression (t
);
2703 case TEMPLATE_TYPE_PARM
:
2704 case TEMPLATE_TEMPLATE_PARM
:
2705 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2706 dump_type (pp
, t
, flags
);
2710 pp_cxx_trait_expression (pp
, t
);
2714 pp_cxx_va_arg_expression (pp
, t
);
2718 pp_cxx_offsetof_expression (pp
, t
);
2721 case ADDRESSOF_EXPR
:
2722 pp_cxx_addressof_expression (pp
, t
);
2726 dump_decl (pp
, t
, flags
);
2729 case EXPR_PACK_EXPANSION
:
2730 case UNARY_LEFT_FOLD_EXPR
:
2731 case UNARY_RIGHT_FOLD_EXPR
:
2732 case BINARY_LEFT_FOLD_EXPR
:
2733 case BINARY_RIGHT_FOLD_EXPR
:
2740 case VEC_DELETE_EXPR
:
2746 case UNORDERED_EXPR
:
2756 case FIX_TRUNC_EXPR
:
2761 case TRUTH_AND_EXPR
:
2763 case TRUTH_XOR_EXPR
:
2764 if (flags
& TFF_EXPR_IN_PARENS
)
2765 pp_cxx_left_paren (pp
);
2767 if (flags
& TFF_EXPR_IN_PARENS
)
2768 pp_cxx_right_paren (pp
);
2772 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2776 pp_string (pp
, M_("<lambda>"));
2780 pp_cxx_left_paren (pp
);
2781 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2782 pp_cxx_right_paren (pp
);
2786 pp_cxx_requires_expr (cxx_pp
, t
);
2790 pp_cxx_simple_requirement (cxx_pp
, t
);
2794 pp_cxx_type_requirement (cxx_pp
, t
);
2798 pp_cxx_compound_requirement (cxx_pp
, t
);
2802 pp_cxx_nested_requirement (cxx_pp
, t
);
2815 pp_cxx_constraint (cxx_pp
, t
);
2818 case PLACEHOLDER_EXPR
:
2819 pp_string (pp
, M_("*this"));
2823 dump_expr_list (pp
, t
, flags
);
2826 /* This list is incomplete, but should suffice for now.
2827 It is very important that `sorry' does not call
2828 `report_error_function'. That could cause an infinite loop. */
2830 pp_unsupported_tree (pp
, t
);
2833 pp_string (pp
, M_("<expression error>"));
2839 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2842 pp_cxx_left_paren (pp
);
2843 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2844 pp_cxx_whitespace (pp
);
2846 pp_cxx_ws_string (pp
, opstring
);
2848 pp_string (pp
, M_("<unknown operator>"));
2849 pp_cxx_whitespace (pp
);
2850 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2851 pp_cxx_right_paren (pp
);
2855 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2857 if (flags
& TFF_EXPR_IN_PARENS
)
2858 pp_cxx_left_paren (pp
);
2859 pp_cxx_ws_string (pp
, opstring
);
2860 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2861 if (flags
& TFF_EXPR_IN_PARENS
)
2862 pp_cxx_right_paren (pp
);
2866 reinit_cxx_pp (void)
2868 pp_clear_output_area (cxx_pp
);
2869 cxx_pp
->padding
= pp_none
;
2870 pp_indentation (cxx_pp
) = 0;
2871 pp_needs_newline (cxx_pp
) = false;
2872 cxx_pp
->enclosing_scope
= current_function_decl
;
2875 /* Same as pp_formatted_text, except the return string is a separate
2876 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2879 pp_ggc_formatted_text (pretty_printer
*pp
)
2881 return ggc_strdup (pp_formatted_text (pp
));
2884 /* Exported interface to stringifying types, exprs and decls under TFF_*
2888 type_as_string (tree typ
, int flags
)
2891 pp_translate_identifiers (cxx_pp
) = false;
2892 dump_type (cxx_pp
, typ
, flags
);
2893 return pp_ggc_formatted_text (cxx_pp
);
2897 type_as_string_translate (tree typ
, int flags
)
2900 dump_type (cxx_pp
, typ
, flags
);
2901 return pp_ggc_formatted_text (cxx_pp
);
2905 expr_as_string (tree decl
, int flags
)
2908 pp_translate_identifiers (cxx_pp
) = false;
2909 dump_expr (cxx_pp
, decl
, flags
);
2910 return pp_ggc_formatted_text (cxx_pp
);
2913 /* Wrap decl_as_string with options appropriate for dwarf. */
2916 decl_as_dwarf_string (tree decl
, int flags
)
2919 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2920 here will be adequate to get the desired behavior. */
2921 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2922 name
= decl_as_string (decl
, flags
);
2923 /* Subsequent calls to the pretty printer shouldn't use this style. */
2924 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2929 decl_as_string (tree decl
, int flags
)
2932 pp_translate_identifiers (cxx_pp
) = false;
2933 dump_decl (cxx_pp
, decl
, flags
);
2934 return pp_ggc_formatted_text (cxx_pp
);
2938 decl_as_string_translate (tree decl
, int flags
)
2941 dump_decl (cxx_pp
, decl
, flags
);
2942 return pp_ggc_formatted_text (cxx_pp
);
2945 /* Wrap lang_decl_name with options appropriate for dwarf. */
2948 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2951 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2952 here will be adequate to get the desired behavior. */
2953 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2954 name
= lang_decl_name (decl
, v
, translate
);
2955 /* Subsequent calls to the pretty printer shouldn't use this style. */
2956 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2960 /* Generate the three forms of printable names for cxx_printable_name. */
2963 lang_decl_name (tree decl
, int v
, bool translate
)
2967 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2968 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2971 pp_translate_identifiers (cxx_pp
) = translate
;
2973 && (DECL_CLASS_SCOPE_P (decl
)
2974 || (DECL_NAMESPACE_SCOPE_P (decl
)
2975 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2977 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2978 pp_cxx_colon_colon (cxx_pp
);
2981 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2982 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2983 else if ((DECL_NAME (decl
) == NULL_TREE
)
2984 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2985 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2987 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2989 return pp_ggc_formatted_text (cxx_pp
);
2992 /* Return the location of a tree passed to %+ formats. */
2995 location_of (tree t
)
2999 t
= TYPE_MAIN_DECL (t
);
3001 return input_location
;
3003 else if (TREE_CODE (t
) == OVERLOAD
)
3007 return DECL_SOURCE_LOCATION (t
);
3008 return EXPR_LOC_OR_LOC (t
, input_location
);
3011 /* Now the interfaces from error et al to dump_type et al. Each takes an
3012 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
3016 decl_to_string (tree decl
, int verbose
)
3020 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
3021 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
3022 flags
= TFF_CLASS_KEY_OR_ENUM
;
3024 flags
|= TFF_DECL_SPECIFIERS
;
3025 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3026 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
3027 flags
|= TFF_TEMPLATE_HEADER
;
3030 dump_decl (cxx_pp
, decl
, flags
);
3031 return pp_ggc_formatted_text (cxx_pp
);
3035 expr_to_string (tree decl
)
3038 dump_expr (cxx_pp
, decl
, 0);
3039 return pp_ggc_formatted_text (cxx_pp
);
3043 fndecl_to_string (tree fndecl
, int verbose
)
3047 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
3048 | TFF_TEMPLATE_HEADER
;
3050 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3052 dump_decl (cxx_pp
, fndecl
, flags
);
3053 return pp_ggc_formatted_text (cxx_pp
);
3058 code_to_string (enum tree_code c
)
3060 return get_tree_code_name (c
);
3064 language_to_string (enum languages c
)
3071 case lang_cplusplus
:
3080 /* Return the proper printed version of a parameter to a C++ function. */
3083 parm_to_string (int p
)
3087 pp_string (cxx_pp
, "'this'");
3089 pp_decimal_int (cxx_pp
, p
+ 1);
3090 return pp_ggc_formatted_text (cxx_pp
);
3094 op_to_string (enum tree_code p
)
3096 tree id
= operator_name_info
[p
].identifier
;
3097 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3101 type_to_string (tree typ
, int verbose
)
3105 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3106 flags
|= TFF_TEMPLATE_HEADER
;
3109 dump_type (cxx_pp
, typ
, flags
);
3110 /* If we're printing a type that involves typedefs, also print the
3111 stripped version. But sometimes the stripped version looks
3112 exactly the same, so we don't want it after all. To avoid printing
3113 it in that case, we play ugly obstack games. */
3114 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3115 && !uses_template_parms (typ
))
3117 int aka_start
, aka_len
; char *p
;
3118 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3119 /* Remember the end of the initial dump. */
3120 int len
= obstack_object_size (ob
);
3121 tree aka
= strip_typedefs (typ
);
3122 pp_string (cxx_pp
, " {aka");
3123 pp_cxx_whitespace (cxx_pp
);
3124 /* And remember the start of the aka dump. */
3125 aka_start
= obstack_object_size (ob
);
3126 dump_type (cxx_pp
, aka
, flags
);
3127 aka_len
= obstack_object_size (ob
) - aka_start
;
3128 pp_right_brace (cxx_pp
);
3129 p
= (char*)obstack_base (ob
);
3130 /* If they are identical, cut off the aka with a NUL. */
3131 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3135 if (typ
&& TYPE_P (typ
) && TREE_CODE (typ
) == ENUMERAL_TYPE
)
3136 pp_string (cxx_pp
, M_(" {enum}"));
3138 return pp_ggc_formatted_text (cxx_pp
);
3142 assop_to_string (enum tree_code p
)
3144 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3145 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3149 args_to_string (tree p
, int verbose
)
3153 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3158 if (TYPE_P (TREE_VALUE (p
)))
3159 return type_as_string_translate (p
, flags
);
3162 for (; p
; p
= TREE_CHAIN (p
))
3164 if (TREE_VALUE (p
) == null_node
)
3165 pp_cxx_ws_string (cxx_pp
, "NULL");
3167 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3169 pp_separate_with_comma (cxx_pp
);
3171 return pp_ggc_formatted_text (cxx_pp
);
3174 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3175 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3179 subst_to_string (tree p
)
3181 tree decl
= TREE_PURPOSE (p
);
3182 tree targs
= TREE_VALUE (p
);
3183 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3184 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3185 |TFF_NO_TEMPLATE_BINDINGS
);
3191 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3192 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3193 return pp_ggc_formatted_text (cxx_pp
);
3197 cv_to_string (tree p
, int v
)
3200 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3201 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3202 return pp_ggc_formatted_text (cxx_pp
);
3206 eh_spec_to_string (tree p
, int /*v*/)
3210 dump_exception_spec (cxx_pp
, p
, flags
);
3211 return pp_ggc_formatted_text (cxx_pp
);
3214 /* Langhook for print_error_function. */
3216 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3217 diagnostic_info
*diagnostic
)
3219 lhd_print_error_function (context
, file
, diagnostic
);
3220 pp_set_prefix (context
->printer
, file
);
3221 maybe_print_instantiation_context (context
);
3225 cp_diagnostic_starter (diagnostic_context
*context
,
3226 diagnostic_info
*diagnostic
)
3228 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3229 cp_print_error_function (context
, diagnostic
);
3230 maybe_print_instantiation_context (context
);
3231 maybe_print_constexpr_context (context
);
3232 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3236 /* Print current function onto BUFFER, in the process of reporting
3237 a diagnostic message. Called from cp_diagnostic_starter. */
3239 cp_print_error_function (diagnostic_context
*context
,
3240 diagnostic_info
*diagnostic
)
3242 /* If we are in an instantiation context, current_function_decl is likely
3243 to be wrong, so just rely on print_instantiation_full_context. */
3244 if (current_instantiation ())
3246 if (diagnostic_last_function_changed (context
, diagnostic
))
3248 const char *old_prefix
= context
->printer
->prefix
;
3249 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3250 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3251 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3252 ? file_name_as_prefix (context
, file
) : NULL
;
3254 pp_set_prefix (context
->printer
, new_prefix
);
3256 if (current_function_decl
== NULL
)
3257 pp_string (context
->printer
, _("At global scope:"));
3262 if (abstract_origin
)
3264 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3265 while (TREE_CODE (ao
) == BLOCK
3266 && BLOCK_ABSTRACT_ORIGIN (ao
)
3267 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3268 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3269 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3273 fndecl
= current_function_decl
;
3275 pp_printf (context
->printer
, function_category (fndecl
),
3276 cxx_printable_name_translate (fndecl
, 2));
3278 while (abstract_origin
)
3281 tree block
= abstract_origin
;
3283 locus
= &BLOCK_SOURCE_LOCATION (block
);
3285 block
= BLOCK_SUPERCONTEXT (block
);
3286 while (block
&& TREE_CODE (block
) == BLOCK
3287 && BLOCK_ABSTRACT_ORIGIN (block
))
3289 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3291 while (TREE_CODE (ao
) == BLOCK
3292 && BLOCK_ABSTRACT_ORIGIN (ao
)
3293 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3294 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3296 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3301 else if (TREE_CODE (ao
) != BLOCK
)
3304 block
= BLOCK_SUPERCONTEXT (block
);
3307 abstract_origin
= block
;
3310 while (block
&& TREE_CODE (block
) == BLOCK
)
3311 block
= BLOCK_SUPERCONTEXT (block
);
3313 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3315 abstract_origin
= NULL
;
3319 expanded_location s
= expand_location (*locus
);
3320 pp_character (context
->printer
, ',');
3321 pp_newline (context
->printer
);
3324 if (context
->show_column
&& s
.column
!= 0)
3325 pp_printf (context
->printer
,
3326 _(" inlined from %qs at %r%s:%d:%d%R"),
3327 cxx_printable_name_translate (fndecl
, 2),
3328 "locus", s
.file
, s
.line
, s
.column
);
3330 pp_printf (context
->printer
,
3331 _(" inlined from %qs at %r%s:%d%R"),
3332 cxx_printable_name_translate (fndecl
, 2),
3333 "locus", s
.file
, s
.line
);
3337 pp_printf (context
->printer
, _(" inlined from %qs"),
3338 cxx_printable_name_translate (fndecl
, 2));
3341 pp_character (context
->printer
, ':');
3343 pp_newline (context
->printer
);
3345 diagnostic_set_last_function (context
, diagnostic
);
3346 pp_destroy_prefix (context
->printer
);
3347 context
->printer
->prefix
= old_prefix
;
3351 /* Returns a description of FUNCTION using standard terminology. The
3352 result is a format string of the form "In CATEGORY %qs". */
3354 function_category (tree fn
)
3356 /* We can get called from the middle-end for diagnostics of function
3357 clones. Make sure we have language specific information before
3358 dereferencing it. */
3359 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3360 && DECL_FUNCTION_MEMBER_P (fn
))
3362 if (DECL_STATIC_FUNCTION_P (fn
))
3363 return _("In static member function %qs");
3364 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3365 return _("In copy constructor %qs");
3366 else if (DECL_CONSTRUCTOR_P (fn
))
3367 return _("In constructor %qs");
3368 else if (DECL_DESTRUCTOR_P (fn
))
3369 return _("In destructor %qs");
3370 else if (LAMBDA_FUNCTION_P (fn
))
3371 return _("In lambda function");
3373 return _("In member function %qs");
3376 return _("In function %qs");
3379 /* Report the full context of a current template instantiation,
3382 print_instantiation_full_context (diagnostic_context
*context
)
3384 struct tinst_level
*p
= current_instantiation ();
3385 location_t location
= input_location
;
3389 pp_verbatim (context
->printer
,
3390 TREE_CODE (p
->decl
) == TREE_LIST
3391 ? _("%s: In substitution of %qS:\n")
3392 : _("%s: In instantiation of %q#D:\n"),
3393 LOCATION_FILE (location
),
3396 location
= p
->locus
;
3400 print_instantiation_partial_context (context
, p
, location
);
3403 /* Helper function of print_instantiation_partial_context() that
3404 prints a single line of instantiation context. */
3407 print_instantiation_partial_context_line (diagnostic_context
*context
,
3408 const struct tinst_level
*t
,
3409 location_t loc
, bool recursive_p
)
3411 if (loc
== UNKNOWN_LOCATION
)
3414 expanded_location xloc
= expand_location (loc
);
3416 if (context
->show_column
)
3417 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3418 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3420 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3421 "locus", xloc
.file
, xloc
.line
);
3425 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3426 pp_verbatim (context
->printer
,
3428 ? _("recursively required by substitution of %qS\n")
3429 : _("required by substitution of %qS\n"),
3432 pp_verbatim (context
->printer
,
3434 ? _("recursively required from %q#D\n")
3435 : _("required from %q#D\n"),
3440 pp_verbatim (context
->printer
,
3442 ? _("recursively required from here\n")
3443 : _("required from here\n"));
3447 /* Same as print_instantiation_full_context but less verbose. */
3450 print_instantiation_partial_context (diagnostic_context
*context
,
3451 struct tinst_level
*t0
, location_t loc
)
3453 struct tinst_level
*t
;
3456 location_t prev_loc
= loc
;
3458 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3459 if (prev_loc
!= t
->locus
)
3461 prev_loc
= t
->locus
;
3467 if (template_backtrace_limit
3468 && n_total
> template_backtrace_limit
)
3470 int skip
= n_total
- template_backtrace_limit
;
3471 int head
= template_backtrace_limit
/ 2;
3473 /* Avoid skipping just 1. If so, skip 2. */
3477 head
= (template_backtrace_limit
- 1) / 2;
3480 for (n
= 0; n
< head
; n
++)
3482 gcc_assert (t
!= NULL
);
3483 if (loc
!= t
->locus
)
3484 print_instantiation_partial_context_line (context
, t
, loc
,
3485 /*recursive_p=*/false);
3489 if (t
!= NULL
&& skip
> 0)
3491 expanded_location xloc
;
3492 xloc
= expand_location (loc
);
3493 if (context
->show_column
)
3494 pp_verbatim (context
->printer
,
3495 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3496 "contexts, use -ftemplate-backtrace-limit=0 to "
3498 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3500 pp_verbatim (context
->printer
,
3501 _("%r%s:%d:%R [ skipping %d instantiation "
3502 "contexts, use -ftemplate-backtrace-limit=0 to "
3504 "locus", xloc
.file
, xloc
.line
, skip
);
3509 } while (t
!= NULL
&& --skip
> 0);
3515 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3520 print_instantiation_partial_context_line (context
, t
, loc
,
3525 print_instantiation_partial_context_line (context
, NULL
, loc
,
3526 /*recursive_p=*/false);
3529 /* Called from cp_thing to print the template context for an error. */
3531 maybe_print_instantiation_context (diagnostic_context
*context
)
3533 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3536 record_last_problematic_instantiation ();
3537 print_instantiation_full_context (context
);
3540 /* Report what constexpr call(s) we're trying to expand, if any. */
3543 maybe_print_constexpr_context (diagnostic_context
*context
)
3545 vec
<tree
> call_stack
= cx_error_context ();
3549 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3551 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3552 const char *s
= expr_as_string (t
, 0);
3553 if (context
->show_column
)
3554 pp_verbatim (context
->printer
,
3555 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3556 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3558 pp_verbatim (context
->printer
,
3559 _("%r%s:%d:%R in constexpr expansion of %qs"),
3560 "locus", xloc
.file
, xloc
.line
, s
);
3561 pp_newline (context
->printer
);
3565 /* Called from output_format -- during diagnostic message processing --
3566 to handle C++ specific format specifier with the following meanings:
3567 %A function argument-list.
3571 %F function declaration.
3572 %L language as used in extern "lang".
3574 %P function parameter whose position is indicated by an integer.
3575 %Q assignment operator.
3576 %S substitution (template + args)
3579 %X exception-specification. */
3581 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3582 int precision
, bool wide
, bool set_locus
, bool verbose
)
3586 #define next_tree (t = va_arg (*text->args_ptr, tree))
3587 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3588 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3589 #define next_int va_arg (*text->args_ptr, int)
3591 if (precision
!= 0 || wide
)
3596 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3597 case 'C': result
= code_to_string (next_tcode
); break;
3600 tree temp
= next_tree
;
3602 && DECL_HAS_DEBUG_EXPR_P (temp
))
3604 temp
= DECL_DEBUG_EXPR (temp
);
3607 result
= expr_to_string (temp
);
3611 result
= decl_to_string (temp
, verbose
);
3614 case 'E': result
= expr_to_string (next_tree
); break;
3615 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3616 case 'L': result
= language_to_string (next_lang
); break;
3617 case 'O': result
= op_to_string (next_tcode
); break;
3618 case 'P': result
= parm_to_string (next_int
); break;
3619 case 'Q': result
= assop_to_string (next_tcode
); break;
3620 case 'S': result
= subst_to_string (next_tree
); break;
3621 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3622 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3623 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3626 percent_K_format (text
);
3633 pp_string (pp
, result
);
3634 if (set_locus
&& t
!= NULL
)
3635 text
->set_location (0, location_of (t
), true);
3643 /* Warn about the use of C++0x features when appropriate. */
3645 maybe_warn_cpp0x (cpp0x_warn_str str
)
3647 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3648 /* We really want to suppress this warning in system headers,
3649 because libstdc++ uses variadic templates even when we aren't
3653 case CPP0X_INITIALIZER_LISTS
:
3654 pedwarn (input_location
, 0,
3655 "extended initializer lists "
3656 "only available with -std=c++11 or -std=gnu++11");
3658 case CPP0X_EXPLICIT_CONVERSION
:
3659 pedwarn (input_location
, 0,
3660 "explicit conversion operators "
3661 "only available with -std=c++11 or -std=gnu++11");
3663 case CPP0X_VARIADIC_TEMPLATES
:
3664 pedwarn (input_location
, 0,
3665 "variadic templates "
3666 "only available with -std=c++11 or -std=gnu++11");
3668 case CPP0X_LAMBDA_EXPR
:
3669 pedwarn (input_location
, 0,
3670 "lambda expressions "
3671 "only available with -std=c++11 or -std=gnu++11");
3674 pedwarn (input_location
, 0,
3675 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3677 case CPP0X_SCOPED_ENUMS
:
3678 pedwarn (input_location
, 0,
3679 "scoped enums only available with -std=c++11 or -std=gnu++11");
3681 case CPP0X_DEFAULTED_DELETED
:
3682 pedwarn (input_location
, 0,
3683 "defaulted and deleted functions "
3684 "only available with -std=c++11 or -std=gnu++11");
3686 case CPP0X_INLINE_NAMESPACES
:
3687 pedwarn (input_location
, OPT_Wpedantic
,
3688 "inline namespaces "
3689 "only available with -std=c++11 or -std=gnu++11");
3691 case CPP0X_OVERRIDE_CONTROLS
:
3692 pedwarn (input_location
, 0,
3693 "override controls (override/final) "
3694 "only available with -std=c++11 or -std=gnu++11");
3697 pedwarn (input_location
, 0,
3698 "non-static data member initializers "
3699 "only available with -std=c++11 or -std=gnu++11");
3701 case CPP0X_USER_DEFINED_LITERALS
:
3702 pedwarn (input_location
, 0,
3703 "user-defined literals "
3704 "only available with -std=c++11 or -std=gnu++11");
3706 case CPP0X_DELEGATING_CTORS
:
3707 pedwarn (input_location
, 0,
3708 "delegating constructors "
3709 "only available with -std=c++11 or -std=gnu++11");
3711 case CPP0X_INHERITING_CTORS
:
3712 pedwarn (input_location
, 0,
3713 "inheriting constructors "
3714 "only available with -std=c++11 or -std=gnu++11");
3716 case CPP0X_ATTRIBUTES
:
3717 pedwarn (input_location
, 0,
3719 "only available with -std=c++11 or -std=gnu++11");
3721 case CPP0X_REF_QUALIFIER
:
3722 pedwarn (input_location
, 0,
3724 "only available with -std=c++11 or -std=gnu++11");
3731 /* Warn about the use of variadic templates when appropriate. */
3733 maybe_warn_variadic_templates (void)
3735 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3739 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3740 option OPT with text GMSGID. Use this function to report
3741 diagnostics for constructs that are invalid C++98, but valid
3744 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3746 diagnostic_info diagnostic
;
3749 rich_location
richloc (line_table
, location
);
3751 va_start (ap
, gmsgid
);
3752 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
3753 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3754 diagnostic
.option_index
= opt
;
3755 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
3760 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3761 we found when we tried to do the lookup. LOCATION is the location of
3762 the NAME identifier. */
3765 qualified_name_lookup_error (tree scope
, tree name
,
3766 tree decl
, location_t location
)
3768 if (scope
== error_mark_node
)
3769 ; /* We already complained. */
3770 else if (TYPE_P (scope
))
3772 if (!COMPLETE_TYPE_P (scope
))
3773 error_at (location
, "incomplete type %qT used in nested name specifier",
3775 else if (TREE_CODE (decl
) == TREE_LIST
)
3777 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3779 print_candidates (decl
);
3782 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3784 else if (scope
!= global_namespace
)
3786 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3787 if (!suggest_alternative_in_explicit_scope (location
, name
, scope
))
3788 suggest_alternatives_for (location
, name
, false);
3792 error_at (location
, "%<::%D%> has not been declared", name
);
3793 suggest_alternatives_for (location
, name
, true);