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
)
1053 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
)),
1057 if ((flags
& TFF_DECL_SPECIFIERS
)
1058 && !DECL_SELF_REFERENCE_P (t
))
1059 pp_cxx_ws_string (pp
, "typedef");
1060 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1061 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1066 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1068 pp_string (pp
, M_("vtable for "));
1069 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1070 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1076 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1078 /* Handle variable template specializations. */
1080 && DECL_LANG_SPECIFIC (t
)
1081 && DECL_TEMPLATE_INFO (t
)
1082 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1084 pp_cxx_begin_template_argument_list (pp
);
1085 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1086 dump_template_argument_list (pp
, args
, flags
);
1087 pp_cxx_end_template_argument_list (pp
);
1092 pp_string (pp
, M_("<return value> "));
1093 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1096 case NAMESPACE_DECL
:
1097 if (flags
& TFF_DECL_SPECIFIERS
)
1098 pp
->declaration (t
);
1101 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1102 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1103 flags
&= ~TFF_UNQUALIFIED_NAME
;
1104 if (DECL_NAME (t
) == NULL_TREE
)
1106 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1107 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1109 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1112 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1117 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1118 pp_colon_colon (pp
);
1119 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1123 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1124 pp_cxx_left_bracket (pp
);
1125 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1126 pp_cxx_right_bracket (pp
);
1129 case ARRAY_NOTATION_REF
:
1130 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1131 pp_cxx_left_bracket (pp
);
1132 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1134 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1136 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1137 pp_cxx_right_bracket (pp
);
1140 /* So that we can do dump_decl on an aggr type. */
1144 dump_type (pp
, t
, flags
);
1148 /* This is a pseudo destructor call which has not been folded into
1149 a PSEUDO_DTOR_EXPR yet. */
1150 pp_cxx_complement (pp
);
1151 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1158 /* These special cases are duplicated here so that other functions
1159 can feed identifiers to error and get them demangled properly. */
1160 case IDENTIFIER_NODE
:
1161 if (IDENTIFIER_TYPENAME_P (t
))
1163 pp_cxx_ws_string (pp
, "operator");
1164 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1165 dump_type (pp
, TREE_TYPE (t
), flags
);
1168 else if (dguide_name_p (t
))
1169 dump_decl (pp
, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t
)),
1170 TFF_PLAIN_IDENTIFIER
);
1172 pp_cxx_tree_identifier (pp
, t
);
1178 t
= OVL_CURRENT (t
);
1179 if (DECL_CLASS_SCOPE_P (t
))
1181 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1182 pp_cxx_colon_colon (pp
);
1184 else if (!DECL_FILE_SCOPE_P (t
))
1186 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1187 pp_cxx_colon_colon (pp
);
1189 dump_decl (pp
, DECL_NAME (t
), flags
);
1193 /* If there's only one function, just treat it like an ordinary
1195 t
= OVL_CURRENT (t
);
1199 if (! DECL_LANG_SPECIFIC (t
))
1201 if (DECL_ABSTRACT_ORIGIN (t
))
1202 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1204 pp_string (pp
, M_("<built-in>"));
1206 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1207 dump_global_iord (pp
, t
);
1209 dump_function_decl (pp
, t
, flags
);
1213 dump_template_decl (pp
, t
, flags
);
1216 case TEMPLATE_ID_EXPR
:
1218 tree name
= TREE_OPERAND (t
, 0);
1219 tree args
= TREE_OPERAND (t
, 1);
1221 if (is_overloaded_fn (name
))
1222 name
= get_first_fn (name
);
1224 name
= DECL_NAME (name
);
1225 dump_decl (pp
, name
, flags
);
1226 pp_cxx_begin_template_argument_list (pp
);
1227 if (args
== error_mark_node
)
1228 pp_string (pp
, M_("<template arguments error>"));
1230 dump_template_argument_list
1231 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1232 pp_cxx_end_template_argument_list (pp
);
1237 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1241 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1242 || (DECL_INITIAL (t
) &&
1243 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1244 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1245 else if (DECL_NAME (t
))
1246 dump_decl (pp
, DECL_NAME (t
), flags
);
1247 else if (DECL_INITIAL (t
))
1248 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1250 pp_string (pp
, M_("<enumerator>"));
1254 pp_cxx_ws_string (pp
, "using");
1255 dump_type (pp
, USING_DECL_SCOPE (t
), flags
);
1256 pp_cxx_colon_colon (pp
);
1257 dump_decl (pp
, DECL_NAME (t
), flags
);
1261 pp
->declaration (t
);
1265 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1268 case NON_DEPENDENT_EXPR
:
1269 dump_expr (pp
, t
, flags
);
1272 case TEMPLATE_TYPE_PARM
:
1273 if (flags
& TFF_DECL_SPECIFIERS
)
1274 pp
->declaration (t
);
1279 case UNBOUND_CLASS_TEMPLATE
:
1280 case TYPE_PACK_EXPANSION
:
1282 dump_type (pp
, t
, flags
);
1286 pp_unsupported_tree (pp
, t
);
1290 pp_string (pp
, M_("<declaration error>"));
1295 /* Dump a template declaration T under control of FLAGS. This means the
1296 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1299 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1301 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1305 if (flags
& TFF_TEMPLATE_HEADER
)
1307 for (parms
= orig_parms
= nreverse (orig_parms
);
1309 parms
= TREE_CHAIN (parms
))
1311 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1312 int len
= TREE_VEC_LENGTH (inner_parms
);
1316 /* Skip over the dummy template levels of a template template
1318 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1322 pp_cxx_ws_string (pp
, "template");
1323 pp_cxx_begin_template_argument_list (pp
);
1325 /* If we've shown the template prefix, we'd better show the
1326 parameters' and decl's type too. */
1327 flags
|= TFF_DECL_SPECIFIERS
;
1329 for (i
= 0; i
< len
; i
++)
1332 pp_separate_with_comma (pp
);
1333 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1336 pp_cxx_end_template_argument_list (pp
);
1337 pp_cxx_whitespace (pp
);
1339 nreverse(orig_parms
);
1341 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1343 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1344 pp_cxx_ws_string (pp
, "class");
1346 /* If this is a parameter pack, print the ellipsis. */
1347 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1348 pp_cxx_ws_string (pp
, "...");
1351 /* Only print the requirements if we're also printing
1352 the template header. */
1354 if (tree ci
= get_constraints (t
))
1355 if (check_constraint_info (ci
))
1356 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1358 pp_cxx_requires_clause (pp
, reqs
);
1359 pp_cxx_whitespace (pp
);
1364 if (DECL_CLASS_TEMPLATE_P (t
))
1365 dump_type (pp
, TREE_TYPE (t
),
1366 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1367 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1368 else if (DECL_TEMPLATE_RESULT (t
)
1369 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1370 /* Alias template. */
1371 || DECL_TYPE_TEMPLATE_P (t
)))
1372 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1375 gcc_assert (TREE_TYPE (t
));
1376 switch (NEXT_CODE (t
))
1380 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1383 /* This case can occur with some invalid code. */
1384 dump_type (pp
, TREE_TYPE (t
),
1385 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1386 | (flags
& TFF_DECL_SPECIFIERS
1387 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1392 /* find_typenames looks through the type of the function template T
1393 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1396 struct find_typenames_t
1398 hash_set
<tree
> *p_set
;
1399 vec
<tree
, va_gc
> *typenames
;
1403 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1405 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1406 tree mv
= NULL_TREE
;
1408 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1409 /* Add the type of the typedef without any additional cv-quals. */
1410 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1411 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1412 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1413 /* Add the typename without any cv-qualifiers. */
1414 mv
= TYPE_MAIN_VARIANT (*tp
);
1416 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1418 /* Don't mess with parameter packs since we don't remember
1419 the pack expansion context for a particular typename. */
1420 *walk_subtrees
= false;
1424 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1425 vec_safe_push (d
->typenames
, mv
);
1427 /* Search into class template arguments, which cp_walk_subtrees
1429 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1430 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1436 static vec
<tree
, va_gc
> *
1437 find_typenames (tree t
)
1439 struct find_typenames_t ft
;
1440 ft
.p_set
= new hash_set
<tree
>;
1441 ft
.typenames
= NULL
;
1442 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1443 find_typenames_r
, &ft
, ft
.p_set
);
1445 return ft
.typenames
;
1448 /* Output the "[with ...]" clause for a template instantiation T iff
1449 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1450 formatting a deduction/substitution diagnostic rather than an
1454 dump_substitution (cxx_pretty_printer
*pp
,
1455 tree t
, tree template_parms
, tree template_args
,
1458 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1459 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1461 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1462 pp_cxx_whitespace (pp
);
1463 pp_cxx_left_bracket (pp
);
1464 pp
->translate_string ("with");
1465 pp_cxx_whitespace (pp
);
1466 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1467 pp_cxx_right_bracket (pp
);
1471 /* Dump the lambda function FN including its 'mutable' qualifier and any
1472 template bindings. */
1475 dump_lambda_function (cxx_pretty_printer
*pp
,
1476 tree fn
, tree template_parms
, tree template_args
,
1479 /* A lambda's signature is essentially its "type". */
1480 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1481 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1483 pp
->padding
= pp_before
;
1484 pp_c_ws_string (pp
, "mutable");
1486 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1489 /* Pretty print a function decl. There are several ways we want to print a
1490 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1491 As error can only apply the '#' flag once to give 0 and 1 for V, there
1492 is %D which doesn't print the throw specs, and %F which does. */
1495 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1499 tree cname
= NULL_TREE
;
1500 tree template_args
= NULL_TREE
;
1501 tree template_parms
= NULL_TREE
;
1502 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1503 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1507 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1508 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1509 t
= DECL_TEMPLATE_RESULT (t
);
1511 /* Save the exceptions, in case t is a specialization and we are
1512 emitting an error about incompatible specifications. */
1513 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1515 /* Likewise for the constexpr specifier, in case t is a specialization. */
1516 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1518 /* Pretty print template instantiations only. */
1519 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1520 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1521 && flag_pretty_templates
)
1525 template_args
= DECL_TI_ARGS (t
);
1526 tmpl
= most_general_template (t
);
1527 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1529 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1534 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1535 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1537 fntype
= TREE_TYPE (t
);
1538 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1540 if (DECL_CLASS_SCOPE_P (t
))
1541 cname
= DECL_CONTEXT (t
);
1542 /* This is for partially instantiated template methods. */
1543 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1544 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1546 if (flags
& TFF_DECL_SPECIFIERS
)
1548 if (DECL_STATIC_FUNCTION_P (t
))
1549 pp_cxx_ws_string (pp
, "static");
1550 else if (DECL_VIRTUAL_P (t
))
1551 pp_cxx_ws_string (pp
, "virtual");
1555 if (DECL_DECLARED_CONCEPT_P (t
))
1556 pp_cxx_ws_string (pp
, "concept");
1558 pp_cxx_ws_string (pp
, "constexpr");
1562 /* Print the return type? */
1564 show_return
= (!DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1565 && !DECL_DESTRUCTOR_P (t
) && !deduction_guide_p (t
));
1568 tree ret
= fndecl_declared_return_type (t
);
1569 dump_type_prefix (pp
, ret
, flags
);
1572 /* Print the function name. */
1573 if (!do_outer_scope
)
1577 dump_type (pp
, cname
, flags
);
1578 pp_cxx_colon_colon (pp
);
1581 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1583 dump_function_name (pp
, t
, flags
);
1585 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1587 dump_parameters (pp
, parmtypes
, flags
);
1589 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1591 pp
->padding
= pp_before
;
1592 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1593 dump_ref_qualifier (pp
, fntype
, flags
);
1596 if (tx_safe_fn_type_p (fntype
))
1598 pp
->padding
= pp_before
;
1599 pp_cxx_ws_string (pp
, "transaction_safe");
1602 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1604 pp
->padding
= pp_before
;
1605 dump_exception_spec (pp
, exceptions
, flags
);
1609 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1610 else if (deduction_guide_p (t
))
1612 pp_cxx_ws_string (pp
, "->");
1613 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1617 if (tree ci
= get_constraints (t
))
1618 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1619 pp_cxx_requires_clause (pp
, reqs
);
1621 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1623 if (tree base
= DECL_INHERITED_CTOR_BASE (t
))
1625 pp_cxx_ws_string (pp
, "[inherited from");
1626 dump_type (pp
, base
, TFF_PLAIN_IDENTIFIER
);
1627 pp_character (pp
, ']');
1630 else if (template_args
)
1632 bool need_comma
= false;
1634 pp_cxx_begin_template_argument_list (pp
);
1635 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1636 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1638 tree arg
= TREE_VEC_ELT (template_args
, i
);
1640 pp_separate_with_comma (pp
);
1641 if (ARGUMENT_PACK_P (arg
))
1642 pp_cxx_left_brace (pp
);
1643 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1644 if (ARGUMENT_PACK_P (arg
))
1645 pp_cxx_right_brace (pp
);
1648 pp_cxx_end_template_argument_list (pp
);
1652 /* Print a parameter list. If this is for a member function, the
1653 member object ptr (and any other hidden args) should have
1654 already been removed. */
1657 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1660 flags
&= ~TFF_SCOPE
;
1661 pp_cxx_left_paren (pp
);
1663 for (first
= 1; parmtypes
!= void_list_node
;
1664 parmtypes
= TREE_CHAIN (parmtypes
))
1667 pp_separate_with_comma (pp
);
1671 pp_cxx_ws_string (pp
, "...");
1675 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1677 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1679 pp_cxx_whitespace (pp
);
1681 pp_cxx_whitespace (pp
);
1682 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1686 pp_cxx_right_paren (pp
);
1689 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1692 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1694 if (FUNCTION_REF_QUALIFIED (t
))
1696 pp
->padding
= pp_before
;
1697 if (FUNCTION_RVALUE_QUALIFIED (t
))
1698 pp_cxx_ws_string (pp
, "&&");
1700 pp_cxx_ws_string (pp
, "&");
1704 /* Print an exception specification. T is the exception specification. */
1707 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1709 if (t
&& TREE_PURPOSE (t
))
1711 pp_cxx_ws_string (pp
, "noexcept");
1712 if (!integer_onep (TREE_PURPOSE (t
)))
1714 pp_cxx_whitespace (pp
);
1715 pp_cxx_left_paren (pp
);
1716 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1717 pp_cxx_ws_string (pp
, "<uninstantiated>");
1719 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1720 pp_cxx_right_paren (pp
);
1725 pp_cxx_ws_string (pp
, "throw");
1726 pp_cxx_whitespace (pp
);
1727 pp_cxx_left_paren (pp
);
1728 if (TREE_VALUE (t
) != NULL_TREE
)
1731 dump_type (pp
, TREE_VALUE (t
), flags
);
1735 pp_separate_with_comma (pp
);
1737 pp_cxx_right_paren (pp
);
1741 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1742 and destructors properly. */
1745 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1747 tree name
= DECL_NAME (t
);
1749 /* We can get here with a decl that was synthesized by language-
1750 independent machinery (e.g. coverage.c) in which case it won't
1751 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1752 will crash. In this case it is safe just to print out the
1754 if (!DECL_LANG_SPECIFIC (t
))
1756 pp_cxx_tree_identifier (pp
, name
);
1760 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1761 t
= DECL_TEMPLATE_RESULT (t
);
1763 /* Don't let the user see __comp_ctor et al. */
1764 if (DECL_CONSTRUCTOR_P (t
)
1765 || DECL_DESTRUCTOR_P (t
))
1767 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1768 name
= get_identifier ("<lambda>");
1769 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1770 name
= get_identifier ("<constructor>");
1772 name
= constructor_name (DECL_CONTEXT (t
));
1775 if (DECL_DESTRUCTOR_P (t
))
1777 pp_cxx_complement (pp
);
1778 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1780 else if (DECL_CONV_FN_P (t
))
1782 /* This cannot use the hack that the operator's return
1783 type is stashed off of its name because it may be
1784 used for error reporting. In the case of conflicting
1785 declarations, both will have the same name, yet
1786 the types will be different, hence the TREE_TYPE field
1787 of the first name will be clobbered by the second. */
1788 pp_cxx_ws_string (pp
, "operator");
1789 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1792 dump_decl (pp
, name
, flags
);
1794 if (DECL_TEMPLATE_INFO (t
)
1795 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1796 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1797 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1798 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1802 /* Dump the template parameters from the template info INFO under control of
1803 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1804 specialization (partial or complete). For partial specializations we show
1805 the specialized parameter values. For a primary template we show no
1809 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1810 int primary
, int flags
)
1812 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1814 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1816 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1817 pp_cxx_begin_template_argument_list (pp
);
1819 /* Be careful only to print things when we have them, so as not
1820 to crash producing error messages. */
1821 if (args
&& !primary
)
1824 len
= get_non_default_template_args_count (args
, flags
);
1826 args
= INNERMOST_TEMPLATE_ARGS (args
);
1827 for (ix
= 0; ix
!= len
; ix
++)
1829 tree arg
= TREE_VEC_ELT (args
, ix
);
1831 /* Only print a comma if we know there is an argument coming. In
1832 the case of an empty template argument pack, no actual
1833 argument will be printed. */
1835 && (!ARGUMENT_PACK_P (arg
)
1836 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1837 pp_separate_with_comma (pp
);
1840 pp_string (pp
, M_("<template parameter error>"));
1842 dump_template_argument (pp
, arg
, flags
);
1847 tree tpl
= TI_TEMPLATE (info
);
1848 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1851 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1852 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1854 for (ix
= 0; ix
!= len
; ix
++)
1858 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1860 pp_string (pp
, M_("<template parameter error>"));
1864 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1867 pp_separate_with_comma (pp
);
1869 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1872 pp_cxx_end_template_argument_list (pp
);
1875 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1876 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1879 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1882 call_expr_arg_iterator iter
;
1884 pp_cxx_left_paren (pp
);
1885 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1891 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1892 if (more_call_expr_args_p (&iter
))
1893 pp_separate_with_comma (pp
);
1896 pp_cxx_right_paren (pp
);
1899 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1900 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1904 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1908 aggr_init_expr_arg_iterator iter
;
1910 pp_cxx_left_paren (pp
);
1911 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1917 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1918 if (more_aggr_init_expr_args_p (&iter
))
1919 pp_separate_with_comma (pp
);
1922 pp_cxx_right_paren (pp
);
1925 /* Print out a list of initializers (subr of dump_expr). */
1928 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1932 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1935 pp_separate_with_comma (pp
);
1939 /* Print out a vector of initializers (subr of dump_expr). */
1942 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1945 unsigned HOST_WIDE_INT idx
;
1948 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1950 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1951 if (idx
!= v
->length () - 1)
1952 pp_separate_with_comma (pp
);
1957 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1958 function. Resolve it to a close relative -- in the sense of static
1959 type -- variant being overridden. That is close to what was written in
1960 the source code. Subroutine of dump_expr. */
1963 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1965 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1966 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1967 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1970 fun
= TREE_CHAIN (fun
);
1971 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1972 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
1978 /* Print out an expression E under control of FLAGS. */
1981 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
1988 if (STATEMENT_CLASS_P (t
))
1990 pp_cxx_ws_string (pp
, M_("<statement>"));
1994 switch (TREE_CODE (t
))
2002 case NAMESPACE_DECL
:
2006 case IDENTIFIER_NODE
:
2007 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
2008 |TFF_TEMPLATE_HEADER
))
2009 | TFF_NO_TEMPLATE_BINDINGS
2010 | TFF_NO_FUNCTION_ARGUMENTS
));
2014 if (SSA_NAME_VAR (t
)
2015 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
2016 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2018 pp_cxx_ws_string (pp
, M_("<unknown>"));
2029 case USERDEF_LITERAL
:
2030 pp_cxx_userdef_literal (pp
, t
);
2034 /* While waiting for caret diagnostics, avoid printing
2035 __cxa_allocate_exception, __cxa_throw, and the like. */
2036 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2041 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2042 pp_cxx_colon_colon (pp
);
2043 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2047 pp_cxx_left_paren (pp
);
2048 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2049 pp_separate_with_comma (pp
);
2050 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2051 pp_cxx_right_paren (pp
);
2055 pp_cxx_left_paren (pp
);
2056 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2057 pp_string (pp
, " ? ");
2058 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2059 pp_string (pp
, " : ");
2060 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2061 pp_cxx_right_paren (pp
);
2065 if (TREE_HAS_CONSTRUCTOR (t
))
2067 pp_cxx_ws_string (pp
, "new");
2068 pp_cxx_whitespace (pp
);
2069 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2072 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2075 case AGGR_INIT_EXPR
:
2077 tree fn
= NULL_TREE
;
2079 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2080 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2082 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2084 if (DECL_CONSTRUCTOR_P (fn
))
2085 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2087 dump_decl (pp
, fn
, 0);
2090 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2092 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2097 tree fn
= CALL_EXPR_FN (t
);
2098 bool skipfirst
= false;
2100 /* Deal with internal functions. */
2101 if (fn
== NULL_TREE
)
2103 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2104 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2108 if (TREE_CODE (fn
) == ADDR_EXPR
)
2109 fn
= TREE_OPERAND (fn
, 0);
2111 /* Nobody is interested in seeing the guts of vcalls. */
2112 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2113 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2115 if (TREE_TYPE (fn
) != NULL_TREE
2116 && NEXT_CODE (fn
) == METHOD_TYPE
2117 && call_expr_nargs (t
))
2119 tree ob
= CALL_EXPR_ARG (t
, 0);
2120 if (TREE_CODE (ob
) == ADDR_EXPR
)
2122 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2123 flags
| TFF_EXPR_IN_PARENS
);
2126 else if (TREE_CODE (ob
) != PARM_DECL
2127 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2129 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2134 if (flag_sanitize
& SANITIZE_UNDEFINED
2135 && is_ubsan_builtin_p (fn
))
2137 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2140 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2141 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2146 /* Note that this only works for G++ target exprs. If somebody
2147 builds a general TARGET_EXPR, there's no way to represent that
2148 it initializes anything other that the parameter slot for the
2149 default argument. Note we may have cleared out the first
2150 operand in expand_expr, so don't go killing ourselves. */
2151 if (TREE_OPERAND (t
, 1))
2152 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2155 case POINTER_PLUS_EXPR
:
2156 dump_binary_op (pp
, "+", t
, flags
);
2161 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2168 case TRUNC_DIV_EXPR
:
2169 case TRUNC_MOD_EXPR
:
2177 case TRUTH_ANDIF_EXPR
:
2178 case TRUTH_ORIF_EXPR
:
2185 case EXACT_DIV_EXPR
:
2186 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2190 case FLOOR_DIV_EXPR
:
2191 case ROUND_DIV_EXPR
:
2193 dump_binary_op (pp
, "/", t
, flags
);
2197 case FLOOR_MOD_EXPR
:
2198 case ROUND_MOD_EXPR
:
2199 dump_binary_op (pp
, "%", t
, flags
);
2204 tree ob
= TREE_OPERAND (t
, 0);
2205 if (INDIRECT_REF_P (ob
))
2207 ob
= TREE_OPERAND (ob
, 0);
2208 if (TREE_CODE (ob
) != PARM_DECL
2210 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2212 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2213 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2221 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2224 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2229 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2230 pp_cxx_left_bracket (pp
);
2231 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2232 pp_cxx_right_bracket (pp
);
2235 case ARRAY_NOTATION_REF
:
2236 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2237 pp_cxx_left_bracket (pp
);
2238 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2240 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2242 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2243 pp_cxx_right_bracket (pp
);
2246 case UNARY_PLUS_EXPR
:
2247 dump_unary_op (pp
, "+", t
, flags
);
2251 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2252 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2253 /* An ADDR_EXPR can have reference type. In that case, we
2254 shouldn't print the `&' doing so indicates to the user
2255 that the expression has pointer type. */
2257 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2258 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2259 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2260 dump_unary_op (pp
, "&&", t
, flags
);
2262 dump_unary_op (pp
, "&", t
, flags
);
2266 if (TREE_HAS_CONSTRUCTOR (t
))
2268 t
= TREE_OPERAND (t
, 0);
2269 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2270 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2271 dump_call_expr_args (pp
, t
, flags
, true);
2275 if (TREE_OPERAND (t
,0) != NULL_TREE
2276 && TREE_TYPE (TREE_OPERAND (t
, 0))
2277 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2278 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2280 dump_unary_op (pp
, "*", t
, flags
);
2285 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2286 && integer_zerop (TREE_OPERAND (t
, 1)))
2287 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2291 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2293 pp_cxx_left_paren (pp
);
2294 if (!integer_onep (TYPE_SIZE_UNIT
2295 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2297 pp_cxx_left_paren (pp
);
2298 dump_type (pp
, ptr_type_node
, flags
);
2299 pp_cxx_right_paren (pp
);
2302 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2303 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2305 pp_cxx_ws_string (pp
, "+");
2306 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2308 pp_cxx_right_paren (pp
);
2315 case TRUTH_NOT_EXPR
:
2316 case PREDECREMENT_EXPR
:
2317 case PREINCREMENT_EXPR
:
2318 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2321 case POSTDECREMENT_EXPR
:
2322 case POSTINCREMENT_EXPR
:
2323 pp_cxx_left_paren (pp
);
2324 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2325 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2326 pp_cxx_right_paren (pp
);
2329 case NON_LVALUE_EXPR
:
2330 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2331 should be another level of INDIRECT_REF so that I don't have to do
2333 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2335 tree next
= TREE_TYPE (TREE_TYPE (t
));
2337 while (TYPE_PTR_P (next
))
2338 next
= TREE_TYPE (next
);
2340 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2342 if (flags
& TFF_EXPR_IN_PARENS
)
2343 pp_cxx_left_paren (pp
);
2345 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2346 if (flags
& TFF_EXPR_IN_PARENS
)
2347 pp_cxx_right_paren (pp
);
2350 /* Else fall through. */
2352 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2356 case IMPLICIT_CONV_EXPR
:
2357 case VIEW_CONVERT_EXPR
:
2359 tree op
= TREE_OPERAND (t
, 0);
2360 tree ttype
= TREE_TYPE (t
);
2361 tree optype
= TREE_TYPE (op
);
2363 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2364 && POINTER_TYPE_P (ttype
)
2365 && POINTER_TYPE_P (optype
)
2366 && same_type_p (TREE_TYPE (optype
),
2369 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2372 if (TREE_CODE (op
) == ADDR_EXPR
)
2373 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2375 dump_unary_op (pp
, "*", t
, flags
);
2378 dump_unary_op (pp
, "&", t
, flags
);
2380 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2382 /* It is a cast, but we cannot tell whether it is a
2383 reinterpret or static cast. Use the C style notation. */
2384 if (flags
& TFF_EXPR_IN_PARENS
)
2385 pp_cxx_left_paren (pp
);
2386 pp_cxx_left_paren (pp
);
2387 dump_type (pp
, TREE_TYPE (t
), flags
);
2388 pp_cxx_right_paren (pp
);
2389 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2390 if (flags
& TFF_EXPR_IN_PARENS
)
2391 pp_cxx_right_paren (pp
);
2394 dump_expr (pp
, op
, flags
);
2399 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2401 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2403 if (integer_zerop (idx
))
2405 /* A NULL pointer-to-member constant. */
2406 pp_cxx_left_paren (pp
);
2407 pp_cxx_left_paren (pp
);
2408 dump_type (pp
, TREE_TYPE (t
), flags
);
2409 pp_cxx_right_paren (pp
);
2410 pp_character (pp
, '0');
2411 pp_cxx_right_paren (pp
);
2414 else if (tree_fits_shwi_p (idx
))
2417 unsigned HOST_WIDE_INT n
;
2419 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2420 t
= TYPE_METHOD_BASETYPE (t
);
2421 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2423 n
= tree_to_shwi (idx
);
2425 /* Map vtable index back one, to allow for the null pointer to
2429 while (n
> 0 && virtuals
)
2432 virtuals
= TREE_CHAIN (virtuals
);
2436 dump_expr (pp
, BV_FN (virtuals
),
2437 flags
| TFF_EXPR_IN_PARENS
);
2442 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2443 pp_string (pp
, "<lambda closure object>");
2444 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2446 dump_type (pp
, TREE_TYPE (t
), 0);
2447 pp_cxx_left_paren (pp
);
2448 pp_cxx_right_paren (pp
);
2452 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2453 dump_type (pp
, TREE_TYPE (t
), 0);
2454 pp_cxx_left_brace (pp
);
2455 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2456 pp_cxx_right_brace (pp
);
2463 tree ob
= TREE_OPERAND (t
, 0);
2464 if (is_dummy_object (ob
))
2466 t
= TREE_OPERAND (t
, 1);
2467 if (TREE_CODE (t
) == FUNCTION_DECL
)
2469 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2470 else if (BASELINK_P (t
))
2471 dump_expr (pp
, OVL_CURRENT (BASELINK_FUNCTIONS (t
)),
2472 flags
| TFF_EXPR_IN_PARENS
);
2474 dump_decl (pp
, t
, flags
);
2478 if (INDIRECT_REF_P (ob
))
2480 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2486 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2490 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2495 case TEMPLATE_PARM_INDEX
:
2496 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2500 if (TREE_OPERAND (t
, 0) == NULL_TREE
2501 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2503 dump_type (pp
, TREE_TYPE (t
), flags
);
2504 pp_cxx_left_paren (pp
);
2505 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2506 pp_cxx_right_paren (pp
);
2510 pp_cxx_left_paren (pp
);
2511 dump_type (pp
, TREE_TYPE (t
), flags
);
2512 pp_cxx_right_paren (pp
);
2513 pp_cxx_left_paren (pp
);
2514 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2515 pp_cxx_right_paren (pp
);
2519 case STATIC_CAST_EXPR
:
2520 pp_cxx_ws_string (pp
, "static_cast");
2522 case REINTERPRET_CAST_EXPR
:
2523 pp_cxx_ws_string (pp
, "reinterpret_cast");
2525 case CONST_CAST_EXPR
:
2526 pp_cxx_ws_string (pp
, "const_cast");
2528 case DYNAMIC_CAST_EXPR
:
2529 pp_cxx_ws_string (pp
, "dynamic_cast");
2531 pp_cxx_begin_template_argument_list (pp
);
2532 dump_type (pp
, TREE_TYPE (t
), flags
);
2533 pp_cxx_end_template_argument_list (pp
);
2534 pp_cxx_left_paren (pp
);
2535 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2536 pp_cxx_right_paren (pp
);
2540 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2546 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2547 pp_cxx_ws_string (pp
, "sizeof");
2550 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2551 pp_cxx_ws_string (pp
, "__alignof__");
2553 op
= TREE_OPERAND (t
, 0);
2554 if (PACK_EXPANSION_P (op
))
2556 pp_string (pp
, "...");
2557 op
= PACK_EXPANSION_PATTERN (op
);
2559 pp_cxx_whitespace (pp
);
2560 pp_cxx_left_paren (pp
);
2561 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2562 dump_type (pp
, TREE_TYPE (op
), flags
);
2563 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2564 dump_type (pp
, op
, flags
);
2566 dump_expr (pp
, op
, flags
);
2567 pp_cxx_right_paren (pp
);
2570 case AT_ENCODE_EXPR
:
2571 pp_cxx_ws_string (pp
, "@encode");
2572 pp_cxx_whitespace (pp
);
2573 pp_cxx_left_paren (pp
);
2574 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2575 pp_cxx_right_paren (pp
);
2579 pp_cxx_ws_string (pp
, "noexcept");
2580 pp_cxx_whitespace (pp
);
2581 pp_cxx_left_paren (pp
);
2582 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2583 pp_cxx_right_paren (pp
);
2588 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2589 pp_cxx_whitespace (pp
);
2590 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2594 pp_string (pp
, M_("<unparsed>"));
2597 case TRY_CATCH_EXPR
:
2598 case WITH_CLEANUP_EXPR
:
2599 case CLEANUP_POINT_EXPR
:
2600 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2603 case PSEUDO_DTOR_EXPR
:
2604 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2606 if (TREE_OPERAND (t
, 1))
2608 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2609 pp_cxx_colon_colon (pp
);
2611 pp_cxx_complement (pp
);
2612 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2615 case TEMPLATE_ID_EXPR
:
2616 dump_decl (pp
, t
, flags
);
2622 case STATEMENT_LIST
:
2623 /* We don't yet have a way of dumping statements in a
2624 human-readable format. */
2625 pp_string (pp
, "({...})");
2629 pp_string (pp
, "while (1) { ");
2630 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2631 pp_cxx_right_brace (pp
);
2635 pp_string (pp
, "if (");
2636 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2637 pp_string (pp
, ") break; ");
2641 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2644 case EMPTY_CLASS_EXPR
:
2645 dump_type (pp
, TREE_TYPE (t
), flags
);
2646 pp_cxx_left_paren (pp
);
2647 pp_cxx_right_paren (pp
);
2650 case NON_DEPENDENT_EXPR
:
2651 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2654 case ARGUMENT_PACK_SELECT
:
2655 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2667 pp_type_specifier_seq (pp
, t
);
2671 /* We get here when we want to print a dependent type as an
2672 id-expression, without any disambiguator decoration. */
2673 pp
->id_expression (t
);
2676 case TEMPLATE_TYPE_PARM
:
2677 case TEMPLATE_TEMPLATE_PARM
:
2678 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2679 dump_type (pp
, t
, flags
);
2683 pp_cxx_trait_expression (pp
, t
);
2687 pp_cxx_va_arg_expression (pp
, t
);
2691 pp_cxx_offsetof_expression (pp
, t
);
2694 case ADDRESSOF_EXPR
:
2695 pp_cxx_addressof_expression (pp
, t
);
2699 dump_decl (pp
, t
, flags
);
2702 case EXPR_PACK_EXPANSION
:
2703 case UNARY_LEFT_FOLD_EXPR
:
2704 case UNARY_RIGHT_FOLD_EXPR
:
2705 case BINARY_LEFT_FOLD_EXPR
:
2706 case BINARY_RIGHT_FOLD_EXPR
:
2713 case VEC_DELETE_EXPR
:
2719 case UNORDERED_EXPR
:
2729 case FIX_TRUNC_EXPR
:
2734 case TRUTH_AND_EXPR
:
2736 case TRUTH_XOR_EXPR
:
2737 if (flags
& TFF_EXPR_IN_PARENS
)
2738 pp_cxx_left_paren (pp
);
2740 if (flags
& TFF_EXPR_IN_PARENS
)
2741 pp_cxx_right_paren (pp
);
2745 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2749 pp_string (pp
, M_("<lambda>"));
2753 pp_cxx_left_paren (pp
);
2754 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2755 pp_cxx_right_paren (pp
);
2759 pp_cxx_requires_expr (cxx_pp
, t
);
2763 pp_cxx_simple_requirement (cxx_pp
, t
);
2767 pp_cxx_type_requirement (cxx_pp
, t
);
2771 pp_cxx_compound_requirement (cxx_pp
, t
);
2775 pp_cxx_nested_requirement (cxx_pp
, t
);
2788 pp_cxx_constraint (cxx_pp
, t
);
2791 case PLACEHOLDER_EXPR
:
2792 pp_string (pp
, M_("*this"));
2795 /* This list is incomplete, but should suffice for now.
2796 It is very important that `sorry' does not call
2797 `report_error_function'. That could cause an infinite loop. */
2799 pp_unsupported_tree (pp
, t
);
2802 pp_string (pp
, M_("<expression error>"));
2808 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2811 pp_cxx_left_paren (pp
);
2812 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2813 pp_cxx_whitespace (pp
);
2815 pp_cxx_ws_string (pp
, opstring
);
2817 pp_string (pp
, M_("<unknown operator>"));
2818 pp_cxx_whitespace (pp
);
2819 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2820 pp_cxx_right_paren (pp
);
2824 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2826 if (flags
& TFF_EXPR_IN_PARENS
)
2827 pp_cxx_left_paren (pp
);
2828 pp_cxx_ws_string (pp
, opstring
);
2829 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2830 if (flags
& TFF_EXPR_IN_PARENS
)
2831 pp_cxx_right_paren (pp
);
2835 reinit_cxx_pp (void)
2837 pp_clear_output_area (cxx_pp
);
2838 cxx_pp
->padding
= pp_none
;
2839 pp_indentation (cxx_pp
) = 0;
2840 pp_needs_newline (cxx_pp
) = false;
2841 cxx_pp
->enclosing_scope
= current_function_decl
;
2844 /* Same as pp_formatted_text, except the return string is a separate
2845 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2848 pp_ggc_formatted_text (pretty_printer
*pp
)
2850 return ggc_strdup (pp_formatted_text (pp
));
2853 /* Exported interface to stringifying types, exprs and decls under TFF_*
2857 type_as_string (tree typ
, int flags
)
2860 pp_translate_identifiers (cxx_pp
) = false;
2861 dump_type (cxx_pp
, typ
, flags
);
2862 return pp_ggc_formatted_text (cxx_pp
);
2866 type_as_string_translate (tree typ
, int flags
)
2869 dump_type (cxx_pp
, typ
, flags
);
2870 return pp_ggc_formatted_text (cxx_pp
);
2874 expr_as_string (tree decl
, int flags
)
2877 pp_translate_identifiers (cxx_pp
) = false;
2878 dump_expr (cxx_pp
, decl
, flags
);
2879 return pp_ggc_formatted_text (cxx_pp
);
2882 /* Wrap decl_as_string with options appropriate for dwarf. */
2885 decl_as_dwarf_string (tree decl
, int flags
)
2888 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2889 here will be adequate to get the desired behavior. */
2890 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2891 name
= decl_as_string (decl
, flags
);
2892 /* Subsequent calls to the pretty printer shouldn't use this style. */
2893 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2898 decl_as_string (tree decl
, int flags
)
2901 pp_translate_identifiers (cxx_pp
) = false;
2902 dump_decl (cxx_pp
, decl
, flags
);
2903 return pp_ggc_formatted_text (cxx_pp
);
2907 decl_as_string_translate (tree decl
, int flags
)
2910 dump_decl (cxx_pp
, decl
, flags
);
2911 return pp_ggc_formatted_text (cxx_pp
);
2914 /* Wrap lang_decl_name with options appropriate for dwarf. */
2917 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2920 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2921 here will be adequate to get the desired behavior. */
2922 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2923 name
= lang_decl_name (decl
, v
, translate
);
2924 /* Subsequent calls to the pretty printer shouldn't use this style. */
2925 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2929 /* Generate the three forms of printable names for cxx_printable_name. */
2932 lang_decl_name (tree decl
, int v
, bool translate
)
2936 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2937 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2940 pp_translate_identifiers (cxx_pp
) = translate
;
2942 && (DECL_CLASS_SCOPE_P (decl
)
2943 || (DECL_NAMESPACE_SCOPE_P (decl
)
2944 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2946 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2947 pp_cxx_colon_colon (cxx_pp
);
2950 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2951 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2952 else if ((DECL_NAME (decl
) == NULL_TREE
)
2953 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2954 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2956 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2958 return pp_ggc_formatted_text (cxx_pp
);
2961 /* Return the location of a tree passed to %+ formats. */
2964 location_of (tree t
)
2968 t
= TYPE_MAIN_DECL (t
);
2970 return input_location
;
2972 else if (TREE_CODE (t
) == OVERLOAD
)
2973 t
= OVL_FUNCTION (t
);
2976 return DECL_SOURCE_LOCATION (t
);
2977 return EXPR_LOC_OR_LOC (t
, input_location
);
2980 /* Now the interfaces from error et al to dump_type et al. Each takes an
2981 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2985 decl_to_string (tree decl
, int verbose
)
2989 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
2990 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
2991 flags
= TFF_CLASS_KEY_OR_ENUM
;
2993 flags
|= TFF_DECL_SPECIFIERS
;
2994 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
2995 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
2996 flags
|= TFF_TEMPLATE_HEADER
;
2999 dump_decl (cxx_pp
, decl
, flags
);
3000 return pp_ggc_formatted_text (cxx_pp
);
3004 expr_to_string (tree decl
)
3007 dump_expr (cxx_pp
, decl
, 0);
3008 return pp_ggc_formatted_text (cxx_pp
);
3012 fndecl_to_string (tree fndecl
, int verbose
)
3016 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
3017 | TFF_TEMPLATE_HEADER
;
3019 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3021 dump_decl (cxx_pp
, fndecl
, flags
);
3022 return pp_ggc_formatted_text (cxx_pp
);
3027 code_to_string (enum tree_code c
)
3029 return get_tree_code_name (c
);
3033 language_to_string (enum languages c
)
3040 case lang_cplusplus
:
3049 /* Return the proper printed version of a parameter to a C++ function. */
3052 parm_to_string (int p
)
3056 pp_string (cxx_pp
, "'this'");
3058 pp_decimal_int (cxx_pp
, p
+ 1);
3059 return pp_ggc_formatted_text (cxx_pp
);
3063 op_to_string (enum tree_code p
)
3065 tree id
= operator_name_info
[p
].identifier
;
3066 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3070 type_to_string (tree typ
, int verbose
)
3074 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3075 flags
|= TFF_TEMPLATE_HEADER
;
3078 dump_type (cxx_pp
, typ
, flags
);
3079 /* If we're printing a type that involves typedefs, also print the
3080 stripped version. But sometimes the stripped version looks
3081 exactly the same, so we don't want it after all. To avoid printing
3082 it in that case, we play ugly obstack games. */
3083 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3084 && !uses_template_parms (typ
))
3086 int aka_start
, aka_len
; char *p
;
3087 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3088 /* Remember the end of the initial dump. */
3089 int len
= obstack_object_size (ob
);
3090 tree aka
= strip_typedefs (typ
);
3091 pp_string (cxx_pp
, " {aka");
3092 pp_cxx_whitespace (cxx_pp
);
3093 /* And remember the start of the aka dump. */
3094 aka_start
= obstack_object_size (ob
);
3095 dump_type (cxx_pp
, aka
, flags
);
3096 aka_len
= obstack_object_size (ob
) - aka_start
;
3097 pp_right_brace (cxx_pp
);
3098 p
= (char*)obstack_base (ob
);
3099 /* If they are identical, cut off the aka with a NUL. */
3100 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3103 return pp_ggc_formatted_text (cxx_pp
);
3107 assop_to_string (enum tree_code p
)
3109 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3110 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3114 args_to_string (tree p
, int verbose
)
3118 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3123 if (TYPE_P (TREE_VALUE (p
)))
3124 return type_as_string_translate (p
, flags
);
3127 for (; p
; p
= TREE_CHAIN (p
))
3129 if (TREE_VALUE (p
) == null_node
)
3130 pp_cxx_ws_string (cxx_pp
, "NULL");
3132 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3134 pp_separate_with_comma (cxx_pp
);
3136 return pp_ggc_formatted_text (cxx_pp
);
3139 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3140 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3144 subst_to_string (tree p
)
3146 tree decl
= TREE_PURPOSE (p
);
3147 tree targs
= TREE_VALUE (p
);
3148 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3149 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3150 |TFF_NO_TEMPLATE_BINDINGS
);
3156 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3157 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3158 return pp_ggc_formatted_text (cxx_pp
);
3162 cv_to_string (tree p
, int v
)
3165 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3166 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3167 return pp_ggc_formatted_text (cxx_pp
);
3171 eh_spec_to_string (tree p
, int /*v*/)
3175 dump_exception_spec (cxx_pp
, p
, flags
);
3176 return pp_ggc_formatted_text (cxx_pp
);
3179 /* Langhook for print_error_function. */
3181 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3182 diagnostic_info
*diagnostic
)
3184 lhd_print_error_function (context
, file
, diagnostic
);
3185 pp_set_prefix (context
->printer
, file
);
3186 maybe_print_instantiation_context (context
);
3190 cp_diagnostic_starter (diagnostic_context
*context
,
3191 diagnostic_info
*diagnostic
)
3193 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3194 cp_print_error_function (context
, diagnostic
);
3195 maybe_print_instantiation_context (context
);
3196 maybe_print_constexpr_context (context
);
3197 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3201 /* Print current function onto BUFFER, in the process of reporting
3202 a diagnostic message. Called from cp_diagnostic_starter. */
3204 cp_print_error_function (diagnostic_context
*context
,
3205 diagnostic_info
*diagnostic
)
3207 /* If we are in an instantiation context, current_function_decl is likely
3208 to be wrong, so just rely on print_instantiation_full_context. */
3209 if (current_instantiation ())
3211 if (diagnostic_last_function_changed (context
, diagnostic
))
3213 const char *old_prefix
= context
->printer
->prefix
;
3214 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3215 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3216 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3217 ? file_name_as_prefix (context
, file
) : NULL
;
3219 pp_set_prefix (context
->printer
, new_prefix
);
3221 if (current_function_decl
== NULL
)
3222 pp_string (context
->printer
, _("At global scope:"));
3227 if (abstract_origin
)
3229 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3230 while (TREE_CODE (ao
) == BLOCK
3231 && BLOCK_ABSTRACT_ORIGIN (ao
)
3232 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3233 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3234 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3238 fndecl
= current_function_decl
;
3240 pp_printf (context
->printer
, function_category (fndecl
),
3241 cxx_printable_name_translate (fndecl
, 2));
3243 while (abstract_origin
)
3246 tree block
= abstract_origin
;
3248 locus
= &BLOCK_SOURCE_LOCATION (block
);
3250 block
= BLOCK_SUPERCONTEXT (block
);
3251 while (block
&& TREE_CODE (block
) == BLOCK
3252 && BLOCK_ABSTRACT_ORIGIN (block
))
3254 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3256 while (TREE_CODE (ao
) == BLOCK
3257 && BLOCK_ABSTRACT_ORIGIN (ao
)
3258 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3259 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3261 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3266 else if (TREE_CODE (ao
) != BLOCK
)
3269 block
= BLOCK_SUPERCONTEXT (block
);
3272 abstract_origin
= block
;
3275 while (block
&& TREE_CODE (block
) == BLOCK
)
3276 block
= BLOCK_SUPERCONTEXT (block
);
3278 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3280 abstract_origin
= NULL
;
3284 expanded_location s
= expand_location (*locus
);
3285 pp_character (context
->printer
, ',');
3286 pp_newline (context
->printer
);
3289 if (context
->show_column
&& s
.column
!= 0)
3290 pp_printf (context
->printer
,
3291 _(" inlined from %qs at %r%s:%d:%d%R"),
3292 cxx_printable_name_translate (fndecl
, 2),
3293 "locus", s
.file
, s
.line
, s
.column
);
3295 pp_printf (context
->printer
,
3296 _(" inlined from %qs at %r%s:%d%R"),
3297 cxx_printable_name_translate (fndecl
, 2),
3298 "locus", s
.file
, s
.line
);
3302 pp_printf (context
->printer
, _(" inlined from %qs"),
3303 cxx_printable_name_translate (fndecl
, 2));
3306 pp_character (context
->printer
, ':');
3308 pp_newline (context
->printer
);
3310 diagnostic_set_last_function (context
, diagnostic
);
3311 pp_destroy_prefix (context
->printer
);
3312 context
->printer
->prefix
= old_prefix
;
3316 /* Returns a description of FUNCTION using standard terminology. The
3317 result is a format string of the form "In CATEGORY %qs". */
3319 function_category (tree fn
)
3321 /* We can get called from the middle-end for diagnostics of function
3322 clones. Make sure we have language specific information before
3323 dereferencing it. */
3324 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3325 && DECL_FUNCTION_MEMBER_P (fn
))
3327 if (DECL_STATIC_FUNCTION_P (fn
))
3328 return _("In static member function %qs");
3329 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3330 return _("In copy constructor %qs");
3331 else if (DECL_CONSTRUCTOR_P (fn
))
3332 return _("In constructor %qs");
3333 else if (DECL_DESTRUCTOR_P (fn
))
3334 return _("In destructor %qs");
3335 else if (LAMBDA_FUNCTION_P (fn
))
3336 return _("In lambda function");
3338 return _("In member function %qs");
3341 return _("In function %qs");
3344 /* Report the full context of a current template instantiation,
3347 print_instantiation_full_context (diagnostic_context
*context
)
3349 struct tinst_level
*p
= current_instantiation ();
3350 location_t location
= input_location
;
3354 pp_verbatim (context
->printer
,
3355 TREE_CODE (p
->decl
) == TREE_LIST
3356 ? _("%s: In substitution of %qS:\n")
3357 : _("%s: In instantiation of %q#D:\n"),
3358 LOCATION_FILE (location
),
3361 location
= p
->locus
;
3365 print_instantiation_partial_context (context
, p
, location
);
3368 /* Helper function of print_instantiation_partial_context() that
3369 prints a single line of instantiation context. */
3372 print_instantiation_partial_context_line (diagnostic_context
*context
,
3373 const struct tinst_level
*t
,
3374 location_t loc
, bool recursive_p
)
3376 if (loc
== UNKNOWN_LOCATION
)
3379 expanded_location xloc
= expand_location (loc
);
3381 if (context
->show_column
)
3382 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3383 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3385 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3386 "locus", xloc
.file
, xloc
.line
);
3390 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3391 pp_verbatim (context
->printer
,
3393 ? _("recursively required by substitution of %qS\n")
3394 : _("required by substitution of %qS\n"),
3397 pp_verbatim (context
->printer
,
3399 ? _("recursively required from %q#D\n")
3400 : _("required from %q#D\n"),
3405 pp_verbatim (context
->printer
,
3407 ? _("recursively required from here\n")
3408 : _("required from here\n"));
3412 /* Same as print_instantiation_full_context but less verbose. */
3415 print_instantiation_partial_context (diagnostic_context
*context
,
3416 struct tinst_level
*t0
, location_t loc
)
3418 struct tinst_level
*t
;
3421 location_t prev_loc
= loc
;
3423 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3424 if (prev_loc
!= t
->locus
)
3426 prev_loc
= t
->locus
;
3432 if (template_backtrace_limit
3433 && n_total
> template_backtrace_limit
)
3435 int skip
= n_total
- template_backtrace_limit
;
3436 int head
= template_backtrace_limit
/ 2;
3438 /* Avoid skipping just 1. If so, skip 2. */
3442 head
= (template_backtrace_limit
- 1) / 2;
3445 for (n
= 0; n
< head
; n
++)
3447 gcc_assert (t
!= NULL
);
3448 if (loc
!= t
->locus
)
3449 print_instantiation_partial_context_line (context
, t
, loc
,
3450 /*recursive_p=*/false);
3454 if (t
!= NULL
&& skip
> 0)
3456 expanded_location xloc
;
3457 xloc
= expand_location (loc
);
3458 if (context
->show_column
)
3459 pp_verbatim (context
->printer
,
3460 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3461 "contexts, use -ftemplate-backtrace-limit=0 to "
3463 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3465 pp_verbatim (context
->printer
,
3466 _("%r%s:%d:%R [ skipping %d instantiation "
3467 "contexts, use -ftemplate-backtrace-limit=0 to "
3469 "locus", xloc
.file
, xloc
.line
, skip
);
3474 } while (t
!= NULL
&& --skip
> 0);
3480 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3485 print_instantiation_partial_context_line (context
, t
, loc
,
3490 print_instantiation_partial_context_line (context
, NULL
, loc
,
3491 /*recursive_p=*/false);
3494 /* Called from cp_thing to print the template context for an error. */
3496 maybe_print_instantiation_context (diagnostic_context
*context
)
3498 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3501 record_last_problematic_instantiation ();
3502 print_instantiation_full_context (context
);
3505 /* Report what constexpr call(s) we're trying to expand, if any. */
3508 maybe_print_constexpr_context (diagnostic_context
*context
)
3510 vec
<tree
> call_stack
= cx_error_context ();
3514 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3516 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3517 const char *s
= expr_as_string (t
, 0);
3518 if (context
->show_column
)
3519 pp_verbatim (context
->printer
,
3520 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3521 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3523 pp_verbatim (context
->printer
,
3524 _("%r%s:%d:%R in constexpr expansion of %qs"),
3525 "locus", xloc
.file
, xloc
.line
, s
);
3526 pp_newline (context
->printer
);
3530 /* Called from output_format -- during diagnostic message processing --
3531 to handle C++ specific format specifier with the following meanings:
3532 %A function argument-list.
3536 %F function declaration.
3537 %L language as used in extern "lang".
3539 %P function parameter whose position is indicated by an integer.
3540 %Q assignment operator.
3541 %S substitution (template + args)
3544 %X exception-specification. */
3546 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3547 int precision
, bool wide
, bool set_locus
, bool verbose
)
3551 #define next_tree (t = va_arg (*text->args_ptr, tree))
3552 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3553 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3554 #define next_int va_arg (*text->args_ptr, int)
3556 if (precision
!= 0 || wide
)
3561 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3562 case 'C': result
= code_to_string (next_tcode
); break;
3565 tree temp
= next_tree
;
3567 && DECL_HAS_DEBUG_EXPR_P (temp
))
3569 temp
= DECL_DEBUG_EXPR (temp
);
3572 result
= expr_to_string (temp
);
3576 result
= decl_to_string (temp
, verbose
);
3579 case 'E': result
= expr_to_string (next_tree
); break;
3580 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3581 case 'L': result
= language_to_string (next_lang
); break;
3582 case 'O': result
= op_to_string (next_tcode
); break;
3583 case 'P': result
= parm_to_string (next_int
); break;
3584 case 'Q': result
= assop_to_string (next_tcode
); break;
3585 case 'S': result
= subst_to_string (next_tree
); break;
3586 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3587 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3588 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3591 percent_K_format (text
);
3598 pp_string (pp
, result
);
3599 if (set_locus
&& t
!= NULL
)
3600 text
->set_location (0, location_of (t
), true);
3608 /* Warn about the use of C++0x features when appropriate. */
3610 maybe_warn_cpp0x (cpp0x_warn_str str
)
3612 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3613 /* We really want to suppress this warning in system headers,
3614 because libstdc++ uses variadic templates even when we aren't
3618 case CPP0X_INITIALIZER_LISTS
:
3619 pedwarn (input_location
, 0,
3620 "extended initializer lists "
3621 "only available with -std=c++11 or -std=gnu++11");
3623 case CPP0X_EXPLICIT_CONVERSION
:
3624 pedwarn (input_location
, 0,
3625 "explicit conversion operators "
3626 "only available with -std=c++11 or -std=gnu++11");
3628 case CPP0X_VARIADIC_TEMPLATES
:
3629 pedwarn (input_location
, 0,
3630 "variadic templates "
3631 "only available with -std=c++11 or -std=gnu++11");
3633 case CPP0X_LAMBDA_EXPR
:
3634 pedwarn (input_location
, 0,
3635 "lambda expressions "
3636 "only available with -std=c++11 or -std=gnu++11");
3639 pedwarn (input_location
, 0,
3640 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3642 case CPP0X_SCOPED_ENUMS
:
3643 pedwarn (input_location
, 0,
3644 "scoped enums only available with -std=c++11 or -std=gnu++11");
3646 case CPP0X_DEFAULTED_DELETED
:
3647 pedwarn (input_location
, 0,
3648 "defaulted and deleted functions "
3649 "only available with -std=c++11 or -std=gnu++11");
3651 case CPP0X_INLINE_NAMESPACES
:
3652 pedwarn (input_location
, OPT_Wpedantic
,
3653 "inline namespaces "
3654 "only available with -std=c++11 or -std=gnu++11");
3656 case CPP0X_OVERRIDE_CONTROLS
:
3657 pedwarn (input_location
, 0,
3658 "override controls (override/final) "
3659 "only available with -std=c++11 or -std=gnu++11");
3662 pedwarn (input_location
, 0,
3663 "non-static data member initializers "
3664 "only available with -std=c++11 or -std=gnu++11");
3666 case CPP0X_USER_DEFINED_LITERALS
:
3667 pedwarn (input_location
, 0,
3668 "user-defined literals "
3669 "only available with -std=c++11 or -std=gnu++11");
3671 case CPP0X_DELEGATING_CTORS
:
3672 pedwarn (input_location
, 0,
3673 "delegating constructors "
3674 "only available with -std=c++11 or -std=gnu++11");
3676 case CPP0X_INHERITING_CTORS
:
3677 pedwarn (input_location
, 0,
3678 "inheriting constructors "
3679 "only available with -std=c++11 or -std=gnu++11");
3681 case CPP0X_ATTRIBUTES
:
3682 pedwarn (input_location
, 0,
3684 "only available with -std=c++11 or -std=gnu++11");
3686 case CPP0X_REF_QUALIFIER
:
3687 pedwarn (input_location
, 0,
3689 "only available with -std=c++11 or -std=gnu++11");
3696 /* Warn about the use of variadic templates when appropriate. */
3698 maybe_warn_variadic_templates (void)
3700 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3704 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3705 option OPT with text GMSGID. Use this function to report
3706 diagnostics for constructs that are invalid C++98, but valid
3709 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3711 diagnostic_info diagnostic
;
3714 rich_location
richloc (line_table
, location
);
3716 va_start (ap
, gmsgid
);
3717 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
3718 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3719 diagnostic
.option_index
= opt
;
3720 ret
= report_diagnostic (&diagnostic
);
3725 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3726 we found when we tried to do the lookup. LOCATION is the location of
3727 the NAME identifier. */
3730 qualified_name_lookup_error (tree scope
, tree name
,
3731 tree decl
, location_t location
)
3733 if (scope
== error_mark_node
)
3734 ; /* We already complained. */
3735 else if (TYPE_P (scope
))
3737 if (!COMPLETE_TYPE_P (scope
))
3738 error_at (location
, "incomplete type %qT used in nested name specifier",
3740 else if (TREE_CODE (decl
) == TREE_LIST
)
3742 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3744 print_candidates (decl
);
3747 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3749 else if (scope
!= global_namespace
)
3751 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3752 suggest_alternatives_for (location
, name
);
3756 error_at (location
, "%<::%D%> has not been declared", name
);
3757 suggest_alternatives_for (location
, name
);