1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "stringpool.h"
25 #include "tree-diagnostic.h"
26 #include "langhooks-def.h"
28 #include "cxx-pretty-print.h"
29 #include "tree-pretty-print.h"
30 #include "c-family/c-objc.h"
32 #include "internal-fn.h"
34 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
35 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
37 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
38 dump C++ ASTs as strings. It is mostly used only by the various
39 tree -> string functions that are occasionally called from the
40 debugger or by the front-end for things like
41 __PRETTY_FUNCTION__. */
42 static cxx_pretty_printer actual_pretty_printer
;
43 static cxx_pretty_printer
* const cxx_pp
= &actual_pretty_printer
;
45 /* Translate if being used for diagnostics, but not for dump files or
47 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
49 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
51 static const char *args_to_string (tree
, int);
52 static const char *assop_to_string (enum tree_code
);
53 static const char *code_to_string (enum tree_code
);
54 static const char *cv_to_string (tree
, int);
55 static const char *decl_to_string (tree
, int);
56 static const char *expr_to_string (tree
);
57 static const char *fndecl_to_string (tree
, int);
58 static const char *op_to_string (enum tree_code
);
59 static const char *parm_to_string (int);
60 static const char *type_to_string (tree
, int);
62 static void dump_alias_template_specialization (cxx_pretty_printer
*, tree
, int);
63 static void dump_type (cxx_pretty_printer
*, tree
, int);
64 static void dump_typename (cxx_pretty_printer
*, tree
, int);
65 static void dump_simple_decl (cxx_pretty_printer
*, tree
, tree
, int);
66 static void dump_decl (cxx_pretty_printer
*, tree
, int);
67 static void dump_template_decl (cxx_pretty_printer
*, tree
, int);
68 static void dump_function_decl (cxx_pretty_printer
*, tree
, int);
69 static void dump_expr (cxx_pretty_printer
*, tree
, int);
70 static void dump_unary_op (cxx_pretty_printer
*, const char *, tree
, int);
71 static void dump_binary_op (cxx_pretty_printer
*, const char *, tree
, int);
72 static void dump_aggr_type (cxx_pretty_printer
*, tree
, int);
73 static void dump_type_prefix (cxx_pretty_printer
*, tree
, int);
74 static void dump_type_suffix (cxx_pretty_printer
*, tree
, int);
75 static void dump_function_name (cxx_pretty_printer
*, tree
, int);
76 static void dump_call_expr_args (cxx_pretty_printer
*, tree
, int, bool);
77 static void dump_aggr_init_expr_args (cxx_pretty_printer
*, tree
, int, bool);
78 static void dump_expr_list (cxx_pretty_printer
*, tree
, int);
79 static void dump_global_iord (cxx_pretty_printer
*, tree
);
80 static void dump_parameters (cxx_pretty_printer
*, tree
, int);
81 static void dump_ref_qualifier (cxx_pretty_printer
*, tree
, int);
82 static void dump_exception_spec (cxx_pretty_printer
*, tree
, int);
83 static void dump_template_argument (cxx_pretty_printer
*, tree
, int);
84 static void dump_template_argument_list (cxx_pretty_printer
*, tree
, int);
85 static void dump_template_parameter (cxx_pretty_printer
*, tree
, int);
86 static void dump_template_bindings (cxx_pretty_printer
*, tree
, tree
,
88 static void dump_scope (cxx_pretty_printer
*, tree
, int);
89 static void dump_template_parms (cxx_pretty_printer
*, tree
, int, int);
90 static int get_non_default_template_args_count (tree
, int);
91 static const char *function_category (tree
);
92 static void maybe_print_constexpr_context (diagnostic_context
*);
93 static void maybe_print_instantiation_context (diagnostic_context
*);
94 static void print_instantiation_full_context (diagnostic_context
*);
95 static void print_instantiation_partial_context (diagnostic_context
*,
98 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
99 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
101 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
102 int, bool, bool, bool);
104 /* CONTEXT->printer is a basic pretty printer that was constructed
105 presumably by diagnostic_initialize(), called early in the
106 compiler's initialization process (in general_init) Before the FE
107 is initialized. This (C++) FE-specific diagnostic initializer is
108 thus replacing the basic pretty printer with one that has C++-aware
112 cxx_initialize_diagnostics (diagnostic_context
*context
)
114 pretty_printer
*base
= context
->printer
;
115 cxx_pretty_printer
*pp
= XNEW (cxx_pretty_printer
);
116 context
->printer
= new (pp
) cxx_pretty_printer ();
118 /* It is safe to free this object because it was previously XNEW()'d. */
119 base
->~pretty_printer ();
122 c_common_diagnostics_set_defaults (context
);
123 diagnostic_starter (context
) = cp_diagnostic_starter
;
124 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
125 diagnostic_format_decoder (context
) = cp_printer
;
128 /* Dump a scope, if deemed necessary. */
131 dump_scope (cxx_pretty_printer
*pp
, tree scope
, int flags
)
133 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
135 if (scope
== NULL_TREE
)
138 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
140 if (scope
!= global_namespace
)
142 dump_decl (pp
, scope
, f
);
143 pp_cxx_colon_colon (pp
);
146 else if (AGGREGATE_TYPE_P (scope
))
148 dump_type (pp
, scope
, f
);
149 pp_cxx_colon_colon (pp
);
151 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
153 dump_function_decl (pp
, scope
, f
);
154 pp_cxx_colon_colon (pp
);
158 /* Dump the template ARGument under control of FLAGS. */
161 dump_template_argument (cxx_pretty_printer
*pp
, tree arg
, int flags
)
163 if (ARGUMENT_PACK_P (arg
))
164 dump_template_argument_list (pp
, ARGUMENT_PACK_ARGS (arg
),
165 /* No default args in argument packs. */
166 flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
167 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
168 dump_type (pp
, arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
171 if (TREE_CODE (arg
) == TREE_LIST
)
172 arg
= TREE_VALUE (arg
);
174 /* 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
)
370 gcc_assert (alias_template_specialization_p (t
));
372 if (!(flags
& TFF_UNQUALIFIED_NAME
))
373 dump_scope (pp
, CP_DECL_CONTEXT (TYPE_NAME (t
)), flags
);
374 name
= TYPE_IDENTIFIER (t
);
375 pp_cxx_tree_identifier (pp
, name
);
376 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
378 flags
& ~TFF_TEMPLATE_HEADER
);
381 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
385 dump_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
390 /* Don't print e.g. "struct mytypedef". */
391 if (TYPE_P (t
) && typedef_variant_p (t
))
393 tree decl
= TYPE_NAME (t
);
394 if ((flags
& TFF_CHASE_TYPEDEF
)
395 || DECL_SELF_REFERENCE_P (decl
)
396 || (!flag_pretty_templates
397 && DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)))
398 t
= strip_typedefs (t
);
399 else if (alias_template_specialization_p (t
))
401 dump_alias_template_specialization (pp
, t
, flags
);
404 else if (same_type_p (t
, TREE_TYPE (decl
)))
408 pp_cxx_cv_qualifier_seq (pp
, t
);
409 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
414 if (TYPE_PTRMEMFUNC_P (t
))
417 switch (TREE_CODE (t
))
420 if (t
== init_list_type_node
)
421 pp_string (pp
, M_("<brace-enclosed initializer list>"));
422 else if (t
== unknown_type_node
)
423 pp_string (pp
, M_("<unresolved overloaded function type>"));
426 pp_cxx_cv_qualifier_seq (pp
, t
);
427 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
432 /* A list of function parms. */
433 dump_parameters (pp
, t
, flags
);
436 case IDENTIFIER_NODE
:
437 pp_cxx_tree_identifier (pp
, t
);
441 dump_type (pp
, BINFO_TYPE (t
), flags
);
447 dump_aggr_type (pp
, t
, flags
);
451 if (flags
& TFF_CHASE_TYPEDEF
)
453 dump_type (pp
, DECL_ORIGINAL_TYPE (t
)
454 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
461 dump_decl (pp
, t
, flags
& ~TFF_DECL_SPECIFIERS
);
470 case FIXED_POINT_TYPE
:
471 pp_type_specifier_seq (pp
, t
);
474 case TEMPLATE_TEMPLATE_PARM
:
475 /* For parameters inside template signature. */
476 if (TYPE_IDENTIFIER (t
))
477 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
479 pp_cxx_canonical_template_parameter (pp
, t
);
482 case BOUND_TEMPLATE_TEMPLATE_PARM
:
484 tree args
= TYPE_TI_ARGS (t
);
485 pp_cxx_cv_qualifier_seq (pp
, t
);
486 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
487 pp_cxx_begin_template_argument_list (pp
);
488 dump_template_argument_list (pp
, args
, flags
);
489 pp_cxx_end_template_argument_list (pp
);
493 case TEMPLATE_TYPE_PARM
:
494 pp_cxx_cv_qualifier_seq (pp
, t
);
495 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
496 pp_cxx_constrained_type_spec (pp
, c
);
497 else if (TYPE_IDENTIFIER (t
))
498 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
500 pp_cxx_canonical_template_parameter
501 (pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
504 /* This is not always necessary for pointers and such, but doing this
505 reduces code size. */
514 dump_type_prefix (pp
, t
, flags
);
515 dump_type_suffix (pp
, t
, flags
);
519 if (! (flags
& TFF_CHASE_TYPEDEF
)
520 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
522 dump_decl (pp
, TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
525 pp_cxx_cv_qualifier_seq (pp
, t
);
526 pp_cxx_ws_string (pp
,
527 TYPENAME_IS_ENUM_P (t
) ? "enum"
528 : TYPENAME_IS_CLASS_P (t
) ? "class"
530 dump_typename (pp
, t
, flags
);
533 case UNBOUND_CLASS_TEMPLATE
:
534 if (! (flags
& TFF_UNQUALIFIED_NAME
))
536 dump_type (pp
, TYPE_CONTEXT (t
), flags
);
537 pp_cxx_colon_colon (pp
);
539 pp_cxx_ws_string (pp
, "template");
540 dump_type (pp
, TYPE_IDENTIFIER (t
), flags
);
544 pp_cxx_ws_string (pp
, "__typeof__");
545 pp_cxx_whitespace (pp
);
546 pp_cxx_left_paren (pp
);
547 dump_expr (pp
, TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
548 pp_cxx_right_paren (pp
);
551 case UNDERLYING_TYPE
:
552 pp_cxx_ws_string (pp
, "__underlying_type");
553 pp_cxx_whitespace (pp
);
554 pp_cxx_left_paren (pp
);
555 dump_expr (pp
, UNDERLYING_TYPE_TYPE (t
), flags
& ~TFF_EXPR_IN_PARENS
);
556 pp_cxx_right_paren (pp
);
559 case TYPE_PACK_EXPANSION
:
560 dump_type (pp
, PACK_EXPANSION_PATTERN (t
), flags
);
561 pp_cxx_ws_string (pp
, "...");
564 case TYPE_ARGUMENT_PACK
:
565 dump_template_argument (pp
, t
, flags
);
569 pp_cxx_ws_string (pp
, "decltype");
570 pp_cxx_whitespace (pp
);
571 pp_cxx_left_paren (pp
);
572 dump_expr (pp
, DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
573 pp_cxx_right_paren (pp
);
577 pp_string (pp
, "std::nullptr_t");
581 pp_unsupported_tree (pp
, t
);
585 pp_string (pp
, M_("<type error>"));
590 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
594 dump_typename (cxx_pretty_printer
*pp
, tree t
, int flags
)
596 tree ctx
= TYPE_CONTEXT (t
);
598 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
599 dump_typename (pp
, ctx
, flags
);
601 dump_type (pp
, ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
602 pp_cxx_colon_colon (pp
);
603 dump_decl (pp
, TYPENAME_TYPE_FULLNAME (t
), flags
);
606 /* Return the name of the supplied aggregate, or enumeral type. */
609 class_key_or_enum_as_string (tree t
)
611 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
613 if (SCOPED_ENUM_P (t
))
618 else if (TREE_CODE (t
) == UNION_TYPE
)
620 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
626 /* Print out a class declaration T under the control of FLAGS,
627 in the form `class foo'. */
630 dump_aggr_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
633 const char *variety
= class_key_or_enum_as_string (t
);
637 pp_cxx_cv_qualifier_seq (pp
, t
);
639 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
640 pp_cxx_ws_string (pp
, variety
);
642 name
= TYPE_NAME (t
);
646 typdef
= (!DECL_ARTIFICIAL (name
)
647 /* An alias specialization is not considered to be a
649 && !alias_template_specialization_p (t
));
652 && ((flags
& TFF_CHASE_TYPEDEF
)
653 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
654 && DECL_TEMPLATE_INFO (name
))))
655 || DECL_SELF_REFERENCE_P (name
))
657 t
= TYPE_MAIN_VARIANT (t
);
658 name
= TYPE_NAME (t
);
662 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
663 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
664 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
665 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
667 if (! (flags
& TFF_UNQUALIFIED_NAME
))
668 dump_scope (pp
, CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
669 flags
&= ~TFF_UNQUALIFIED_NAME
;
672 /* Because the template names are mangled, we have to locate
673 the most general template, and use that name. */
674 tree tpl
= TYPE_TI_TEMPLATE (t
);
676 while (DECL_TEMPLATE_INFO (tpl
))
677 tpl
= DECL_TI_TEMPLATE (tpl
);
680 name
= DECL_NAME (name
);
683 if (name
== 0 || anon_aggrname_p (name
))
685 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
686 pp_string (pp
, M_("<unnamed>"));
688 pp_printf (pp
, M_("<unnamed %s>"), variety
);
690 else if (LAMBDA_TYPE_P (t
))
692 /* A lambda's "type" is essentially its signature. */
693 pp_string (pp
, M_("<lambda"));
694 if (lambda_function (t
))
696 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
701 pp_cxx_tree_identifier (pp
, name
);
703 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
704 !CLASSTYPE_USE_TEMPLATE (t
),
705 flags
& ~TFF_TEMPLATE_HEADER
);
708 /* Dump into the obstack the initial part of the output for a given type.
709 This is necessary when dealing with things like functions returning
712 return type of `int (* fee ())()': pointer -> function -> int. Both
713 pointer (and reference and offset) and function (and member) types must
714 deal with prefix and suffix.
716 Arrays must also do this for DECL nodes, like int a[], and for things like
720 dump_type_prefix (cxx_pretty_printer
*pp
, tree t
, int flags
)
722 if (TYPE_PTRMEMFUNC_P (t
))
724 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
728 switch (TREE_CODE (t
))
733 tree sub
= TREE_TYPE (t
);
735 dump_type_prefix (pp
, sub
, flags
);
736 if (TREE_CODE (sub
) == ARRAY_TYPE
737 || TREE_CODE (sub
) == FUNCTION_TYPE
)
739 pp_cxx_whitespace (pp
);
740 pp_cxx_left_paren (pp
);
741 pp_c_attributes_display (pp
, TYPE_ATTRIBUTES (sub
));
745 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
747 if (TYPE_REF_IS_RVALUE (t
))
748 pp_ampersand_ampersand (pp
);
752 pp
->padding
= pp_before
;
753 pp_cxx_cv_qualifier_seq (pp
, t
);
759 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
760 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
763 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
764 pp_cxx_left_paren (pp
);
765 dump_type (pp
, TYPE_OFFSET_BASETYPE (t
), flags
);
766 pp_cxx_colon_colon (pp
);
769 pp_cxx_cv_qualifier_seq (pp
, t
);
770 pp
->padding
= pp_before
;
773 /* This can be reached without a pointer when dealing with
774 templates, e.g. std::is_function. */
776 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
780 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
782 pp_cxx_left_paren (pp
);
783 dump_aggr_type (pp
, TYPE_METHOD_BASETYPE (t
), flags
);
784 pp_cxx_colon_colon (pp
);
788 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
792 case IDENTIFIER_NODE
:
797 case TEMPLATE_TYPE_PARM
:
798 case TEMPLATE_TEMPLATE_PARM
:
799 case BOUND_TEMPLATE_TEMPLATE_PARM
:
810 case UNDERLYING_TYPE
:
812 case TYPE_PACK_EXPANSION
:
813 case FIXED_POINT_TYPE
:
815 dump_type (pp
, t
, flags
);
816 pp
->padding
= pp_before
;
820 pp_unsupported_tree (pp
, t
);
823 pp_string (pp
, M_("<typeprefixerror>"));
828 /* Dump the suffix of type T, under control of FLAGS. This is the part
829 which appears after the identifier (or function parms). */
832 dump_type_suffix (cxx_pretty_printer
*pp
, tree t
, int flags
)
834 if (TYPE_PTRMEMFUNC_P (t
))
835 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
837 switch (TREE_CODE (t
))
842 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
843 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
844 pp_cxx_right_paren (pp
);
845 if (TREE_CODE (t
) == POINTER_TYPE
)
846 flags
|= TFF_POINTER
;
847 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
854 if (TREE_CODE (t
) == METHOD_TYPE
)
855 /* Can only be reached through a pointer. */
856 pp_cxx_right_paren (pp
);
857 arg
= TYPE_ARG_TYPES (t
);
858 if (TREE_CODE (t
) == METHOD_TYPE
)
859 arg
= TREE_CHAIN (arg
);
861 /* Function pointers don't have default args. Not in standard C++,
862 anyway; they may in g++, but we'll just pretend otherwise. */
863 dump_parameters (pp
, arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
865 pp
->padding
= pp_before
;
866 pp_cxx_cv_qualifiers (pp
, type_memfn_quals (t
),
867 TREE_CODE (t
) == FUNCTION_TYPE
868 && (flags
& TFF_POINTER
));
869 dump_ref_qualifier (pp
, t
, flags
);
870 if (tx_safe_fn_type_p (t
))
871 pp_cxx_ws_string (pp
, "transaction_safe");
872 dump_exception_spec (pp
, TYPE_RAISES_EXCEPTIONS (t
), flags
);
873 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
879 pp_cxx_left_bracket (pp
);
880 if (tree dtype
= TYPE_DOMAIN (t
))
882 tree max
= TYPE_MAX_VALUE (dtype
);
883 /* Zero-length arrays have an upper bound of SIZE_MAX. */
884 if (integer_all_onesp (max
))
885 pp_character (pp
, '0');
886 else if (tree_fits_shwi_p (max
))
887 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
891 if (TREE_CODE (max
) == SAVE_EXPR
)
892 max
= TREE_OPERAND (max
, 0);
893 if (TREE_CODE (max
) == MINUS_EXPR
894 || TREE_CODE (max
) == PLUS_EXPR
)
896 max
= TREE_OPERAND (max
, 0);
897 while (CONVERT_EXPR_P (max
))
898 max
= TREE_OPERAND (max
, 0);
901 max
= fold_build2_loc (input_location
,
902 PLUS_EXPR
, dtype
, max
,
903 build_int_cst (dtype
, 1));
904 dump_expr (pp
, max
, flags
& ~TFF_EXPR_IN_PARENS
);
907 pp_cxx_right_bracket (pp
);
908 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
912 case IDENTIFIER_NODE
:
917 case TEMPLATE_TYPE_PARM
:
918 case TEMPLATE_TEMPLATE_PARM
:
919 case BOUND_TEMPLATE_TEMPLATE_PARM
:
930 case UNDERLYING_TYPE
:
932 case TYPE_PACK_EXPANSION
:
933 case FIXED_POINT_TYPE
:
938 pp_unsupported_tree (pp
, t
);
940 /* Don't mark it here, we should have already done in
947 dump_global_iord (cxx_pretty_printer
*pp
, tree t
)
949 const char *p
= NULL
;
951 if (DECL_GLOBAL_CTOR_P (t
))
952 p
= M_("(static initializers for %s)");
953 else if (DECL_GLOBAL_DTOR_P (t
))
954 p
= M_("(static destructors for %s)");
958 pp_printf (pp
, p
, DECL_SOURCE_FILE (t
));
962 dump_simple_decl (cxx_pretty_printer
*pp
, tree t
, tree type
, int flags
)
964 if (flags
& TFF_DECL_SPECIFIERS
)
966 if (VAR_P (t
) && DECL_DECLARED_CONSTEXPR_P (t
))
968 if (DECL_LANG_SPECIFIC (t
) && DECL_DECLARED_CONCEPT_P (t
))
969 pp_cxx_ws_string (pp
, "concept");
971 pp_cxx_ws_string (pp
, "constexpr");
973 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
976 if (! (flags
& TFF_UNQUALIFIED_NAME
)
977 && TREE_CODE (t
) != PARM_DECL
978 && (!DECL_INITIAL (t
)
979 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
980 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
981 flags
&= ~TFF_UNQUALIFIED_NAME
;
982 if ((flags
& TFF_DECL_SPECIFIERS
)
983 && DECL_TEMPLATE_PARM_P (t
)
984 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
985 pp_string (pp
, "...");
988 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
991 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
992 pp_string (pp
, " capture>");
995 dump_decl (pp
, DECL_NAME (t
), flags
);
998 pp_string (pp
, M_("<anonymous>"));
999 if (flags
& TFF_DECL_SPECIFIERS
)
1000 dump_type_suffix (pp
, type
, flags
);
1003 /* Dump a human readable string for the decl T under control of FLAGS. */
1006 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1011 /* If doing Objective-C++, give Objective-C a chance to demangle
1012 Objective-C method names. */
1013 if (c_dialect_objc ())
1015 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1018 pp_string (pp
, demangled
);
1023 switch (TREE_CODE (t
))
1026 /* Don't say 'typedef class A' */
1027 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1029 if ((flags
& TFF_DECL_SPECIFIERS
)
1030 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1032 /* Say `class T' not just `T'. */
1033 pp_cxx_ws_string (pp
, "class");
1035 /* Emit the `...' for a parameter pack. */
1036 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1037 pp_cxx_ws_string (pp
, "...");
1040 dump_type (pp
, TREE_TYPE (t
), flags
);
1043 if (TYPE_DECL_ALIAS_P (t
)
1044 && (flags
& TFF_DECL_SPECIFIERS
1045 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1047 pp_cxx_ws_string (pp
, "using");
1048 dump_decl (pp
, DECL_NAME (t
), flags
);
1049 pp_cxx_whitespace (pp
);
1050 pp_cxx_ws_string (pp
, "=");
1051 pp_cxx_whitespace (pp
);
1052 dump_type (pp
, DECL_ORIGINAL_TYPE (t
), flags
);
1055 if ((flags
& TFF_DECL_SPECIFIERS
)
1056 && !DECL_SELF_REFERENCE_P (t
))
1057 pp_cxx_ws_string (pp
, "typedef");
1058 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1059 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1064 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1066 pp_string (pp
, M_("vtable for "));
1067 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1068 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1074 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1076 /* Handle variable template specializations. */
1078 && DECL_LANG_SPECIFIC (t
)
1079 && DECL_TEMPLATE_INFO (t
)
1080 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1082 pp_cxx_begin_template_argument_list (pp
);
1083 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1084 dump_template_argument_list (pp
, args
, flags
);
1085 pp_cxx_end_template_argument_list (pp
);
1090 pp_string (pp
, M_("<return value> "));
1091 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1094 case NAMESPACE_DECL
:
1095 if (flags
& TFF_DECL_SPECIFIERS
)
1096 pp
->declaration (t
);
1099 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1100 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1101 flags
&= ~TFF_UNQUALIFIED_NAME
;
1102 if (DECL_NAME (t
) == NULL_TREE
)
1104 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1105 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1107 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1110 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1115 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1116 pp_colon_colon (pp
);
1117 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1121 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1122 pp_cxx_left_bracket (pp
);
1123 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1124 pp_cxx_right_bracket (pp
);
1127 case ARRAY_NOTATION_REF
:
1128 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1129 pp_cxx_left_bracket (pp
);
1130 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1132 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1134 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1135 pp_cxx_right_bracket (pp
);
1138 /* So that we can do dump_decl on an aggr type. */
1142 dump_type (pp
, t
, flags
);
1146 /* This is a pseudo destructor call which has not been folded into
1147 a PSEUDO_DTOR_EXPR yet. */
1148 pp_cxx_complement (pp
);
1149 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1156 /* These special cases are duplicated here so that other functions
1157 can feed identifiers to error and get them demangled properly. */
1158 case IDENTIFIER_NODE
:
1159 if (IDENTIFIER_TYPENAME_P (t
))
1161 pp_cxx_ws_string (pp
, "operator");
1162 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1163 dump_type (pp
, TREE_TYPE (t
), flags
);
1166 else if (dguide_name_p (t
))
1167 dump_decl (pp
, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t
)),
1168 TFF_PLAIN_IDENTIFIER
);
1170 pp_cxx_tree_identifier (pp
, t
);
1176 t
= OVL_CURRENT (t
);
1177 if (DECL_CLASS_SCOPE_P (t
))
1179 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1180 pp_cxx_colon_colon (pp
);
1182 else if (!DECL_FILE_SCOPE_P (t
))
1184 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1185 pp_cxx_colon_colon (pp
);
1187 dump_decl (pp
, DECL_NAME (t
), flags
);
1191 /* If there's only one function, just treat it like an ordinary
1193 t
= OVL_CURRENT (t
);
1197 if (! DECL_LANG_SPECIFIC (t
))
1199 if (DECL_ABSTRACT_ORIGIN (t
))
1200 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1202 pp_string (pp
, M_("<built-in>"));
1204 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1205 dump_global_iord (pp
, t
);
1207 dump_function_decl (pp
, t
, flags
);
1211 dump_template_decl (pp
, t
, flags
);
1214 case TEMPLATE_ID_EXPR
:
1216 tree name
= TREE_OPERAND (t
, 0);
1217 tree args
= TREE_OPERAND (t
, 1);
1219 if (is_overloaded_fn (name
))
1220 name
= get_first_fn (name
);
1222 name
= DECL_NAME (name
);
1223 dump_decl (pp
, name
, flags
);
1224 pp_cxx_begin_template_argument_list (pp
);
1225 if (args
== error_mark_node
)
1226 pp_string (pp
, M_("<template arguments error>"));
1228 dump_template_argument_list
1229 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1230 pp_cxx_end_template_argument_list (pp
);
1235 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1239 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1240 || (DECL_INITIAL (t
) &&
1241 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1242 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1243 else if (DECL_NAME (t
))
1244 dump_decl (pp
, DECL_NAME (t
), flags
);
1245 else if (DECL_INITIAL (t
))
1246 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1248 pp_string (pp
, M_("<enumerator>"));
1252 pp_cxx_ws_string (pp
, "using");
1253 dump_type (pp
, USING_DECL_SCOPE (t
), flags
);
1254 pp_cxx_colon_colon (pp
);
1255 dump_decl (pp
, DECL_NAME (t
), flags
);
1259 pp
->declaration (t
);
1263 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1266 case NON_DEPENDENT_EXPR
:
1267 dump_expr (pp
, t
, flags
);
1270 case TEMPLATE_TYPE_PARM
:
1271 if (flags
& TFF_DECL_SPECIFIERS
)
1272 pp
->declaration (t
);
1277 case UNBOUND_CLASS_TEMPLATE
:
1278 case TYPE_PACK_EXPANSION
:
1280 dump_type (pp
, t
, flags
);
1284 pp_unsupported_tree (pp
, t
);
1288 pp_string (pp
, M_("<declaration error>"));
1293 /* Dump a template declaration T under control of FLAGS. This means the
1294 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1297 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1299 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1303 if (flags
& TFF_TEMPLATE_HEADER
)
1305 for (parms
= orig_parms
= nreverse (orig_parms
);
1307 parms
= TREE_CHAIN (parms
))
1309 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1310 int len
= TREE_VEC_LENGTH (inner_parms
);
1314 /* Skip over the dummy template levels of a template template
1316 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1320 pp_cxx_ws_string (pp
, "template");
1321 pp_cxx_begin_template_argument_list (pp
);
1323 /* If we've shown the template prefix, we'd better show the
1324 parameters' and decl's type too. */
1325 flags
|= TFF_DECL_SPECIFIERS
;
1327 for (i
= 0; i
< len
; i
++)
1330 pp_separate_with_comma (pp
);
1331 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1334 pp_cxx_end_template_argument_list (pp
);
1335 pp_cxx_whitespace (pp
);
1337 nreverse(orig_parms
);
1339 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1341 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1342 pp_cxx_ws_string (pp
, "class");
1344 /* If this is a parameter pack, print the ellipsis. */
1345 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1346 pp_cxx_ws_string (pp
, "...");
1349 /* Only print the requirements if we're also printing
1350 the template header. */
1352 if (tree ci
= get_constraints (t
))
1353 if (check_constraint_info (ci
))
1354 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1356 pp_cxx_requires_clause (pp
, reqs
);
1357 pp_cxx_whitespace (pp
);
1362 if (DECL_CLASS_TEMPLATE_P (t
))
1363 dump_type (pp
, TREE_TYPE (t
),
1364 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1365 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1366 else if (DECL_TEMPLATE_RESULT (t
)
1367 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1368 /* Alias template. */
1369 || DECL_TYPE_TEMPLATE_P (t
)))
1370 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1373 gcc_assert (TREE_TYPE (t
));
1374 switch (NEXT_CODE (t
))
1378 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1381 /* This case can occur with some invalid code. */
1382 dump_type (pp
, TREE_TYPE (t
),
1383 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1384 | (flags
& TFF_DECL_SPECIFIERS
1385 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1390 /* find_typenames looks through the type of the function template T
1391 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1394 struct find_typenames_t
1396 hash_set
<tree
> *p_set
;
1397 vec
<tree
, va_gc
> *typenames
;
1401 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1403 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1404 tree mv
= NULL_TREE
;
1406 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1407 /* Add the type of the typedef without any additional cv-quals. */
1408 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1409 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1410 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1411 /* Add the typename without any cv-qualifiers. */
1412 mv
= TYPE_MAIN_VARIANT (*tp
);
1414 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1416 /* Don't mess with parameter packs since we don't remember
1417 the pack expansion context for a particular typename. */
1418 *walk_subtrees
= false;
1422 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1423 vec_safe_push (d
->typenames
, mv
);
1425 /* Search into class template arguments, which cp_walk_subtrees
1427 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1428 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1434 static vec
<tree
, va_gc
> *
1435 find_typenames (tree t
)
1437 struct find_typenames_t ft
;
1438 ft
.p_set
= new hash_set
<tree
>;
1439 ft
.typenames
= NULL
;
1440 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1441 find_typenames_r
, &ft
, ft
.p_set
);
1443 return ft
.typenames
;
1446 /* Output the "[with ...]" clause for a template instantiation T iff
1447 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1448 formatting a deduction/substitution diagnostic rather than an
1452 dump_substitution (cxx_pretty_printer
*pp
,
1453 tree t
, tree template_parms
, tree template_args
,
1456 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1457 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1459 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1460 pp_cxx_whitespace (pp
);
1461 pp_cxx_left_bracket (pp
);
1462 pp
->translate_string ("with");
1463 pp_cxx_whitespace (pp
);
1464 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1465 pp_cxx_right_bracket (pp
);
1469 /* Dump the lambda function FN including its 'mutable' qualifier and any
1470 template bindings. */
1473 dump_lambda_function (cxx_pretty_printer
*pp
,
1474 tree fn
, tree template_parms
, tree template_args
,
1477 /* A lambda's signature is essentially its "type". */
1478 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1479 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1481 pp
->padding
= pp_before
;
1482 pp_c_ws_string (pp
, "mutable");
1484 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1487 /* Pretty print a function decl. There are several ways we want to print a
1488 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1489 As error can only apply the '#' flag once to give 0 and 1 for V, there
1490 is %D which doesn't print the throw specs, and %F which does. */
1493 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1497 tree cname
= NULL_TREE
;
1498 tree template_args
= NULL_TREE
;
1499 tree template_parms
= NULL_TREE
;
1500 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1501 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1505 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1506 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1507 t
= DECL_TEMPLATE_RESULT (t
);
1509 /* Save the exceptions, in case t is a specialization and we are
1510 emitting an error about incompatible specifications. */
1511 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1513 /* Likewise for the constexpr specifier, in case t is a specialization. */
1514 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1516 /* Pretty print template instantiations only. */
1517 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1518 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1519 && flag_pretty_templates
)
1523 template_args
= DECL_TI_ARGS (t
);
1524 tmpl
= most_general_template (t
);
1525 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1527 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1532 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1533 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1535 fntype
= TREE_TYPE (t
);
1536 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1538 if (DECL_CLASS_SCOPE_P (t
))
1539 cname
= DECL_CONTEXT (t
);
1540 /* This is for partially instantiated template methods. */
1541 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1542 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1544 if (flags
& TFF_DECL_SPECIFIERS
)
1546 if (DECL_STATIC_FUNCTION_P (t
))
1547 pp_cxx_ws_string (pp
, "static");
1548 else if (DECL_VIRTUAL_P (t
))
1549 pp_cxx_ws_string (pp
, "virtual");
1553 if (DECL_DECLARED_CONCEPT_P (t
))
1554 pp_cxx_ws_string (pp
, "concept");
1556 pp_cxx_ws_string (pp
, "constexpr");
1560 /* Print the return type? */
1562 show_return
= (!DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1563 && !DECL_DESTRUCTOR_P (t
) && !deduction_guide_p (t
));
1566 tree ret
= fndecl_declared_return_type (t
);
1567 dump_type_prefix (pp
, ret
, flags
);
1570 /* Print the function name. */
1571 if (!do_outer_scope
)
1575 dump_type (pp
, cname
, flags
);
1576 pp_cxx_colon_colon (pp
);
1579 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1581 dump_function_name (pp
, t
, flags
);
1583 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1585 dump_parameters (pp
, parmtypes
, flags
);
1587 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1589 pp
->padding
= pp_before
;
1590 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1591 dump_ref_qualifier (pp
, fntype
, flags
);
1594 if (tx_safe_fn_type_p (fntype
))
1596 pp
->padding
= pp_before
;
1597 pp_cxx_ws_string (pp
, "transaction_safe");
1600 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1602 pp
->padding
= pp_before
;
1603 dump_exception_spec (pp
, exceptions
, flags
);
1607 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1608 else if (deduction_guide_p (t
))
1610 pp_cxx_ws_string (pp
, "->");
1611 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1615 if (tree ci
= get_constraints (t
))
1616 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1617 pp_cxx_requires_clause (pp
, reqs
);
1619 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1621 if (tree base
= DECL_INHERITED_CTOR_BASE (t
))
1623 pp_cxx_ws_string (pp
, "[inherited from");
1624 dump_type (pp
, base
, TFF_PLAIN_IDENTIFIER
);
1625 pp_character (pp
, ']');
1628 else if (template_args
)
1630 bool need_comma
= false;
1632 pp_cxx_begin_template_argument_list (pp
);
1633 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1634 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1636 tree arg
= TREE_VEC_ELT (template_args
, i
);
1638 pp_separate_with_comma (pp
);
1639 if (ARGUMENT_PACK_P (arg
))
1640 pp_cxx_left_brace (pp
);
1641 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1642 if (ARGUMENT_PACK_P (arg
))
1643 pp_cxx_right_brace (pp
);
1646 pp_cxx_end_template_argument_list (pp
);
1650 /* Print a parameter list. If this is for a member function, the
1651 member object ptr (and any other hidden args) should have
1652 already been removed. */
1655 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1658 flags
&= ~TFF_SCOPE
;
1659 pp_cxx_left_paren (pp
);
1661 for (first
= 1; parmtypes
!= void_list_node
;
1662 parmtypes
= TREE_CHAIN (parmtypes
))
1665 pp_separate_with_comma (pp
);
1669 pp_cxx_ws_string (pp
, "...");
1673 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1675 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1677 pp_cxx_whitespace (pp
);
1679 pp_cxx_whitespace (pp
);
1680 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1684 pp_cxx_right_paren (pp
);
1687 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1690 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1692 if (FUNCTION_REF_QUALIFIED (t
))
1694 pp
->padding
= pp_before
;
1695 if (FUNCTION_RVALUE_QUALIFIED (t
))
1696 pp_cxx_ws_string (pp
, "&&");
1698 pp_cxx_ws_string (pp
, "&");
1702 /* Print an exception specification. T is the exception specification. */
1705 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1707 if (t
&& TREE_PURPOSE (t
))
1709 pp_cxx_ws_string (pp
, "noexcept");
1710 if (!integer_onep (TREE_PURPOSE (t
)))
1712 pp_cxx_whitespace (pp
);
1713 pp_cxx_left_paren (pp
);
1714 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1715 pp_cxx_ws_string (pp
, "<uninstantiated>");
1717 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1718 pp_cxx_right_paren (pp
);
1723 pp_cxx_ws_string (pp
, "throw");
1724 pp_cxx_whitespace (pp
);
1725 pp_cxx_left_paren (pp
);
1726 if (TREE_VALUE (t
) != NULL_TREE
)
1729 dump_type (pp
, TREE_VALUE (t
), flags
);
1733 pp_separate_with_comma (pp
);
1735 pp_cxx_right_paren (pp
);
1739 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1740 and destructors properly. */
1743 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1745 tree name
= DECL_NAME (t
);
1747 /* We can get here with a decl that was synthesized by language-
1748 independent machinery (e.g. coverage.c) in which case it won't
1749 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1750 will crash. In this case it is safe just to print out the
1752 if (!DECL_LANG_SPECIFIC (t
))
1754 pp_cxx_tree_identifier (pp
, name
);
1758 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1759 t
= DECL_TEMPLATE_RESULT (t
);
1761 /* Don't let the user see __comp_ctor et al. */
1762 if (DECL_CONSTRUCTOR_P (t
)
1763 || DECL_DESTRUCTOR_P (t
))
1765 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1766 name
= get_identifier ("<lambda>");
1767 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1768 name
= get_identifier ("<constructor>");
1770 name
= constructor_name (DECL_CONTEXT (t
));
1773 if (DECL_DESTRUCTOR_P (t
))
1775 pp_cxx_complement (pp
);
1776 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1778 else if (DECL_CONV_FN_P (t
))
1780 /* This cannot use the hack that the operator's return
1781 type is stashed off of its name because it may be
1782 used for error reporting. In the case of conflicting
1783 declarations, both will have the same name, yet
1784 the types will be different, hence the TREE_TYPE field
1785 of the first name will be clobbered by the second. */
1786 pp_cxx_ws_string (pp
, "operator");
1787 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1790 dump_decl (pp
, name
, flags
);
1792 if (DECL_TEMPLATE_INFO (t
)
1793 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1794 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1795 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1796 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1800 /* Dump the template parameters from the template info INFO under control of
1801 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1802 specialization (partial or complete). For partial specializations we show
1803 the specialized parameter values. For a primary template we show no
1807 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1808 int primary
, int flags
)
1810 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1812 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1814 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1815 pp_cxx_begin_template_argument_list (pp
);
1817 /* Be careful only to print things when we have them, so as not
1818 to crash producing error messages. */
1819 if (args
&& !primary
)
1822 len
= get_non_default_template_args_count (args
, flags
);
1824 args
= INNERMOST_TEMPLATE_ARGS (args
);
1825 for (ix
= 0; ix
!= len
; ix
++)
1827 tree arg
= TREE_VEC_ELT (args
, ix
);
1829 /* Only print a comma if we know there is an argument coming. In
1830 the case of an empty template argument pack, no actual
1831 argument will be printed. */
1833 && (!ARGUMENT_PACK_P (arg
)
1834 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1835 pp_separate_with_comma (pp
);
1838 pp_string (pp
, M_("<template parameter error>"));
1840 dump_template_argument (pp
, arg
, flags
);
1845 tree tpl
= TI_TEMPLATE (info
);
1846 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1849 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1850 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1852 for (ix
= 0; ix
!= len
; ix
++)
1856 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1858 pp_string (pp
, M_("<template parameter error>"));
1862 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1865 pp_separate_with_comma (pp
);
1867 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1870 pp_cxx_end_template_argument_list (pp
);
1873 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1874 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1877 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1880 call_expr_arg_iterator iter
;
1882 pp_cxx_left_paren (pp
);
1883 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1889 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1890 if (more_call_expr_args_p (&iter
))
1891 pp_separate_with_comma (pp
);
1894 pp_cxx_right_paren (pp
);
1897 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1898 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1902 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1906 aggr_init_expr_arg_iterator iter
;
1908 pp_cxx_left_paren (pp
);
1909 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1915 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1916 if (more_aggr_init_expr_args_p (&iter
))
1917 pp_separate_with_comma (pp
);
1920 pp_cxx_right_paren (pp
);
1923 /* Print out a list of initializers (subr of dump_expr). */
1926 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1930 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1933 pp_separate_with_comma (pp
);
1937 /* Print out a vector of initializers (subr of dump_expr). */
1940 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1943 unsigned HOST_WIDE_INT idx
;
1946 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1948 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1949 if (idx
!= v
->length () - 1)
1950 pp_separate_with_comma (pp
);
1955 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1956 function. Resolve it to a close relative -- in the sense of static
1957 type -- variant being overridden. That is close to what was written in
1958 the source code. Subroutine of dump_expr. */
1961 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1963 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1964 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1965 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1968 fun
= TREE_CHAIN (fun
);
1969 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1970 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1976 /* Print out an expression E under control of FLAGS. */
1979 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
1986 if (STATEMENT_CLASS_P (t
))
1988 pp_cxx_ws_string (pp
, M_("<statement>"));
1992 switch (TREE_CODE (t
))
2000 case NAMESPACE_DECL
:
2004 case IDENTIFIER_NODE
:
2005 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
2006 |TFF_TEMPLATE_HEADER
))
2007 | TFF_NO_TEMPLATE_BINDINGS
2008 | TFF_NO_FUNCTION_ARGUMENTS
));
2012 if (SSA_NAME_VAR (t
)
2013 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
2014 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2016 pp_cxx_ws_string (pp
, M_("<unknown>"));
2027 case USERDEF_LITERAL
:
2028 pp_cxx_userdef_literal (pp
, t
);
2032 /* While waiting for caret diagnostics, avoid printing
2033 __cxa_allocate_exception, __cxa_throw, and the like. */
2034 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2039 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2040 pp_cxx_colon_colon (pp
);
2041 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2045 pp_cxx_left_paren (pp
);
2046 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2047 pp_separate_with_comma (pp
);
2048 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2049 pp_cxx_right_paren (pp
);
2053 pp_cxx_left_paren (pp
);
2054 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2055 pp_string (pp
, " ? ");
2056 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2057 pp_string (pp
, " : ");
2058 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2059 pp_cxx_right_paren (pp
);
2063 if (TREE_HAS_CONSTRUCTOR (t
))
2065 pp_cxx_ws_string (pp
, "new");
2066 pp_cxx_whitespace (pp
);
2067 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2070 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2073 case AGGR_INIT_EXPR
:
2075 tree fn
= NULL_TREE
;
2077 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2078 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2080 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2082 if (DECL_CONSTRUCTOR_P (fn
))
2083 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2085 dump_decl (pp
, fn
, 0);
2088 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2090 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2095 tree fn
= CALL_EXPR_FN (t
);
2096 bool skipfirst
= false;
2098 /* Deal with internal functions. */
2099 if (fn
== NULL_TREE
)
2101 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2102 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2106 if (TREE_CODE (fn
) == ADDR_EXPR
)
2107 fn
= TREE_OPERAND (fn
, 0);
2109 /* Nobody is interested in seeing the guts of vcalls. */
2110 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2111 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2113 if (TREE_TYPE (fn
) != NULL_TREE
2114 && NEXT_CODE (fn
) == METHOD_TYPE
2115 && call_expr_nargs (t
))
2117 tree ob
= CALL_EXPR_ARG (t
, 0);
2118 if (TREE_CODE (ob
) == ADDR_EXPR
)
2120 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2121 flags
| TFF_EXPR_IN_PARENS
);
2124 else if (TREE_CODE (ob
) != PARM_DECL
2125 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2127 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2132 if (flag_sanitize
& SANITIZE_UNDEFINED
2133 && is_ubsan_builtin_p (fn
))
2135 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2138 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2139 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2144 /* Note that this only works for G++ target exprs. If somebody
2145 builds a general TARGET_EXPR, there's no way to represent that
2146 it initializes anything other that the parameter slot for the
2147 default argument. Note we may have cleared out the first
2148 operand in expand_expr, so don't go killing ourselves. */
2149 if (TREE_OPERAND (t
, 1))
2150 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2153 case POINTER_PLUS_EXPR
:
2154 dump_binary_op (pp
, "+", t
, flags
);
2159 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2166 case TRUNC_DIV_EXPR
:
2167 case TRUNC_MOD_EXPR
:
2175 case TRUTH_ANDIF_EXPR
:
2176 case TRUTH_ORIF_EXPR
:
2183 case EXACT_DIV_EXPR
:
2184 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2188 case FLOOR_DIV_EXPR
:
2189 case ROUND_DIV_EXPR
:
2191 dump_binary_op (pp
, "/", t
, flags
);
2195 case FLOOR_MOD_EXPR
:
2196 case ROUND_MOD_EXPR
:
2197 dump_binary_op (pp
, "%", t
, flags
);
2202 tree ob
= TREE_OPERAND (t
, 0);
2203 if (INDIRECT_REF_P (ob
))
2205 ob
= TREE_OPERAND (ob
, 0);
2206 if (TREE_CODE (ob
) != PARM_DECL
2208 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2210 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2211 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2219 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2222 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2227 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2228 pp_cxx_left_bracket (pp
);
2229 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2230 pp_cxx_right_bracket (pp
);
2233 case ARRAY_NOTATION_REF
:
2234 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2235 pp_cxx_left_bracket (pp
);
2236 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2238 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2240 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2241 pp_cxx_right_bracket (pp
);
2244 case UNARY_PLUS_EXPR
:
2245 dump_unary_op (pp
, "+", t
, flags
);
2249 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2250 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2251 /* An ADDR_EXPR can have reference type. In that case, we
2252 shouldn't print the `&' doing so indicates to the user
2253 that the expression has pointer type. */
2255 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2256 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2257 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2258 dump_unary_op (pp
, "&&", t
, flags
);
2260 dump_unary_op (pp
, "&", t
, flags
);
2264 if (TREE_HAS_CONSTRUCTOR (t
))
2266 t
= TREE_OPERAND (t
, 0);
2267 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2268 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2269 dump_call_expr_args (pp
, t
, flags
, true);
2273 if (TREE_OPERAND (t
,0) != NULL_TREE
2274 && TREE_TYPE (TREE_OPERAND (t
, 0))
2275 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2276 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2278 dump_unary_op (pp
, "*", t
, flags
);
2283 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2284 && integer_zerop (TREE_OPERAND (t
, 1)))
2285 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2289 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2291 pp_cxx_left_paren (pp
);
2292 if (!integer_onep (TYPE_SIZE_UNIT
2293 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2295 pp_cxx_left_paren (pp
);
2296 dump_type (pp
, ptr_type_node
, flags
);
2297 pp_cxx_right_paren (pp
);
2300 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2301 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2303 pp_cxx_ws_string (pp
, "+");
2304 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2306 pp_cxx_right_paren (pp
);
2313 case TRUTH_NOT_EXPR
:
2314 case PREDECREMENT_EXPR
:
2315 case PREINCREMENT_EXPR
:
2316 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2319 case POSTDECREMENT_EXPR
:
2320 case POSTINCREMENT_EXPR
:
2321 pp_cxx_left_paren (pp
);
2322 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2323 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2324 pp_cxx_right_paren (pp
);
2327 case NON_LVALUE_EXPR
:
2328 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2329 should be another level of INDIRECT_REF so that I don't have to do
2331 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2333 tree next
= TREE_TYPE (TREE_TYPE (t
));
2335 while (TYPE_PTR_P (next
))
2336 next
= TREE_TYPE (next
);
2338 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2340 if (flags
& TFF_EXPR_IN_PARENS
)
2341 pp_cxx_left_paren (pp
);
2343 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2344 if (flags
& TFF_EXPR_IN_PARENS
)
2345 pp_cxx_right_paren (pp
);
2348 /* Else fall through. */
2350 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2354 case IMPLICIT_CONV_EXPR
:
2355 case VIEW_CONVERT_EXPR
:
2357 tree op
= TREE_OPERAND (t
, 0);
2358 tree ttype
= TREE_TYPE (t
);
2359 tree optype
= TREE_TYPE (op
);
2361 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2362 && POINTER_TYPE_P (ttype
)
2363 && POINTER_TYPE_P (optype
)
2364 && same_type_p (TREE_TYPE (optype
),
2367 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2370 if (TREE_CODE (op
) == ADDR_EXPR
)
2371 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2373 dump_unary_op (pp
, "*", t
, flags
);
2376 dump_unary_op (pp
, "&", t
, flags
);
2378 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2380 /* It is a cast, but we cannot tell whether it is a
2381 reinterpret or static cast. Use the C style notation. */
2382 if (flags
& TFF_EXPR_IN_PARENS
)
2383 pp_cxx_left_paren (pp
);
2384 pp_cxx_left_paren (pp
);
2385 dump_type (pp
, TREE_TYPE (t
), flags
);
2386 pp_cxx_right_paren (pp
);
2387 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2388 if (flags
& TFF_EXPR_IN_PARENS
)
2389 pp_cxx_right_paren (pp
);
2392 dump_expr (pp
, op
, flags
);
2397 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2399 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2401 if (integer_zerop (idx
))
2403 /* A NULL pointer-to-member constant. */
2404 pp_cxx_left_paren (pp
);
2405 pp_cxx_left_paren (pp
);
2406 dump_type (pp
, TREE_TYPE (t
), flags
);
2407 pp_cxx_right_paren (pp
);
2408 pp_character (pp
, '0');
2409 pp_cxx_right_paren (pp
);
2412 else if (tree_fits_shwi_p (idx
))
2415 unsigned HOST_WIDE_INT n
;
2417 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2418 t
= TYPE_METHOD_BASETYPE (t
);
2419 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2421 n
= tree_to_shwi (idx
);
2423 /* Map vtable index back one, to allow for the null pointer to
2427 while (n
> 0 && virtuals
)
2430 virtuals
= TREE_CHAIN (virtuals
);
2434 dump_expr (pp
, BV_FN (virtuals
),
2435 flags
| TFF_EXPR_IN_PARENS
);
2440 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2441 pp_string (pp
, "<lambda closure object>");
2442 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2444 dump_type (pp
, TREE_TYPE (t
), 0);
2445 pp_cxx_left_paren (pp
);
2446 pp_cxx_right_paren (pp
);
2450 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2451 dump_type (pp
, TREE_TYPE (t
), 0);
2452 pp_cxx_left_brace (pp
);
2453 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2454 pp_cxx_right_brace (pp
);
2461 tree ob
= TREE_OPERAND (t
, 0);
2462 if (is_dummy_object (ob
))
2464 t
= TREE_OPERAND (t
, 1);
2465 if (TREE_CODE (t
) == FUNCTION_DECL
)
2467 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2468 else if (BASELINK_P (t
))
2469 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2470 flags
| TFF_EXPR_IN_PARENS
);
2472 dump_decl (pp
, t
, flags
);
2476 if (INDIRECT_REF_P (ob
))
2478 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2484 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2488 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2493 case TEMPLATE_PARM_INDEX
:
2494 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2498 if (TREE_OPERAND (t
, 0) == NULL_TREE
2499 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2501 dump_type (pp
, TREE_TYPE (t
), flags
);
2502 pp_cxx_left_paren (pp
);
2503 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2504 pp_cxx_right_paren (pp
);
2508 pp_cxx_left_paren (pp
);
2509 dump_type (pp
, TREE_TYPE (t
), flags
);
2510 pp_cxx_right_paren (pp
);
2511 pp_cxx_left_paren (pp
);
2512 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2513 pp_cxx_right_paren (pp
);
2517 case STATIC_CAST_EXPR
:
2518 pp_cxx_ws_string (pp
, "static_cast");
2520 case REINTERPRET_CAST_EXPR
:
2521 pp_cxx_ws_string (pp
, "reinterpret_cast");
2523 case CONST_CAST_EXPR
:
2524 pp_cxx_ws_string (pp
, "const_cast");
2526 case DYNAMIC_CAST_EXPR
:
2527 pp_cxx_ws_string (pp
, "dynamic_cast");
2529 pp_cxx_begin_template_argument_list (pp
);
2530 dump_type (pp
, TREE_TYPE (t
), flags
);
2531 pp_cxx_end_template_argument_list (pp
);
2532 pp_cxx_left_paren (pp
);
2533 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2534 pp_cxx_right_paren (pp
);
2538 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2544 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2545 pp_cxx_ws_string (pp
, "sizeof");
2548 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2549 pp_cxx_ws_string (pp
, "__alignof__");
2551 op
= TREE_OPERAND (t
, 0);
2552 if (PACK_EXPANSION_P (op
))
2554 pp_string (pp
, "...");
2555 op
= PACK_EXPANSION_PATTERN (op
);
2557 pp_cxx_whitespace (pp
);
2558 pp_cxx_left_paren (pp
);
2559 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2560 dump_type (pp
, TREE_TYPE (op
), flags
);
2561 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2562 dump_type (pp
, op
, flags
);
2564 dump_expr (pp
, op
, flags
);
2565 pp_cxx_right_paren (pp
);
2568 case AT_ENCODE_EXPR
:
2569 pp_cxx_ws_string (pp
, "@encode");
2570 pp_cxx_whitespace (pp
);
2571 pp_cxx_left_paren (pp
);
2572 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2573 pp_cxx_right_paren (pp
);
2577 pp_cxx_ws_string (pp
, "noexcept");
2578 pp_cxx_whitespace (pp
);
2579 pp_cxx_left_paren (pp
);
2580 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2581 pp_cxx_right_paren (pp
);
2586 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2587 pp_cxx_whitespace (pp
);
2588 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2592 pp_string (pp
, M_("<unparsed>"));
2595 case TRY_CATCH_EXPR
:
2596 case WITH_CLEANUP_EXPR
:
2597 case CLEANUP_POINT_EXPR
:
2598 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2601 case PSEUDO_DTOR_EXPR
:
2602 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2604 if (TREE_OPERAND (t
, 1))
2606 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2607 pp_cxx_colon_colon (pp
);
2609 pp_cxx_complement (pp
);
2610 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2613 case TEMPLATE_ID_EXPR
:
2614 dump_decl (pp
, t
, flags
);
2620 case STATEMENT_LIST
:
2621 /* We don't yet have a way of dumping statements in a
2622 human-readable format. */
2623 pp_string (pp
, "({...})");
2627 pp_string (pp
, "while (1) { ");
2628 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2629 pp_cxx_right_brace (pp
);
2633 pp_string (pp
, "if (");
2634 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2635 pp_string (pp
, ") break; ");
2639 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2642 case EMPTY_CLASS_EXPR
:
2643 dump_type (pp
, TREE_TYPE (t
), flags
);
2644 pp_cxx_left_paren (pp
);
2645 pp_cxx_right_paren (pp
);
2648 case NON_DEPENDENT_EXPR
:
2649 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2652 case ARGUMENT_PACK_SELECT
:
2653 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2665 pp_type_specifier_seq (pp
, t
);
2669 /* We get here when we want to print a dependent type as an
2670 id-expression, without any disambiguator decoration. */
2671 pp
->id_expression (t
);
2674 case TEMPLATE_TYPE_PARM
:
2675 case TEMPLATE_TEMPLATE_PARM
:
2676 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2677 dump_type (pp
, t
, flags
);
2681 pp_cxx_trait_expression (pp
, t
);
2685 pp_cxx_va_arg_expression (pp
, t
);
2689 pp_cxx_offsetof_expression (pp
, t
);
2692 case ADDRESSOF_EXPR
:
2693 pp_cxx_addressof_expression (pp
, t
);
2697 dump_decl (pp
, t
, flags
);
2700 case EXPR_PACK_EXPANSION
:
2701 case UNARY_LEFT_FOLD_EXPR
:
2702 case UNARY_RIGHT_FOLD_EXPR
:
2703 case BINARY_LEFT_FOLD_EXPR
:
2704 case BINARY_RIGHT_FOLD_EXPR
:
2711 case VEC_DELETE_EXPR
:
2717 case UNORDERED_EXPR
:
2727 case FIX_TRUNC_EXPR
:
2732 case TRUTH_AND_EXPR
:
2734 case TRUTH_XOR_EXPR
:
2735 if (flags
& TFF_EXPR_IN_PARENS
)
2736 pp_cxx_left_paren (pp
);
2738 if (flags
& TFF_EXPR_IN_PARENS
)
2739 pp_cxx_right_paren (pp
);
2743 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2747 pp_string (pp
, M_("<lambda>"));
2751 pp_cxx_left_paren (pp
);
2752 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2753 pp_cxx_right_paren (pp
);
2757 pp_cxx_requires_expr (cxx_pp
, t
);
2761 pp_cxx_simple_requirement (cxx_pp
, t
);
2765 pp_cxx_type_requirement (cxx_pp
, t
);
2769 pp_cxx_compound_requirement (cxx_pp
, t
);
2773 pp_cxx_nested_requirement (cxx_pp
, t
);
2786 pp_cxx_constraint (cxx_pp
, t
);
2789 case PLACEHOLDER_EXPR
:
2790 pp_string (pp
, M_("*this"));
2793 /* This list is incomplete, but should suffice for now.
2794 It is very important that `sorry' does not call
2795 `report_error_function'. That could cause an infinite loop. */
2797 pp_unsupported_tree (pp
, t
);
2800 pp_string (pp
, M_("<expression error>"));
2806 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2809 pp_cxx_left_paren (pp
);
2810 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2811 pp_cxx_whitespace (pp
);
2813 pp_cxx_ws_string (pp
, opstring
);
2815 pp_string (pp
, M_("<unknown operator>"));
2816 pp_cxx_whitespace (pp
);
2817 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2818 pp_cxx_right_paren (pp
);
2822 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2824 if (flags
& TFF_EXPR_IN_PARENS
)
2825 pp_cxx_left_paren (pp
);
2826 pp_cxx_ws_string (pp
, opstring
);
2827 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2828 if (flags
& TFF_EXPR_IN_PARENS
)
2829 pp_cxx_right_paren (pp
);
2833 reinit_cxx_pp (void)
2835 pp_clear_output_area (cxx_pp
);
2836 cxx_pp
->padding
= pp_none
;
2837 pp_indentation (cxx_pp
) = 0;
2838 pp_needs_newline (cxx_pp
) = false;
2839 cxx_pp
->enclosing_scope
= current_function_decl
;
2842 /* Same as pp_formatted_text, except the return string is a separate
2843 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2846 pp_ggc_formatted_text (pretty_printer
*pp
)
2848 return ggc_strdup (pp_formatted_text (pp
));
2851 /* Exported interface to stringifying types, exprs and decls under TFF_*
2855 type_as_string (tree typ
, int flags
)
2858 pp_translate_identifiers (cxx_pp
) = false;
2859 dump_type (cxx_pp
, typ
, flags
);
2860 return pp_ggc_formatted_text (cxx_pp
);
2864 type_as_string_translate (tree typ
, int flags
)
2867 dump_type (cxx_pp
, typ
, flags
);
2868 return pp_ggc_formatted_text (cxx_pp
);
2872 expr_as_string (tree decl
, int flags
)
2875 pp_translate_identifiers (cxx_pp
) = false;
2876 dump_expr (cxx_pp
, decl
, flags
);
2877 return pp_ggc_formatted_text (cxx_pp
);
2880 /* Wrap decl_as_string with options appropriate for dwarf. */
2883 decl_as_dwarf_string (tree decl
, int flags
)
2886 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2887 here will be adequate to get the desired behavior. */
2888 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2889 name
= decl_as_string (decl
, flags
);
2890 /* Subsequent calls to the pretty printer shouldn't use this style. */
2891 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2896 decl_as_string (tree decl
, int flags
)
2899 pp_translate_identifiers (cxx_pp
) = false;
2900 dump_decl (cxx_pp
, decl
, flags
);
2901 return pp_ggc_formatted_text (cxx_pp
);
2905 decl_as_string_translate (tree decl
, int flags
)
2908 dump_decl (cxx_pp
, decl
, flags
);
2909 return pp_ggc_formatted_text (cxx_pp
);
2912 /* Wrap lang_decl_name with options appropriate for dwarf. */
2915 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2918 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2919 here will be adequate to get the desired behavior. */
2920 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2921 name
= lang_decl_name (decl
, v
, translate
);
2922 /* Subsequent calls to the pretty printer shouldn't use this style. */
2923 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2927 /* Generate the three forms of printable names for cxx_printable_name. */
2930 lang_decl_name (tree decl
, int v
, bool translate
)
2934 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2935 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2938 pp_translate_identifiers (cxx_pp
) = translate
;
2940 && (DECL_CLASS_SCOPE_P (decl
)
2941 || (DECL_NAMESPACE_SCOPE_P (decl
)
2942 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2944 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2945 pp_cxx_colon_colon (cxx_pp
);
2948 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2949 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2950 else if ((DECL_NAME (decl
) == NULL_TREE
)
2951 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2952 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2954 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2956 return pp_ggc_formatted_text (cxx_pp
);
2959 /* Return the location of a tree passed to %+ formats. */
2962 location_of (tree t
)
2966 t
= TYPE_MAIN_DECL (t
);
2968 return input_location
;
2970 else if (TREE_CODE (t
) == OVERLOAD
)
2971 t
= OVL_FUNCTION (t
);
2974 return DECL_SOURCE_LOCATION (t
);
2975 return EXPR_LOC_OR_LOC (t
, input_location
);
2978 /* Now the interfaces from error et al to dump_type et al. Each takes an
2979 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2983 decl_to_string (tree decl
, int verbose
)
2987 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2988 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2989 flags
= TFF_CLASS_KEY_OR_ENUM
;
2991 flags
|= TFF_DECL_SPECIFIERS
;
2992 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2993 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2994 flags
|= TFF_TEMPLATE_HEADER
;
2997 dump_decl (cxx_pp
, decl
, flags
);
2998 return pp_ggc_formatted_text (cxx_pp
);
3002 expr_to_string (tree decl
)
3005 dump_expr (cxx_pp
, decl
, 0);
3006 return pp_ggc_formatted_text (cxx_pp
);
3010 fndecl_to_string (tree fndecl
, int verbose
)
3014 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
3015 | TFF_TEMPLATE_HEADER
;
3017 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3019 dump_decl (cxx_pp
, fndecl
, flags
);
3020 return pp_ggc_formatted_text (cxx_pp
);
3025 code_to_string (enum tree_code c
)
3027 return get_tree_code_name (c
);
3031 language_to_string (enum languages c
)
3038 case lang_cplusplus
:
3047 /* Return the proper printed version of a parameter to a C++ function. */
3050 parm_to_string (int p
)
3054 pp_string (cxx_pp
, "'this'");
3056 pp_decimal_int (cxx_pp
, p
+ 1);
3057 return pp_ggc_formatted_text (cxx_pp
);
3061 op_to_string (enum tree_code p
)
3063 tree id
= operator_name_info
[p
].identifier
;
3064 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3068 type_to_string (tree typ
, int verbose
)
3072 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3073 flags
|= TFF_TEMPLATE_HEADER
;
3076 dump_type (cxx_pp
, typ
, flags
);
3077 /* If we're printing a type that involves typedefs, also print the
3078 stripped version. But sometimes the stripped version looks
3079 exactly the same, so we don't want it after all. To avoid printing
3080 it in that case, we play ugly obstack games. */
3081 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3082 && !uses_template_parms (typ
))
3084 int aka_start
, aka_len
; char *p
;
3085 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3086 /* Remember the end of the initial dump. */
3087 int len
= obstack_object_size (ob
);
3088 tree aka
= strip_typedefs (typ
);
3089 pp_string (cxx_pp
, " {aka");
3090 pp_cxx_whitespace (cxx_pp
);
3091 /* And remember the start of the aka dump. */
3092 aka_start
= obstack_object_size (ob
);
3093 dump_type (cxx_pp
, aka
, flags
);
3094 aka_len
= obstack_object_size (ob
) - aka_start
;
3095 pp_right_brace (cxx_pp
);
3096 p
= (char*)obstack_base (ob
);
3097 /* If they are identical, cut off the aka with a NUL. */
3098 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3101 return pp_ggc_formatted_text (cxx_pp
);
3105 assop_to_string (enum tree_code p
)
3107 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3108 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3112 args_to_string (tree p
, int verbose
)
3116 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3121 if (TYPE_P (TREE_VALUE (p
)))
3122 return type_as_string_translate (p
, flags
);
3125 for (; p
; p
= TREE_CHAIN (p
))
3127 if (TREE_VALUE (p
) == null_node
)
3128 pp_cxx_ws_string (cxx_pp
, "NULL");
3130 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3132 pp_separate_with_comma (cxx_pp
);
3134 return pp_ggc_formatted_text (cxx_pp
);
3137 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3138 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3142 subst_to_string (tree p
)
3144 tree decl
= TREE_PURPOSE (p
);
3145 tree targs
= TREE_VALUE (p
);
3146 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3147 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3148 |TFF_NO_TEMPLATE_BINDINGS
);
3154 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3155 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3156 return pp_ggc_formatted_text (cxx_pp
);
3160 cv_to_string (tree p
, int v
)
3163 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3164 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3165 return pp_ggc_formatted_text (cxx_pp
);
3169 eh_spec_to_string (tree p
, int /*v*/)
3173 dump_exception_spec (cxx_pp
, p
, flags
);
3174 return pp_ggc_formatted_text (cxx_pp
);
3177 /* Langhook for print_error_function. */
3179 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3180 diagnostic_info
*diagnostic
)
3182 lhd_print_error_function (context
, file
, diagnostic
);
3183 pp_set_prefix (context
->printer
, file
);
3184 maybe_print_instantiation_context (context
);
3188 cp_diagnostic_starter (diagnostic_context
*context
,
3189 diagnostic_info
*diagnostic
)
3191 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3192 cp_print_error_function (context
, diagnostic
);
3193 maybe_print_instantiation_context (context
);
3194 maybe_print_constexpr_context (context
);
3195 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3199 /* Print current function onto BUFFER, in the process of reporting
3200 a diagnostic message. Called from cp_diagnostic_starter. */
3202 cp_print_error_function (diagnostic_context
*context
,
3203 diagnostic_info
*diagnostic
)
3205 /* If we are in an instantiation context, current_function_decl is likely
3206 to be wrong, so just rely on print_instantiation_full_context. */
3207 if (current_instantiation ())
3209 if (diagnostic_last_function_changed (context
, diagnostic
))
3211 const char *old_prefix
= context
->printer
->prefix
;
3212 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3213 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3214 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3215 ? file_name_as_prefix (context
, file
) : NULL
;
3217 pp_set_prefix (context
->printer
, new_prefix
);
3219 if (current_function_decl
== NULL
)
3220 pp_string (context
->printer
, _("At global scope:"));
3225 if (abstract_origin
)
3227 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3228 while (TREE_CODE (ao
) == BLOCK
3229 && BLOCK_ABSTRACT_ORIGIN (ao
)
3230 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3231 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3232 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3236 fndecl
= current_function_decl
;
3238 pp_printf (context
->printer
, function_category (fndecl
),
3239 cxx_printable_name_translate (fndecl
, 2));
3241 while (abstract_origin
)
3244 tree block
= abstract_origin
;
3246 locus
= &BLOCK_SOURCE_LOCATION (block
);
3248 block
= BLOCK_SUPERCONTEXT (block
);
3249 while (block
&& TREE_CODE (block
) == BLOCK
3250 && BLOCK_ABSTRACT_ORIGIN (block
))
3252 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3254 while (TREE_CODE (ao
) == BLOCK
3255 && BLOCK_ABSTRACT_ORIGIN (ao
)
3256 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3257 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3259 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3264 else if (TREE_CODE (ao
) != BLOCK
)
3267 block
= BLOCK_SUPERCONTEXT (block
);
3270 abstract_origin
= block
;
3273 while (block
&& TREE_CODE (block
) == BLOCK
)
3274 block
= BLOCK_SUPERCONTEXT (block
);
3276 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3278 abstract_origin
= NULL
;
3282 expanded_location s
= expand_location (*locus
);
3283 pp_character (context
->printer
, ',');
3284 pp_newline (context
->printer
);
3287 if (context
->show_column
&& s
.column
!= 0)
3288 pp_printf (context
->printer
,
3289 _(" inlined from %qs at %r%s:%d:%d%R"),
3290 cxx_printable_name_translate (fndecl
, 2),
3291 "locus", s
.file
, s
.line
, s
.column
);
3293 pp_printf (context
->printer
,
3294 _(" inlined from %qs at %r%s:%d%R"),
3295 cxx_printable_name_translate (fndecl
, 2),
3296 "locus", s
.file
, s
.line
);
3300 pp_printf (context
->printer
, _(" inlined from %qs"),
3301 cxx_printable_name_translate (fndecl
, 2));
3304 pp_character (context
->printer
, ':');
3306 pp_newline (context
->printer
);
3308 diagnostic_set_last_function (context
, diagnostic
);
3309 pp_destroy_prefix (context
->printer
);
3310 context
->printer
->prefix
= old_prefix
;
3314 /* Returns a description of FUNCTION using standard terminology. The
3315 result is a format string of the form "In CATEGORY %qs". */
3317 function_category (tree fn
)
3319 /* We can get called from the middle-end for diagnostics of function
3320 clones. Make sure we have language specific information before
3321 dereferencing it. */
3322 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3323 && DECL_FUNCTION_MEMBER_P (fn
))
3325 if (DECL_STATIC_FUNCTION_P (fn
))
3326 return _("In static member function %qs");
3327 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3328 return _("In copy constructor %qs");
3329 else if (DECL_CONSTRUCTOR_P (fn
))
3330 return _("In constructor %qs");
3331 else if (DECL_DESTRUCTOR_P (fn
))
3332 return _("In destructor %qs");
3333 else if (LAMBDA_FUNCTION_P (fn
))
3334 return _("In lambda function");
3336 return _("In member function %qs");
3339 return _("In function %qs");
3342 /* Report the full context of a current template instantiation,
3345 print_instantiation_full_context (diagnostic_context
*context
)
3347 struct tinst_level
*p
= current_instantiation ();
3348 location_t location
= input_location
;
3352 pp_verbatim (context
->printer
,
3353 TREE_CODE (p
->decl
) == TREE_LIST
3354 ? _("%s: In substitution of %qS:\n")
3355 : _("%s: In instantiation of %q#D:\n"),
3356 LOCATION_FILE (location
),
3359 location
= p
->locus
;
3363 print_instantiation_partial_context (context
, p
, location
);
3366 /* Helper function of print_instantiation_partial_context() that
3367 prints a single line of instantiation context. */
3370 print_instantiation_partial_context_line (diagnostic_context
*context
,
3371 const struct tinst_level
*t
,
3372 location_t loc
, bool recursive_p
)
3374 if (loc
== UNKNOWN_LOCATION
)
3377 expanded_location xloc
= expand_location (loc
);
3379 if (context
->show_column
)
3380 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3381 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3383 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3384 "locus", xloc
.file
, xloc
.line
);
3388 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3389 pp_verbatim (context
->printer
,
3391 ? _("recursively required by substitution of %qS\n")
3392 : _("required by substitution of %qS\n"),
3395 pp_verbatim (context
->printer
,
3397 ? _("recursively required from %q#D\n")
3398 : _("required from %q#D\n"),
3403 pp_verbatim (context
->printer
,
3405 ? _("recursively required from here\n")
3406 : _("required from here\n"));
3410 /* Same as print_instantiation_full_context but less verbose. */
3413 print_instantiation_partial_context (diagnostic_context
*context
,
3414 struct tinst_level
*t0
, location_t loc
)
3416 struct tinst_level
*t
;
3419 location_t prev_loc
= loc
;
3421 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3422 if (prev_loc
!= t
->locus
)
3424 prev_loc
= t
->locus
;
3430 if (template_backtrace_limit
3431 && n_total
> template_backtrace_limit
)
3433 int skip
= n_total
- template_backtrace_limit
;
3434 int head
= template_backtrace_limit
/ 2;
3436 /* Avoid skipping just 1. If so, skip 2. */
3440 head
= (template_backtrace_limit
- 1) / 2;
3443 for (n
= 0; n
< head
; n
++)
3445 gcc_assert (t
!= NULL
);
3446 if (loc
!= t
->locus
)
3447 print_instantiation_partial_context_line (context
, t
, loc
,
3448 /*recursive_p=*/false);
3452 if (t
!= NULL
&& skip
> 0)
3454 expanded_location xloc
;
3455 xloc
= expand_location (loc
);
3456 if (context
->show_column
)
3457 pp_verbatim (context
->printer
,
3458 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3459 "contexts, use -ftemplate-backtrace-limit=0 to "
3461 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3463 pp_verbatim (context
->printer
,
3464 _("%r%s:%d:%R [ skipping %d instantiation "
3465 "contexts, use -ftemplate-backtrace-limit=0 to "
3467 "locus", xloc
.file
, xloc
.line
, skip
);
3472 } while (t
!= NULL
&& --skip
> 0);
3478 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3483 print_instantiation_partial_context_line (context
, t
, loc
,
3488 print_instantiation_partial_context_line (context
, NULL
, loc
,
3489 /*recursive_p=*/false);
3492 /* Called from cp_thing to print the template context for an error. */
3494 maybe_print_instantiation_context (diagnostic_context
*context
)
3496 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3499 record_last_problematic_instantiation ();
3500 print_instantiation_full_context (context
);
3503 /* Report what constexpr call(s) we're trying to expand, if any. */
3506 maybe_print_constexpr_context (diagnostic_context
*context
)
3508 vec
<tree
> call_stack
= cx_error_context ();
3512 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3514 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3515 const char *s
= expr_as_string (t
, 0);
3516 if (context
->show_column
)
3517 pp_verbatim (context
->printer
,
3518 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3519 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3521 pp_verbatim (context
->printer
,
3522 _("%r%s:%d:%R in constexpr expansion of %qs"),
3523 "locus", xloc
.file
, xloc
.line
, s
);
3524 pp_newline (context
->printer
);
3528 /* Called from output_format -- during diagnostic message processing --
3529 to handle C++ specific format specifier with the following meanings:
3530 %A function argument-list.
3534 %F function declaration.
3535 %L language as used in extern "lang".
3537 %P function parameter whose position is indicated by an integer.
3538 %Q assignment operator.
3539 %S substitution (template + args)
3542 %X exception-specification. */
3544 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3545 int precision
, bool wide
, bool set_locus
, bool verbose
)
3549 #define next_tree (t = va_arg (*text->args_ptr, tree))
3550 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3551 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3552 #define next_int va_arg (*text->args_ptr, int)
3554 if (precision
!= 0 || wide
)
3559 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3560 case 'C': result
= code_to_string (next_tcode
); break;
3563 tree temp
= next_tree
;
3565 && DECL_HAS_DEBUG_EXPR_P (temp
))
3567 temp
= DECL_DEBUG_EXPR (temp
);
3570 result
= expr_to_string (temp
);
3574 result
= decl_to_string (temp
, verbose
);
3577 case 'E': result
= expr_to_string (next_tree
); break;
3578 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3579 case 'L': result
= language_to_string (next_lang
); break;
3580 case 'O': result
= op_to_string (next_tcode
); break;
3581 case 'P': result
= parm_to_string (next_int
); break;
3582 case 'Q': result
= assop_to_string (next_tcode
); break;
3583 case 'S': result
= subst_to_string (next_tree
); break;
3584 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3585 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3586 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3589 percent_K_format (text
);
3596 pp_string (pp
, result
);
3597 if (set_locus
&& t
!= NULL
)
3598 text
->set_location (0, location_of (t
), true);
3606 /* Warn about the use of C++0x features when appropriate. */
3608 maybe_warn_cpp0x (cpp0x_warn_str str
)
3610 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3611 /* We really want to suppress this warning in system headers,
3612 because libstdc++ uses variadic templates even when we aren't
3616 case CPP0X_INITIALIZER_LISTS
:
3617 pedwarn (input_location
, 0,
3618 "extended initializer lists "
3619 "only available with -std=c++11 or -std=gnu++11");
3621 case CPP0X_EXPLICIT_CONVERSION
:
3622 pedwarn (input_location
, 0,
3623 "explicit conversion operators "
3624 "only available with -std=c++11 or -std=gnu++11");
3626 case CPP0X_VARIADIC_TEMPLATES
:
3627 pedwarn (input_location
, 0,
3628 "variadic templates "
3629 "only available with -std=c++11 or -std=gnu++11");
3631 case CPP0X_LAMBDA_EXPR
:
3632 pedwarn (input_location
, 0,
3633 "lambda expressions "
3634 "only available with -std=c++11 or -std=gnu++11");
3637 pedwarn (input_location
, 0,
3638 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3640 case CPP0X_SCOPED_ENUMS
:
3641 pedwarn (input_location
, 0,
3642 "scoped enums only available with -std=c++11 or -std=gnu++11");
3644 case CPP0X_DEFAULTED_DELETED
:
3645 pedwarn (input_location
, 0,
3646 "defaulted and deleted functions "
3647 "only available with -std=c++11 or -std=gnu++11");
3649 case CPP0X_INLINE_NAMESPACES
:
3650 pedwarn (input_location
, OPT_Wpedantic
,
3651 "inline namespaces "
3652 "only available with -std=c++11 or -std=gnu++11");
3654 case CPP0X_OVERRIDE_CONTROLS
:
3655 pedwarn (input_location
, 0,
3656 "override controls (override/final) "
3657 "only available with -std=c++11 or -std=gnu++11");
3660 pedwarn (input_location
, 0,
3661 "non-static data member initializers "
3662 "only available with -std=c++11 or -std=gnu++11");
3664 case CPP0X_USER_DEFINED_LITERALS
:
3665 pedwarn (input_location
, 0,
3666 "user-defined literals "
3667 "only available with -std=c++11 or -std=gnu++11");
3669 case CPP0X_DELEGATING_CTORS
:
3670 pedwarn (input_location
, 0,
3671 "delegating constructors "
3672 "only available with -std=c++11 or -std=gnu++11");
3674 case CPP0X_INHERITING_CTORS
:
3675 pedwarn (input_location
, 0,
3676 "inheriting constructors "
3677 "only available with -std=c++11 or -std=gnu++11");
3679 case CPP0X_ATTRIBUTES
:
3680 pedwarn (input_location
, 0,
3682 "only available with -std=c++11 or -std=gnu++11");
3684 case CPP0X_REF_QUALIFIER
:
3685 pedwarn (input_location
, 0,
3687 "only available with -std=c++11 or -std=gnu++11");
3694 /* Warn about the use of variadic templates when appropriate. */
3696 maybe_warn_variadic_templates (void)
3698 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3702 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3703 option OPT with text GMSGID. Use this function to report
3704 diagnostics for constructs that are invalid C++98, but valid
3707 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3709 diagnostic_info diagnostic
;
3712 rich_location
richloc (line_table
, location
);
3714 va_start (ap
, gmsgid
);
3715 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
3716 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3717 diagnostic
.option_index
= opt
;
3718 ret
= report_diagnostic (&diagnostic
);
3723 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3724 we found when we tried to do the lookup. LOCATION is the location of
3725 the NAME identifier. */
3728 qualified_name_lookup_error (tree scope
, tree name
,
3729 tree decl
, location_t location
)
3731 if (scope
== error_mark_node
)
3732 ; /* We already complained. */
3733 else if (TYPE_P (scope
))
3735 if (!COMPLETE_TYPE_P (scope
))
3736 error_at (location
, "incomplete type %qT used in nested name specifier",
3738 else if (TREE_CODE (decl
) == TREE_LIST
)
3740 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3742 print_candidates (decl
);
3745 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3747 else if (scope
!= global_namespace
)
3749 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3750 suggest_alternatives_for (location
, name
);
3754 error_at (location
, "%<::%D%> has not been declared", name
);
3755 suggest_alternatives_for (location
, name
);