1 /* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "stringpool.h"
25 #include "tree-diagnostic.h"
26 #include "langhooks-def.h"
28 #include "cxx-pretty-print.h"
29 #include "tree-pretty-print.h"
30 #include "c-family/c-objc.h"
32 #include "internal-fn.h"
34 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
35 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
37 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
38 dump C++ ASTs as strings. It is mostly used only by the various
39 tree -> string functions that are occasionally called from the
40 debugger or by the front-end for things like
41 __PRETTY_FUNCTION__. */
42 static cxx_pretty_printer actual_pretty_printer
;
43 static cxx_pretty_printer
* const cxx_pp
= &actual_pretty_printer
;
45 /* Translate if being used for diagnostics, but not for dump files or
47 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
49 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
51 static const char *args_to_string (tree
, int);
52 static const char *assop_to_string (enum tree_code
);
53 static const char *code_to_string (enum tree_code
);
54 static const char *cv_to_string (tree
, int);
55 static const char *decl_to_string (tree
, int);
56 static const char *expr_to_string (tree
);
57 static const char *fndecl_to_string (tree
, int);
58 static const char *op_to_string (enum tree_code
);
59 static const char *parm_to_string (int);
60 static const char *type_to_string (tree
, int);
62 static void dump_alias_template_specialization (cxx_pretty_printer
*, tree
, int);
63 static void dump_type (cxx_pretty_printer
*, tree
, int);
64 static void dump_typename (cxx_pretty_printer
*, tree
, int);
65 static void dump_simple_decl (cxx_pretty_printer
*, tree
, tree
, int);
66 static void dump_decl (cxx_pretty_printer
*, tree
, int);
67 static void dump_template_decl (cxx_pretty_printer
*, tree
, int);
68 static void dump_function_decl (cxx_pretty_printer
*, tree
, int);
69 static void dump_expr (cxx_pretty_printer
*, tree
, int);
70 static void dump_unary_op (cxx_pretty_printer
*, const char *, tree
, int);
71 static void dump_binary_op (cxx_pretty_printer
*, const char *, tree
, int);
72 static void dump_aggr_type (cxx_pretty_printer
*, tree
, int);
73 static void dump_type_prefix (cxx_pretty_printer
*, tree
, int);
74 static void dump_type_suffix (cxx_pretty_printer
*, tree
, int);
75 static void dump_function_name (cxx_pretty_printer
*, tree
, int);
76 static void dump_call_expr_args (cxx_pretty_printer
*, tree
, int, bool);
77 static void dump_aggr_init_expr_args (cxx_pretty_printer
*, tree
, int, bool);
78 static void dump_expr_list (cxx_pretty_printer
*, tree
, int);
79 static void dump_global_iord (cxx_pretty_printer
*, tree
);
80 static void dump_parameters (cxx_pretty_printer
*, tree
, int);
81 static void dump_ref_qualifier (cxx_pretty_printer
*, tree
, int);
82 static void dump_exception_spec (cxx_pretty_printer
*, tree
, int);
83 static void dump_template_argument (cxx_pretty_printer
*, tree
, int);
84 static void dump_template_argument_list (cxx_pretty_printer
*, tree
, int);
85 static void dump_template_parameter (cxx_pretty_printer
*, tree
, int);
86 static void dump_template_bindings (cxx_pretty_printer
*, tree
, tree
,
88 static void dump_scope (cxx_pretty_printer
*, tree
, int);
89 static void dump_template_parms (cxx_pretty_printer
*, tree
, int, int);
90 static int get_non_default_template_args_count (tree
, int);
91 static const char *function_category (tree
);
92 static void maybe_print_constexpr_context (diagnostic_context
*);
93 static void maybe_print_instantiation_context (diagnostic_context
*);
94 static void print_instantiation_full_context (diagnostic_context
*);
95 static void print_instantiation_partial_context (diagnostic_context
*,
98 static void cp_diagnostic_starter (diagnostic_context
*, diagnostic_info
*);
99 static void cp_print_error_function (diagnostic_context
*, diagnostic_info
*);
101 static bool cp_printer (pretty_printer
*, text_info
*, const char *,
102 int, bool, bool, bool);
104 /* CONTEXT->printer is a basic pretty printer that was constructed
105 presumably by diagnostic_initialize(), called early in the
106 compiler's initialization process (in general_init) Before the FE
107 is initialized. This (C++) FE-specific diagnostic initializer is
108 thus replacing the basic pretty printer with one that has C++-aware
112 cxx_initialize_diagnostics (diagnostic_context
*context
)
114 pretty_printer
*base
= context
->printer
;
115 cxx_pretty_printer
*pp
= XNEW (cxx_pretty_printer
);
116 context
->printer
= new (pp
) cxx_pretty_printer ();
118 /* It is safe to free this object because it was previously XNEW()'d. */
119 base
->~pretty_printer ();
122 c_common_diagnostics_set_defaults (context
);
123 diagnostic_starter (context
) = cp_diagnostic_starter
;
124 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
125 diagnostic_format_decoder (context
) = cp_printer
;
128 /* Dump a scope, if deemed necessary. */
131 dump_scope (cxx_pretty_printer
*pp
, tree scope
, int flags
)
133 int f
= flags
& (TFF_SCOPE
| TFF_CHASE_TYPEDEF
);
135 if (scope
== NULL_TREE
)
138 if (TREE_CODE (scope
) == NAMESPACE_DECL
)
140 if (scope
!= global_namespace
)
142 dump_decl (pp
, scope
, f
);
143 pp_cxx_colon_colon (pp
);
146 else if (AGGREGATE_TYPE_P (scope
))
148 dump_type (pp
, scope
, f
);
149 pp_cxx_colon_colon (pp
);
151 else if ((flags
& TFF_SCOPE
) && TREE_CODE (scope
) == FUNCTION_DECL
)
153 dump_function_decl (pp
, scope
, f
);
154 pp_cxx_colon_colon (pp
);
158 /* Dump the template ARGument under control of FLAGS. */
161 dump_template_argument (cxx_pretty_printer
*pp
, tree arg
, int flags
)
163 if (ARGUMENT_PACK_P (arg
))
164 dump_template_argument_list (pp
, ARGUMENT_PACK_ARGS (arg
),
165 /* No default args in argument packs. */
166 flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
167 else if (TYPE_P (arg
) || TREE_CODE (arg
) == TEMPLATE_DECL
)
168 dump_type (pp
, arg
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
171 if (TREE_CODE (arg
) == TREE_LIST
)
172 arg
= TREE_VALUE (arg
);
174 /* Strip implicit conversions. */
175 while (CONVERT_EXPR_P (arg
))
176 arg
= TREE_OPERAND (arg
, 0);
178 dump_expr (pp
, arg
, (flags
| TFF_EXPR_IN_PARENS
) & ~TFF_CLASS_KEY_OR_ENUM
);
182 /* Count the number of template arguments ARGS whose value does not
183 match the (optional) default template parameter in PARAMS */
186 get_non_default_template_args_count (tree args
, int flags
)
188 int n
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args
));
190 if (/* We use this flag when generating debug information. We don't
191 want to expand templates at this point, for this may generate
192 new decls, which gets decl counts out of sync, which may in
193 turn cause codegen differences between compilations with and
195 (flags
& TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
) != 0
196 || !flag_pretty_templates
)
199 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args
));
202 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
206 dump_template_argument_list (cxx_pretty_printer
*pp
, tree args
, int flags
)
208 int n
= get_non_default_template_args_count (args
, flags
);
212 for (i
= 0; i
< n
; ++i
)
214 tree arg
= TREE_VEC_ELT (args
, i
);
216 /* Only print a comma if we know there is an argument coming. In
217 the case of an empty template argument pack, no actual
218 argument will be printed. */
220 && (!ARGUMENT_PACK_P (arg
)
221 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
222 pp_separate_with_comma (pp
);
224 dump_template_argument (pp
, arg
, flags
);
229 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
232 dump_template_parameter (cxx_pretty_printer
*pp
, tree parm
, int flags
)
237 if (parm
== error_mark_node
)
240 p
= TREE_VALUE (parm
);
241 a
= TREE_PURPOSE (parm
);
243 if (TREE_CODE (p
) == TYPE_DECL
)
245 if (flags
& TFF_DECL_SPECIFIERS
)
247 pp_cxx_ws_string (pp
, "class");
248 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p
)))
249 pp_cxx_ws_string (pp
, "...");
251 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
253 else if (DECL_NAME (p
))
254 pp_cxx_tree_identifier (pp
, DECL_NAME (p
));
256 pp_cxx_canonical_template_parameter (pp
, TREE_TYPE (p
));
259 dump_decl (pp
, p
, flags
| TFF_DECL_SPECIFIERS
);
261 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && a
!= NULL_TREE
)
263 pp_cxx_whitespace (pp
);
265 pp_cxx_whitespace (pp
);
266 if (TREE_CODE (p
) == TYPE_DECL
|| TREE_CODE (p
) == TEMPLATE_DECL
)
267 dump_type (pp
, a
, flags
& ~TFF_CHASE_TYPEDEF
);
269 dump_expr (pp
, a
, flags
| TFF_EXPR_IN_PARENS
);
273 /* Dump, under control of FLAGS, a template-parameter-list binding.
274 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
278 dump_template_bindings (cxx_pretty_printer
*pp
, tree parms
, tree args
,
279 vec
<tree
, va_gc
> *typenames
)
281 bool need_semicolon
= false;
287 tree p
= TREE_VALUE (parms
);
288 int lvl
= TMPL_PARMS_DEPTH (parms
);
291 tree lvl_args
= NULL_TREE
;
293 /* Don't crash if we had an invalid argument list. */
294 if (TMPL_ARGS_DEPTH (args
) >= lvl
)
295 lvl_args
= TMPL_ARGS_LEVEL (args
, lvl
);
297 for (i
= 0; i
< TREE_VEC_LENGTH (p
); ++i
)
299 tree arg
= NULL_TREE
;
301 /* Don't crash if we had an invalid argument list. */
302 if (lvl_args
&& NUM_TMPL_ARGS (lvl_args
) > arg_idx
)
303 arg
= TREE_VEC_ELT (lvl_args
, arg_idx
);
306 pp_separate_with_semicolon (pp
);
307 dump_template_parameter (pp
, TREE_VEC_ELT (p
, i
),
308 TFF_PLAIN_IDENTIFIER
);
309 pp_cxx_whitespace (pp
);
311 pp_cxx_whitespace (pp
);
314 if (ARGUMENT_PACK_P (arg
))
315 pp_cxx_left_brace (pp
);
316 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
317 if (ARGUMENT_PACK_P (arg
))
318 pp_cxx_right_brace (pp
);
321 pp_string (pp
, M_("<missing>"));
324 need_semicolon
= true;
327 parms
= TREE_CHAIN (parms
);
330 /* Don't bother with typenames for a partial instantiation. */
331 if (vec_safe_is_empty (typenames
) || uses_template_parms (args
))
334 /* Don't try to print typenames when we're processing a clone. */
335 if (current_function_decl
336 && !DECL_LANG_SPECIFIC (current_function_decl
))
339 /* Don't try to do this once cgraph starts throwing away front-end
344 FOR_EACH_VEC_SAFE_ELT (typenames
, i
, t
)
347 pp_separate_with_semicolon (pp
);
348 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
349 pp_cxx_whitespace (pp
);
351 pp_cxx_whitespace (pp
);
352 push_deferring_access_checks (dk_no_check
);
353 t
= tsubst (t
, args
, tf_none
, NULL_TREE
);
354 pop_deferring_access_checks ();
355 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
356 pp_simple_type_specifier doesn't know about it. */
357 t
= strip_typedefs (t
);
358 dump_type (pp
, t
, TFF_PLAIN_IDENTIFIER
);
362 /* Dump a human-readable equivalent of the alias template
363 specialization of T. */
366 dump_alias_template_specialization (cxx_pretty_printer
*pp
, tree t
, int flags
)
368 gcc_assert (alias_template_specialization_p (t
));
370 tree decl
= TYPE_NAME (t
);
371 if (!(flags
& TFF_UNQUALIFIED_NAME
))
372 dump_scope (pp
, CP_DECL_CONTEXT (decl
), flags
);
373 pp_cxx_tree_identifier (pp
, DECL_NAME (decl
));
374 dump_template_parms (pp
, DECL_TEMPLATE_INFO (decl
),
376 flags
& ~TFF_TEMPLATE_HEADER
);
379 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
383 dump_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
388 /* Don't print e.g. "struct mytypedef". */
389 if (TYPE_P (t
) && typedef_variant_p (t
))
391 tree decl
= TYPE_NAME (t
);
392 if ((flags
& TFF_CHASE_TYPEDEF
)
393 || DECL_SELF_REFERENCE_P (decl
)
394 || (!flag_pretty_templates
395 && DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)))
396 t
= strip_typedefs (t
);
397 else if (alias_template_specialization_p (t
))
399 dump_alias_template_specialization (pp
, t
, flags
);
402 else if (same_type_p (t
, TREE_TYPE (decl
)))
406 pp_cxx_cv_qualifier_seq (pp
, t
);
407 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
412 if (TYPE_PTRMEMFUNC_P (t
))
415 switch (TREE_CODE (t
))
418 if (t
== init_list_type_node
)
419 pp_string (pp
, M_("<brace-enclosed initializer list>"));
420 else if (t
== unknown_type_node
)
421 pp_string (pp
, M_("<unresolved overloaded function type>"));
424 pp_cxx_cv_qualifier_seq (pp
, t
);
425 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
430 /* A list of function parms. */
431 dump_parameters (pp
, t
, flags
);
434 case IDENTIFIER_NODE
:
435 pp_cxx_tree_identifier (pp
, t
);
439 dump_type (pp
, BINFO_TYPE (t
), flags
);
445 dump_aggr_type (pp
, t
, flags
);
449 if (flags
& TFF_CHASE_TYPEDEF
)
451 dump_type (pp
, DECL_ORIGINAL_TYPE (t
)
452 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
), flags
);
459 dump_decl (pp
, t
, flags
& ~TFF_DECL_SPECIFIERS
);
468 case FIXED_POINT_TYPE
:
469 pp_type_specifier_seq (pp
, t
);
472 case TEMPLATE_TEMPLATE_PARM
:
473 /* For parameters inside template signature. */
474 if (TYPE_IDENTIFIER (t
))
475 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
477 pp_cxx_canonical_template_parameter (pp
, t
);
480 case BOUND_TEMPLATE_TEMPLATE_PARM
:
482 tree args
= TYPE_TI_ARGS (t
);
483 pp_cxx_cv_qualifier_seq (pp
, t
);
484 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
485 pp_cxx_begin_template_argument_list (pp
);
486 dump_template_argument_list (pp
, args
, flags
);
487 pp_cxx_end_template_argument_list (pp
);
491 case TEMPLATE_TYPE_PARM
:
492 pp_cxx_cv_qualifier_seq (pp
, t
);
493 if (tree c
= PLACEHOLDER_TYPE_CONSTRAINTS (t
))
494 pp_cxx_constrained_type_spec (pp
, c
);
495 else if (TYPE_IDENTIFIER (t
))
496 pp_cxx_tree_identifier (pp
, TYPE_IDENTIFIER (t
));
498 pp_cxx_canonical_template_parameter
499 (pp
, TEMPLATE_TYPE_PARM_INDEX (t
));
502 /* This is not always necessary for pointers and such, but doing this
503 reduces code size. */
512 dump_type_prefix (pp
, t
, flags
);
513 dump_type_suffix (pp
, t
, flags
);
517 if (! (flags
& TFF_CHASE_TYPEDEF
)
518 && DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
520 dump_decl (pp
, TYPE_NAME (t
), TFF_PLAIN_IDENTIFIER
);
523 pp_cxx_cv_qualifier_seq (pp
, t
);
524 pp_cxx_ws_string (pp
,
525 TYPENAME_IS_ENUM_P (t
) ? "enum"
526 : TYPENAME_IS_CLASS_P (t
) ? "class"
528 dump_typename (pp
, t
, flags
);
531 case UNBOUND_CLASS_TEMPLATE
:
532 if (! (flags
& TFF_UNQUALIFIED_NAME
))
534 dump_type (pp
, TYPE_CONTEXT (t
), flags
);
535 pp_cxx_colon_colon (pp
);
537 pp_cxx_ws_string (pp
, "template");
538 dump_type (pp
, TYPE_IDENTIFIER (t
), flags
);
542 pp_cxx_ws_string (pp
, "__typeof__");
543 pp_cxx_whitespace (pp
);
544 pp_cxx_left_paren (pp
);
545 dump_expr (pp
, TYPEOF_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
546 pp_cxx_right_paren (pp
);
549 case UNDERLYING_TYPE
:
550 pp_cxx_ws_string (pp
, "__underlying_type");
551 pp_cxx_whitespace (pp
);
552 pp_cxx_left_paren (pp
);
553 dump_expr (pp
, UNDERLYING_TYPE_TYPE (t
), flags
& ~TFF_EXPR_IN_PARENS
);
554 pp_cxx_right_paren (pp
);
557 case TYPE_PACK_EXPANSION
:
558 dump_type (pp
, PACK_EXPANSION_PATTERN (t
), flags
);
559 pp_cxx_ws_string (pp
, "...");
562 case TYPE_ARGUMENT_PACK
:
563 dump_template_argument (pp
, t
, flags
);
567 pp_cxx_ws_string (pp
, "decltype");
568 pp_cxx_whitespace (pp
);
569 pp_cxx_left_paren (pp
);
570 dump_expr (pp
, DECLTYPE_TYPE_EXPR (t
), flags
& ~TFF_EXPR_IN_PARENS
);
571 pp_cxx_right_paren (pp
);
575 pp_string (pp
, "std::nullptr_t");
579 pp_unsupported_tree (pp
, t
);
583 pp_string (pp
, M_("<type error>"));
588 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
592 dump_typename (cxx_pretty_printer
*pp
, tree t
, int flags
)
594 tree ctx
= TYPE_CONTEXT (t
);
596 if (TREE_CODE (ctx
) == TYPENAME_TYPE
)
597 dump_typename (pp
, ctx
, flags
);
599 dump_type (pp
, ctx
, flags
& ~TFF_CLASS_KEY_OR_ENUM
);
600 pp_cxx_colon_colon (pp
);
601 dump_decl (pp
, TYPENAME_TYPE_FULLNAME (t
), flags
);
604 /* Return the name of the supplied aggregate, or enumeral type. */
607 class_key_or_enum_as_string (tree t
)
609 if (TREE_CODE (t
) == ENUMERAL_TYPE
)
611 if (SCOPED_ENUM_P (t
))
616 else if (TREE_CODE (t
) == UNION_TYPE
)
618 else if (TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_DECLARED_CLASS (t
))
624 /* Print out a class declaration T under the control of FLAGS,
625 in the form `class foo'. */
628 dump_aggr_type (cxx_pretty_printer
*pp
, tree t
, int flags
)
631 const char *variety
= class_key_or_enum_as_string (t
);
635 pp_cxx_cv_qualifier_seq (pp
, t
);
637 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
638 pp_cxx_ws_string (pp
, variety
);
640 name
= TYPE_NAME (t
);
644 typdef
= (!DECL_ARTIFICIAL (name
)
645 /* An alias specialization is not considered to be a
647 && !alias_template_specialization_p (t
));
650 && ((flags
& TFF_CHASE_TYPEDEF
)
651 || (!flag_pretty_templates
&& DECL_LANG_SPECIFIC (name
)
652 && DECL_TEMPLATE_INFO (name
))))
653 || DECL_SELF_REFERENCE_P (name
))
655 t
= TYPE_MAIN_VARIANT (t
);
656 name
= TYPE_NAME (t
);
660 tmplate
= !typdef
&& TREE_CODE (t
) != ENUMERAL_TYPE
661 && TYPE_LANG_SPECIFIC (t
) && CLASSTYPE_TEMPLATE_INFO (t
)
662 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t
)) != TEMPLATE_DECL
663 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)));
665 if (! (flags
& TFF_UNQUALIFIED_NAME
))
666 dump_scope (pp
, CP_DECL_CONTEXT (name
), flags
| TFF_SCOPE
);
667 flags
&= ~TFF_UNQUALIFIED_NAME
;
670 /* Because the template names are mangled, we have to locate
671 the most general template, and use that name. */
672 tree tpl
= TYPE_TI_TEMPLATE (t
);
674 while (DECL_TEMPLATE_INFO (tpl
))
675 tpl
= DECL_TI_TEMPLATE (tpl
);
678 name
= DECL_NAME (name
);
681 if (name
== 0 || anon_aggrname_p (name
))
683 if (flags
& TFF_CLASS_KEY_OR_ENUM
)
684 pp_string (pp
, M_("<unnamed>"));
686 pp_printf (pp
, M_("<unnamed %s>"), variety
);
688 else if (LAMBDA_TYPE_P (t
))
690 /* A lambda's "type" is essentially its signature. */
691 pp_string (pp
, M_("<lambda"));
692 if (lambda_function (t
))
694 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t
)),
699 pp_cxx_tree_identifier (pp
, name
);
701 dump_template_parms (pp
, TYPE_TEMPLATE_INFO (t
),
702 !CLASSTYPE_USE_TEMPLATE (t
),
703 flags
& ~TFF_TEMPLATE_HEADER
);
706 /* Dump into the obstack the initial part of the output for a given type.
707 This is necessary when dealing with things like functions returning
710 return type of `int (* fee ())()': pointer -> function -> int. Both
711 pointer (and reference and offset) and function (and member) types must
712 deal with prefix and suffix.
714 Arrays must also do this for DECL nodes, like int a[], and for things like
718 dump_type_prefix (cxx_pretty_printer
*pp
, tree t
, int flags
)
720 if (TYPE_PTRMEMFUNC_P (t
))
722 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
726 switch (TREE_CODE (t
))
731 tree sub
= TREE_TYPE (t
);
733 dump_type_prefix (pp
, sub
, flags
);
734 if (TREE_CODE (sub
) == ARRAY_TYPE
735 || TREE_CODE (sub
) == FUNCTION_TYPE
)
737 pp_cxx_whitespace (pp
);
738 pp_cxx_left_paren (pp
);
739 pp_c_attributes_display (pp
, TYPE_ATTRIBUTES (sub
));
743 else if (TREE_CODE (t
) == REFERENCE_TYPE
)
745 if (TYPE_REF_IS_RVALUE (t
))
746 pp_ampersand_ampersand (pp
);
750 pp
->padding
= pp_before
;
751 pp_cxx_cv_qualifier_seq (pp
, t
);
757 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
758 if (TREE_CODE (t
) == OFFSET_TYPE
) /* pmfs deal with this in d_t_p */
761 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
762 pp_cxx_left_paren (pp
);
763 dump_type (pp
, TYPE_OFFSET_BASETYPE (t
), flags
);
764 pp_cxx_colon_colon (pp
);
767 pp_cxx_cv_qualifier_seq (pp
, t
);
768 pp
->padding
= pp_before
;
771 /* This can be reached without a pointer when dealing with
772 templates, e.g. std::is_function. */
774 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
778 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
780 pp_cxx_left_paren (pp
);
781 dump_aggr_type (pp
, TYPE_METHOD_BASETYPE (t
), flags
);
782 pp_cxx_colon_colon (pp
);
786 dump_type_prefix (pp
, TREE_TYPE (t
), flags
);
790 case IDENTIFIER_NODE
:
795 case TEMPLATE_TYPE_PARM
:
796 case TEMPLATE_TEMPLATE_PARM
:
797 case BOUND_TEMPLATE_TEMPLATE_PARM
:
808 case UNDERLYING_TYPE
:
810 case TYPE_PACK_EXPANSION
:
811 case FIXED_POINT_TYPE
:
813 dump_type (pp
, t
, flags
);
814 pp
->padding
= pp_before
;
818 pp_unsupported_tree (pp
, t
);
821 pp_string (pp
, M_("<typeprefixerror>"));
826 /* Dump the suffix of type T, under control of FLAGS. This is the part
827 which appears after the identifier (or function parms). */
830 dump_type_suffix (cxx_pretty_printer
*pp
, tree t
, int flags
)
832 if (TYPE_PTRMEMFUNC_P (t
))
833 t
= TYPE_PTRMEMFUNC_FN_TYPE (t
);
835 switch (TREE_CODE (t
))
840 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
841 || TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
842 pp_cxx_right_paren (pp
);
843 if (TREE_CODE (t
) == POINTER_TYPE
)
844 flags
|= TFF_POINTER
;
845 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
852 if (TREE_CODE (t
) == METHOD_TYPE
)
853 /* Can only be reached through a pointer. */
854 pp_cxx_right_paren (pp
);
855 arg
= TYPE_ARG_TYPES (t
);
856 if (TREE_CODE (t
) == METHOD_TYPE
)
857 arg
= TREE_CHAIN (arg
);
859 /* Function pointers don't have default args. Not in standard C++,
860 anyway; they may in g++, but we'll just pretend otherwise. */
861 dump_parameters (pp
, arg
, flags
& ~TFF_FUNCTION_DEFAULT_ARGUMENTS
);
863 pp
->padding
= pp_before
;
864 pp_cxx_cv_qualifiers (pp
, type_memfn_quals (t
),
865 TREE_CODE (t
) == FUNCTION_TYPE
866 && (flags
& TFF_POINTER
));
867 dump_ref_qualifier (pp
, t
, flags
);
868 if (tx_safe_fn_type_p (t
))
869 pp_cxx_ws_string (pp
, "transaction_safe");
870 dump_exception_spec (pp
, TYPE_RAISES_EXCEPTIONS (t
), flags
);
871 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
877 pp_cxx_left_bracket (pp
);
878 if (tree dtype
= TYPE_DOMAIN (t
))
880 tree max
= TYPE_MAX_VALUE (dtype
);
881 /* Zero-length arrays have an upper bound of SIZE_MAX. */
882 if (integer_all_onesp (max
))
883 pp_character (pp
, '0');
884 else if (tree_fits_shwi_p (max
))
885 pp_wide_integer (pp
, tree_to_shwi (max
) + 1);
889 if (TREE_CODE (max
) == SAVE_EXPR
)
890 max
= TREE_OPERAND (max
, 0);
891 if (TREE_CODE (max
) == MINUS_EXPR
892 || TREE_CODE (max
) == PLUS_EXPR
)
894 max
= TREE_OPERAND (max
, 0);
895 while (CONVERT_EXPR_P (max
))
896 max
= TREE_OPERAND (max
, 0);
899 max
= fold_build2_loc (input_location
,
900 PLUS_EXPR
, dtype
, max
,
901 build_int_cst (dtype
, 1));
902 dump_expr (pp
, max
, flags
& ~TFF_EXPR_IN_PARENS
);
905 pp_cxx_right_bracket (pp
);
906 dump_type_suffix (pp
, TREE_TYPE (t
), flags
);
910 case IDENTIFIER_NODE
:
915 case TEMPLATE_TYPE_PARM
:
916 case TEMPLATE_TEMPLATE_PARM
:
917 case BOUND_TEMPLATE_TEMPLATE_PARM
:
928 case UNDERLYING_TYPE
:
930 case TYPE_PACK_EXPANSION
:
931 case FIXED_POINT_TYPE
:
936 pp_unsupported_tree (pp
, t
);
938 /* Don't mark it here, we should have already done in
945 dump_global_iord (cxx_pretty_printer
*pp
, tree t
)
947 const char *p
= NULL
;
949 if (DECL_GLOBAL_CTOR_P (t
))
950 p
= M_("(static initializers for %s)");
951 else if (DECL_GLOBAL_DTOR_P (t
))
952 p
= M_("(static destructors for %s)");
956 pp_printf (pp
, p
, DECL_SOURCE_FILE (t
));
960 dump_simple_decl (cxx_pretty_printer
*pp
, tree t
, tree type
, int flags
)
962 if (flags
& TFF_DECL_SPECIFIERS
)
964 if (VAR_P (t
) && DECL_DECLARED_CONSTEXPR_P (t
))
966 if (DECL_LANG_SPECIFIC (t
) && DECL_DECLARED_CONCEPT_P (t
))
967 pp_cxx_ws_string (pp
, "concept");
969 pp_cxx_ws_string (pp
, "constexpr");
971 dump_type_prefix (pp
, type
, flags
& ~TFF_UNQUALIFIED_NAME
);
974 if (! (flags
& TFF_UNQUALIFIED_NAME
)
975 && TREE_CODE (t
) != PARM_DECL
976 && (!DECL_INITIAL (t
)
977 || TREE_CODE (DECL_INITIAL (t
)) != TEMPLATE_PARM_INDEX
))
978 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
979 flags
&= ~TFF_UNQUALIFIED_NAME
;
980 if ((flags
& TFF_DECL_SPECIFIERS
)
981 && DECL_TEMPLATE_PARM_P (t
)
982 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t
)))
983 pp_string (pp
, "...");
986 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_NORMAL_CAPTURE_P (t
))
989 pp_string (pp
, IDENTIFIER_POINTER (DECL_NAME (t
)) + 2);
990 pp_string (pp
, " capture>");
993 dump_decl (pp
, DECL_NAME (t
), flags
);
996 pp_string (pp
, M_("<anonymous>"));
997 if (flags
& TFF_DECL_SPECIFIERS
)
998 dump_type_suffix (pp
, type
, flags
);
1001 /* Print an IDENTIFIER_NODE that is the name of a declaration. */
1004 dump_decl_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1006 /* These special cases are duplicated here so that other functions
1007 can feed identifiers to error and get them demangled properly. */
1008 if (IDENTIFIER_TYPENAME_P (t
))
1010 pp_cxx_ws_string (pp
, "operator");
1011 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1012 dump_type (pp
, TREE_TYPE (t
), flags
);
1015 if (dguide_name_p (t
))
1017 dump_decl (pp
, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t
)),
1018 TFF_UNQUALIFIED_NAME
);
1022 const char *str
= IDENTIFIER_POINTER (t
);
1023 if (!strncmp (str
, "_ZGR", 3))
1025 pp_cxx_ws_string (pp
, "<temporary>");
1029 pp_cxx_tree_identifier (pp
, t
);
1032 /* Dump a human readable string for the decl T under control of FLAGS. */
1035 dump_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1040 /* If doing Objective-C++, give Objective-C a chance to demangle
1041 Objective-C method names. */
1042 if (c_dialect_objc ())
1044 const char *demangled
= objc_maybe_printable_name (t
, flags
);
1047 pp_string (pp
, demangled
);
1052 switch (TREE_CODE (t
))
1055 /* Don't say 'typedef class A' */
1056 if (DECL_ARTIFICIAL (t
) && !DECL_SELF_REFERENCE_P (t
))
1058 if ((flags
& TFF_DECL_SPECIFIERS
)
1059 && TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TYPE_PARM
)
1061 /* Say `class T' not just `T'. */
1062 pp_cxx_ws_string (pp
, "class");
1064 /* Emit the `...' for a parameter pack. */
1065 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1066 pp_cxx_ws_string (pp
, "...");
1069 dump_type (pp
, TREE_TYPE (t
), flags
);
1072 if (TYPE_DECL_ALIAS_P (t
)
1073 && (flags
& TFF_DECL_SPECIFIERS
1074 || flags
& TFF_CLASS_KEY_OR_ENUM
))
1076 pp_cxx_ws_string (pp
, "using");
1077 dump_decl (pp
, DECL_NAME (t
), flags
);
1078 pp_cxx_whitespace (pp
);
1079 pp_cxx_ws_string (pp
, "=");
1080 pp_cxx_whitespace (pp
);
1081 dump_type (pp
, (DECL_ORIGINAL_TYPE (t
)
1082 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
)),
1086 if ((flags
& TFF_DECL_SPECIFIERS
)
1087 && !DECL_SELF_REFERENCE_P (t
))
1088 pp_cxx_ws_string (pp
, "typedef");
1089 dump_simple_decl (pp
, t
, DECL_ORIGINAL_TYPE (t
)
1090 ? DECL_ORIGINAL_TYPE (t
) : TREE_TYPE (t
),
1095 if (DECL_NAME (t
) && VTABLE_NAME_P (DECL_NAME (t
)))
1097 pp_string (pp
, M_("vtable for "));
1098 gcc_assert (TYPE_P (DECL_CONTEXT (t
)));
1099 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1105 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1107 /* Handle variable template specializations. */
1109 && DECL_LANG_SPECIFIC (t
)
1110 && DECL_TEMPLATE_INFO (t
)
1111 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1113 pp_cxx_begin_template_argument_list (pp
);
1114 tree args
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1115 dump_template_argument_list (pp
, args
, flags
);
1116 pp_cxx_end_template_argument_list (pp
);
1121 pp_string (pp
, M_("<return value> "));
1122 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1125 case NAMESPACE_DECL
:
1126 if (flags
& TFF_DECL_SPECIFIERS
)
1127 pp
->declaration (t
);
1130 if (! (flags
& TFF_UNQUALIFIED_NAME
))
1131 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1132 flags
&= ~TFF_UNQUALIFIED_NAME
;
1133 if (DECL_NAME (t
) == NULL_TREE
)
1135 if (!(pp
->flags
& pp_c_flag_gnu_v3
))
1136 pp_cxx_ws_string (pp
, M_("{anonymous}"));
1138 pp_cxx_ws_string (pp
, M_("(anonymous namespace)"));
1141 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1146 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1147 pp_colon_colon (pp
);
1148 dump_decl (pp
, TREE_OPERAND (t
, 1), TFF_UNQUALIFIED_NAME
);
1152 dump_decl (pp
, TREE_OPERAND (t
, 0), flags
);
1153 pp_cxx_left_bracket (pp
);
1154 dump_decl (pp
, TREE_OPERAND (t
, 1), flags
);
1155 pp_cxx_right_bracket (pp
);
1158 case ARRAY_NOTATION_REF
:
1159 dump_decl (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
1160 pp_cxx_left_bracket (pp
);
1161 dump_decl (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
1163 dump_decl (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
1165 dump_decl (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
1166 pp_cxx_right_bracket (pp
);
1169 /* So that we can do dump_decl on an aggr type. */
1173 dump_type (pp
, t
, flags
);
1177 /* This is a pseudo destructor call which has not been folded into
1178 a PSEUDO_DTOR_EXPR yet. */
1179 pp_cxx_complement (pp
);
1180 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
1187 case IDENTIFIER_NODE
:
1188 dump_decl_name (pp
, t
, flags
);
1194 t
= OVL_CURRENT (t
);
1195 if (DECL_CLASS_SCOPE_P (t
))
1197 dump_type (pp
, DECL_CONTEXT (t
), flags
);
1198 pp_cxx_colon_colon (pp
);
1200 else if (!DECL_FILE_SCOPE_P (t
))
1202 dump_decl (pp
, DECL_CONTEXT (t
), flags
);
1203 pp_cxx_colon_colon (pp
);
1205 dump_decl (pp
, DECL_NAME (t
), flags
);
1209 /* If there's only one function, just treat it like an ordinary
1215 if (! DECL_LANG_SPECIFIC (t
))
1217 if (DECL_ABSTRACT_ORIGIN (t
)
1218 && DECL_ABSTRACT_ORIGIN (t
) != t
)
1219 dump_decl (pp
, DECL_ABSTRACT_ORIGIN (t
), flags
);
1221 dump_function_name (pp
, t
, flags
);
1223 else if (DECL_GLOBAL_CTOR_P (t
) || DECL_GLOBAL_DTOR_P (t
))
1224 dump_global_iord (pp
, t
);
1226 dump_function_decl (pp
, t
, flags
);
1230 dump_template_decl (pp
, t
, flags
);
1233 case TEMPLATE_ID_EXPR
:
1235 tree name
= TREE_OPERAND (t
, 0);
1236 tree args
= TREE_OPERAND (t
, 1);
1238 if (!identifier_p (name
))
1239 name
= OVL_NAME (name
);
1240 dump_decl (pp
, name
, flags
);
1241 pp_cxx_begin_template_argument_list (pp
);
1242 if (args
== error_mark_node
)
1243 pp_string (pp
, M_("<template arguments error>"));
1245 dump_template_argument_list
1246 (pp
, args
, flags
|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS
);
1247 pp_cxx_end_template_argument_list (pp
);
1252 pp_cxx_tree_identifier (pp
, DECL_NAME (t
));
1256 if ((TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == ENUMERAL_TYPE
)
1257 || (DECL_INITIAL (t
) &&
1258 TREE_CODE (DECL_INITIAL (t
)) == TEMPLATE_PARM_INDEX
))
1259 dump_simple_decl (pp
, t
, TREE_TYPE (t
), flags
);
1260 else if (DECL_NAME (t
))
1261 dump_decl (pp
, DECL_NAME (t
), flags
);
1262 else if (DECL_INITIAL (t
))
1263 dump_expr (pp
, DECL_INITIAL (t
), flags
| TFF_EXPR_IN_PARENS
);
1265 pp_string (pp
, M_("<enumerator>"));
1270 pp_cxx_ws_string (pp
, "using");
1271 tree scope
= USING_DECL_SCOPE (t
);
1272 bool variadic
= false;
1273 if (PACK_EXPANSION_P (scope
))
1275 scope
= PACK_EXPANSION_PATTERN (scope
);
1278 dump_type (pp
, scope
, flags
);
1279 pp_cxx_colon_colon (pp
);
1280 dump_decl (pp
, DECL_NAME (t
), flags
);
1282 pp_cxx_ws_string (pp
, "...");
1287 pp
->declaration (t
);
1291 dump_decl (pp
, BASELINK_FUNCTIONS (t
), flags
);
1294 case NON_DEPENDENT_EXPR
:
1295 dump_expr (pp
, t
, flags
);
1298 case TEMPLATE_TYPE_PARM
:
1299 if (flags
& TFF_DECL_SPECIFIERS
)
1300 pp
->declaration (t
);
1305 case UNBOUND_CLASS_TEMPLATE
:
1306 case TYPE_PACK_EXPANSION
:
1308 dump_type (pp
, t
, flags
);
1312 pp_unsupported_tree (pp
, t
);
1316 pp_string (pp
, M_("<declaration error>"));
1321 /* Dump a template declaration T under control of FLAGS. This means the
1322 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1325 dump_template_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1327 tree orig_parms
= DECL_TEMPLATE_PARMS (t
);
1331 if (flags
& TFF_TEMPLATE_HEADER
)
1333 for (parms
= orig_parms
= nreverse (orig_parms
);
1335 parms
= TREE_CHAIN (parms
))
1337 tree inner_parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1338 int len
= TREE_VEC_LENGTH (inner_parms
);
1342 /* Skip over the dummy template levels of a template template
1344 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == TEMPLATE_TEMPLATE_PARM
);
1348 pp_cxx_ws_string (pp
, "template");
1349 pp_cxx_begin_template_argument_list (pp
);
1351 /* If we've shown the template prefix, we'd better show the
1352 parameters' and decl's type too. */
1353 flags
|= TFF_DECL_SPECIFIERS
;
1355 for (i
= 0; i
< len
; i
++)
1358 pp_separate_with_comma (pp
);
1359 dump_template_parameter (pp
, TREE_VEC_ELT (inner_parms
, i
),
1362 pp_cxx_end_template_argument_list (pp
);
1363 pp_cxx_whitespace (pp
);
1365 nreverse(orig_parms
);
1367 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t
))
1369 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1370 pp_cxx_ws_string (pp
, "class");
1372 /* If this is a parameter pack, print the ellipsis. */
1373 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t
)))
1374 pp_cxx_ws_string (pp
, "...");
1377 /* Only print the requirements if we're also printing
1378 the template header. */
1380 if (tree ci
= get_constraints (t
))
1381 if (check_constraint_info (ci
))
1382 if (tree reqs
= CI_TEMPLATE_REQS (ci
))
1384 pp_cxx_requires_clause (pp
, reqs
);
1385 pp_cxx_whitespace (pp
);
1390 if (DECL_CLASS_TEMPLATE_P (t
))
1391 dump_type (pp
, TREE_TYPE (t
),
1392 ((flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1393 | (flags
& TFF_DECL_SPECIFIERS
? TFF_CLASS_KEY_OR_ENUM
: 0)));
1394 else if (DECL_TEMPLATE_RESULT (t
)
1395 && (VAR_P (DECL_TEMPLATE_RESULT (t
))
1396 /* Alias template. */
1397 || DECL_TYPE_TEMPLATE_P (t
)))
1398 dump_decl (pp
, DECL_TEMPLATE_RESULT (t
), flags
| TFF_TEMPLATE_NAME
);
1401 gcc_assert (TREE_TYPE (t
));
1402 switch (NEXT_CODE (t
))
1406 dump_function_decl (pp
, t
, flags
| TFF_TEMPLATE_NAME
);
1409 /* This case can occur with some invalid code. */
1410 dump_type (pp
, TREE_TYPE (t
),
1411 (flags
& ~TFF_CLASS_KEY_OR_ENUM
) | TFF_TEMPLATE_NAME
1412 | (flags
& TFF_DECL_SPECIFIERS
1413 ? TFF_CLASS_KEY_OR_ENUM
: 0));
1418 /* find_typenames looks through the type of the function template T
1419 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1422 struct find_typenames_t
1424 hash_set
<tree
> *p_set
;
1425 vec
<tree
, va_gc
> *typenames
;
1429 find_typenames_r (tree
*tp
, int *walk_subtrees
, void *data
)
1431 struct find_typenames_t
*d
= (struct find_typenames_t
*)data
;
1432 tree mv
= NULL_TREE
;
1434 if (TYPE_P (*tp
) && is_typedef_decl (TYPE_NAME (*tp
)))
1435 /* Add the type of the typedef without any additional cv-quals. */
1436 mv
= TREE_TYPE (TYPE_NAME (*tp
));
1437 else if (TREE_CODE (*tp
) == TYPENAME_TYPE
1438 || TREE_CODE (*tp
) == DECLTYPE_TYPE
)
1439 /* Add the typename without any cv-qualifiers. */
1440 mv
= TYPE_MAIN_VARIANT (*tp
);
1442 if (TREE_CODE (*tp
) == TYPE_PACK_EXPANSION
)
1444 /* Don't mess with parameter packs since we don't remember
1445 the pack expansion context for a particular typename. */
1446 *walk_subtrees
= false;
1450 if (mv
&& (mv
== *tp
|| !d
->p_set
->add (mv
)))
1451 vec_safe_push (d
->typenames
, mv
);
1453 /* Search into class template arguments, which cp_walk_subtrees
1455 if (CLASS_TYPE_P (*tp
) && CLASSTYPE_TEMPLATE_INFO (*tp
))
1456 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp
), find_typenames_r
,
1462 static vec
<tree
, va_gc
> *
1463 find_typenames (tree t
)
1465 struct find_typenames_t ft
;
1466 ft
.p_set
= new hash_set
<tree
>;
1467 ft
.typenames
= NULL
;
1468 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t
)),
1469 find_typenames_r
, &ft
, ft
.p_set
);
1471 return ft
.typenames
;
1474 /* Output the "[with ...]" clause for a template instantiation T iff
1475 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1476 formatting a deduction/substitution diagnostic rather than an
1480 dump_substitution (cxx_pretty_printer
*pp
,
1481 tree t
, tree template_parms
, tree template_args
,
1484 if (template_parms
!= NULL_TREE
&& template_args
!= NULL_TREE
1485 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
))
1487 vec
<tree
, va_gc
> *typenames
= t
? find_typenames (t
) : NULL
;
1488 pp_cxx_whitespace (pp
);
1489 pp_cxx_left_bracket (pp
);
1490 pp
->translate_string ("with");
1491 pp_cxx_whitespace (pp
);
1492 dump_template_bindings (pp
, template_parms
, template_args
, typenames
);
1493 pp_cxx_right_bracket (pp
);
1497 /* Dump the lambda function FN including its 'mutable' qualifier and any
1498 template bindings. */
1501 dump_lambda_function (cxx_pretty_printer
*pp
,
1502 tree fn
, tree template_parms
, tree template_args
,
1505 /* A lambda's signature is essentially its "type". */
1506 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
1507 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn
))) & TYPE_QUAL_CONST
))
1509 pp
->padding
= pp_before
;
1510 pp_c_ws_string (pp
, "mutable");
1512 dump_substitution (pp
, fn
, template_parms
, template_args
, flags
);
1515 /* Pretty print a function decl. There are several ways we want to print a
1516 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1517 As error can only apply the '#' flag once to give 0 and 1 for V, there
1518 is %D which doesn't print the throw specs, and %F which does. */
1521 dump_function_decl (cxx_pretty_printer
*pp
, tree t
, int flags
)
1525 tree cname
= NULL_TREE
;
1526 tree template_args
= NULL_TREE
;
1527 tree template_parms
= NULL_TREE
;
1528 int show_return
= flags
& TFF_RETURN_TYPE
|| flags
& TFF_DECL_SPECIFIERS
;
1529 int do_outer_scope
= ! (flags
& TFF_UNQUALIFIED_NAME
);
1533 flags
&= ~(TFF_UNQUALIFIED_NAME
| TFF_TEMPLATE_NAME
);
1534 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1535 t
= DECL_TEMPLATE_RESULT (t
);
1537 /* Save the exceptions, in case t is a specialization and we are
1538 emitting an error about incompatible specifications. */
1539 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
1541 /* Likewise for the constexpr specifier, in case t is a specialization. */
1542 constexpr_p
= DECL_DECLARED_CONSTEXPR_P (t
);
1544 /* Pretty print template instantiations only. */
1545 if (DECL_USE_TEMPLATE (t
) && DECL_TEMPLATE_INFO (t
)
1546 && !(flags
& TFF_NO_TEMPLATE_BINDINGS
)
1547 && flag_pretty_templates
)
1551 template_args
= DECL_TI_ARGS (t
);
1552 tmpl
= most_general_template (t
);
1553 if (tmpl
&& TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1555 template_parms
= DECL_TEMPLATE_PARMS (tmpl
);
1560 if (DECL_NAME (t
) && LAMBDA_FUNCTION_P (t
))
1561 return dump_lambda_function (pp
, t
, template_parms
, template_args
, flags
);
1563 fntype
= TREE_TYPE (t
);
1564 parmtypes
= FUNCTION_FIRST_USER_PARMTYPE (t
);
1566 if (DECL_CLASS_SCOPE_P (t
))
1567 cname
= DECL_CONTEXT (t
);
1568 /* This is for partially instantiated template methods. */
1569 else if (TREE_CODE (fntype
) == METHOD_TYPE
)
1570 cname
= TREE_TYPE (TREE_VALUE (parmtypes
));
1572 if (flags
& TFF_DECL_SPECIFIERS
)
1574 if (DECL_STATIC_FUNCTION_P (t
))
1575 pp_cxx_ws_string (pp
, "static");
1576 else if (DECL_VIRTUAL_P (t
))
1577 pp_cxx_ws_string (pp
, "virtual");
1581 if (DECL_DECLARED_CONCEPT_P (t
))
1582 pp_cxx_ws_string (pp
, "concept");
1584 pp_cxx_ws_string (pp
, "constexpr");
1588 /* Print the return type? */
1590 show_return
= (!DECL_CONV_FN_P (t
) && !DECL_CONSTRUCTOR_P (t
)
1591 && !DECL_DESTRUCTOR_P (t
) && !deduction_guide_p (t
));
1594 tree ret
= fndecl_declared_return_type (t
);
1595 dump_type_prefix (pp
, ret
, flags
);
1598 /* Print the function name. */
1599 if (!do_outer_scope
)
1603 dump_type (pp
, cname
, flags
);
1604 pp_cxx_colon_colon (pp
);
1607 dump_scope (pp
, CP_DECL_CONTEXT (t
), flags
);
1609 dump_function_name (pp
, t
, flags
);
1611 if (!(flags
& TFF_NO_FUNCTION_ARGUMENTS
))
1613 dump_parameters (pp
, parmtypes
, flags
);
1615 if (TREE_CODE (fntype
) == METHOD_TYPE
)
1617 pp
->padding
= pp_before
;
1618 pp_cxx_cv_qualifier_seq (pp
, class_of_this_parm (fntype
));
1619 dump_ref_qualifier (pp
, fntype
, flags
);
1622 if (tx_safe_fn_type_p (fntype
))
1624 pp
->padding
= pp_before
;
1625 pp_cxx_ws_string (pp
, "transaction_safe");
1628 if (flags
& TFF_EXCEPTION_SPECIFICATION
)
1630 pp
->padding
= pp_before
;
1631 dump_exception_spec (pp
, exceptions
, flags
);
1635 dump_type_suffix (pp
, TREE_TYPE (fntype
), flags
);
1636 else if (deduction_guide_p (t
))
1638 pp_cxx_ws_string (pp
, "->");
1639 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1643 if (tree ci
= get_constraints (t
))
1644 if (tree reqs
= CI_DECLARATOR_REQS (ci
))
1645 pp_cxx_requires_clause (pp
, reqs
);
1647 dump_substitution (pp
, t
, template_parms
, template_args
, flags
);
1649 if (tree base
= DECL_INHERITED_CTOR_BASE (t
))
1651 pp_cxx_ws_string (pp
, "[inherited from");
1652 dump_type (pp
, base
, TFF_PLAIN_IDENTIFIER
);
1653 pp_character (pp
, ']');
1656 else if (template_args
)
1658 bool need_comma
= false;
1660 pp_cxx_begin_template_argument_list (pp
);
1661 template_args
= INNERMOST_TEMPLATE_ARGS (template_args
);
1662 for (i
= 0; i
< TREE_VEC_LENGTH (template_args
); ++i
)
1664 tree arg
= TREE_VEC_ELT (template_args
, i
);
1666 pp_separate_with_comma (pp
);
1667 if (ARGUMENT_PACK_P (arg
))
1668 pp_cxx_left_brace (pp
);
1669 dump_template_argument (pp
, arg
, TFF_PLAIN_IDENTIFIER
);
1670 if (ARGUMENT_PACK_P (arg
))
1671 pp_cxx_right_brace (pp
);
1674 pp_cxx_end_template_argument_list (pp
);
1678 /* Print a parameter list. If this is for a member function, the
1679 member object ptr (and any other hidden args) should have
1680 already been removed. */
1683 dump_parameters (cxx_pretty_printer
*pp
, tree parmtypes
, int flags
)
1686 flags
&= ~TFF_SCOPE
;
1687 pp_cxx_left_paren (pp
);
1689 for (first
= 1; parmtypes
!= void_list_node
;
1690 parmtypes
= TREE_CHAIN (parmtypes
))
1693 pp_separate_with_comma (pp
);
1697 pp_cxx_ws_string (pp
, "...");
1701 dump_type (pp
, TREE_VALUE (parmtypes
), flags
);
1703 if ((flags
& TFF_FUNCTION_DEFAULT_ARGUMENTS
) && TREE_PURPOSE (parmtypes
))
1705 pp_cxx_whitespace (pp
);
1707 pp_cxx_whitespace (pp
);
1708 dump_expr (pp
, TREE_PURPOSE (parmtypes
), flags
| TFF_EXPR_IN_PARENS
);
1712 pp_cxx_right_paren (pp
);
1715 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1718 dump_ref_qualifier (cxx_pretty_printer
*pp
, tree t
, int flags ATTRIBUTE_UNUSED
)
1720 if (FUNCTION_REF_QUALIFIED (t
))
1722 pp
->padding
= pp_before
;
1723 if (FUNCTION_RVALUE_QUALIFIED (t
))
1724 pp_cxx_ws_string (pp
, "&&");
1726 pp_cxx_ws_string (pp
, "&");
1730 /* Print an exception specification. T is the exception specification. */
1733 dump_exception_spec (cxx_pretty_printer
*pp
, tree t
, int flags
)
1735 if (t
&& TREE_PURPOSE (t
))
1737 pp_cxx_ws_string (pp
, "noexcept");
1738 if (!integer_onep (TREE_PURPOSE (t
)))
1740 pp_cxx_whitespace (pp
);
1741 pp_cxx_left_paren (pp
);
1742 if (DEFERRED_NOEXCEPT_SPEC_P (t
))
1743 pp_cxx_ws_string (pp
, "<uninstantiated>");
1745 dump_expr (pp
, TREE_PURPOSE (t
), flags
);
1746 pp_cxx_right_paren (pp
);
1751 pp_cxx_ws_string (pp
, "throw");
1752 pp_cxx_whitespace (pp
);
1753 pp_cxx_left_paren (pp
);
1754 if (TREE_VALUE (t
) != NULL_TREE
)
1757 dump_type (pp
, TREE_VALUE (t
), flags
);
1761 pp_separate_with_comma (pp
);
1763 pp_cxx_right_paren (pp
);
1767 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1768 and destructors properly. */
1771 dump_function_name (cxx_pretty_printer
*pp
, tree t
, int flags
)
1773 tree name
= DECL_NAME (t
);
1775 /* We can get here with a decl that was synthesized by language-
1776 independent machinery (e.g. coverage.c) in which case it won't
1777 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1778 will crash. In this case it is safe just to print out the
1780 if (!DECL_LANG_SPECIFIC (t
))
1782 pp_cxx_tree_identifier (pp
, name
);
1786 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1787 t
= DECL_TEMPLATE_RESULT (t
);
1789 /* Don't let the user see __comp_ctor et al. */
1790 if (DECL_CONSTRUCTOR_P (t
)
1791 || DECL_DESTRUCTOR_P (t
))
1793 if (LAMBDA_TYPE_P (DECL_CONTEXT (t
)))
1794 name
= get_identifier ("<lambda>");
1795 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t
)))
1796 name
= get_identifier ("<constructor>");
1798 name
= constructor_name (DECL_CONTEXT (t
));
1801 if (DECL_DESTRUCTOR_P (t
))
1803 pp_cxx_complement (pp
);
1804 dump_decl (pp
, name
, TFF_PLAIN_IDENTIFIER
);
1806 else if (DECL_CONV_FN_P (t
))
1808 /* This cannot use the hack that the operator's return
1809 type is stashed off of its name because it may be
1810 used for error reporting. In the case of conflicting
1811 declarations, both will have the same name, yet
1812 the types will be different, hence the TREE_TYPE field
1813 of the first name will be clobbered by the second. */
1814 pp_cxx_ws_string (pp
, "operator");
1815 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
1818 dump_decl (pp
, name
, flags
);
1820 if (DECL_TEMPLATE_INFO (t
)
1821 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t
)
1822 && (TREE_CODE (DECL_TI_TEMPLATE (t
)) != TEMPLATE_DECL
1823 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))))
1824 dump_template_parms (pp
, DECL_TEMPLATE_INFO (t
), !DECL_USE_TEMPLATE (t
),
1828 /* Dump the template parameters from the template info INFO under control of
1829 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1830 specialization (partial or complete). For partial specializations we show
1831 the specialized parameter values. For a primary template we show no
1835 dump_template_parms (cxx_pretty_printer
*pp
, tree info
,
1836 int primary
, int flags
)
1838 tree args
= info
? TI_ARGS (info
) : NULL_TREE
;
1840 if (primary
&& flags
& TFF_TEMPLATE_NAME
)
1842 flags
&= ~(TFF_CLASS_KEY_OR_ENUM
| TFF_TEMPLATE_NAME
);
1843 pp_cxx_begin_template_argument_list (pp
);
1845 /* Be careful only to print things when we have them, so as not
1846 to crash producing error messages. */
1847 if (args
&& !primary
)
1850 len
= get_non_default_template_args_count (args
, flags
);
1852 args
= INNERMOST_TEMPLATE_ARGS (args
);
1853 for (ix
= 0; ix
!= len
; ix
++)
1855 tree arg
= TREE_VEC_ELT (args
, ix
);
1857 /* Only print a comma if we know there is an argument coming. In
1858 the case of an empty template argument pack, no actual
1859 argument will be printed. */
1861 && (!ARGUMENT_PACK_P (arg
)
1862 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg
)) > 0))
1863 pp_separate_with_comma (pp
);
1866 pp_string (pp
, M_("<template parameter error>"));
1868 dump_template_argument (pp
, arg
, flags
);
1873 tree tpl
= TI_TEMPLATE (info
);
1874 tree parms
= DECL_TEMPLATE_PARMS (tpl
);
1877 parms
= TREE_CODE (parms
) == TREE_LIST
? TREE_VALUE (parms
) : NULL_TREE
;
1878 len
= parms
? TREE_VEC_LENGTH (parms
) : 0;
1880 for (ix
= 0; ix
!= len
; ix
++)
1884 if (TREE_VEC_ELT (parms
, ix
) == error_mark_node
)
1886 pp_string (pp
, M_("<template parameter error>"));
1890 parm
= TREE_VALUE (TREE_VEC_ELT (parms
, ix
));
1893 pp_separate_with_comma (pp
);
1895 dump_decl (pp
, parm
, flags
& ~TFF_DECL_SPECIFIERS
);
1898 pp_cxx_end_template_argument_list (pp
);
1901 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1902 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1905 dump_call_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
, bool skipfirst
)
1908 call_expr_arg_iterator iter
;
1910 pp_cxx_left_paren (pp
);
1911 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, t
)
1917 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1918 if (more_call_expr_args_p (&iter
))
1919 pp_separate_with_comma (pp
);
1922 pp_cxx_right_paren (pp
);
1925 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1926 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1930 dump_aggr_init_expr_args (cxx_pretty_printer
*pp
, tree t
, int flags
,
1934 aggr_init_expr_arg_iterator iter
;
1936 pp_cxx_left_paren (pp
);
1937 FOR_EACH_AGGR_INIT_EXPR_ARG (arg
, iter
, t
)
1943 dump_expr (pp
, arg
, flags
| TFF_EXPR_IN_PARENS
);
1944 if (more_aggr_init_expr_args_p (&iter
))
1945 pp_separate_with_comma (pp
);
1948 pp_cxx_right_paren (pp
);
1951 /* Print out a list of initializers (subr of dump_expr). */
1954 dump_expr_list (cxx_pretty_printer
*pp
, tree l
, int flags
)
1958 dump_expr (pp
, TREE_VALUE (l
), flags
| TFF_EXPR_IN_PARENS
);
1961 pp_separate_with_comma (pp
);
1965 /* Print out a vector of initializers (subr of dump_expr). */
1968 dump_expr_init_vec (cxx_pretty_printer
*pp
, vec
<constructor_elt
, va_gc
> *v
,
1971 unsigned HOST_WIDE_INT idx
;
1974 FOR_EACH_CONSTRUCTOR_VALUE (v
, idx
, value
)
1976 dump_expr (pp
, value
, flags
| TFF_EXPR_IN_PARENS
);
1977 if (idx
!= v
->length () - 1)
1978 pp_separate_with_comma (pp
);
1983 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1984 function. Resolve it to a close relative -- in the sense of static
1985 type -- variant being overridden. That is close to what was written in
1986 the source code. Subroutine of dump_expr. */
1989 resolve_virtual_fun_from_obj_type_ref (tree ref
)
1991 tree obj_type
= TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref
));
1992 HOST_WIDE_INT index
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1993 tree fun
= BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type
)));
1996 fun
= TREE_CHAIN (fun
);
1997 index
-= (TARGET_VTABLE_USES_DESCRIPTORS
1998 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
2004 /* Print out an expression E under control of FLAGS. */
2007 dump_expr (cxx_pretty_printer
*pp
, tree t
, int flags
)
2014 if (STATEMENT_CLASS_P (t
))
2016 pp_cxx_ws_string (pp
, M_("<statement>"));
2020 switch (TREE_CODE (t
))
2028 case NAMESPACE_DECL
:
2032 case IDENTIFIER_NODE
:
2033 dump_decl (pp
, t
, ((flags
& ~(TFF_DECL_SPECIFIERS
|TFF_RETURN_TYPE
2034 |TFF_TEMPLATE_HEADER
))
2035 | TFF_NO_TEMPLATE_BINDINGS
2036 | TFF_NO_FUNCTION_ARGUMENTS
));
2040 if (SSA_NAME_VAR (t
)
2041 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t
)))
2042 dump_expr (pp
, SSA_NAME_VAR (t
), flags
);
2044 pp_cxx_ws_string (pp
, M_("<unknown>"));
2055 case USERDEF_LITERAL
:
2056 pp_cxx_userdef_literal (pp
, t
);
2060 /* While waiting for caret diagnostics, avoid printing
2061 __cxa_allocate_exception, __cxa_throw, and the like. */
2062 pp_cxx_ws_string (pp
, M_("<throw-expression>"));
2067 dump_type (pp
, PTRMEM_CST_CLASS (t
), flags
);
2068 pp_cxx_colon_colon (pp
);
2069 pp_cxx_tree_identifier (pp
, DECL_NAME (PTRMEM_CST_MEMBER (t
)));
2073 pp_cxx_left_paren (pp
);
2074 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2075 pp_separate_with_comma (pp
);
2076 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2077 pp_cxx_right_paren (pp
);
2082 pp_cxx_left_paren (pp
);
2083 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2084 pp_string (pp
, " ? ");
2085 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2086 pp_string (pp
, " : ");
2087 dump_expr (pp
, TREE_OPERAND (t
, 2), flags
| TFF_EXPR_IN_PARENS
);
2088 pp_cxx_right_paren (pp
);
2092 if (TREE_HAS_CONSTRUCTOR (t
))
2094 pp_cxx_ws_string (pp
, "new");
2095 pp_cxx_whitespace (pp
);
2096 dump_type (pp
, TREE_TYPE (TREE_TYPE (t
)), flags
);
2099 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2102 case AGGR_INIT_EXPR
:
2104 tree fn
= NULL_TREE
;
2106 if (TREE_CODE (AGGR_INIT_EXPR_FN (t
)) == ADDR_EXPR
)
2107 fn
= TREE_OPERAND (AGGR_INIT_EXPR_FN (t
), 0);
2109 if (fn
&& TREE_CODE (fn
) == FUNCTION_DECL
)
2111 if (DECL_CONSTRUCTOR_P (fn
))
2112 dump_type (pp
, DECL_CONTEXT (fn
), flags
);
2114 dump_decl (pp
, fn
, 0);
2117 dump_expr (pp
, AGGR_INIT_EXPR_FN (t
), 0);
2119 dump_aggr_init_expr_args (pp
, t
, flags
, true);
2124 tree fn
= CALL_EXPR_FN (t
);
2125 bool skipfirst
= false;
2127 /* Deal with internal functions. */
2128 if (fn
== NULL_TREE
)
2130 pp_string (pp
, internal_fn_name (CALL_EXPR_IFN (t
)));
2131 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2135 if (TREE_CODE (fn
) == ADDR_EXPR
)
2136 fn
= TREE_OPERAND (fn
, 0);
2138 /* Nobody is interested in seeing the guts of vcalls. */
2139 if (TREE_CODE (fn
) == OBJ_TYPE_REF
)
2140 fn
= resolve_virtual_fun_from_obj_type_ref (fn
);
2142 if (TREE_TYPE (fn
) != NULL_TREE
2143 && NEXT_CODE (fn
) == METHOD_TYPE
2144 && call_expr_nargs (t
))
2146 tree ob
= CALL_EXPR_ARG (t
, 0);
2147 if (TREE_CODE (ob
) == ADDR_EXPR
)
2149 dump_expr (pp
, TREE_OPERAND (ob
, 0),
2150 flags
| TFF_EXPR_IN_PARENS
);
2153 else if (TREE_CODE (ob
) != PARM_DECL
2154 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this"))
2156 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2161 if (flag_sanitize
& SANITIZE_UNDEFINED
2162 && is_ubsan_builtin_p (fn
))
2164 pp_string (cxx_pp
, M_("<ubsan routine call>"));
2167 dump_expr (pp
, fn
, flags
| TFF_EXPR_IN_PARENS
);
2168 dump_call_expr_args (pp
, t
, flags
, skipfirst
);
2173 /* Note that this only works for G++ target exprs. If somebody
2174 builds a general TARGET_EXPR, there's no way to represent that
2175 it initializes anything other that the parameter slot for the
2176 default argument. Note we may have cleared out the first
2177 operand in expand_expr, so don't go killing ourselves. */
2178 if (TREE_OPERAND (t
, 1))
2179 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2182 case POINTER_PLUS_EXPR
:
2183 dump_binary_op (pp
, "+", t
, flags
);
2188 dump_binary_op (pp
, assignment_operator_name_info
[NOP_EXPR
].name
,
2195 case TRUNC_DIV_EXPR
:
2196 case TRUNC_MOD_EXPR
:
2204 case TRUTH_ANDIF_EXPR
:
2205 case TRUTH_ORIF_EXPR
:
2212 case EXACT_DIV_EXPR
:
2213 dump_binary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2217 case FLOOR_DIV_EXPR
:
2218 case ROUND_DIV_EXPR
:
2220 dump_binary_op (pp
, "/", t
, flags
);
2224 case FLOOR_MOD_EXPR
:
2225 case ROUND_MOD_EXPR
:
2226 dump_binary_op (pp
, "%", t
, flags
);
2231 tree ob
= TREE_OPERAND (t
, 0);
2232 if (INDIRECT_REF_P (ob
))
2234 ob
= TREE_OPERAND (ob
, 0);
2235 if (TREE_CODE (ob
) != PARM_DECL
2237 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob
)), "this")))
2239 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2240 if (TREE_CODE (TREE_TYPE (ob
)) == REFERENCE_TYPE
)
2248 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2249 if (TREE_CODE (ob
) != ARROW_EXPR
)
2252 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
& ~TFF_EXPR_IN_PARENS
);
2257 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2258 pp_cxx_left_bracket (pp
);
2259 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2260 pp_cxx_right_bracket (pp
);
2263 case ARRAY_NOTATION_REF
:
2264 dump_expr (pp
, ARRAY_NOTATION_ARRAY (t
), flags
| TFF_EXPR_IN_PARENS
);
2265 pp_cxx_left_bracket (pp
);
2266 dump_expr (pp
, ARRAY_NOTATION_START (t
), flags
| TFF_EXPR_IN_PARENS
);
2268 dump_expr (pp
, ARRAY_NOTATION_LENGTH (t
), flags
| TFF_EXPR_IN_PARENS
);
2270 dump_expr (pp
, ARRAY_NOTATION_STRIDE (t
), flags
| TFF_EXPR_IN_PARENS
);
2271 pp_cxx_right_bracket (pp
);
2274 case UNARY_PLUS_EXPR
:
2275 dump_unary_op (pp
, "+", t
, flags
);
2279 if (TREE_CODE (TREE_OPERAND (t
, 0)) == FUNCTION_DECL
2280 || TREE_CODE (TREE_OPERAND (t
, 0)) == STRING_CST
2281 /* An ADDR_EXPR can have reference type. In that case, we
2282 shouldn't print the `&' doing so indicates to the user
2283 that the expression has pointer type. */
2285 && TREE_CODE (TREE_TYPE (t
)) == REFERENCE_TYPE
))
2286 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2287 else if (TREE_CODE (TREE_OPERAND (t
, 0)) == LABEL_DECL
)
2288 dump_unary_op (pp
, "&&", t
, flags
);
2290 dump_unary_op (pp
, "&", t
, flags
);
2294 if (TREE_HAS_CONSTRUCTOR (t
))
2296 t
= TREE_OPERAND (t
, 0);
2297 gcc_assert (TREE_CODE (t
) == CALL_EXPR
);
2298 dump_expr (pp
, CALL_EXPR_FN (t
), flags
| TFF_EXPR_IN_PARENS
);
2299 dump_call_expr_args (pp
, t
, flags
, true);
2303 if (TREE_OPERAND (t
,0) != NULL_TREE
2304 && TREE_TYPE (TREE_OPERAND (t
, 0))
2305 && NEXT_CODE (TREE_OPERAND (t
, 0)) == REFERENCE_TYPE
)
2306 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2308 dump_unary_op (pp
, "*", t
, flags
);
2313 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2314 && integer_zerop (TREE_OPERAND (t
, 1)))
2315 dump_expr (pp
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0), flags
);
2319 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2321 pp_cxx_left_paren (pp
);
2322 if (!integer_onep (TYPE_SIZE_UNIT
2323 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2325 pp_cxx_left_paren (pp
);
2326 dump_type (pp
, ptr_type_node
, flags
);
2327 pp_cxx_right_paren (pp
);
2330 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2331 if (!integer_zerop (TREE_OPERAND (t
, 1)))
2333 pp_cxx_ws_string (pp
, "+");
2334 dump_expr (pp
, fold_convert (ssizetype
, TREE_OPERAND (t
, 1)),
2336 pp_cxx_right_paren (pp
);
2343 case TRUTH_NOT_EXPR
:
2344 case PREDECREMENT_EXPR
:
2345 case PREINCREMENT_EXPR
:
2346 dump_unary_op (pp
, operator_name_info
[TREE_CODE (t
)].name
, t
, flags
);
2349 case POSTDECREMENT_EXPR
:
2350 case POSTINCREMENT_EXPR
:
2351 pp_cxx_left_paren (pp
);
2352 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2353 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2354 pp_cxx_right_paren (pp
);
2357 case NON_LVALUE_EXPR
:
2358 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2359 should be another level of INDIRECT_REF so that I don't have to do
2361 if (TREE_TYPE (t
) != NULL_TREE
&& NEXT_CODE (t
) == POINTER_TYPE
)
2363 tree next
= TREE_TYPE (TREE_TYPE (t
));
2365 while (TYPE_PTR_P (next
))
2366 next
= TREE_TYPE (next
);
2368 if (TREE_CODE (next
) == FUNCTION_TYPE
)
2370 if (flags
& TFF_EXPR_IN_PARENS
)
2371 pp_cxx_left_paren (pp
);
2373 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2374 if (flags
& TFF_EXPR_IN_PARENS
)
2375 pp_cxx_right_paren (pp
);
2378 /* Else fall through. */
2380 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2384 case IMPLICIT_CONV_EXPR
:
2385 case VIEW_CONVERT_EXPR
:
2387 tree op
= TREE_OPERAND (t
, 0);
2388 tree ttype
= TREE_TYPE (t
);
2389 tree optype
= TREE_TYPE (op
);
2391 if (TREE_CODE (ttype
) != TREE_CODE (optype
)
2392 && POINTER_TYPE_P (ttype
)
2393 && POINTER_TYPE_P (optype
)
2394 && same_type_p (TREE_TYPE (optype
),
2397 if (TREE_CODE (ttype
) == REFERENCE_TYPE
)
2400 if (TREE_CODE (op
) == ADDR_EXPR
)
2401 dump_expr (pp
, TREE_OPERAND (op
, 0), flags
);
2403 dump_unary_op (pp
, "*", t
, flags
);
2406 dump_unary_op (pp
, "&", t
, flags
);
2408 else if (!same_type_p (TREE_TYPE (op
), TREE_TYPE (t
)))
2410 /* It is a cast, but we cannot tell whether it is a
2411 reinterpret or static cast. Use the C style notation. */
2412 if (flags
& TFF_EXPR_IN_PARENS
)
2413 pp_cxx_left_paren (pp
);
2414 pp_cxx_left_paren (pp
);
2415 dump_type (pp
, TREE_TYPE (t
), flags
);
2416 pp_cxx_right_paren (pp
);
2417 dump_expr (pp
, op
, flags
| TFF_EXPR_IN_PARENS
);
2418 if (flags
& TFF_EXPR_IN_PARENS
)
2419 pp_cxx_right_paren (pp
);
2422 dump_expr (pp
, op
, flags
);
2427 if (TREE_TYPE (t
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t
)))
2429 tree idx
= build_ptrmemfunc_access_expr (t
, pfn_identifier
);
2431 if (integer_zerop (idx
))
2433 /* A NULL pointer-to-member constant. */
2434 pp_cxx_left_paren (pp
);
2435 pp_cxx_left_paren (pp
);
2436 dump_type (pp
, TREE_TYPE (t
), flags
);
2437 pp_cxx_right_paren (pp
);
2438 pp_character (pp
, '0');
2439 pp_cxx_right_paren (pp
);
2442 else if (tree_fits_shwi_p (idx
))
2445 unsigned HOST_WIDE_INT n
;
2447 t
= TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t
)));
2448 t
= TYPE_METHOD_BASETYPE (t
);
2449 virtuals
= BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t
)));
2451 n
= tree_to_shwi (idx
);
2453 /* Map vtable index back one, to allow for the null pointer to
2457 while (n
> 0 && virtuals
)
2460 virtuals
= TREE_CHAIN (virtuals
);
2464 dump_expr (pp
, BV_FN (virtuals
),
2465 flags
| TFF_EXPR_IN_PARENS
);
2470 if (TREE_TYPE (t
) && LAMBDA_TYPE_P (TREE_TYPE (t
)))
2471 pp_string (pp
, "<lambda closure object>");
2472 if (TREE_TYPE (t
) && EMPTY_CONSTRUCTOR_P (t
))
2474 dump_type (pp
, TREE_TYPE (t
), 0);
2475 pp_cxx_left_paren (pp
);
2476 pp_cxx_right_paren (pp
);
2480 if (!BRACE_ENCLOSED_INITIALIZER_P (t
))
2481 dump_type (pp
, TREE_TYPE (t
), 0);
2482 pp_cxx_left_brace (pp
);
2483 dump_expr_init_vec (pp
, CONSTRUCTOR_ELTS (t
), flags
);
2484 pp_cxx_right_brace (pp
);
2491 tree ob
= TREE_OPERAND (t
, 0);
2492 if (is_dummy_object (ob
))
2494 t
= TREE_OPERAND (t
, 1);
2495 if (TREE_CODE (t
) == FUNCTION_DECL
)
2497 dump_expr (pp
, t
, flags
| TFF_EXPR_IN_PARENS
);
2498 else if (BASELINK_P (t
))
2499 dump_expr (pp
, OVL_FIRST (BASELINK_FUNCTIONS (t
)),
2500 flags
| TFF_EXPR_IN_PARENS
);
2502 dump_decl (pp
, t
, flags
);
2506 if (INDIRECT_REF_P (ob
))
2508 dump_expr (pp
, TREE_OPERAND (ob
, 0), flags
| TFF_EXPR_IN_PARENS
);
2514 dump_expr (pp
, ob
, flags
| TFF_EXPR_IN_PARENS
);
2518 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2523 case TEMPLATE_PARM_INDEX
:
2524 dump_decl (pp
, TEMPLATE_PARM_DECL (t
), flags
& ~TFF_DECL_SPECIFIERS
);
2528 if (TREE_OPERAND (t
, 0) == NULL_TREE
2529 || TREE_CHAIN (TREE_OPERAND (t
, 0)))
2531 dump_type (pp
, TREE_TYPE (t
), flags
);
2532 pp_cxx_left_paren (pp
);
2533 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2534 pp_cxx_right_paren (pp
);
2538 pp_cxx_left_paren (pp
);
2539 dump_type (pp
, TREE_TYPE (t
), flags
);
2540 pp_cxx_right_paren (pp
);
2541 pp_cxx_left_paren (pp
);
2542 dump_expr_list (pp
, TREE_OPERAND (t
, 0), flags
);
2543 pp_cxx_right_paren (pp
);
2547 case STATIC_CAST_EXPR
:
2548 pp_cxx_ws_string (pp
, "static_cast");
2550 case REINTERPRET_CAST_EXPR
:
2551 pp_cxx_ws_string (pp
, "reinterpret_cast");
2553 case CONST_CAST_EXPR
:
2554 pp_cxx_ws_string (pp
, "const_cast");
2556 case DYNAMIC_CAST_EXPR
:
2557 pp_cxx_ws_string (pp
, "dynamic_cast");
2559 pp_cxx_begin_template_argument_list (pp
);
2560 dump_type (pp
, TREE_TYPE (t
), flags
);
2561 pp_cxx_end_template_argument_list (pp
);
2562 pp_cxx_left_paren (pp
);
2563 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2564 pp_cxx_right_paren (pp
);
2568 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2574 if (TREE_CODE (t
) == SIZEOF_EXPR
)
2575 pp_cxx_ws_string (pp
, "sizeof");
2578 gcc_assert (TREE_CODE (t
) == ALIGNOF_EXPR
);
2579 pp_cxx_ws_string (pp
, "__alignof__");
2581 op
= TREE_OPERAND (t
, 0);
2582 if (PACK_EXPANSION_P (op
))
2584 pp_string (pp
, "...");
2585 op
= PACK_EXPANSION_PATTERN (op
);
2587 pp_cxx_whitespace (pp
);
2588 pp_cxx_left_paren (pp
);
2589 if (TREE_CODE (t
) == SIZEOF_EXPR
&& SIZEOF_EXPR_TYPE_P (t
))
2590 dump_type (pp
, TREE_TYPE (op
), flags
);
2591 else if (TYPE_P (TREE_OPERAND (t
, 0)))
2592 dump_type (pp
, op
, flags
);
2594 dump_expr (pp
, op
, flags
);
2595 pp_cxx_right_paren (pp
);
2598 case AT_ENCODE_EXPR
:
2599 pp_cxx_ws_string (pp
, "@encode");
2600 pp_cxx_whitespace (pp
);
2601 pp_cxx_left_paren (pp
);
2602 dump_type (pp
, TREE_OPERAND (t
, 0), flags
);
2603 pp_cxx_right_paren (pp
);
2607 pp_cxx_ws_string (pp
, "noexcept");
2608 pp_cxx_whitespace (pp
);
2609 pp_cxx_left_paren (pp
);
2610 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2611 pp_cxx_right_paren (pp
);
2616 pp_cxx_ws_string (pp
, operator_name_info
[TREE_CODE (t
)].name
);
2617 pp_cxx_whitespace (pp
);
2618 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2622 pp_string (pp
, M_("<unparsed>"));
2625 case TRY_CATCH_EXPR
:
2626 case WITH_CLEANUP_EXPR
:
2627 case CLEANUP_POINT_EXPR
:
2628 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2631 case PSEUDO_DTOR_EXPR
:
2632 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2634 if (TREE_OPERAND (t
, 1))
2636 dump_type (pp
, TREE_OPERAND (t
, 1), flags
);
2637 pp_cxx_colon_colon (pp
);
2639 pp_cxx_complement (pp
);
2640 dump_type (pp
, TREE_OPERAND (t
, 2), flags
);
2643 case TEMPLATE_ID_EXPR
:
2644 dump_decl (pp
, t
, flags
);
2650 case STATEMENT_LIST
:
2651 /* We don't yet have a way of dumping statements in a
2652 human-readable format. */
2653 pp_string (pp
, "({...})");
2657 pp_string (pp
, "while (1) { ");
2658 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2659 pp_cxx_right_brace (pp
);
2663 pp_string (pp
, "if (");
2664 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2665 pp_string (pp
, ") break; ");
2669 dump_expr (pp
, BASELINK_FUNCTIONS (t
), flags
& ~TFF_EXPR_IN_PARENS
);
2672 case EMPTY_CLASS_EXPR
:
2673 dump_type (pp
, TREE_TYPE (t
), flags
);
2674 pp_cxx_left_paren (pp
);
2675 pp_cxx_right_paren (pp
);
2678 case NON_DEPENDENT_EXPR
:
2679 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
);
2682 case ARGUMENT_PACK_SELECT
:
2683 dump_template_argument (pp
, ARGUMENT_PACK_SELECT_FROM_PACK (t
), flags
);
2695 pp_type_specifier_seq (pp
, t
);
2699 /* We get here when we want to print a dependent type as an
2700 id-expression, without any disambiguator decoration. */
2701 pp
->id_expression (t
);
2704 case TEMPLATE_TYPE_PARM
:
2705 case TEMPLATE_TEMPLATE_PARM
:
2706 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2707 dump_type (pp
, t
, flags
);
2711 pp_cxx_trait_expression (pp
, t
);
2715 pp_cxx_va_arg_expression (pp
, t
);
2719 pp_cxx_offsetof_expression (pp
, t
);
2722 case ADDRESSOF_EXPR
:
2723 pp_cxx_addressof_expression (pp
, t
);
2727 dump_decl (pp
, t
, flags
);
2730 case EXPR_PACK_EXPANSION
:
2731 case UNARY_LEFT_FOLD_EXPR
:
2732 case UNARY_RIGHT_FOLD_EXPR
:
2733 case BINARY_LEFT_FOLD_EXPR
:
2734 case BINARY_RIGHT_FOLD_EXPR
:
2741 case VEC_DELETE_EXPR
:
2747 case UNORDERED_EXPR
:
2757 case FIX_TRUNC_EXPR
:
2762 case TRUTH_AND_EXPR
:
2764 case TRUTH_XOR_EXPR
:
2765 if (flags
& TFF_EXPR_IN_PARENS
)
2766 pp_cxx_left_paren (pp
);
2768 if (flags
& TFF_EXPR_IN_PARENS
)
2769 pp_cxx_right_paren (pp
);
2773 dump_expr (pp
, resolve_virtual_fun_from_obj_type_ref (t
), flags
);
2777 pp_string (pp
, M_("<lambda>"));
2781 pp_cxx_left_paren (pp
);
2782 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2783 pp_cxx_right_paren (pp
);
2787 pp_cxx_requires_expr (cxx_pp
, t
);
2791 pp_cxx_simple_requirement (cxx_pp
, t
);
2795 pp_cxx_type_requirement (cxx_pp
, t
);
2799 pp_cxx_compound_requirement (cxx_pp
, t
);
2803 pp_cxx_nested_requirement (cxx_pp
, t
);
2816 pp_cxx_constraint (cxx_pp
, t
);
2819 case PLACEHOLDER_EXPR
:
2820 pp_string (pp
, M_("*this"));
2824 dump_expr_list (pp
, t
, flags
);
2827 /* This list is incomplete, but should suffice for now.
2828 It is very important that `sorry' does not call
2829 `report_error_function'. That could cause an infinite loop. */
2831 pp_unsupported_tree (pp
, t
);
2834 pp_string (pp
, M_("<expression error>"));
2840 dump_binary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
,
2843 pp_cxx_left_paren (pp
);
2844 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
| TFF_EXPR_IN_PARENS
);
2845 pp_cxx_whitespace (pp
);
2847 pp_cxx_ws_string (pp
, opstring
);
2849 pp_string (pp
, M_("<unknown operator>"));
2850 pp_cxx_whitespace (pp
);
2851 dump_expr (pp
, TREE_OPERAND (t
, 1), flags
| TFF_EXPR_IN_PARENS
);
2852 pp_cxx_right_paren (pp
);
2856 dump_unary_op (cxx_pretty_printer
*pp
, const char *opstring
, tree t
, int flags
)
2858 if (flags
& TFF_EXPR_IN_PARENS
)
2859 pp_cxx_left_paren (pp
);
2860 pp_cxx_ws_string (pp
, opstring
);
2861 dump_expr (pp
, TREE_OPERAND (t
, 0), flags
& ~TFF_EXPR_IN_PARENS
);
2862 if (flags
& TFF_EXPR_IN_PARENS
)
2863 pp_cxx_right_paren (pp
);
2867 reinit_cxx_pp (void)
2869 pp_clear_output_area (cxx_pp
);
2870 cxx_pp
->padding
= pp_none
;
2871 pp_indentation (cxx_pp
) = 0;
2872 pp_needs_newline (cxx_pp
) = false;
2873 cxx_pp
->enclosing_scope
= current_function_decl
;
2876 /* Same as pp_formatted_text, except the return string is a separate
2877 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2880 pp_ggc_formatted_text (pretty_printer
*pp
)
2882 return ggc_strdup (pp_formatted_text (pp
));
2885 /* Exported interface to stringifying types, exprs and decls under TFF_*
2889 type_as_string (tree typ
, int flags
)
2892 pp_translate_identifiers (cxx_pp
) = false;
2893 dump_type (cxx_pp
, typ
, flags
);
2894 return pp_ggc_formatted_text (cxx_pp
);
2898 type_as_string_translate (tree typ
, int flags
)
2901 dump_type (cxx_pp
, typ
, flags
);
2902 return pp_ggc_formatted_text (cxx_pp
);
2906 expr_as_string (tree decl
, int flags
)
2909 pp_translate_identifiers (cxx_pp
) = false;
2910 dump_expr (cxx_pp
, decl
, flags
);
2911 return pp_ggc_formatted_text (cxx_pp
);
2914 /* Wrap decl_as_string with options appropriate for dwarf. */
2917 decl_as_dwarf_string (tree decl
, int flags
)
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
= decl_as_string (decl
, flags
);
2924 /* Subsequent calls to the pretty printer shouldn't use this style. */
2925 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2930 decl_as_string (tree decl
, int flags
)
2933 pp_translate_identifiers (cxx_pp
) = false;
2934 dump_decl (cxx_pp
, decl
, flags
);
2935 return pp_ggc_formatted_text (cxx_pp
);
2939 decl_as_string_translate (tree decl
, int flags
)
2942 dump_decl (cxx_pp
, decl
, flags
);
2943 return pp_ggc_formatted_text (cxx_pp
);
2946 /* Wrap lang_decl_name with options appropriate for dwarf. */
2949 lang_decl_dwarf_name (tree decl
, int v
, bool translate
)
2952 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2953 here will be adequate to get the desired behavior. */
2954 cxx_pp
->flags
|= pp_c_flag_gnu_v3
;
2955 name
= lang_decl_name (decl
, v
, translate
);
2956 /* Subsequent calls to the pretty printer shouldn't use this style. */
2957 cxx_pp
->flags
&= ~pp_c_flag_gnu_v3
;
2961 /* Generate the three forms of printable names for cxx_printable_name. */
2964 lang_decl_name (tree decl
, int v
, bool translate
)
2968 ? decl_as_string_translate (decl
, TFF_DECL_SPECIFIERS
)
2969 : decl_as_string (decl
, TFF_DECL_SPECIFIERS
));
2972 pp_translate_identifiers (cxx_pp
) = translate
;
2974 && (DECL_CLASS_SCOPE_P (decl
)
2975 || (DECL_NAMESPACE_SCOPE_P (decl
)
2976 && CP_DECL_CONTEXT (decl
) != global_namespace
)))
2978 dump_type (cxx_pp
, CP_DECL_CONTEXT (decl
), TFF_PLAIN_IDENTIFIER
);
2979 pp_cxx_colon_colon (cxx_pp
);
2982 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2983 dump_function_name (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
);
2984 else if ((DECL_NAME (decl
) == NULL_TREE
)
2985 && TREE_CODE (decl
) == NAMESPACE_DECL
)
2986 dump_decl (cxx_pp
, decl
, TFF_PLAIN_IDENTIFIER
| TFF_UNQUALIFIED_NAME
);
2988 dump_decl (cxx_pp
, DECL_NAME (decl
), TFF_PLAIN_IDENTIFIER
);
2990 return pp_ggc_formatted_text (cxx_pp
);
2993 /* Return the location of a tree passed to %+ formats. */
2996 location_of (tree t
)
3000 t
= TYPE_MAIN_DECL (t
);
3002 return input_location
;
3004 else if (TREE_CODE (t
) == OVERLOAD
)
3008 return DECL_SOURCE_LOCATION (t
);
3009 return EXPR_LOC_OR_LOC (t
, input_location
);
3012 /* Now the interfaces from error et al to dump_type et al. Each takes an
3013 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
3017 decl_to_string (tree decl
, int verbose
)
3021 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == RECORD_TYPE
3022 || TREE_CODE (decl
) == UNION_TYPE
|| TREE_CODE (decl
) == ENUMERAL_TYPE
)
3023 flags
= TFF_CLASS_KEY_OR_ENUM
;
3025 flags
|= TFF_DECL_SPECIFIERS
;
3026 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
3027 flags
|= TFF_DECL_SPECIFIERS
| TFF_RETURN_TYPE
;
3028 flags
|= TFF_TEMPLATE_HEADER
;
3031 dump_decl (cxx_pp
, decl
, flags
);
3032 return pp_ggc_formatted_text (cxx_pp
);
3036 expr_to_string (tree decl
)
3039 dump_expr (cxx_pp
, decl
, 0);
3040 return pp_ggc_formatted_text (cxx_pp
);
3044 fndecl_to_string (tree fndecl
, int verbose
)
3048 flags
= TFF_EXCEPTION_SPECIFICATION
| TFF_DECL_SPECIFIERS
3049 | TFF_TEMPLATE_HEADER
;
3051 flags
|= TFF_FUNCTION_DEFAULT_ARGUMENTS
;
3053 dump_decl (cxx_pp
, fndecl
, flags
);
3054 return pp_ggc_formatted_text (cxx_pp
);
3059 code_to_string (enum tree_code c
)
3061 return get_tree_code_name (c
);
3065 language_to_string (enum languages c
)
3072 case lang_cplusplus
:
3081 /* Return the proper printed version of a parameter to a C++ function. */
3084 parm_to_string (int p
)
3088 pp_string (cxx_pp
, "'this'");
3090 pp_decimal_int (cxx_pp
, p
+ 1);
3091 return pp_ggc_formatted_text (cxx_pp
);
3095 op_to_string (enum tree_code p
)
3097 tree id
= operator_name_info
[p
].identifier
;
3098 return id
? IDENTIFIER_POINTER (id
) : M_("<unknown>");
3102 type_to_string (tree typ
, int verbose
)
3106 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3107 flags
|= TFF_TEMPLATE_HEADER
;
3110 dump_type (cxx_pp
, typ
, flags
);
3111 /* If we're printing a type that involves typedefs, also print the
3112 stripped version. But sometimes the stripped version looks
3113 exactly the same, so we don't want it after all. To avoid printing
3114 it in that case, we play ugly obstack games. */
3115 if (typ
&& TYPE_P (typ
) && typ
!= TYPE_CANONICAL (typ
)
3116 && !uses_template_parms (typ
))
3118 int aka_start
, aka_len
; char *p
;
3119 struct obstack
*ob
= pp_buffer (cxx_pp
)->obstack
;
3120 /* Remember the end of the initial dump. */
3121 int len
= obstack_object_size (ob
);
3122 tree aka
= strip_typedefs (typ
);
3123 pp_string (cxx_pp
, " {aka");
3124 pp_cxx_whitespace (cxx_pp
);
3125 /* And remember the start of the aka dump. */
3126 aka_start
= obstack_object_size (ob
);
3127 dump_type (cxx_pp
, aka
, flags
);
3128 aka_len
= obstack_object_size (ob
) - aka_start
;
3129 pp_right_brace (cxx_pp
);
3130 p
= (char*)obstack_base (ob
);
3131 /* If they are identical, cut off the aka with a NUL. */
3132 if (len
== aka_len
&& memcmp (p
, p
+aka_start
, len
) == 0)
3136 if (typ
&& TYPE_P (typ
) && TREE_CODE (typ
) == ENUMERAL_TYPE
)
3137 pp_string (cxx_pp
, M_(" {enum}"));
3139 return pp_ggc_formatted_text (cxx_pp
);
3143 assop_to_string (enum tree_code p
)
3145 tree id
= assignment_operator_name_info
[(int) p
].identifier
;
3146 return id
? IDENTIFIER_POINTER (id
) : M_("{unknown}");
3150 args_to_string (tree p
, int verbose
)
3154 flags
|= TFF_CLASS_KEY_OR_ENUM
;
3159 if (TYPE_P (TREE_VALUE (p
)))
3160 return type_as_string_translate (p
, flags
);
3163 for (; p
; p
= TREE_CHAIN (p
))
3165 if (TREE_VALUE (p
) == null_node
)
3166 pp_cxx_ws_string (cxx_pp
, "NULL");
3168 dump_type (cxx_pp
, error_type (TREE_VALUE (p
)), flags
);
3170 pp_separate_with_comma (cxx_pp
);
3172 return pp_ggc_formatted_text (cxx_pp
);
3175 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3176 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3180 subst_to_string (tree p
)
3182 tree decl
= TREE_PURPOSE (p
);
3183 tree targs
= TREE_VALUE (p
);
3184 tree tparms
= DECL_TEMPLATE_PARMS (decl
);
3185 int flags
= (TFF_DECL_SPECIFIERS
|TFF_TEMPLATE_HEADER
3186 |TFF_NO_TEMPLATE_BINDINGS
);
3192 dump_template_decl (cxx_pp
, TREE_PURPOSE (p
), flags
);
3193 dump_substitution (cxx_pp
, NULL
, tparms
, targs
, /*flags=*/0);
3194 return pp_ggc_formatted_text (cxx_pp
);
3198 cv_to_string (tree p
, int v
)
3201 cxx_pp
->padding
= v
? pp_before
: pp_none
;
3202 pp_cxx_cv_qualifier_seq (cxx_pp
, p
);
3203 return pp_ggc_formatted_text (cxx_pp
);
3207 eh_spec_to_string (tree p
, int /*v*/)
3211 dump_exception_spec (cxx_pp
, p
, flags
);
3212 return pp_ggc_formatted_text (cxx_pp
);
3215 /* Langhook for print_error_function. */
3217 cxx_print_error_function (diagnostic_context
*context
, const char *file
,
3218 diagnostic_info
*diagnostic
)
3220 lhd_print_error_function (context
, file
, diagnostic
);
3221 pp_set_prefix (context
->printer
, file
);
3222 maybe_print_instantiation_context (context
);
3226 cp_diagnostic_starter (diagnostic_context
*context
,
3227 diagnostic_info
*diagnostic
)
3229 diagnostic_report_current_module (context
, diagnostic_location (diagnostic
));
3230 cp_print_error_function (context
, diagnostic
);
3231 maybe_print_instantiation_context (context
);
3232 maybe_print_constexpr_context (context
);
3233 pp_set_prefix (context
->printer
, diagnostic_build_prefix (context
,
3237 /* Print current function onto BUFFER, in the process of reporting
3238 a diagnostic message. Called from cp_diagnostic_starter. */
3240 cp_print_error_function (diagnostic_context
*context
,
3241 diagnostic_info
*diagnostic
)
3243 /* If we are in an instantiation context, current_function_decl is likely
3244 to be wrong, so just rely on print_instantiation_full_context. */
3245 if (current_instantiation ())
3247 if (diagnostic_last_function_changed (context
, diagnostic
))
3249 const char *old_prefix
= context
->printer
->prefix
;
3250 const char *file
= LOCATION_FILE (diagnostic_location (diagnostic
));
3251 tree abstract_origin
= diagnostic_abstract_origin (diagnostic
);
3252 char *new_prefix
= (file
&& abstract_origin
== NULL
)
3253 ? file_name_as_prefix (context
, file
) : NULL
;
3255 pp_set_prefix (context
->printer
, new_prefix
);
3257 if (current_function_decl
== NULL
)
3258 pp_string (context
->printer
, _("At global scope:"));
3263 if (abstract_origin
)
3265 ao
= BLOCK_ABSTRACT_ORIGIN (abstract_origin
);
3266 while (TREE_CODE (ao
) == BLOCK
3267 && BLOCK_ABSTRACT_ORIGIN (ao
)
3268 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3269 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3270 gcc_assert (TREE_CODE (ao
) == FUNCTION_DECL
);
3274 fndecl
= current_function_decl
;
3276 pp_printf (context
->printer
, function_category (fndecl
),
3277 cxx_printable_name_translate (fndecl
, 2));
3279 while (abstract_origin
)
3282 tree block
= abstract_origin
;
3284 locus
= &BLOCK_SOURCE_LOCATION (block
);
3286 block
= BLOCK_SUPERCONTEXT (block
);
3287 while (block
&& TREE_CODE (block
) == BLOCK
3288 && BLOCK_ABSTRACT_ORIGIN (block
))
3290 ao
= BLOCK_ABSTRACT_ORIGIN (block
);
3292 while (TREE_CODE (ao
) == BLOCK
3293 && BLOCK_ABSTRACT_ORIGIN (ao
)
3294 && BLOCK_ABSTRACT_ORIGIN (ao
) != ao
)
3295 ao
= BLOCK_ABSTRACT_ORIGIN (ao
);
3297 if (TREE_CODE (ao
) == FUNCTION_DECL
)
3302 else if (TREE_CODE (ao
) != BLOCK
)
3305 block
= BLOCK_SUPERCONTEXT (block
);
3308 abstract_origin
= block
;
3311 while (block
&& TREE_CODE (block
) == BLOCK
)
3312 block
= BLOCK_SUPERCONTEXT (block
);
3314 if (block
&& TREE_CODE (block
) == FUNCTION_DECL
)
3316 abstract_origin
= NULL
;
3320 expanded_location s
= expand_location (*locus
);
3321 pp_character (context
->printer
, ',');
3322 pp_newline (context
->printer
);
3325 if (context
->show_column
&& s
.column
!= 0)
3326 pp_printf (context
->printer
,
3327 _(" inlined from %qs at %r%s:%d:%d%R"),
3328 cxx_printable_name_translate (fndecl
, 2),
3329 "locus", s
.file
, s
.line
, s
.column
);
3331 pp_printf (context
->printer
,
3332 _(" inlined from %qs at %r%s:%d%R"),
3333 cxx_printable_name_translate (fndecl
, 2),
3334 "locus", s
.file
, s
.line
);
3338 pp_printf (context
->printer
, _(" inlined from %qs"),
3339 cxx_printable_name_translate (fndecl
, 2));
3342 pp_character (context
->printer
, ':');
3344 pp_newline (context
->printer
);
3346 diagnostic_set_last_function (context
, diagnostic
);
3347 pp_destroy_prefix (context
->printer
);
3348 context
->printer
->prefix
= old_prefix
;
3352 /* Returns a description of FUNCTION using standard terminology. The
3353 result is a format string of the form "In CATEGORY %qs". */
3355 function_category (tree fn
)
3357 /* We can get called from the middle-end for diagnostics of function
3358 clones. Make sure we have language specific information before
3359 dereferencing it. */
3360 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn
))
3361 && DECL_FUNCTION_MEMBER_P (fn
))
3363 if (DECL_STATIC_FUNCTION_P (fn
))
3364 return _("In static member function %qs");
3365 else if (DECL_COPY_CONSTRUCTOR_P (fn
))
3366 return _("In copy constructor %qs");
3367 else if (DECL_CONSTRUCTOR_P (fn
))
3368 return _("In constructor %qs");
3369 else if (DECL_DESTRUCTOR_P (fn
))
3370 return _("In destructor %qs");
3371 else if (LAMBDA_FUNCTION_P (fn
))
3372 return _("In lambda function");
3374 return _("In member function %qs");
3377 return _("In function %qs");
3380 /* Report the full context of a current template instantiation,
3383 print_instantiation_full_context (diagnostic_context
*context
)
3385 struct tinst_level
*p
= current_instantiation ();
3386 location_t location
= input_location
;
3390 pp_verbatim (context
->printer
,
3391 TREE_CODE (p
->decl
) == TREE_LIST
3392 ? _("%s: In substitution of %qS:\n")
3393 : _("%s: In instantiation of %q#D:\n"),
3394 LOCATION_FILE (location
),
3397 location
= p
->locus
;
3401 print_instantiation_partial_context (context
, p
, location
);
3404 /* Helper function of print_instantiation_partial_context() that
3405 prints a single line of instantiation context. */
3408 print_instantiation_partial_context_line (diagnostic_context
*context
,
3409 const struct tinst_level
*t
,
3410 location_t loc
, bool recursive_p
)
3412 if (loc
== UNKNOWN_LOCATION
)
3415 expanded_location xloc
= expand_location (loc
);
3417 if (context
->show_column
)
3418 pp_verbatim (context
->printer
, _("%r%s:%d:%d:%R "),
3419 "locus", xloc
.file
, xloc
.line
, xloc
.column
);
3421 pp_verbatim (context
->printer
, _("%r%s:%d:%R "),
3422 "locus", xloc
.file
, xloc
.line
);
3426 if (TREE_CODE (t
->decl
) == TREE_LIST
)
3427 pp_verbatim (context
->printer
,
3429 ? _("recursively required by substitution of %qS\n")
3430 : _("required by substitution of %qS\n"),
3433 pp_verbatim (context
->printer
,
3435 ? _("recursively required from %q#D\n")
3436 : _("required from %q#D\n"),
3441 pp_verbatim (context
->printer
,
3443 ? _("recursively required from here\n")
3444 : _("required from here\n"));
3448 /* Same as print_instantiation_full_context but less verbose. */
3451 print_instantiation_partial_context (diagnostic_context
*context
,
3452 struct tinst_level
*t0
, location_t loc
)
3454 struct tinst_level
*t
;
3457 location_t prev_loc
= loc
;
3459 for (t
= t0
; t
!= NULL
; t
= t
->next
)
3460 if (prev_loc
!= t
->locus
)
3462 prev_loc
= t
->locus
;
3468 if (template_backtrace_limit
3469 && n_total
> template_backtrace_limit
)
3471 int skip
= n_total
- template_backtrace_limit
;
3472 int head
= template_backtrace_limit
/ 2;
3474 /* Avoid skipping just 1. If so, skip 2. */
3478 head
= (template_backtrace_limit
- 1) / 2;
3481 for (n
= 0; n
< head
; n
++)
3483 gcc_assert (t
!= NULL
);
3484 if (loc
!= t
->locus
)
3485 print_instantiation_partial_context_line (context
, t
, loc
,
3486 /*recursive_p=*/false);
3490 if (t
!= NULL
&& skip
> 0)
3492 expanded_location xloc
;
3493 xloc
= expand_location (loc
);
3494 if (context
->show_column
)
3495 pp_verbatim (context
->printer
,
3496 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3497 "contexts, use -ftemplate-backtrace-limit=0 to "
3499 "locus", xloc
.file
, xloc
.line
, xloc
.column
, skip
);
3501 pp_verbatim (context
->printer
,
3502 _("%r%s:%d:%R [ skipping %d instantiation "
3503 "contexts, use -ftemplate-backtrace-limit=0 to "
3505 "locus", xloc
.file
, xloc
.line
, skip
);
3510 } while (t
!= NULL
&& --skip
> 0);
3516 while (t
->next
!= NULL
&& t
->locus
== t
->next
->locus
)
3521 print_instantiation_partial_context_line (context
, t
, loc
,
3526 print_instantiation_partial_context_line (context
, NULL
, loc
,
3527 /*recursive_p=*/false);
3530 /* Called from cp_thing to print the template context for an error. */
3532 maybe_print_instantiation_context (diagnostic_context
*context
)
3534 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3537 record_last_problematic_instantiation ();
3538 print_instantiation_full_context (context
);
3541 /* Report what constexpr call(s) we're trying to expand, if any. */
3544 maybe_print_constexpr_context (diagnostic_context
*context
)
3546 vec
<tree
> call_stack
= cx_error_context ();
3550 FOR_EACH_VEC_ELT (call_stack
, ix
, t
)
3552 expanded_location xloc
= expand_location (EXPR_LOCATION (t
));
3553 const char *s
= expr_as_string (t
, 0);
3554 if (context
->show_column
)
3555 pp_verbatim (context
->printer
,
3556 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3557 "locus", xloc
.file
, xloc
.line
, xloc
.column
, s
);
3559 pp_verbatim (context
->printer
,
3560 _("%r%s:%d:%R in constexpr expansion of %qs"),
3561 "locus", xloc
.file
, xloc
.line
, s
);
3562 pp_newline (context
->printer
);
3566 /* Called from output_format -- during diagnostic message processing --
3567 to handle C++ specific format specifier with the following meanings:
3568 %A function argument-list.
3572 %F function declaration.
3573 %L language as used in extern "lang".
3575 %P function parameter whose position is indicated by an integer.
3576 %Q assignment operator.
3577 %S substitution (template + args)
3580 %X exception-specification. */
3582 cp_printer (pretty_printer
*pp
, text_info
*text
, const char *spec
,
3583 int precision
, bool wide
, bool set_locus
, bool verbose
)
3587 #define next_tree (t = va_arg (*text->args_ptr, tree))
3588 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3589 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3590 #define next_int va_arg (*text->args_ptr, int)
3592 if (precision
!= 0 || wide
)
3597 case 'A': result
= args_to_string (next_tree
, verbose
); break;
3598 case 'C': result
= code_to_string (next_tcode
); break;
3601 tree temp
= next_tree
;
3603 && DECL_HAS_DEBUG_EXPR_P (temp
))
3605 temp
= DECL_DEBUG_EXPR (temp
);
3608 result
= expr_to_string (temp
);
3612 result
= decl_to_string (temp
, verbose
);
3615 case 'E': result
= expr_to_string (next_tree
); break;
3616 case 'F': result
= fndecl_to_string (next_tree
, verbose
); break;
3617 case 'L': result
= language_to_string (next_lang
); break;
3618 case 'O': result
= op_to_string (next_tcode
); break;
3619 case 'P': result
= parm_to_string (next_int
); break;
3620 case 'Q': result
= assop_to_string (next_tcode
); break;
3621 case 'S': result
= subst_to_string (next_tree
); break;
3622 case 'T': result
= type_to_string (next_tree
, verbose
); break;
3623 case 'V': result
= cv_to_string (next_tree
, verbose
); break;
3624 case 'X': result
= eh_spec_to_string (next_tree
, verbose
); break;
3627 percent_K_format (text
);
3634 pp_string (pp
, result
);
3635 if (set_locus
&& t
!= NULL
)
3636 text
->set_location (0, location_of (t
), true);
3644 /* Warn about the use of C++0x features when appropriate. */
3646 maybe_warn_cpp0x (cpp0x_warn_str str
)
3648 if ((cxx_dialect
== cxx98
) && !in_system_header_at (input_location
))
3649 /* We really want to suppress this warning in system headers,
3650 because libstdc++ uses variadic templates even when we aren't
3654 case CPP0X_INITIALIZER_LISTS
:
3655 pedwarn (input_location
, 0,
3656 "extended initializer lists "
3657 "only available with -std=c++11 or -std=gnu++11");
3659 case CPP0X_EXPLICIT_CONVERSION
:
3660 pedwarn (input_location
, 0,
3661 "explicit conversion operators "
3662 "only available with -std=c++11 or -std=gnu++11");
3664 case CPP0X_VARIADIC_TEMPLATES
:
3665 pedwarn (input_location
, 0,
3666 "variadic templates "
3667 "only available with -std=c++11 or -std=gnu++11");
3669 case CPP0X_LAMBDA_EXPR
:
3670 pedwarn (input_location
, 0,
3671 "lambda expressions "
3672 "only available with -std=c++11 or -std=gnu++11");
3675 pedwarn (input_location
, 0,
3676 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3678 case CPP0X_SCOPED_ENUMS
:
3679 pedwarn (input_location
, 0,
3680 "scoped enums only available with -std=c++11 or -std=gnu++11");
3682 case CPP0X_DEFAULTED_DELETED
:
3683 pedwarn (input_location
, 0,
3684 "defaulted and deleted functions "
3685 "only available with -std=c++11 or -std=gnu++11");
3687 case CPP0X_INLINE_NAMESPACES
:
3688 pedwarn (input_location
, OPT_Wpedantic
,
3689 "inline namespaces "
3690 "only available with -std=c++11 or -std=gnu++11");
3692 case CPP0X_OVERRIDE_CONTROLS
:
3693 pedwarn (input_location
, 0,
3694 "override controls (override/final) "
3695 "only available with -std=c++11 or -std=gnu++11");
3698 pedwarn (input_location
, 0,
3699 "non-static data member initializers "
3700 "only available with -std=c++11 or -std=gnu++11");
3702 case CPP0X_USER_DEFINED_LITERALS
:
3703 pedwarn (input_location
, 0,
3704 "user-defined literals "
3705 "only available with -std=c++11 or -std=gnu++11");
3707 case CPP0X_DELEGATING_CTORS
:
3708 pedwarn (input_location
, 0,
3709 "delegating constructors "
3710 "only available with -std=c++11 or -std=gnu++11");
3712 case CPP0X_INHERITING_CTORS
:
3713 pedwarn (input_location
, 0,
3714 "inheriting constructors "
3715 "only available with -std=c++11 or -std=gnu++11");
3717 case CPP0X_ATTRIBUTES
:
3718 pedwarn (input_location
, 0,
3720 "only available with -std=c++11 or -std=gnu++11");
3722 case CPP0X_REF_QUALIFIER
:
3723 pedwarn (input_location
, 0,
3725 "only available with -std=c++11 or -std=gnu++11");
3732 /* Warn about the use of variadic templates when appropriate. */
3734 maybe_warn_variadic_templates (void)
3736 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES
);
3740 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3741 option OPT with text GMSGID. Use this function to report
3742 diagnostics for constructs that are invalid C++98, but valid
3745 pedwarn_cxx98 (location_t location
, int opt
, const char *gmsgid
, ...)
3747 diagnostic_info diagnostic
;
3750 rich_location
richloc (line_table
, location
);
3752 va_start (ap
, gmsgid
);
3753 diagnostic_set_info (&diagnostic
, gmsgid
, &ap
, &richloc
,
3754 (cxx_dialect
== cxx98
) ? DK_PEDWARN
: DK_WARNING
);
3755 diagnostic
.option_index
= opt
;
3756 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
3761 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3762 we found when we tried to do the lookup. LOCATION is the location of
3763 the NAME identifier. */
3766 qualified_name_lookup_error (tree scope
, tree name
,
3767 tree decl
, location_t location
)
3769 if (scope
== error_mark_node
)
3770 ; /* We already complained. */
3771 else if (TYPE_P (scope
))
3773 if (!COMPLETE_TYPE_P (scope
))
3774 error_at (location
, "incomplete type %qT used in nested name specifier",
3776 else if (TREE_CODE (decl
) == TREE_LIST
)
3778 error_at (location
, "reference to %<%T::%D%> is ambiguous",
3780 print_candidates (decl
);
3783 error_at (location
, "%qD is not a member of %qT", name
, scope
);
3785 else if (scope
!= global_namespace
)
3787 error_at (location
, "%qD is not a member of %qD", name
, scope
);
3788 if (!suggest_alternative_in_explicit_scope (location
, name
, scope
))
3789 suggest_alternatives_for (location
, name
, false);
3793 error_at (location
, "%<::%D%> has not been declared", name
);
3794 suggest_alternatives_for (location
, name
, true);