Add DW_CFA_AARCH64_negate_ra_state to dwarf2.def/h and dwarfnames.c
[official-gcc.git] / gcc / cp / error.c
blobe4071547091ecaa93bc963c681f15f458155a6b1
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)
9 any later version.
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/>. */
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "cp-tree.h"
24 #include "stringpool.h"
25 #include "tree-diagnostic.h"
26 #include "langhooks-def.h"
27 #include "intl.h"
28 #include "cxx-pretty-print.h"
29 #include "tree-pretty-print.h"
30 #include "gimple-pretty-print.h"
31 #include "c-family/c-objc.h"
32 #include "ubsan.h"
33 #include "internal-fn.h"
35 #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
36 #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
38 /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
39 dump C++ ASTs as strings. It is mostly used only by the various
40 tree -> string functions that are occasionally called from the
41 debugger or by the front-end for things like
42 __PRETTY_FUNCTION__. */
43 static cxx_pretty_printer actual_pretty_printer;
44 static cxx_pretty_printer * const cxx_pp = &actual_pretty_printer;
46 /* Translate if being used for diagnostics, but not for dump files or
47 __PRETTY_FUNCTION. */
48 #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
50 # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
52 static const char *args_to_string (tree, int);
53 static const char *assop_to_string (enum tree_code);
54 static const char *code_to_string (enum tree_code);
55 static const char *cv_to_string (tree, int);
56 static const char *decl_to_string (tree, int);
57 static const char *expr_to_string (tree);
58 static const char *fndecl_to_string (tree, int);
59 static const char *op_to_string (enum tree_code);
60 static const char *parm_to_string (int);
61 static const char *type_to_string (tree, int);
63 static void dump_alias_template_specialization (cxx_pretty_printer *, tree, int);
64 static void dump_type (cxx_pretty_printer *, tree, int);
65 static void dump_typename (cxx_pretty_printer *, tree, int);
66 static void dump_simple_decl (cxx_pretty_printer *, tree, tree, int);
67 static void dump_decl (cxx_pretty_printer *, tree, int);
68 static void dump_template_decl (cxx_pretty_printer *, tree, int);
69 static void dump_function_decl (cxx_pretty_printer *, tree, int);
70 static void dump_expr (cxx_pretty_printer *, tree, int);
71 static void dump_unary_op (cxx_pretty_printer *, const char *, tree, int);
72 static void dump_binary_op (cxx_pretty_printer *, const char *, tree, int);
73 static void dump_aggr_type (cxx_pretty_printer *, tree, int);
74 static void dump_type_prefix (cxx_pretty_printer *, tree, int);
75 static void dump_type_suffix (cxx_pretty_printer *, tree, int);
76 static void dump_function_name (cxx_pretty_printer *, tree, int);
77 static void dump_call_expr_args (cxx_pretty_printer *, tree, int, bool);
78 static void dump_aggr_init_expr_args (cxx_pretty_printer *, tree, int, bool);
79 static void dump_expr_list (cxx_pretty_printer *, tree, int);
80 static void dump_global_iord (cxx_pretty_printer *, tree);
81 static void dump_parameters (cxx_pretty_printer *, tree, int);
82 static void dump_ref_qualifier (cxx_pretty_printer *, tree, int);
83 static void dump_exception_spec (cxx_pretty_printer *, tree, int);
84 static void dump_template_argument (cxx_pretty_printer *, tree, int);
85 static void dump_template_argument_list (cxx_pretty_printer *, tree, int);
86 static void dump_template_parameter (cxx_pretty_printer *, tree, int);
87 static void dump_template_bindings (cxx_pretty_printer *, tree, tree,
88 vec<tree, va_gc> *);
89 static void dump_scope (cxx_pretty_printer *, tree, int);
90 static void dump_template_parms (cxx_pretty_printer *, tree, int, int);
91 static int get_non_default_template_args_count (tree, int);
92 static const char *function_category (tree);
93 static void maybe_print_constexpr_context (diagnostic_context *);
94 static void maybe_print_instantiation_context (diagnostic_context *);
95 static void print_instantiation_full_context (diagnostic_context *);
96 static void print_instantiation_partial_context (diagnostic_context *,
97 struct tinst_level *,
98 location_t);
99 static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
100 static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
102 static bool cp_printer (pretty_printer *, text_info *, const char *,
103 int, bool, bool, bool, bool, const char **);
105 /* Struct for handling %H or %I, which require delaying printing the
106 type until a postprocessing stage. */
108 struct deferred_printed_type
110 deferred_printed_type ()
111 : m_tree (NULL_TREE), m_buffer_ptr (NULL), m_verbose (false), m_quote (false)
114 deferred_printed_type (tree type, const char **buffer_ptr, bool verbose,
115 bool quote)
116 : m_tree (type), m_buffer_ptr (buffer_ptr), m_verbose (verbose),
117 m_quote (quote)
119 gcc_assert (type);
120 gcc_assert (buffer_ptr);
123 /* The tree is not GTY-marked: they are only non-NULL within a
124 call to pp_format. */
125 tree m_tree;
126 const char **m_buffer_ptr;
127 bool m_verbose;
128 bool m_quote;
131 /* Subclass of format_postprocessor for the C++ frontend.
132 This handles the %H and %I formatting codes, printing them
133 in a postprocessing phase (since they affect each other). */
135 class cxx_format_postprocessor : public format_postprocessor
137 public:
138 cxx_format_postprocessor ()
139 : m_type_a (), m_type_b ()
142 void handle (pretty_printer *pp) FINAL OVERRIDE;
144 deferred_printed_type m_type_a;
145 deferred_printed_type m_type_b;
148 /* CONTEXT->printer is a basic pretty printer that was constructed
149 presumably by diagnostic_initialize(), called early in the
150 compiler's initialization process (in general_init) Before the FE
151 is initialized. This (C++) FE-specific diagnostic initializer is
152 thus replacing the basic pretty printer with one that has C++-aware
153 capacities. */
155 void
156 cxx_initialize_diagnostics (diagnostic_context *context)
158 pretty_printer *base = context->printer;
159 cxx_pretty_printer *pp = XNEW (cxx_pretty_printer);
160 context->printer = new (pp) cxx_pretty_printer ();
162 /* It is safe to free this object because it was previously XNEW()'d. */
163 base->~pretty_printer ();
164 XDELETE (base);
166 c_common_diagnostics_set_defaults (context);
167 diagnostic_starter (context) = cp_diagnostic_starter;
168 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
169 diagnostic_format_decoder (context) = cp_printer;
170 pp->m_format_postprocessor = new cxx_format_postprocessor ();
173 /* Dump a scope, if deemed necessary. */
175 static void
176 dump_scope (cxx_pretty_printer *pp, tree scope, int flags)
178 int f = flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF);
180 if (scope == NULL_TREE)
181 return;
183 if (TREE_CODE (scope) == NAMESPACE_DECL)
185 if (scope != global_namespace)
187 dump_decl (pp, scope, f);
188 pp_cxx_colon_colon (pp);
191 else if (AGGREGATE_TYPE_P (scope))
193 dump_type (pp, scope, f);
194 pp_cxx_colon_colon (pp);
196 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
198 dump_function_decl (pp, scope, f);
199 pp_cxx_colon_colon (pp);
203 /* Dump the template ARGument under control of FLAGS. */
205 static void
206 dump_template_argument (cxx_pretty_printer *pp, tree arg, int flags)
208 if (ARGUMENT_PACK_P (arg))
209 dump_template_argument_list (pp, ARGUMENT_PACK_ARGS (arg),
210 /* No default args in argument packs. */
211 flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
212 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
213 dump_type (pp, arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
214 else
216 if (TREE_CODE (arg) == TREE_LIST)
217 arg = TREE_VALUE (arg);
219 /* Strip implicit conversions. */
220 while (CONVERT_EXPR_P (arg))
221 arg = TREE_OPERAND (arg, 0);
223 dump_expr (pp, arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
227 /* Count the number of template arguments ARGS whose value does not
228 match the (optional) default template parameter in PARAMS */
230 static int
231 get_non_default_template_args_count (tree args, int flags)
233 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
235 if (/* We use this flag when generating debug information. We don't
236 want to expand templates at this point, for this may generate
237 new decls, which gets decl counts out of sync, which may in
238 turn cause codegen differences between compilations with and
239 without -g. */
240 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
241 || !flag_pretty_templates)
242 return n;
244 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
247 /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
248 of FLAGS. */
250 static void
251 dump_template_argument_list (cxx_pretty_printer *pp, tree args, int flags)
253 int n = get_non_default_template_args_count (args, flags);
254 int need_comma = 0;
255 int i;
257 for (i = 0; i < n; ++i)
259 tree arg = TREE_VEC_ELT (args, i);
261 /* Only print a comma if we know there is an argument coming. In
262 the case of an empty template argument pack, no actual
263 argument will be printed. */
264 if (need_comma
265 && (!ARGUMENT_PACK_P (arg)
266 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
267 pp_separate_with_comma (pp);
269 dump_template_argument (pp, arg, flags);
270 need_comma = 1;
274 /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
276 static void
277 dump_template_parameter (cxx_pretty_printer *pp, tree parm, int flags)
279 tree p;
280 tree a;
282 if (parm == error_mark_node)
283 return;
285 p = TREE_VALUE (parm);
286 a = TREE_PURPOSE (parm);
288 if (TREE_CODE (p) == TYPE_DECL)
290 if (flags & TFF_DECL_SPECIFIERS)
292 pp_cxx_ws_string (pp, "class");
293 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
294 pp_cxx_ws_string (pp, "...");
295 if (DECL_NAME (p))
296 pp_cxx_tree_identifier (pp, DECL_NAME (p));
298 else if (DECL_NAME (p))
299 pp_cxx_tree_identifier (pp, DECL_NAME (p));
300 else
301 pp_cxx_canonical_template_parameter (pp, TREE_TYPE (p));
303 else
304 dump_decl (pp, p, flags | TFF_DECL_SPECIFIERS);
306 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
308 pp_cxx_whitespace (pp);
309 pp_equal (pp);
310 pp_cxx_whitespace (pp);
311 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
312 dump_type (pp, a, flags & ~TFF_CHASE_TYPEDEF);
313 else
314 dump_expr (pp, a, flags | TFF_EXPR_IN_PARENS);
318 /* Dump, under control of FLAGS, a template-parameter-list binding.
319 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
320 TREE_VEC. */
322 static void
323 dump_template_bindings (cxx_pretty_printer *pp, tree parms, tree args,
324 vec<tree, va_gc> *typenames)
326 bool need_semicolon = false;
327 int i;
328 tree t;
330 while (parms)
332 tree p = TREE_VALUE (parms);
333 int lvl = TMPL_PARMS_DEPTH (parms);
334 int arg_idx = 0;
335 int i;
336 tree lvl_args = NULL_TREE;
338 /* Don't crash if we had an invalid argument list. */
339 if (TMPL_ARGS_DEPTH (args) >= lvl)
340 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
342 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
344 tree arg = NULL_TREE;
346 /* Don't crash if we had an invalid argument list. */
347 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
348 arg = TREE_VEC_ELT (lvl_args, arg_idx);
350 if (need_semicolon)
351 pp_separate_with_semicolon (pp);
352 dump_template_parameter (pp, TREE_VEC_ELT (p, i),
353 TFF_PLAIN_IDENTIFIER);
354 pp_cxx_whitespace (pp);
355 pp_equal (pp);
356 pp_cxx_whitespace (pp);
357 if (arg)
359 if (ARGUMENT_PACK_P (arg))
360 pp_cxx_left_brace (pp);
361 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
362 if (ARGUMENT_PACK_P (arg))
363 pp_cxx_right_brace (pp);
365 else
366 pp_string (pp, M_("<missing>"));
368 ++arg_idx;
369 need_semicolon = true;
372 parms = TREE_CHAIN (parms);
375 /* Don't bother with typenames for a partial instantiation. */
376 if (vec_safe_is_empty (typenames) || uses_template_parms (args))
377 return;
379 /* Don't try to print typenames when we're processing a clone. */
380 if (current_function_decl
381 && !DECL_LANG_SPECIFIC (current_function_decl))
382 return;
384 /* Don't try to do this once cgraph starts throwing away front-end
385 information. */
386 if (at_eof >= 2)
387 return;
389 FOR_EACH_VEC_SAFE_ELT (typenames, i, t)
391 if (need_semicolon)
392 pp_separate_with_semicolon (pp);
393 dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
394 pp_cxx_whitespace (pp);
395 pp_equal (pp);
396 pp_cxx_whitespace (pp);
397 push_deferring_access_checks (dk_no_check);
398 t = tsubst (t, args, tf_none, NULL_TREE);
399 pop_deferring_access_checks ();
400 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
401 pp_simple_type_specifier doesn't know about it. */
402 t = strip_typedefs (t);
403 dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
407 /* Dump a human-readable equivalent of the alias template
408 specialization of T. */
410 static void
411 dump_alias_template_specialization (cxx_pretty_printer *pp, tree t, int flags)
413 gcc_assert (alias_template_specialization_p (t));
415 tree decl = TYPE_NAME (t);
416 if (!(flags & TFF_UNQUALIFIED_NAME))
417 dump_scope (pp, CP_DECL_CONTEXT (decl), flags);
418 pp_cxx_tree_identifier (pp, DECL_NAME (decl));
419 dump_template_parms (pp, DECL_TEMPLATE_INFO (decl),
420 /*primary=*/false,
421 flags & ~TFF_TEMPLATE_HEADER);
424 /* Dump a human-readable equivalent of TYPE. FLAGS controls the
425 format. */
427 static void
428 dump_type (cxx_pretty_printer *pp, tree t, int flags)
430 if (t == NULL_TREE)
431 return;
433 /* Don't print e.g. "struct mytypedef". */
434 if (TYPE_P (t) && typedef_variant_p (t))
436 tree decl = TYPE_NAME (t);
437 if ((flags & TFF_CHASE_TYPEDEF)
438 || DECL_SELF_REFERENCE_P (decl)
439 || (!flag_pretty_templates
440 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)))
441 t = strip_typedefs (t);
442 else if (alias_template_specialization_p (t))
444 dump_alias_template_specialization (pp, t, flags);
445 return;
447 else if (same_type_p (t, TREE_TYPE (decl)))
448 t = decl;
449 else
451 pp_cxx_cv_qualifier_seq (pp, t);
452 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
453 return;
457 if (TYPE_PTRMEMFUNC_P (t))
458 goto offset_type;
460 switch (TREE_CODE (t))
462 case LANG_TYPE:
463 if (t == init_list_type_node)
464 pp_string (pp, M_("<brace-enclosed initializer list>"));
465 else if (t == unknown_type_node)
466 pp_string (pp, M_("<unresolved overloaded function type>"));
467 else
469 pp_cxx_cv_qualifier_seq (pp, t);
470 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
472 break;
474 case TREE_LIST:
475 /* A list of function parms. */
476 dump_parameters (pp, t, flags);
477 break;
479 case IDENTIFIER_NODE:
480 pp_cxx_tree_identifier (pp, t);
481 break;
483 case TREE_BINFO:
484 dump_type (pp, BINFO_TYPE (t), flags);
485 break;
487 case RECORD_TYPE:
488 case UNION_TYPE:
489 case ENUMERAL_TYPE:
490 dump_aggr_type (pp, t, flags);
491 break;
493 case TYPE_DECL:
494 if (flags & TFF_CHASE_TYPEDEF)
496 dump_type (pp, DECL_ORIGINAL_TYPE (t)
497 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
498 break;
500 /* Fall through. */
502 case TEMPLATE_DECL:
503 case NAMESPACE_DECL:
504 dump_decl (pp, t, flags & ~TFF_DECL_SPECIFIERS);
505 break;
507 case INTEGER_TYPE:
508 case REAL_TYPE:
509 case VOID_TYPE:
510 case BOOLEAN_TYPE:
511 case COMPLEX_TYPE:
512 case VECTOR_TYPE:
513 case FIXED_POINT_TYPE:
514 pp_type_specifier_seq (pp, t);
515 break;
517 case TEMPLATE_TEMPLATE_PARM:
518 /* For parameters inside template signature. */
519 if (TYPE_IDENTIFIER (t))
520 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
521 else
522 pp_cxx_canonical_template_parameter (pp, t);
523 break;
525 case BOUND_TEMPLATE_TEMPLATE_PARM:
527 tree args = TYPE_TI_ARGS (t);
528 pp_cxx_cv_qualifier_seq (pp, t);
529 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
530 pp_cxx_begin_template_argument_list (pp);
531 dump_template_argument_list (pp, args, flags);
532 pp_cxx_end_template_argument_list (pp);
534 break;
536 case TEMPLATE_TYPE_PARM:
537 pp_cxx_cv_qualifier_seq (pp, t);
538 if (tree c = PLACEHOLDER_TYPE_CONSTRAINTS (t))
539 pp_cxx_constrained_type_spec (pp, c);
540 else if (TYPE_IDENTIFIER (t))
541 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
542 else
543 pp_cxx_canonical_template_parameter
544 (pp, TEMPLATE_TYPE_PARM_INDEX (t));
545 break;
547 /* This is not always necessary for pointers and such, but doing this
548 reduces code size. */
549 case ARRAY_TYPE:
550 case POINTER_TYPE:
551 case REFERENCE_TYPE:
552 case OFFSET_TYPE:
553 offset_type:
554 case FUNCTION_TYPE:
555 case METHOD_TYPE:
557 dump_type_prefix (pp, t, flags);
558 dump_type_suffix (pp, t, flags);
559 break;
561 case TYPENAME_TYPE:
562 if (! (flags & TFF_CHASE_TYPEDEF)
563 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
565 dump_decl (pp, TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
566 break;
568 pp_cxx_cv_qualifier_seq (pp, t);
569 pp_cxx_ws_string (pp,
570 TYPENAME_IS_ENUM_P (t) ? "enum"
571 : TYPENAME_IS_CLASS_P (t) ? "class"
572 : "typename");
573 dump_typename (pp, t, flags);
574 break;
576 case UNBOUND_CLASS_TEMPLATE:
577 if (! (flags & TFF_UNQUALIFIED_NAME))
579 dump_type (pp, TYPE_CONTEXT (t), flags);
580 pp_cxx_colon_colon (pp);
582 pp_cxx_ws_string (pp, "template");
583 dump_type (pp, TYPE_IDENTIFIER (t), flags);
584 break;
586 case TYPEOF_TYPE:
587 pp_cxx_ws_string (pp, "__typeof__");
588 pp_cxx_whitespace (pp);
589 pp_cxx_left_paren (pp);
590 dump_expr (pp, TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
591 pp_cxx_right_paren (pp);
592 break;
594 case UNDERLYING_TYPE:
595 pp_cxx_ws_string (pp, "__underlying_type");
596 pp_cxx_whitespace (pp);
597 pp_cxx_left_paren (pp);
598 dump_expr (pp, UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
599 pp_cxx_right_paren (pp);
600 break;
602 case TYPE_PACK_EXPANSION:
603 dump_type (pp, PACK_EXPANSION_PATTERN (t), flags);
604 pp_cxx_ws_string (pp, "...");
605 break;
607 case TYPE_ARGUMENT_PACK:
608 dump_template_argument (pp, t, flags);
609 break;
611 case DECLTYPE_TYPE:
612 pp_cxx_ws_string (pp, "decltype");
613 pp_cxx_whitespace (pp);
614 pp_cxx_left_paren (pp);
615 dump_expr (pp, DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
616 pp_cxx_right_paren (pp);
617 break;
619 case NULLPTR_TYPE:
620 pp_string (pp, "std::nullptr_t");
621 break;
623 default:
624 pp_unsupported_tree (pp, t);
625 /* Fall through. */
627 case ERROR_MARK:
628 pp_string (pp, M_("<type error>"));
629 break;
633 /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
634 a TYPENAME_TYPE. */
636 static void
637 dump_typename (cxx_pretty_printer *pp, tree t, int flags)
639 tree ctx = TYPE_CONTEXT (t);
641 if (TREE_CODE (ctx) == TYPENAME_TYPE)
642 dump_typename (pp, ctx, flags);
643 else
644 dump_type (pp, ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
645 pp_cxx_colon_colon (pp);
646 dump_decl (pp, TYPENAME_TYPE_FULLNAME (t), flags);
649 /* Return the name of the supplied aggregate, or enumeral type. */
651 const char *
652 class_key_or_enum_as_string (tree t)
654 if (TREE_CODE (t) == ENUMERAL_TYPE)
656 if (SCOPED_ENUM_P (t))
657 return "enum class";
658 else
659 return "enum";
661 else if (TREE_CODE (t) == UNION_TYPE)
662 return "union";
663 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
664 return "class";
665 else
666 return "struct";
669 /* Print out a class declaration T under the control of FLAGS,
670 in the form `class foo'. */
672 static void
673 dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags)
675 tree name;
676 const char *variety = class_key_or_enum_as_string (t);
677 int typdef = 0;
678 int tmplate = 0;
680 pp_cxx_cv_qualifier_seq (pp, t);
682 if (flags & TFF_CLASS_KEY_OR_ENUM)
683 pp_cxx_ws_string (pp, variety);
685 name = TYPE_NAME (t);
687 if (name)
689 typdef = (!DECL_ARTIFICIAL (name)
690 /* An alias specialization is not considered to be a
691 typedef. */
692 && !alias_template_specialization_p (t));
694 if ((typdef
695 && ((flags & TFF_CHASE_TYPEDEF)
696 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
697 && DECL_TEMPLATE_INFO (name))))
698 || DECL_SELF_REFERENCE_P (name))
700 t = TYPE_MAIN_VARIANT (t);
701 name = TYPE_NAME (t);
702 typdef = 0;
705 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
706 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
707 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
708 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
710 if (! (flags & TFF_UNQUALIFIED_NAME))
711 dump_scope (pp, CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
712 flags &= ~TFF_UNQUALIFIED_NAME;
713 if (tmplate)
715 /* Because the template names are mangled, we have to locate
716 the most general template, and use that name. */
717 tree tpl = TYPE_TI_TEMPLATE (t);
719 while (DECL_TEMPLATE_INFO (tpl))
720 tpl = DECL_TI_TEMPLATE (tpl);
721 name = tpl;
723 name = DECL_NAME (name);
726 if (name == 0 || anon_aggrname_p (name))
728 if (flags & TFF_CLASS_KEY_OR_ENUM)
729 pp_string (pp, M_("<unnamed>"));
730 else
731 pp_printf (pp, M_("<unnamed %s>"), variety);
733 else if (LAMBDA_TYPE_P (t))
735 /* A lambda's "type" is essentially its signature. */
736 pp_string (pp, M_("<lambda"));
737 if (lambda_function (t))
738 dump_parameters (pp,
739 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
740 flags);
741 pp_greater (pp);
743 else
744 pp_cxx_tree_identifier (pp, name);
745 if (tmplate)
746 dump_template_parms (pp, TYPE_TEMPLATE_INFO (t),
747 !CLASSTYPE_USE_TEMPLATE (t),
748 flags & ~TFF_TEMPLATE_HEADER);
751 /* Dump into the obstack the initial part of the output for a given type.
752 This is necessary when dealing with things like functions returning
753 functions. Examples:
755 return type of `int (* fee ())()': pointer -> function -> int. Both
756 pointer (and reference and offset) and function (and member) types must
757 deal with prefix and suffix.
759 Arrays must also do this for DECL nodes, like int a[], and for things like
760 int *[]&. */
762 static void
763 dump_type_prefix (cxx_pretty_printer *pp, tree t, int flags)
765 if (TYPE_PTRMEMFUNC_P (t))
767 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
768 goto offset_type;
771 switch (TREE_CODE (t))
773 case POINTER_TYPE:
774 case REFERENCE_TYPE:
776 tree sub = TREE_TYPE (t);
778 dump_type_prefix (pp, sub, flags);
779 if (TREE_CODE (sub) == ARRAY_TYPE
780 || TREE_CODE (sub) == FUNCTION_TYPE)
782 pp_cxx_whitespace (pp);
783 pp_cxx_left_paren (pp);
784 pp_c_attributes_display (pp, TYPE_ATTRIBUTES (sub));
786 if (TYPE_PTR_P (t))
787 pp_star (pp);
788 else if (TREE_CODE (t) == REFERENCE_TYPE)
790 if (TYPE_REF_IS_RVALUE (t))
791 pp_ampersand_ampersand (pp);
792 else
793 pp_ampersand (pp);
795 pp->padding = pp_before;
796 pp_cxx_cv_qualifier_seq (pp, t);
798 break;
800 case OFFSET_TYPE:
801 offset_type:
802 dump_type_prefix (pp, TREE_TYPE (t), flags);
803 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
805 pp_maybe_space (pp);
806 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
807 pp_cxx_left_paren (pp);
808 dump_type (pp, TYPE_OFFSET_BASETYPE (t), flags);
809 pp_cxx_colon_colon (pp);
811 pp_cxx_star (pp);
812 pp_cxx_cv_qualifier_seq (pp, t);
813 pp->padding = pp_before;
814 break;
816 /* This can be reached without a pointer when dealing with
817 templates, e.g. std::is_function. */
818 case FUNCTION_TYPE:
819 dump_type_prefix (pp, TREE_TYPE (t), flags);
820 break;
822 case METHOD_TYPE:
823 dump_type_prefix (pp, TREE_TYPE (t), flags);
824 pp_maybe_space (pp);
825 pp_cxx_left_paren (pp);
826 dump_aggr_type (pp, TYPE_METHOD_BASETYPE (t), flags);
827 pp_cxx_colon_colon (pp);
828 break;
830 case ARRAY_TYPE:
831 dump_type_prefix (pp, TREE_TYPE (t), flags);
832 break;
834 case ENUMERAL_TYPE:
835 case IDENTIFIER_NODE:
836 case INTEGER_TYPE:
837 case BOOLEAN_TYPE:
838 case REAL_TYPE:
839 case RECORD_TYPE:
840 case TEMPLATE_TYPE_PARM:
841 case TEMPLATE_TEMPLATE_PARM:
842 case BOUND_TEMPLATE_TEMPLATE_PARM:
843 case TREE_LIST:
844 case TYPE_DECL:
845 case TREE_VEC:
846 case UNION_TYPE:
847 case LANG_TYPE:
848 case VOID_TYPE:
849 case TYPENAME_TYPE:
850 case COMPLEX_TYPE:
851 case VECTOR_TYPE:
852 case TYPEOF_TYPE:
853 case UNDERLYING_TYPE:
854 case DECLTYPE_TYPE:
855 case TYPE_PACK_EXPANSION:
856 case FIXED_POINT_TYPE:
857 case NULLPTR_TYPE:
858 dump_type (pp, t, flags);
859 pp->padding = pp_before;
860 break;
862 default:
863 pp_unsupported_tree (pp, t);
864 /* fall through. */
865 case ERROR_MARK:
866 pp_string (pp, M_("<typeprefixerror>"));
867 break;
871 /* Dump the suffix of type T, under control of FLAGS. This is the part
872 which appears after the identifier (or function parms). */
874 static void
875 dump_type_suffix (cxx_pretty_printer *pp, tree t, int flags)
877 if (TYPE_PTRMEMFUNC_P (t))
878 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
880 switch (TREE_CODE (t))
882 case POINTER_TYPE:
883 case REFERENCE_TYPE:
884 case OFFSET_TYPE:
885 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
886 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
887 pp_cxx_right_paren (pp);
888 if (TREE_CODE (t) == POINTER_TYPE)
889 flags |= TFF_POINTER;
890 dump_type_suffix (pp, TREE_TYPE (t), flags);
891 break;
893 case FUNCTION_TYPE:
894 case METHOD_TYPE:
896 tree arg;
897 if (TREE_CODE (t) == METHOD_TYPE)
898 /* Can only be reached through a pointer. */
899 pp_cxx_right_paren (pp);
900 arg = TYPE_ARG_TYPES (t);
901 if (TREE_CODE (t) == METHOD_TYPE)
902 arg = TREE_CHAIN (arg);
904 /* Function pointers don't have default args. Not in standard C++,
905 anyway; they may in g++, but we'll just pretend otherwise. */
906 dump_parameters (pp, arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
908 pp->padding = pp_before;
909 pp_cxx_cv_qualifiers (pp, type_memfn_quals (t),
910 TREE_CODE (t) == FUNCTION_TYPE
911 && (flags & TFF_POINTER));
912 dump_ref_qualifier (pp, t, flags);
913 if (tx_safe_fn_type_p (t))
914 pp_cxx_ws_string (pp, "transaction_safe");
915 dump_exception_spec (pp, TYPE_RAISES_EXCEPTIONS (t), flags);
916 dump_type_suffix (pp, TREE_TYPE (t), flags);
917 break;
920 case ARRAY_TYPE:
921 pp_maybe_space (pp);
922 pp_cxx_left_bracket (pp);
923 if (tree dtype = TYPE_DOMAIN (t))
925 tree max = TYPE_MAX_VALUE (dtype);
926 /* Zero-length arrays have an upper bound of SIZE_MAX. */
927 if (integer_all_onesp (max))
928 pp_character (pp, '0');
929 else if (tree_fits_shwi_p (max))
930 pp_wide_integer (pp, tree_to_shwi (max) + 1);
931 else
933 STRIP_NOPS (max);
934 if (TREE_CODE (max) == SAVE_EXPR)
935 max = TREE_OPERAND (max, 0);
936 if (TREE_CODE (max) == MINUS_EXPR
937 || TREE_CODE (max) == PLUS_EXPR)
939 max = TREE_OPERAND (max, 0);
940 while (CONVERT_EXPR_P (max))
941 max = TREE_OPERAND (max, 0);
943 else
944 max = fold_build2_loc (input_location,
945 PLUS_EXPR, dtype, max,
946 build_int_cst (dtype, 1));
947 dump_expr (pp, max, flags & ~TFF_EXPR_IN_PARENS);
950 pp_cxx_right_bracket (pp);
951 dump_type_suffix (pp, TREE_TYPE (t), flags);
952 break;
954 case ENUMERAL_TYPE:
955 case IDENTIFIER_NODE:
956 case INTEGER_TYPE:
957 case BOOLEAN_TYPE:
958 case REAL_TYPE:
959 case RECORD_TYPE:
960 case TEMPLATE_TYPE_PARM:
961 case TEMPLATE_TEMPLATE_PARM:
962 case BOUND_TEMPLATE_TEMPLATE_PARM:
963 case TREE_LIST:
964 case TYPE_DECL:
965 case TREE_VEC:
966 case UNION_TYPE:
967 case LANG_TYPE:
968 case VOID_TYPE:
969 case TYPENAME_TYPE:
970 case COMPLEX_TYPE:
971 case VECTOR_TYPE:
972 case TYPEOF_TYPE:
973 case UNDERLYING_TYPE:
974 case DECLTYPE_TYPE:
975 case TYPE_PACK_EXPANSION:
976 case FIXED_POINT_TYPE:
977 case NULLPTR_TYPE:
978 break;
980 default:
981 pp_unsupported_tree (pp, t);
982 case ERROR_MARK:
983 /* Don't mark it here, we should have already done in
984 dump_type_prefix. */
985 break;
989 static void
990 dump_global_iord (cxx_pretty_printer *pp, tree t)
992 const char *p = NULL;
994 if (DECL_GLOBAL_CTOR_P (t))
995 p = M_("(static initializers for %s)");
996 else if (DECL_GLOBAL_DTOR_P (t))
997 p = M_("(static destructors for %s)");
998 else
999 gcc_unreachable ();
1001 pp_printf (pp, p, DECL_SOURCE_FILE (t));
1004 static void
1005 dump_simple_decl (cxx_pretty_printer *pp, tree t, tree type, int flags)
1007 if (flags & TFF_DECL_SPECIFIERS)
1009 if (VAR_P (t) && DECL_DECLARED_CONSTEXPR_P (t))
1011 if (DECL_LANG_SPECIFIC (t) && DECL_DECLARED_CONCEPT_P (t))
1012 pp_cxx_ws_string (pp, "concept");
1013 else
1014 pp_cxx_ws_string (pp, "constexpr");
1016 dump_type_prefix (pp, type, flags & ~TFF_UNQUALIFIED_NAME);
1017 pp_maybe_space (pp);
1019 if (! (flags & TFF_UNQUALIFIED_NAME)
1020 && TREE_CODE (t) != PARM_DECL
1021 && (!DECL_INITIAL (t)
1022 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
1023 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1024 flags &= ~TFF_UNQUALIFIED_NAME;
1025 if ((flags & TFF_DECL_SPECIFIERS)
1026 && DECL_TEMPLATE_PARM_P (t)
1027 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
1028 pp_string (pp, "...");
1029 if (DECL_NAME (t))
1031 if (TREE_CODE (t) == FIELD_DECL && DECL_NORMAL_CAPTURE_P (t))
1033 pp_less (pp);
1034 pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t)) + 2);
1035 pp_string (pp, " capture>");
1037 else
1038 dump_decl (pp, DECL_NAME (t), flags);
1040 else if (DECL_DECOMPOSITION_P (t))
1041 pp_string (pp, M_("<structured bindings>"));
1042 else
1043 pp_string (pp, M_("<anonymous>"));
1044 if (flags & TFF_DECL_SPECIFIERS)
1045 dump_type_suffix (pp, type, flags);
1048 /* Print an IDENTIFIER_NODE that is the name of a declaration. */
1050 static void
1051 dump_decl_name (cxx_pretty_printer *pp, tree t, int flags)
1053 /* These special cases are duplicated here so that other functions
1054 can feed identifiers to error and get them demangled properly. */
1055 if (IDENTIFIER_CONV_OP_P (t))
1057 pp_cxx_ws_string (pp, "operator");
1058 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1059 dump_type (pp, TREE_TYPE (t), flags);
1060 return;
1062 if (dguide_name_p (t))
1064 dump_decl (pp, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t)),
1065 TFF_UNQUALIFIED_NAME);
1066 return;
1069 const char *str = IDENTIFIER_POINTER (t);
1070 if (!strncmp (str, "_ZGR", 3))
1072 pp_cxx_ws_string (pp, "<temporary>");
1073 return;
1076 pp_cxx_tree_identifier (pp, t);
1079 /* Dump a human readable string for the decl T under control of FLAGS. */
1081 static void
1082 dump_decl (cxx_pretty_printer *pp, tree t, int flags)
1084 if (t == NULL_TREE)
1085 return;
1087 /* If doing Objective-C++, give Objective-C a chance to demangle
1088 Objective-C method names. */
1089 if (c_dialect_objc ())
1091 const char *demangled = objc_maybe_printable_name (t, flags);
1092 if (demangled)
1094 pp_string (pp, demangled);
1095 return;
1099 switch (TREE_CODE (t))
1101 case TYPE_DECL:
1102 /* Don't say 'typedef class A' */
1103 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
1105 if ((flags & TFF_DECL_SPECIFIERS)
1106 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
1108 /* Say `class T' not just `T'. */
1109 pp_cxx_ws_string (pp, "class");
1111 /* Emit the `...' for a parameter pack. */
1112 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1113 pp_cxx_ws_string (pp, "...");
1116 dump_type (pp, TREE_TYPE (t), flags);
1117 break;
1119 if (TYPE_DECL_ALIAS_P (t)
1120 && (flags & TFF_DECL_SPECIFIERS
1121 || flags & TFF_CLASS_KEY_OR_ENUM))
1123 pp_cxx_ws_string (pp, "using");
1124 dump_decl (pp, DECL_NAME (t), flags);
1125 pp_cxx_whitespace (pp);
1126 pp_cxx_ws_string (pp, "=");
1127 pp_cxx_whitespace (pp);
1128 dump_type (pp, (DECL_ORIGINAL_TYPE (t)
1129 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t)),
1130 flags);
1131 break;
1133 if ((flags & TFF_DECL_SPECIFIERS)
1134 && !DECL_SELF_REFERENCE_P (t))
1135 pp_cxx_ws_string (pp, "typedef");
1136 dump_simple_decl (pp, t, DECL_ORIGINAL_TYPE (t)
1137 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
1138 flags);
1139 break;
1141 case VAR_DECL:
1142 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
1144 pp_string (pp, M_("vtable for "));
1145 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
1146 dump_type (pp, DECL_CONTEXT (t), flags);
1147 break;
1149 /* Fall through. */
1150 case FIELD_DECL:
1151 case PARM_DECL:
1152 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1154 /* Handle variable template specializations. */
1155 if (VAR_P (t)
1156 && DECL_LANG_SPECIFIC (t)
1157 && DECL_TEMPLATE_INFO (t)
1158 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))
1160 pp_cxx_begin_template_argument_list (pp);
1161 tree args = INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t));
1162 dump_template_argument_list (pp, args, flags);
1163 pp_cxx_end_template_argument_list (pp);
1165 break;
1167 case RESULT_DECL:
1168 pp_string (pp, M_("<return value> "));
1169 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1170 break;
1172 case NAMESPACE_DECL:
1173 if (flags & TFF_DECL_SPECIFIERS)
1174 pp->declaration (t);
1175 else
1177 if (! (flags & TFF_UNQUALIFIED_NAME))
1178 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1179 flags &= ~TFF_UNQUALIFIED_NAME;
1180 if (DECL_NAME (t) == NULL_TREE)
1182 if (!(pp->flags & pp_c_flag_gnu_v3))
1183 pp_cxx_ws_string (pp, M_("{anonymous}"));
1184 else
1185 pp_cxx_ws_string (pp, M_("(anonymous namespace)"));
1187 else
1188 pp_cxx_tree_identifier (pp, DECL_NAME (t));
1190 break;
1192 case SCOPE_REF:
1193 dump_type (pp, TREE_OPERAND (t, 0), flags);
1194 pp_cxx_colon_colon (pp);
1195 dump_decl (pp, TREE_OPERAND (t, 1), TFF_UNQUALIFIED_NAME);
1196 break;
1198 case ARRAY_REF:
1199 dump_decl (pp, TREE_OPERAND (t, 0), flags);
1200 pp_cxx_left_bracket (pp);
1201 dump_decl (pp, TREE_OPERAND (t, 1), flags);
1202 pp_cxx_right_bracket (pp);
1203 break;
1205 case ARRAY_NOTATION_REF:
1206 dump_decl (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
1207 pp_cxx_left_bracket (pp);
1208 dump_decl (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
1209 pp_colon (pp);
1210 dump_decl (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
1211 pp_colon (pp);
1212 dump_decl (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
1213 pp_cxx_right_bracket (pp);
1214 break;
1216 /* So that we can do dump_decl on an aggr type. */
1217 case RECORD_TYPE:
1218 case UNION_TYPE:
1219 case ENUMERAL_TYPE:
1220 dump_type (pp, t, flags);
1221 break;
1223 case BIT_NOT_EXPR:
1224 /* This is a pseudo destructor call which has not been folded into
1225 a PSEUDO_DTOR_EXPR yet. */
1226 pp_cxx_complement (pp);
1227 dump_type (pp, TREE_OPERAND (t, 0), flags);
1228 break;
1230 case TYPE_EXPR:
1231 gcc_unreachable ();
1232 break;
1234 case IDENTIFIER_NODE:
1235 dump_decl_name (pp, t, flags);
1236 break;
1238 case OVERLOAD:
1239 if (!OVL_SINGLE_P (t))
1241 tree ctx = ovl_scope (t);
1242 if (ctx != global_namespace)
1244 if (TYPE_P (ctx))
1245 dump_type (pp, ctx, flags);
1246 else
1247 dump_decl (pp, ctx, flags);
1248 pp_cxx_colon_colon (pp);
1250 dump_decl (pp, OVL_NAME (t), flags);
1251 break;
1254 /* If there's only one function, just treat it like an ordinary
1255 FUNCTION_DECL. */
1256 t = OVL_FIRST (t);
1257 /* Fall through. */
1259 case FUNCTION_DECL:
1260 if (! DECL_LANG_SPECIFIC (t))
1262 if (DECL_ABSTRACT_ORIGIN (t)
1263 && DECL_ABSTRACT_ORIGIN (t) != t)
1264 dump_decl (pp, DECL_ABSTRACT_ORIGIN (t), flags);
1265 else
1266 dump_function_name (pp, t, flags);
1268 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1269 dump_global_iord (pp, t);
1270 else
1271 dump_function_decl (pp, t, flags);
1272 break;
1274 case TEMPLATE_DECL:
1275 dump_template_decl (pp, t, flags);
1276 break;
1278 case TEMPLATE_ID_EXPR:
1280 tree name = TREE_OPERAND (t, 0);
1281 tree args = TREE_OPERAND (t, 1);
1283 if (!identifier_p (name))
1284 name = OVL_NAME (name);
1285 dump_decl (pp, name, flags);
1286 pp_cxx_begin_template_argument_list (pp);
1287 if (args == error_mark_node)
1288 pp_string (pp, M_("<template arguments error>"));
1289 else if (args)
1290 dump_template_argument_list
1291 (pp, args, flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
1292 pp_cxx_end_template_argument_list (pp);
1294 break;
1296 case LABEL_DECL:
1297 pp_cxx_tree_identifier (pp, DECL_NAME (t));
1298 break;
1300 case CONST_DECL:
1301 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1302 || (DECL_INITIAL (t) &&
1303 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1304 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1305 else if (DECL_NAME (t))
1306 dump_decl (pp, DECL_NAME (t), flags);
1307 else if (DECL_INITIAL (t))
1308 dump_expr (pp, DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1309 else
1310 pp_string (pp, M_("<enumerator>"));
1311 break;
1313 case USING_DECL:
1315 pp_cxx_ws_string (pp, "using");
1316 tree scope = USING_DECL_SCOPE (t);
1317 bool variadic = false;
1318 if (PACK_EXPANSION_P (scope))
1320 scope = PACK_EXPANSION_PATTERN (scope);
1321 variadic = true;
1323 dump_type (pp, scope, flags);
1324 pp_cxx_colon_colon (pp);
1325 dump_decl (pp, DECL_NAME (t), flags);
1326 if (variadic)
1327 pp_cxx_ws_string (pp, "...");
1329 break;
1331 case STATIC_ASSERT:
1332 pp->declaration (t);
1333 break;
1335 case BASELINK:
1336 dump_decl (pp, BASELINK_FUNCTIONS (t), flags);
1337 break;
1339 case NON_DEPENDENT_EXPR:
1340 dump_expr (pp, t, flags);
1341 break;
1343 case TEMPLATE_TYPE_PARM:
1344 if (flags & TFF_DECL_SPECIFIERS)
1345 pp->declaration (t);
1346 else
1347 pp->type_id (t);
1348 break;
1350 case UNBOUND_CLASS_TEMPLATE:
1351 case TYPE_PACK_EXPANSION:
1352 case TREE_BINFO:
1353 dump_type (pp, t, flags);
1354 break;
1356 default:
1357 pp_unsupported_tree (pp, t);
1358 /* Fall through. */
1360 case ERROR_MARK:
1361 pp_string (pp, M_("<declaration error>"));
1362 break;
1366 /* Dump a template declaration T under control of FLAGS. This means the
1367 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1369 static void
1370 dump_template_decl (cxx_pretty_printer *pp, tree t, int flags)
1372 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1373 tree parms;
1374 int i;
1376 if (flags & TFF_TEMPLATE_HEADER)
1378 for (parms = orig_parms = nreverse (orig_parms);
1379 parms;
1380 parms = TREE_CHAIN (parms))
1382 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1383 int len = TREE_VEC_LENGTH (inner_parms);
1385 if (len == 0)
1387 /* Skip over the dummy template levels of a template template
1388 parm. */
1389 gcc_assert (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TEMPLATE_PARM);
1390 continue;
1393 pp_cxx_ws_string (pp, "template");
1394 pp_cxx_begin_template_argument_list (pp);
1396 /* If we've shown the template prefix, we'd better show the
1397 parameters' and decl's type too. */
1398 flags |= TFF_DECL_SPECIFIERS;
1400 for (i = 0; i < len; i++)
1402 if (i)
1403 pp_separate_with_comma (pp);
1404 dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i),
1405 flags);
1407 pp_cxx_end_template_argument_list (pp);
1408 pp_cxx_whitespace (pp);
1410 nreverse(orig_parms);
1412 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1414 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1415 pp_cxx_ws_string (pp, "class");
1417 /* If this is a parameter pack, print the ellipsis. */
1418 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1419 pp_cxx_ws_string (pp, "...");
1422 /* Only print the requirements if we're also printing
1423 the template header. */
1424 if (flag_concepts)
1425 if (tree ci = get_constraints (t))
1426 if (check_constraint_info (ci))
1427 if (tree reqs = CI_TEMPLATE_REQS (ci))
1429 pp_cxx_requires_clause (pp, reqs);
1430 pp_cxx_whitespace (pp);
1435 if (DECL_CLASS_TEMPLATE_P (t))
1436 dump_type (pp, TREE_TYPE (t),
1437 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1438 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1439 else if (DECL_TEMPLATE_RESULT (t)
1440 && (VAR_P (DECL_TEMPLATE_RESULT (t))
1441 /* Alias template. */
1442 || DECL_TYPE_TEMPLATE_P (t)))
1443 dump_decl (pp, DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1444 else
1446 gcc_assert (TREE_TYPE (t));
1447 switch (NEXT_CODE (t))
1449 case METHOD_TYPE:
1450 case FUNCTION_TYPE:
1451 dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME);
1452 break;
1453 default:
1454 /* This case can occur with some invalid code. */
1455 dump_type (pp, TREE_TYPE (t),
1456 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1457 | (flags & TFF_DECL_SPECIFIERS
1458 ? TFF_CLASS_KEY_OR_ENUM : 0));
1463 /* find_typenames looks through the type of the function template T
1464 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1465 it finds. */
1467 struct find_typenames_t
1469 hash_set<tree> *p_set;
1470 vec<tree, va_gc> *typenames;
1473 static tree
1474 find_typenames_r (tree *tp, int *walk_subtrees, void *data)
1476 struct find_typenames_t *d = (struct find_typenames_t *)data;
1477 tree mv = NULL_TREE;
1479 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1480 /* Add the type of the typedef without any additional cv-quals. */
1481 mv = TREE_TYPE (TYPE_NAME (*tp));
1482 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1483 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1484 /* Add the typename without any cv-qualifiers. */
1485 mv = TYPE_MAIN_VARIANT (*tp);
1487 if (TREE_CODE (*tp) == TYPE_PACK_EXPANSION)
1489 /* Don't mess with parameter packs since we don't remember
1490 the pack expansion context for a particular typename. */
1491 *walk_subtrees = false;
1492 return NULL_TREE;
1495 if (mv && (mv == *tp || !d->p_set->add (mv)))
1496 vec_safe_push (d->typenames, mv);
1498 /* Search into class template arguments, which cp_walk_subtrees
1499 doesn't do. */
1500 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1501 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1502 data, d->p_set);
1504 return NULL_TREE;
1507 static vec<tree, va_gc> *
1508 find_typenames (tree t)
1510 struct find_typenames_t ft;
1511 ft.p_set = new hash_set<tree>;
1512 ft.typenames = NULL;
1513 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1514 find_typenames_r, &ft, ft.p_set);
1515 delete ft.p_set;
1516 return ft.typenames;
1519 /* Output the "[with ...]" clause for a template instantiation T iff
1520 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1521 formatting a deduction/substitution diagnostic rather than an
1522 instantiation. */
1524 static void
1525 dump_substitution (cxx_pretty_printer *pp,
1526 tree t, tree template_parms, tree template_args,
1527 int flags)
1529 if (template_parms != NULL_TREE && template_args != NULL_TREE
1530 && !(flags & TFF_NO_TEMPLATE_BINDINGS))
1532 vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL;
1533 pp_cxx_whitespace (pp);
1534 pp_cxx_left_bracket (pp);
1535 pp->translate_string ("with");
1536 pp_cxx_whitespace (pp);
1537 dump_template_bindings (pp, template_parms, template_args, typenames);
1538 pp_cxx_right_bracket (pp);
1542 /* Dump the lambda function FN including its 'mutable' qualifier and any
1543 template bindings. */
1545 static void
1546 dump_lambda_function (cxx_pretty_printer *pp,
1547 tree fn, tree template_parms, tree template_args,
1548 int flags)
1550 /* A lambda's signature is essentially its "type". */
1551 dump_type (pp, DECL_CONTEXT (fn), flags);
1552 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST))
1554 pp->padding = pp_before;
1555 pp_c_ws_string (pp, "mutable");
1557 dump_substitution (pp, fn, template_parms, template_args, flags);
1560 /* Pretty print a function decl. There are several ways we want to print a
1561 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1562 As error can only apply the '#' flag once to give 0 and 1 for V, there
1563 is %D which doesn't print the throw specs, and %F which does. */
1565 static void
1566 dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
1568 tree fntype;
1569 tree parmtypes;
1570 tree cname = NULL_TREE;
1571 tree template_args = NULL_TREE;
1572 tree template_parms = NULL_TREE;
1573 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1574 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1575 tree exceptions;
1576 bool constexpr_p;
1578 flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME);
1579 if (TREE_CODE (t) == TEMPLATE_DECL)
1580 t = DECL_TEMPLATE_RESULT (t);
1582 /* Save the exceptions, in case t is a specialization and we are
1583 emitting an error about incompatible specifications. */
1584 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1586 /* Likewise for the constexpr specifier, in case t is a specialization. */
1587 constexpr_p = DECL_DECLARED_CONSTEXPR_P (t);
1589 /* Pretty print template instantiations only. */
1590 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1591 && !(flags & TFF_NO_TEMPLATE_BINDINGS)
1592 && flag_pretty_templates)
1594 tree tmpl;
1596 template_args = DECL_TI_ARGS (t);
1597 tmpl = most_general_template (t);
1598 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1600 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1601 t = tmpl;
1605 if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1606 return dump_lambda_function (pp, t, template_parms, template_args, flags);
1608 fntype = TREE_TYPE (t);
1609 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1611 if (DECL_CLASS_SCOPE_P (t))
1612 cname = DECL_CONTEXT (t);
1613 /* This is for partially instantiated template methods. */
1614 else if (TREE_CODE (fntype) == METHOD_TYPE)
1615 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1617 if (flags & TFF_DECL_SPECIFIERS)
1619 if (DECL_STATIC_FUNCTION_P (t))
1620 pp_cxx_ws_string (pp, "static");
1621 else if (DECL_VIRTUAL_P (t))
1622 pp_cxx_ws_string (pp, "virtual");
1624 if (constexpr_p)
1626 if (DECL_DECLARED_CONCEPT_P (t))
1627 pp_cxx_ws_string (pp, "concept");
1628 else
1629 pp_cxx_ws_string (pp, "constexpr");
1633 /* Print the return type? */
1634 if (show_return)
1635 show_return = (!DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1636 && !DECL_DESTRUCTOR_P (t) && !deduction_guide_p (t));
1637 if (show_return)
1639 tree ret = fndecl_declared_return_type (t);
1640 dump_type_prefix (pp, ret, flags);
1643 /* Print the function name. */
1644 if (!do_outer_scope)
1645 /* Nothing. */;
1646 else if (cname)
1648 dump_type (pp, cname, flags);
1649 pp_cxx_colon_colon (pp);
1651 else
1652 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1654 dump_function_name (pp, t, flags);
1656 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1658 dump_parameters (pp, parmtypes, flags);
1660 if (TREE_CODE (fntype) == METHOD_TYPE)
1662 pp->padding = pp_before;
1663 pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype));
1664 dump_ref_qualifier (pp, fntype, flags);
1667 if (tx_safe_fn_type_p (fntype))
1669 pp->padding = pp_before;
1670 pp_cxx_ws_string (pp, "transaction_safe");
1673 if (flags & TFF_EXCEPTION_SPECIFICATION)
1675 pp->padding = pp_before;
1676 dump_exception_spec (pp, exceptions, flags);
1679 if (show_return)
1680 dump_type_suffix (pp, TREE_TYPE (fntype), flags);
1681 else if (deduction_guide_p (t))
1683 pp_cxx_ws_string (pp, "->");
1684 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
1687 if (flag_concepts)
1688 if (tree ci = get_constraints (t))
1689 if (tree reqs = CI_DECLARATOR_REQS (ci))
1690 pp_cxx_requires_clause (pp, reqs);
1692 dump_substitution (pp, t, template_parms, template_args, flags);
1694 if (tree base = DECL_INHERITED_CTOR_BASE (t))
1696 pp_cxx_ws_string (pp, "[inherited from");
1697 dump_type (pp, base, TFF_PLAIN_IDENTIFIER);
1698 pp_character (pp, ']');
1701 else if (template_args)
1703 bool need_comma = false;
1704 int i;
1705 pp_cxx_begin_template_argument_list (pp);
1706 template_args = INNERMOST_TEMPLATE_ARGS (template_args);
1707 for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
1709 tree arg = TREE_VEC_ELT (template_args, i);
1710 if (need_comma)
1711 pp_separate_with_comma (pp);
1712 if (ARGUMENT_PACK_P (arg))
1713 pp_cxx_left_brace (pp);
1714 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
1715 if (ARGUMENT_PACK_P (arg))
1716 pp_cxx_right_brace (pp);
1717 need_comma = true;
1719 pp_cxx_end_template_argument_list (pp);
1723 /* Print a parameter list. If this is for a member function, the
1724 member object ptr (and any other hidden args) should have
1725 already been removed. */
1727 static void
1728 dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags)
1730 int first = 1;
1731 flags &= ~TFF_SCOPE;
1732 pp_cxx_left_paren (pp);
1734 for (first = 1; parmtypes != void_list_node;
1735 parmtypes = TREE_CHAIN (parmtypes))
1737 if (!first)
1738 pp_separate_with_comma (pp);
1739 first = 0;
1740 if (!parmtypes)
1742 pp_cxx_ws_string (pp, "...");
1743 break;
1746 dump_type (pp, TREE_VALUE (parmtypes), flags);
1748 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1750 pp_cxx_whitespace (pp);
1751 pp_equal (pp);
1752 pp_cxx_whitespace (pp);
1753 dump_expr (pp, TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1757 pp_cxx_right_paren (pp);
1760 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1762 static void
1763 dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED)
1765 if (FUNCTION_REF_QUALIFIED (t))
1767 pp->padding = pp_before;
1768 if (FUNCTION_RVALUE_QUALIFIED (t))
1769 pp_cxx_ws_string (pp, "&&");
1770 else
1771 pp_cxx_ws_string (pp, "&");
1775 /* Print an exception specification. T is the exception specification. */
1777 static void
1778 dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags)
1780 if (t && TREE_PURPOSE (t))
1782 pp_cxx_ws_string (pp, "noexcept");
1783 if (!integer_onep (TREE_PURPOSE (t)))
1785 pp_cxx_whitespace (pp);
1786 pp_cxx_left_paren (pp);
1787 if (DEFERRED_NOEXCEPT_SPEC_P (t))
1788 pp_cxx_ws_string (pp, "<uninstantiated>");
1789 else
1790 dump_expr (pp, TREE_PURPOSE (t), flags);
1791 pp_cxx_right_paren (pp);
1794 else if (t)
1796 pp_cxx_ws_string (pp, "throw");
1797 pp_cxx_whitespace (pp);
1798 pp_cxx_left_paren (pp);
1799 if (TREE_VALUE (t) != NULL_TREE)
1800 while (1)
1802 dump_type (pp, TREE_VALUE (t), flags);
1803 t = TREE_CHAIN (t);
1804 if (!t)
1805 break;
1806 pp_separate_with_comma (pp);
1808 pp_cxx_right_paren (pp);
1812 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1813 and destructors properly. */
1815 static void
1816 dump_function_name (cxx_pretty_printer *pp, tree t, int flags)
1818 tree name = DECL_NAME (t);
1820 /* We can get here with a decl that was synthesized by language-
1821 independent machinery (e.g. coverage.c) in which case it won't
1822 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1823 will crash. In this case it is safe just to print out the
1824 literal name. */
1825 if (!DECL_LANG_SPECIFIC (t))
1827 pp_cxx_tree_identifier (pp, name);
1828 return;
1831 if (TREE_CODE (t) == TEMPLATE_DECL)
1832 t = DECL_TEMPLATE_RESULT (t);
1834 /* Don't let the user see __comp_ctor et al. */
1835 if (DECL_CONSTRUCTOR_P (t)
1836 || DECL_DESTRUCTOR_P (t))
1838 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1839 name = get_identifier ("<lambda>");
1840 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t)))
1841 name = get_identifier ("<constructor>");
1842 else
1843 name = constructor_name (DECL_CONTEXT (t));
1846 if (DECL_DESTRUCTOR_P (t))
1848 pp_cxx_complement (pp);
1849 dump_decl (pp, name, TFF_PLAIN_IDENTIFIER);
1851 else if (DECL_CONV_FN_P (t))
1853 /* This cannot use the hack that the operator's return
1854 type is stashed off of its name because it may be
1855 used for error reporting. In the case of conflicting
1856 declarations, both will have the same name, yet
1857 the types will be different, hence the TREE_TYPE field
1858 of the first name will be clobbered by the second. */
1859 pp_cxx_ws_string (pp, "operator");
1860 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
1862 else
1863 dump_decl (pp, name, flags);
1865 if (DECL_TEMPLATE_INFO (t)
1866 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1867 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1868 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1869 dump_template_parms (pp, DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t),
1870 flags);
1873 /* Dump the template parameters from the template info INFO under control of
1874 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1875 specialization (partial or complete). For partial specializations we show
1876 the specialized parameter values. For a primary template we show no
1877 decoration. */
1879 static void
1880 dump_template_parms (cxx_pretty_printer *pp, tree info,
1881 int primary, int flags)
1883 tree args = info ? TI_ARGS (info) : NULL_TREE;
1885 if (primary && flags & TFF_TEMPLATE_NAME)
1886 return;
1887 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1888 pp_cxx_begin_template_argument_list (pp);
1890 /* Be careful only to print things when we have them, so as not
1891 to crash producing error messages. */
1892 if (args && !primary)
1894 int len, ix;
1895 len = get_non_default_template_args_count (args, flags);
1897 args = INNERMOST_TEMPLATE_ARGS (args);
1898 for (ix = 0; ix != len; ix++)
1900 tree arg = TREE_VEC_ELT (args, ix);
1902 /* Only print a comma if we know there is an argument coming. In
1903 the case of an empty template argument pack, no actual
1904 argument will be printed. */
1905 if (ix
1906 && (!ARGUMENT_PACK_P (arg)
1907 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1908 pp_separate_with_comma (pp);
1910 if (!arg)
1911 pp_string (pp, M_("<template parameter error>"));
1912 else
1913 dump_template_argument (pp, arg, flags);
1916 else if (primary)
1918 tree tpl = TI_TEMPLATE (info);
1919 tree parms = DECL_TEMPLATE_PARMS (tpl);
1920 int len, ix;
1922 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1923 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1925 for (ix = 0; ix != len; ix++)
1927 tree parm;
1929 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1931 pp_string (pp, M_("<template parameter error>"));
1932 continue;
1935 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1937 if (ix)
1938 pp_separate_with_comma (pp);
1940 dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS);
1943 pp_cxx_end_template_argument_list (pp);
1946 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1947 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1949 static void
1950 dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst)
1952 tree arg;
1953 call_expr_arg_iterator iter;
1955 pp_cxx_left_paren (pp);
1956 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1958 if (skipfirst)
1959 skipfirst = false;
1960 else
1962 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1963 if (more_call_expr_args_p (&iter))
1964 pp_separate_with_comma (pp);
1967 pp_cxx_right_paren (pp);
1970 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1971 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1972 true. */
1974 static void
1975 dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags,
1976 bool skipfirst)
1978 tree arg;
1979 aggr_init_expr_arg_iterator iter;
1981 pp_cxx_left_paren (pp);
1982 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1984 if (skipfirst)
1985 skipfirst = false;
1986 else
1988 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1989 if (more_aggr_init_expr_args_p (&iter))
1990 pp_separate_with_comma (pp);
1993 pp_cxx_right_paren (pp);
1996 /* Print out a list of initializers (subr of dump_expr). */
1998 static void
1999 dump_expr_list (cxx_pretty_printer *pp, tree l, int flags)
2001 while (l)
2003 dump_expr (pp, TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
2004 l = TREE_CHAIN (l);
2005 if (l)
2006 pp_separate_with_comma (pp);
2010 /* Print out a vector of initializers (subr of dump_expr). */
2012 static void
2013 dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v,
2014 int flags)
2016 unsigned HOST_WIDE_INT idx;
2017 tree value;
2019 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
2021 dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS);
2022 if (idx != v->length () - 1)
2023 pp_separate_with_comma (pp);
2028 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
2029 function. Resolve it to a close relative -- in the sense of static
2030 type -- variant being overridden. That is close to what was written in
2031 the source code. Subroutine of dump_expr. */
2033 static tree
2034 resolve_virtual_fun_from_obj_type_ref (tree ref)
2036 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
2037 HOST_WIDE_INT index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref));
2038 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
2039 while (index)
2041 fun = TREE_CHAIN (fun);
2042 index -= (TARGET_VTABLE_USES_DESCRIPTORS
2043 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
2046 return BV_FN (fun);
2049 /* Print out an expression E under control of FLAGS. */
2051 static void
2052 dump_expr (cxx_pretty_printer *pp, tree t, int flags)
2054 tree op;
2056 if (t == 0)
2057 return;
2059 if (STATEMENT_CLASS_P (t))
2061 pp_cxx_ws_string (pp, M_("<statement>"));
2062 return;
2065 switch (TREE_CODE (t))
2067 case VAR_DECL:
2068 case PARM_DECL:
2069 case FIELD_DECL:
2070 case CONST_DECL:
2071 case FUNCTION_DECL:
2072 case TEMPLATE_DECL:
2073 case NAMESPACE_DECL:
2074 case LABEL_DECL:
2075 case OVERLOAD:
2076 case TYPE_DECL:
2077 case IDENTIFIER_NODE:
2078 dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
2079 |TFF_TEMPLATE_HEADER))
2080 | TFF_NO_TEMPLATE_BINDINGS
2081 | TFF_NO_FUNCTION_ARGUMENTS));
2082 break;
2084 case SSA_NAME:
2085 if (SSA_NAME_VAR (t)
2086 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t)))
2087 dump_expr (pp, SSA_NAME_VAR (t), flags);
2088 else
2089 pp_cxx_ws_string (pp, M_("<unknown>"));
2090 break;
2092 case VOID_CST:
2093 case INTEGER_CST:
2094 case REAL_CST:
2095 case STRING_CST:
2096 case COMPLEX_CST:
2097 pp->constant (t);
2098 break;
2100 case USERDEF_LITERAL:
2101 pp_cxx_userdef_literal (pp, t);
2102 break;
2104 case THROW_EXPR:
2105 /* While waiting for caret diagnostics, avoid printing
2106 __cxa_allocate_exception, __cxa_throw, and the like. */
2107 pp_cxx_ws_string (pp, M_("<throw-expression>"));
2108 break;
2110 case PTRMEM_CST:
2111 pp_ampersand (pp);
2112 dump_type (pp, PTRMEM_CST_CLASS (t), flags);
2113 pp_cxx_colon_colon (pp);
2114 pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
2115 break;
2117 case COMPOUND_EXPR:
2118 pp_cxx_left_paren (pp);
2119 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2120 pp_separate_with_comma (pp);
2121 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2122 pp_cxx_right_paren (pp);
2123 break;
2125 case COND_EXPR:
2126 case VEC_COND_EXPR:
2127 pp_cxx_left_paren (pp);
2128 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2129 pp_string (pp, " ? ");
2130 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2131 pp_string (pp, " : ");
2132 dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
2133 pp_cxx_right_paren (pp);
2134 break;
2136 case SAVE_EXPR:
2137 if (TREE_HAS_CONSTRUCTOR (t))
2139 pp_cxx_ws_string (pp, "new");
2140 pp_cxx_whitespace (pp);
2141 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
2143 else
2144 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2145 break;
2147 case AGGR_INIT_EXPR:
2149 tree fn = NULL_TREE;
2151 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
2152 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
2154 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
2156 if (DECL_CONSTRUCTOR_P (fn))
2157 dump_type (pp, DECL_CONTEXT (fn), flags);
2158 else
2159 dump_decl (pp, fn, 0);
2161 else
2162 dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0);
2164 dump_aggr_init_expr_args (pp, t, flags, true);
2165 break;
2167 case CALL_EXPR:
2169 tree fn = CALL_EXPR_FN (t);
2170 bool skipfirst = false;
2172 /* Deal with internal functions. */
2173 if (fn == NULL_TREE)
2175 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t)));
2176 dump_call_expr_args (pp, t, flags, skipfirst);
2177 break;
2180 if (TREE_CODE (fn) == ADDR_EXPR)
2181 fn = TREE_OPERAND (fn, 0);
2183 /* Nobody is interested in seeing the guts of vcalls. */
2184 if (TREE_CODE (fn) == OBJ_TYPE_REF)
2185 fn = resolve_virtual_fun_from_obj_type_ref (fn);
2187 if (TREE_TYPE (fn) != NULL_TREE
2188 && NEXT_CODE (fn) == METHOD_TYPE
2189 && call_expr_nargs (t))
2191 tree ob = CALL_EXPR_ARG (t, 0);
2192 if (TREE_CODE (ob) == ADDR_EXPR)
2194 dump_expr (pp, TREE_OPERAND (ob, 0),
2195 flags | TFF_EXPR_IN_PARENS);
2196 pp_cxx_dot (pp);
2198 else if (!is_this_parameter (ob))
2200 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2201 pp_cxx_arrow (pp);
2203 skipfirst = true;
2205 if (flag_sanitize & SANITIZE_UNDEFINED
2206 && is_ubsan_builtin_p (fn))
2208 pp_string (cxx_pp, M_("<ubsan routine call>"));
2209 break;
2211 dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS);
2212 dump_call_expr_args (pp, t, flags, skipfirst);
2214 break;
2216 case TARGET_EXPR:
2217 /* Note that this only works for G++ target exprs. If somebody
2218 builds a general TARGET_EXPR, there's no way to represent that
2219 it initializes anything other that the parameter slot for the
2220 default argument. Note we may have cleared out the first
2221 operand in expand_expr, so don't go killing ourselves. */
2222 if (TREE_OPERAND (t, 1))
2223 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2224 break;
2226 case POINTER_PLUS_EXPR:
2227 dump_binary_op (pp, "+", t, flags);
2228 break;
2230 case INIT_EXPR:
2231 case MODIFY_EXPR:
2232 dump_binary_op (pp, assignment_operator_name_info[NOP_EXPR].name,
2233 t, flags);
2234 break;
2236 case PLUS_EXPR:
2237 case MINUS_EXPR:
2238 case MULT_EXPR:
2239 case TRUNC_DIV_EXPR:
2240 case TRUNC_MOD_EXPR:
2241 case MIN_EXPR:
2242 case MAX_EXPR:
2243 case LSHIFT_EXPR:
2244 case RSHIFT_EXPR:
2245 case BIT_IOR_EXPR:
2246 case BIT_XOR_EXPR:
2247 case BIT_AND_EXPR:
2248 case TRUTH_ANDIF_EXPR:
2249 case TRUTH_ORIF_EXPR:
2250 case LT_EXPR:
2251 case LE_EXPR:
2252 case GT_EXPR:
2253 case GE_EXPR:
2254 case EQ_EXPR:
2255 case NE_EXPR:
2256 case EXACT_DIV_EXPR:
2257 dump_binary_op (pp, operator_name_info[TREE_CODE (t)].name, t, flags);
2258 break;
2260 case CEIL_DIV_EXPR:
2261 case FLOOR_DIV_EXPR:
2262 case ROUND_DIV_EXPR:
2263 case RDIV_EXPR:
2264 dump_binary_op (pp, "/", t, flags);
2265 break;
2267 case CEIL_MOD_EXPR:
2268 case FLOOR_MOD_EXPR:
2269 case ROUND_MOD_EXPR:
2270 dump_binary_op (pp, "%", t, flags);
2271 break;
2273 case COMPONENT_REF:
2275 tree ob = TREE_OPERAND (t, 0);
2276 if (INDIRECT_REF_P (ob))
2278 ob = TREE_OPERAND (ob, 0);
2279 if (!is_this_parameter (ob))
2281 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2282 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
2283 pp_cxx_dot (pp);
2284 else
2285 pp_cxx_arrow (pp);
2288 else
2290 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2291 if (TREE_CODE (ob) != ARROW_EXPR)
2292 pp_cxx_dot (pp);
2294 dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
2296 break;
2298 case ARRAY_REF:
2299 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2300 pp_cxx_left_bracket (pp);
2301 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2302 pp_cxx_right_bracket (pp);
2303 break;
2305 case ARRAY_NOTATION_REF:
2306 dump_expr (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
2307 pp_cxx_left_bracket (pp);
2308 dump_expr (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
2309 pp_colon (pp);
2310 dump_expr (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
2311 pp_colon (pp);
2312 dump_expr (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
2313 pp_cxx_right_bracket (pp);
2314 break;
2316 case UNARY_PLUS_EXPR:
2317 dump_unary_op (pp, "+", t, flags);
2318 break;
2320 case ADDR_EXPR:
2321 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
2322 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
2323 /* An ADDR_EXPR can have reference type. In that case, we
2324 shouldn't print the `&' doing so indicates to the user
2325 that the expression has pointer type. */
2326 || (TREE_TYPE (t)
2327 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
2328 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2329 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
2330 dump_unary_op (pp, "&&", t, flags);
2331 else
2332 dump_unary_op (pp, "&", t, flags);
2333 break;
2335 case INDIRECT_REF:
2336 if (TREE_HAS_CONSTRUCTOR (t))
2338 t = TREE_OPERAND (t, 0);
2339 gcc_assert (TREE_CODE (t) == CALL_EXPR);
2340 dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
2341 dump_call_expr_args (pp, t, flags, true);
2343 else
2345 if (TREE_OPERAND (t,0) != NULL_TREE
2346 && TREE_TYPE (TREE_OPERAND (t, 0))
2347 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
2348 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2349 else
2350 dump_unary_op (pp, "*", t, flags);
2352 break;
2354 case MEM_REF:
2355 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
2356 && integer_zerop (TREE_OPERAND (t, 1)))
2357 dump_expr (pp, TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
2358 else
2360 pp_cxx_star (pp);
2361 if (!integer_zerop (TREE_OPERAND (t, 1)))
2363 pp_cxx_left_paren (pp);
2364 if (!integer_onep (TYPE_SIZE_UNIT
2365 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
2367 pp_cxx_left_paren (pp);
2368 dump_type (pp, ptr_type_node, flags);
2369 pp_cxx_right_paren (pp);
2372 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2373 if (!integer_zerop (TREE_OPERAND (t, 1)))
2375 pp_cxx_ws_string (pp, "+");
2376 dump_expr (pp, fold_convert (ssizetype, TREE_OPERAND (t, 1)),
2377 flags);
2378 pp_cxx_right_paren (pp);
2381 break;
2383 case NEGATE_EXPR:
2384 case BIT_NOT_EXPR:
2385 case TRUTH_NOT_EXPR:
2386 case PREDECREMENT_EXPR:
2387 case PREINCREMENT_EXPR:
2388 dump_unary_op (pp, operator_name_info [TREE_CODE (t)].name, t, flags);
2389 break;
2391 case POSTDECREMENT_EXPR:
2392 case POSTINCREMENT_EXPR:
2393 pp_cxx_left_paren (pp);
2394 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2395 pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2396 pp_cxx_right_paren (pp);
2397 break;
2399 case NON_LVALUE_EXPR:
2400 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2401 should be another level of INDIRECT_REF so that I don't have to do
2402 this. */
2403 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2405 tree next = TREE_TYPE (TREE_TYPE (t));
2407 while (TYPE_PTR_P (next))
2408 next = TREE_TYPE (next);
2410 if (TREE_CODE (next) == FUNCTION_TYPE)
2412 if (flags & TFF_EXPR_IN_PARENS)
2413 pp_cxx_left_paren (pp);
2414 pp_cxx_star (pp);
2415 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2416 if (flags & TFF_EXPR_IN_PARENS)
2417 pp_cxx_right_paren (pp);
2418 break;
2420 /* Else fall through. */
2422 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2423 break;
2425 CASE_CONVERT:
2426 case IMPLICIT_CONV_EXPR:
2427 case VIEW_CONVERT_EXPR:
2429 tree op = TREE_OPERAND (t, 0);
2430 tree ttype = TREE_TYPE (t);
2431 tree optype = TREE_TYPE (op);
2433 if (TREE_CODE (ttype) != TREE_CODE (optype)
2434 && POINTER_TYPE_P (ttype)
2435 && POINTER_TYPE_P (optype)
2436 && same_type_p (TREE_TYPE (optype),
2437 TREE_TYPE (ttype)))
2439 if (TREE_CODE (ttype) == REFERENCE_TYPE)
2441 STRIP_NOPS (op);
2442 if (TREE_CODE (op) == ADDR_EXPR)
2443 dump_expr (pp, TREE_OPERAND (op, 0), flags);
2444 else
2445 dump_unary_op (pp, "*", t, flags);
2447 else
2448 dump_unary_op (pp, "&", t, flags);
2450 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2452 /* It is a cast, but we cannot tell whether it is a
2453 reinterpret or static cast. Use the C style notation. */
2454 if (flags & TFF_EXPR_IN_PARENS)
2455 pp_cxx_left_paren (pp);
2456 pp_cxx_left_paren (pp);
2457 dump_type (pp, TREE_TYPE (t), flags);
2458 pp_cxx_right_paren (pp);
2459 dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS);
2460 if (flags & TFF_EXPR_IN_PARENS)
2461 pp_cxx_right_paren (pp);
2463 else
2464 dump_expr (pp, op, flags);
2465 break;
2468 case CONSTRUCTOR:
2469 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2471 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2473 if (integer_zerop (idx))
2475 /* A NULL pointer-to-member constant. */
2476 pp_cxx_left_paren (pp);
2477 pp_cxx_left_paren (pp);
2478 dump_type (pp, TREE_TYPE (t), flags);
2479 pp_cxx_right_paren (pp);
2480 pp_character (pp, '0');
2481 pp_cxx_right_paren (pp);
2482 break;
2484 else if (tree_fits_shwi_p (idx))
2486 tree virtuals;
2487 unsigned HOST_WIDE_INT n;
2489 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2490 t = TYPE_METHOD_BASETYPE (t);
2491 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2493 n = tree_to_shwi (idx);
2495 /* Map vtable index back one, to allow for the null pointer to
2496 member. */
2497 --n;
2499 while (n > 0 && virtuals)
2501 --n;
2502 virtuals = TREE_CHAIN (virtuals);
2504 if (virtuals)
2506 dump_expr (pp, BV_FN (virtuals),
2507 flags | TFF_EXPR_IN_PARENS);
2508 break;
2512 if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t)))
2513 pp_string (pp, "<lambda closure object>");
2514 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2516 dump_type (pp, TREE_TYPE (t), 0);
2517 pp_cxx_left_paren (pp);
2518 pp_cxx_right_paren (pp);
2520 else
2522 if (!BRACE_ENCLOSED_INITIALIZER_P (t))
2523 dump_type (pp, TREE_TYPE (t), 0);
2524 pp_cxx_left_brace (pp);
2525 dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags);
2526 pp_cxx_right_brace (pp);
2529 break;
2531 case OFFSET_REF:
2533 tree ob = TREE_OPERAND (t, 0);
2534 if (is_dummy_object (ob))
2536 t = TREE_OPERAND (t, 1);
2537 if (TREE_CODE (t) == FUNCTION_DECL)
2538 /* A::f */
2539 dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS);
2540 else if (BASELINK_P (t))
2541 dump_expr (pp, OVL_FIRST (BASELINK_FUNCTIONS (t)),
2542 flags | TFF_EXPR_IN_PARENS);
2543 else
2544 dump_decl (pp, t, flags);
2546 else
2548 if (INDIRECT_REF_P (ob))
2550 dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2551 pp_cxx_arrow (pp);
2552 pp_cxx_star (pp);
2554 else
2556 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2557 pp_cxx_dot (pp);
2558 pp_cxx_star (pp);
2560 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2562 break;
2565 case TEMPLATE_PARM_INDEX:
2566 dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2567 break;
2569 case CAST_EXPR:
2570 if (TREE_OPERAND (t, 0) == NULL_TREE
2571 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2573 dump_type (pp, TREE_TYPE (t), flags);
2574 pp_cxx_left_paren (pp);
2575 dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2576 pp_cxx_right_paren (pp);
2578 else
2580 pp_cxx_left_paren (pp);
2581 dump_type (pp, TREE_TYPE (t), flags);
2582 pp_cxx_right_paren (pp);
2583 pp_cxx_left_paren (pp);
2584 dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2585 pp_cxx_right_paren (pp);
2587 break;
2589 case STATIC_CAST_EXPR:
2590 pp_cxx_ws_string (pp, "static_cast");
2591 goto cast;
2592 case REINTERPRET_CAST_EXPR:
2593 pp_cxx_ws_string (pp, "reinterpret_cast");
2594 goto cast;
2595 case CONST_CAST_EXPR:
2596 pp_cxx_ws_string (pp, "const_cast");
2597 goto cast;
2598 case DYNAMIC_CAST_EXPR:
2599 pp_cxx_ws_string (pp, "dynamic_cast");
2600 cast:
2601 pp_cxx_begin_template_argument_list (pp);
2602 dump_type (pp, TREE_TYPE (t), flags);
2603 pp_cxx_end_template_argument_list (pp);
2604 pp_cxx_left_paren (pp);
2605 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2606 pp_cxx_right_paren (pp);
2607 break;
2609 case ARROW_EXPR:
2610 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2611 pp_cxx_arrow (pp);
2612 break;
2614 case SIZEOF_EXPR:
2615 case ALIGNOF_EXPR:
2616 if (TREE_CODE (t) == SIZEOF_EXPR)
2617 pp_cxx_ws_string (pp, "sizeof");
2618 else
2620 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2621 pp_cxx_ws_string (pp, "__alignof__");
2623 op = TREE_OPERAND (t, 0);
2624 if (PACK_EXPANSION_P (op))
2626 pp_string (pp, "...");
2627 op = PACK_EXPANSION_PATTERN (op);
2629 pp_cxx_whitespace (pp);
2630 pp_cxx_left_paren (pp);
2631 if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
2632 dump_type (pp, TREE_TYPE (op), flags);
2633 else if (TYPE_P (TREE_OPERAND (t, 0)))
2634 dump_type (pp, op, flags);
2635 else
2636 dump_expr (pp, op, flags);
2637 pp_cxx_right_paren (pp);
2638 break;
2640 case AT_ENCODE_EXPR:
2641 pp_cxx_ws_string (pp, "@encode");
2642 pp_cxx_whitespace (pp);
2643 pp_cxx_left_paren (pp);
2644 dump_type (pp, TREE_OPERAND (t, 0), flags);
2645 pp_cxx_right_paren (pp);
2646 break;
2648 case NOEXCEPT_EXPR:
2649 pp_cxx_ws_string (pp, "noexcept");
2650 pp_cxx_whitespace (pp);
2651 pp_cxx_left_paren (pp);
2652 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2653 pp_cxx_right_paren (pp);
2654 break;
2656 case REALPART_EXPR:
2657 case IMAGPART_EXPR:
2658 pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2659 pp_cxx_whitespace (pp);
2660 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2661 break;
2663 case DEFAULT_ARG:
2664 pp_string (pp, M_("<unparsed>"));
2665 break;
2667 case TRY_CATCH_EXPR:
2668 case CLEANUP_POINT_EXPR:
2669 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2670 break;
2672 case PSEUDO_DTOR_EXPR:
2673 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2674 pp_cxx_dot (pp);
2675 if (TREE_OPERAND (t, 1))
2677 dump_type (pp, TREE_OPERAND (t, 1), flags);
2678 pp_cxx_colon_colon (pp);
2680 pp_cxx_complement (pp);
2681 dump_type (pp, TREE_OPERAND (t, 2), flags);
2682 break;
2684 case TEMPLATE_ID_EXPR:
2685 dump_decl (pp, t, flags);
2686 break;
2688 case BIND_EXPR:
2689 case STMT_EXPR:
2690 case EXPR_STMT:
2691 case STATEMENT_LIST:
2692 /* We don't yet have a way of dumping statements in a
2693 human-readable format. */
2694 pp_string (pp, "({...})");
2695 break;
2697 case LOOP_EXPR:
2698 pp_string (pp, "while (1) { ");
2699 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2700 pp_cxx_right_brace (pp);
2701 break;
2703 case EXIT_EXPR:
2704 pp_string (pp, "if (");
2705 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2706 pp_string (pp, ") break; ");
2707 break;
2709 case BASELINK:
2710 dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
2711 break;
2713 case EMPTY_CLASS_EXPR:
2714 dump_type (pp, TREE_TYPE (t), flags);
2715 pp_cxx_left_paren (pp);
2716 pp_cxx_right_paren (pp);
2717 break;
2719 case NON_DEPENDENT_EXPR:
2720 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2721 break;
2723 case ARGUMENT_PACK_SELECT:
2724 dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2725 break;
2727 case RECORD_TYPE:
2728 case UNION_TYPE:
2729 case ENUMERAL_TYPE:
2730 case REAL_TYPE:
2731 case VOID_TYPE:
2732 case BOOLEAN_TYPE:
2733 case INTEGER_TYPE:
2734 case COMPLEX_TYPE:
2735 case VECTOR_TYPE:
2736 pp_type_specifier_seq (pp, t);
2737 break;
2739 case TYPENAME_TYPE:
2740 /* We get here when we want to print a dependent type as an
2741 id-expression, without any disambiguator decoration. */
2742 pp->id_expression (t);
2743 break;
2745 case TEMPLATE_TYPE_PARM:
2746 case TEMPLATE_TEMPLATE_PARM:
2747 case BOUND_TEMPLATE_TEMPLATE_PARM:
2748 dump_type (pp, t, flags);
2749 break;
2751 case TRAIT_EXPR:
2752 pp_cxx_trait_expression (pp, t);
2753 break;
2755 case VA_ARG_EXPR:
2756 pp_cxx_va_arg_expression (pp, t);
2757 break;
2759 case OFFSETOF_EXPR:
2760 pp_cxx_offsetof_expression (pp, t);
2761 break;
2763 case ADDRESSOF_EXPR:
2764 pp_cxx_addressof_expression (pp, t);
2765 break;
2767 case SCOPE_REF:
2768 dump_decl (pp, t, flags);
2769 break;
2771 case EXPR_PACK_EXPANSION:
2772 case UNARY_LEFT_FOLD_EXPR:
2773 case UNARY_RIGHT_FOLD_EXPR:
2774 case BINARY_LEFT_FOLD_EXPR:
2775 case BINARY_RIGHT_FOLD_EXPR:
2776 case TYPEID_EXPR:
2777 case MEMBER_REF:
2778 case DOTSTAR_EXPR:
2779 case NEW_EXPR:
2780 case VEC_NEW_EXPR:
2781 case DELETE_EXPR:
2782 case VEC_DELETE_EXPR:
2783 case MODOP_EXPR:
2784 case ABS_EXPR:
2785 case CONJ_EXPR:
2786 case VECTOR_CST:
2787 case FIXED_CST:
2788 case UNORDERED_EXPR:
2789 case ORDERED_EXPR:
2790 case UNLT_EXPR:
2791 case UNLE_EXPR:
2792 case UNGT_EXPR:
2793 case UNGE_EXPR:
2794 case UNEQ_EXPR:
2795 case LTGT_EXPR:
2796 case COMPLEX_EXPR:
2797 case BIT_FIELD_REF:
2798 case FIX_TRUNC_EXPR:
2799 case FLOAT_EXPR:
2800 pp->expression (t);
2801 break;
2803 case TRUTH_AND_EXPR:
2804 case TRUTH_OR_EXPR:
2805 case TRUTH_XOR_EXPR:
2806 if (flags & TFF_EXPR_IN_PARENS)
2807 pp_cxx_left_paren (pp);
2808 pp->expression (t);
2809 if (flags & TFF_EXPR_IN_PARENS)
2810 pp_cxx_right_paren (pp);
2811 break;
2813 case OBJ_TYPE_REF:
2814 dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
2815 break;
2817 case LAMBDA_EXPR:
2818 pp_string (pp, M_("<lambda>"));
2819 break;
2821 case PAREN_EXPR:
2822 pp_cxx_left_paren (pp);
2823 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2824 pp_cxx_right_paren (pp);
2825 break;
2827 case REQUIRES_EXPR:
2828 pp_cxx_requires_expr (cxx_pp, t);
2829 break;
2831 case SIMPLE_REQ:
2832 pp_cxx_simple_requirement (cxx_pp, t);
2833 break;
2835 case TYPE_REQ:
2836 pp_cxx_type_requirement (cxx_pp, t);
2837 break;
2839 case COMPOUND_REQ:
2840 pp_cxx_compound_requirement (cxx_pp, t);
2841 break;
2843 case NESTED_REQ:
2844 pp_cxx_nested_requirement (cxx_pp, t);
2845 break;
2847 case PRED_CONSTR:
2848 case CHECK_CONSTR:
2849 case EXPR_CONSTR:
2850 case TYPE_CONSTR:
2851 case ICONV_CONSTR:
2852 case DEDUCT_CONSTR:
2853 case EXCEPT_CONSTR:
2854 case PARM_CONSTR:
2855 case CONJ_CONSTR:
2856 case DISJ_CONSTR:
2857 pp_cxx_constraint (cxx_pp, t);
2858 break;
2860 case PLACEHOLDER_EXPR:
2861 pp_string (pp, M_("*this"));
2862 break;
2864 case TREE_LIST:
2865 dump_expr_list (pp, t, flags);
2866 break;
2868 /* This list is incomplete, but should suffice for now.
2869 It is very important that `sorry' does not call
2870 `report_error_function'. That could cause an infinite loop. */
2871 default:
2872 pp_unsupported_tree (pp, t);
2873 /* Fall through. */
2874 case ERROR_MARK:
2875 pp_string (pp, M_("<expression error>"));
2876 break;
2880 static void
2881 dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
2882 int flags)
2884 pp_cxx_left_paren (pp);
2885 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2886 pp_cxx_whitespace (pp);
2887 if (opstring)
2888 pp_cxx_ws_string (pp, opstring);
2889 else
2890 pp_string (pp, M_("<unknown operator>"));
2891 pp_cxx_whitespace (pp);
2892 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2893 pp_cxx_right_paren (pp);
2896 static void
2897 dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
2899 if (flags & TFF_EXPR_IN_PARENS)
2900 pp_cxx_left_paren (pp);
2901 pp_cxx_ws_string (pp, opstring);
2902 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2903 if (flags & TFF_EXPR_IN_PARENS)
2904 pp_cxx_right_paren (pp);
2907 static void
2908 reinit_cxx_pp (void)
2910 pp_clear_output_area (cxx_pp);
2911 cxx_pp->padding = pp_none;
2912 pp_indentation (cxx_pp) = 0;
2913 pp_needs_newline (cxx_pp) = false;
2914 cxx_pp->enclosing_scope = current_function_decl;
2917 /* Same as pp_formatted_text, except the return string is a separate
2918 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2920 inline const char *
2921 pp_ggc_formatted_text (pretty_printer *pp)
2923 return ggc_strdup (pp_formatted_text (pp));
2926 /* Exported interface to stringifying types, exprs and decls under TFF_*
2927 control. */
2929 const char *
2930 type_as_string (tree typ, int flags)
2932 reinit_cxx_pp ();
2933 pp_translate_identifiers (cxx_pp) = false;
2934 dump_type (cxx_pp, typ, flags);
2935 return pp_ggc_formatted_text (cxx_pp);
2938 const char *
2939 type_as_string_translate (tree typ, int flags)
2941 reinit_cxx_pp ();
2942 dump_type (cxx_pp, typ, flags);
2943 return pp_ggc_formatted_text (cxx_pp);
2946 const char *
2947 expr_as_string (tree decl, int flags)
2949 reinit_cxx_pp ();
2950 pp_translate_identifiers (cxx_pp) = false;
2951 dump_expr (cxx_pp, decl, flags);
2952 return pp_ggc_formatted_text (cxx_pp);
2955 /* Wrap decl_as_string with options appropriate for dwarf. */
2957 const char *
2958 decl_as_dwarf_string (tree decl, int flags)
2960 const char *name;
2961 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2962 here will be adequate to get the desired behavior. */
2963 cxx_pp->flags |= pp_c_flag_gnu_v3;
2964 name = decl_as_string (decl, flags);
2965 /* Subsequent calls to the pretty printer shouldn't use this style. */
2966 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2967 return name;
2970 const char *
2971 decl_as_string (tree decl, int flags)
2973 reinit_cxx_pp ();
2974 pp_translate_identifiers (cxx_pp) = false;
2975 dump_decl (cxx_pp, decl, flags);
2976 return pp_ggc_formatted_text (cxx_pp);
2979 const char *
2980 decl_as_string_translate (tree decl, int flags)
2982 reinit_cxx_pp ();
2983 dump_decl (cxx_pp, decl, flags);
2984 return pp_ggc_formatted_text (cxx_pp);
2987 /* Wrap lang_decl_name with options appropriate for dwarf. */
2989 const char *
2990 lang_decl_dwarf_name (tree decl, int v, bool translate)
2992 const char *name;
2993 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2994 here will be adequate to get the desired behavior. */
2995 cxx_pp->flags |= pp_c_flag_gnu_v3;
2996 name = lang_decl_name (decl, v, translate);
2997 /* Subsequent calls to the pretty printer shouldn't use this style. */
2998 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2999 return name;
3002 /* Generate the three forms of printable names for cxx_printable_name. */
3004 const char *
3005 lang_decl_name (tree decl, int v, bool translate)
3007 if (v >= 2)
3008 return (translate
3009 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
3010 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
3012 reinit_cxx_pp ();
3013 pp_translate_identifiers (cxx_pp) = translate;
3014 if (v == 1
3015 && (DECL_CLASS_SCOPE_P (decl)
3016 || (DECL_NAMESPACE_SCOPE_P (decl)
3017 && CP_DECL_CONTEXT (decl) != global_namespace)))
3019 dump_type (cxx_pp, CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
3020 pp_cxx_colon_colon (cxx_pp);
3023 if (TREE_CODE (decl) == FUNCTION_DECL)
3024 dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER);
3025 else if ((DECL_NAME (decl) == NULL_TREE)
3026 && TREE_CODE (decl) == NAMESPACE_DECL)
3027 dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER | TFF_UNQUALIFIED_NAME);
3028 else
3029 dump_decl (cxx_pp, DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
3031 return pp_ggc_formatted_text (cxx_pp);
3034 /* Return the location of a tree passed to %+ formats. */
3036 location_t
3037 location_of (tree t)
3039 if (TYPE_P (t))
3041 t = TYPE_MAIN_DECL (t);
3042 if (t == NULL_TREE)
3043 return input_location;
3045 else if (TREE_CODE (t) == OVERLOAD)
3046 t = OVL_FIRST (t);
3048 if (DECL_P (t))
3049 return DECL_SOURCE_LOCATION (t);
3050 if (TREE_CODE (t) == DEFAULT_ARG)
3051 return defarg_location (t);
3052 return EXPR_LOC_OR_LOC (t, input_location);
3055 /* Now the interfaces from error et al to dump_type et al. Each takes an
3056 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
3057 function. */
3059 static const char *
3060 decl_to_string (tree decl, int verbose)
3062 int flags = 0;
3064 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
3065 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
3066 flags = TFF_CLASS_KEY_OR_ENUM;
3067 if (verbose)
3068 flags |= TFF_DECL_SPECIFIERS;
3069 else if (TREE_CODE (decl) == FUNCTION_DECL)
3070 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
3071 flags |= TFF_TEMPLATE_HEADER;
3073 reinit_cxx_pp ();
3074 dump_decl (cxx_pp, decl, flags);
3075 return pp_ggc_formatted_text (cxx_pp);
3078 static const char *
3079 expr_to_string (tree decl)
3081 reinit_cxx_pp ();
3082 dump_expr (cxx_pp, decl, 0);
3083 return pp_ggc_formatted_text (cxx_pp);
3086 static const char *
3087 fndecl_to_string (tree fndecl, int verbose)
3089 int flags;
3091 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
3092 | TFF_TEMPLATE_HEADER;
3093 if (verbose)
3094 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
3095 reinit_cxx_pp ();
3096 dump_decl (cxx_pp, fndecl, flags);
3097 return pp_ggc_formatted_text (cxx_pp);
3101 static const char *
3102 code_to_string (enum tree_code c)
3104 return get_tree_code_name (c);
3107 const char *
3108 language_to_string (enum languages c)
3110 switch (c)
3112 case lang_c:
3113 return "C";
3115 case lang_cplusplus:
3116 return "C++";
3118 default:
3119 gcc_unreachable ();
3121 return NULL;
3124 /* Return the proper printed version of a parameter to a C++ function. */
3126 static const char *
3127 parm_to_string (int p)
3129 reinit_cxx_pp ();
3130 if (p < 0)
3131 pp_string (cxx_pp, "'this'");
3132 else
3133 pp_decimal_int (cxx_pp, p + 1);
3134 return pp_ggc_formatted_text (cxx_pp);
3137 static const char *
3138 op_to_string (enum tree_code p)
3140 tree id = operator_name_info[p].identifier;
3141 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
3144 static const char *
3145 type_to_string (tree typ, int verbose)
3147 int flags = 0;
3148 if (verbose)
3149 flags |= TFF_CLASS_KEY_OR_ENUM;
3150 flags |= TFF_TEMPLATE_HEADER;
3152 reinit_cxx_pp ();
3153 dump_type (cxx_pp, typ, flags);
3154 /* If we're printing a type that involves typedefs, also print the
3155 stripped version. But sometimes the stripped version looks
3156 exactly the same, so we don't want it after all. To avoid printing
3157 it in that case, we play ugly obstack games. */
3158 if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
3159 && !uses_template_parms (typ))
3161 int aka_start, aka_len; char *p;
3162 struct obstack *ob = pp_buffer (cxx_pp)->obstack;
3163 /* Remember the end of the initial dump. */
3164 int len = obstack_object_size (ob);
3165 tree aka = strip_typedefs (typ);
3166 pp_string (cxx_pp, " {aka");
3167 pp_cxx_whitespace (cxx_pp);
3168 /* And remember the start of the aka dump. */
3169 aka_start = obstack_object_size (ob);
3170 dump_type (cxx_pp, aka, flags);
3171 aka_len = obstack_object_size (ob) - aka_start;
3172 pp_right_brace (cxx_pp);
3173 p = (char*)obstack_base (ob);
3174 /* If they are identical, cut off the aka with a NUL. */
3175 if (len == aka_len && memcmp (p, p+aka_start, len) == 0)
3176 p[len] = '\0';
3178 return pp_ggc_formatted_text (cxx_pp);
3181 static const char *
3182 assop_to_string (enum tree_code p)
3184 tree id = assignment_operator_name_info[(int) p].identifier;
3185 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
3188 static const char *
3189 args_to_string (tree p, int verbose)
3191 int flags = 0;
3192 if (verbose)
3193 flags |= TFF_CLASS_KEY_OR_ENUM;
3195 if (p == NULL_TREE)
3196 return "";
3198 if (TYPE_P (TREE_VALUE (p)))
3199 return type_as_string_translate (p, flags);
3201 reinit_cxx_pp ();
3202 for (; p; p = TREE_CHAIN (p))
3204 if (TREE_VALUE (p) == null_node)
3205 pp_cxx_ws_string (cxx_pp, "NULL");
3206 else
3207 dump_type (cxx_pp, error_type (TREE_VALUE (p)), flags);
3208 if (TREE_CHAIN (p))
3209 pp_separate_with_comma (cxx_pp);
3211 return pp_ggc_formatted_text (cxx_pp);
3214 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3215 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3216 arguments. */
3218 static const char *
3219 subst_to_string (tree p)
3221 tree decl = TREE_PURPOSE (p);
3222 tree targs = TREE_VALUE (p);
3223 tree tparms = DECL_TEMPLATE_PARMS (decl);
3224 int flags = (TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER
3225 |TFF_NO_TEMPLATE_BINDINGS);
3227 if (p == NULL_TREE)
3228 return "";
3230 reinit_cxx_pp ();
3231 dump_template_decl (cxx_pp, TREE_PURPOSE (p), flags);
3232 dump_substitution (cxx_pp, NULL, tparms, targs, /*flags=*/0);
3233 return pp_ggc_formatted_text (cxx_pp);
3236 static const char *
3237 cv_to_string (tree p, int v)
3239 reinit_cxx_pp ();
3240 cxx_pp->padding = v ? pp_before : pp_none;
3241 pp_cxx_cv_qualifier_seq (cxx_pp, p);
3242 return pp_ggc_formatted_text (cxx_pp);
3245 static const char *
3246 eh_spec_to_string (tree p, int /*v*/)
3248 int flags = 0;
3249 reinit_cxx_pp ();
3250 dump_exception_spec (cxx_pp, p, flags);
3251 return pp_ggc_formatted_text (cxx_pp);
3254 /* Langhook for print_error_function. */
3255 void
3256 cxx_print_error_function (diagnostic_context *context, const char *file,
3257 diagnostic_info *diagnostic)
3259 lhd_print_error_function (context, file, diagnostic);
3260 pp_set_prefix (context->printer, file);
3261 maybe_print_instantiation_context (context);
3264 static void
3265 cp_diagnostic_starter (diagnostic_context *context,
3266 diagnostic_info *diagnostic)
3268 diagnostic_report_current_module (context, diagnostic_location (diagnostic));
3269 cp_print_error_function (context, diagnostic);
3270 maybe_print_instantiation_context (context);
3271 maybe_print_constexpr_context (context);
3272 pp_set_prefix (context->printer, diagnostic_build_prefix (context,
3273 diagnostic));
3276 /* Print current function onto BUFFER, in the process of reporting
3277 a diagnostic message. Called from cp_diagnostic_starter. */
3278 static void
3279 cp_print_error_function (diagnostic_context *context,
3280 diagnostic_info *diagnostic)
3282 /* If we are in an instantiation context, current_function_decl is likely
3283 to be wrong, so just rely on print_instantiation_full_context. */
3284 if (current_instantiation ())
3285 return;
3286 if (diagnostic_last_function_changed (context, diagnostic))
3288 const char *old_prefix = context->printer->prefix;
3289 const char *file = LOCATION_FILE (diagnostic_location (diagnostic));
3290 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
3291 char *new_prefix = (file && abstract_origin == NULL)
3292 ? file_name_as_prefix (context, file) : NULL;
3294 pp_set_prefix (context->printer, new_prefix);
3296 if (current_function_decl == NULL)
3297 pp_string (context->printer, _("At global scope:"));
3298 else
3300 tree fndecl, ao;
3302 if (abstract_origin)
3304 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
3305 while (TREE_CODE (ao) == BLOCK
3306 && BLOCK_ABSTRACT_ORIGIN (ao)
3307 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3308 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3309 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
3310 fndecl = ao;
3312 else
3313 fndecl = current_function_decl;
3315 pp_printf (context->printer, function_category (fndecl),
3316 cxx_printable_name_translate (fndecl, 2));
3318 while (abstract_origin)
3320 location_t *locus;
3321 tree block = abstract_origin;
3323 locus = &BLOCK_SOURCE_LOCATION (block);
3324 fndecl = NULL;
3325 block = BLOCK_SUPERCONTEXT (block);
3326 while (block && TREE_CODE (block) == BLOCK
3327 && BLOCK_ABSTRACT_ORIGIN (block))
3329 ao = BLOCK_ABSTRACT_ORIGIN (block);
3331 while (TREE_CODE (ao) == BLOCK
3332 && BLOCK_ABSTRACT_ORIGIN (ao)
3333 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3334 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3336 if (TREE_CODE (ao) == FUNCTION_DECL)
3338 fndecl = ao;
3339 break;
3341 else if (TREE_CODE (ao) != BLOCK)
3342 break;
3344 block = BLOCK_SUPERCONTEXT (block);
3346 if (fndecl)
3347 abstract_origin = block;
3348 else
3350 while (block && TREE_CODE (block) == BLOCK)
3351 block = BLOCK_SUPERCONTEXT (block);
3353 if (block && TREE_CODE (block) == FUNCTION_DECL)
3354 fndecl = block;
3355 abstract_origin = NULL;
3357 if (fndecl)
3359 expanded_location s = expand_location (*locus);
3360 pp_character (context->printer, ',');
3361 pp_newline (context->printer);
3362 if (s.file != NULL)
3364 if (context->show_column && s.column != 0)
3365 pp_printf (context->printer,
3366 _(" inlined from %qs at %r%s:%d:%d%R"),
3367 cxx_printable_name_translate (fndecl, 2),
3368 "locus", s.file, s.line, s.column);
3369 else
3370 pp_printf (context->printer,
3371 _(" inlined from %qs at %r%s:%d%R"),
3372 cxx_printable_name_translate (fndecl, 2),
3373 "locus", s.file, s.line);
3376 else
3377 pp_printf (context->printer, _(" inlined from %qs"),
3378 cxx_printable_name_translate (fndecl, 2));
3381 pp_character (context->printer, ':');
3383 pp_newline (context->printer);
3385 diagnostic_set_last_function (context, diagnostic);
3386 pp_destroy_prefix (context->printer);
3387 context->printer->prefix = old_prefix;
3391 /* Returns a description of FUNCTION using standard terminology. The
3392 result is a format string of the form "In CATEGORY %qs". */
3393 static const char *
3394 function_category (tree fn)
3396 /* We can get called from the middle-end for diagnostics of function
3397 clones. Make sure we have language specific information before
3398 dereferencing it. */
3399 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
3400 && DECL_FUNCTION_MEMBER_P (fn))
3402 if (DECL_STATIC_FUNCTION_P (fn))
3403 return _("In static member function %qs");
3404 else if (DECL_COPY_CONSTRUCTOR_P (fn))
3405 return _("In copy constructor %qs");
3406 else if (DECL_CONSTRUCTOR_P (fn))
3407 return _("In constructor %qs");
3408 else if (DECL_DESTRUCTOR_P (fn))
3409 return _("In destructor %qs");
3410 else if (LAMBDA_FUNCTION_P (fn))
3411 return _("In lambda function");
3412 else
3413 return _("In member function %qs");
3415 else
3416 return _("In function %qs");
3419 /* Report the full context of a current template instantiation,
3420 onto BUFFER. */
3421 static void
3422 print_instantiation_full_context (diagnostic_context *context)
3424 struct tinst_level *p = current_instantiation ();
3425 location_t location = input_location;
3427 if (p)
3429 pp_verbatim (context->printer,
3430 TREE_CODE (p->decl) == TREE_LIST
3431 ? _("%s: In substitution of %qS:\n")
3432 : _("%s: In instantiation of %q#D:\n"),
3433 LOCATION_FILE (location),
3434 p->decl);
3436 location = p->locus;
3437 p = p->next;
3440 print_instantiation_partial_context (context, p, location);
3443 /* Helper function of print_instantiation_partial_context() that
3444 prints a single line of instantiation context. */
3446 static void
3447 print_instantiation_partial_context_line (diagnostic_context *context,
3448 const struct tinst_level *t,
3449 location_t loc, bool recursive_p)
3451 if (loc == UNKNOWN_LOCATION)
3452 return;
3454 expanded_location xloc = expand_location (loc);
3456 if (context->show_column)
3457 pp_verbatim (context->printer, _("%r%s:%d:%d:%R "),
3458 "locus", xloc.file, xloc.line, xloc.column);
3459 else
3460 pp_verbatim (context->printer, _("%r%s:%d:%R "),
3461 "locus", xloc.file, xloc.line);
3463 if (t != NULL)
3465 if (TREE_CODE (t->decl) == TREE_LIST)
3466 pp_verbatim (context->printer,
3467 recursive_p
3468 ? _("recursively required by substitution of %qS\n")
3469 : _("required by substitution of %qS\n"),
3470 t->decl);
3471 else
3472 pp_verbatim (context->printer,
3473 recursive_p
3474 ? _("recursively required from %q#D\n")
3475 : _("required from %q#D\n"),
3476 t->decl);
3478 else
3480 pp_verbatim (context->printer,
3481 recursive_p
3482 ? _("recursively required from here\n")
3483 : _("required from here\n"));
3487 /* Same as print_instantiation_full_context but less verbose. */
3489 static void
3490 print_instantiation_partial_context (diagnostic_context *context,
3491 struct tinst_level *t0, location_t loc)
3493 struct tinst_level *t;
3494 int n_total = 0;
3495 int n;
3496 location_t prev_loc = loc;
3498 for (t = t0; t != NULL; t = t->next)
3499 if (prev_loc != t->locus)
3501 prev_loc = t->locus;
3502 n_total++;
3505 t = t0;
3507 if (template_backtrace_limit
3508 && n_total > template_backtrace_limit)
3510 int skip = n_total - template_backtrace_limit;
3511 int head = template_backtrace_limit / 2;
3513 /* Avoid skipping just 1. If so, skip 2. */
3514 if (skip == 1)
3516 skip = 2;
3517 head = (template_backtrace_limit - 1) / 2;
3520 for (n = 0; n < head; n++)
3522 gcc_assert (t != NULL);
3523 if (loc != t->locus)
3524 print_instantiation_partial_context_line (context, t, loc,
3525 /*recursive_p=*/false);
3526 loc = t->locus;
3527 t = t->next;
3529 if (t != NULL && skip > 0)
3531 expanded_location xloc;
3532 xloc = expand_location (loc);
3533 if (context->show_column)
3534 pp_verbatim (context->printer,
3535 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3536 "contexts, use -ftemplate-backtrace-limit=0 to "
3537 "disable ]\n"),
3538 "locus", xloc.file, xloc.line, xloc.column, skip);
3539 else
3540 pp_verbatim (context->printer,
3541 _("%r%s:%d:%R [ skipping %d instantiation "
3542 "contexts, use -ftemplate-backtrace-limit=0 to "
3543 "disable ]\n"),
3544 "locus", xloc.file, xloc.line, skip);
3546 do {
3547 loc = t->locus;
3548 t = t->next;
3549 } while (t != NULL && --skip > 0);
3553 while (t != NULL)
3555 while (t->next != NULL && t->locus == t->next->locus)
3557 loc = t->locus;
3558 t = t->next;
3560 print_instantiation_partial_context_line (context, t, loc,
3561 t->locus == loc);
3562 loc = t->locus;
3563 t = t->next;
3565 print_instantiation_partial_context_line (context, NULL, loc,
3566 /*recursive_p=*/false);
3569 /* Called from cp_thing to print the template context for an error. */
3570 static void
3571 maybe_print_instantiation_context (diagnostic_context *context)
3573 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3574 return;
3576 record_last_problematic_instantiation ();
3577 print_instantiation_full_context (context);
3580 /* Report what constexpr call(s) we're trying to expand, if any. */
3582 void
3583 maybe_print_constexpr_context (diagnostic_context *context)
3585 vec<tree> call_stack = cx_error_context ();
3586 unsigned ix;
3587 tree t;
3589 FOR_EACH_VEC_ELT (call_stack, ix, t)
3591 expanded_location xloc = expand_location (EXPR_LOCATION (t));
3592 const char *s = expr_as_string (t, 0);
3593 if (context->show_column)
3594 pp_verbatim (context->printer,
3595 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3596 "locus", xloc.file, xloc.line, xloc.column, s);
3597 else
3598 pp_verbatim (context->printer,
3599 _("%r%s:%d:%R in constexpr expansion of %qs"),
3600 "locus", xloc.file, xloc.line, s);
3601 pp_newline (context->printer);
3606 /* Return true iff TYPE_A and TYPE_B are template types that are
3607 meaningful to compare. */
3609 static bool
3610 comparable_template_types_p (tree type_a, tree type_b)
3612 if (!CLASS_TYPE_P (type_a))
3613 return false;
3614 if (!CLASS_TYPE_P (type_b))
3615 return false;
3617 tree tinfo_a = TYPE_TEMPLATE_INFO (type_a);
3618 tree tinfo_b = TYPE_TEMPLATE_INFO (type_b);
3619 if (!tinfo_a || !tinfo_b)
3620 return false;
3622 return TI_TEMPLATE (tinfo_a) == TI_TEMPLATE (tinfo_b);
3625 /* Start a new line indented by SPC spaces on PP. */
3627 static void
3628 newline_and_indent (pretty_printer *pp, int spc)
3630 pp_newline (pp);
3631 for (int i = 0; i < spc; i++)
3632 pp_space (pp);
3635 /* Generate a GC-allocated string for ARG, an expression or type. */
3637 static const char *
3638 arg_to_string (tree arg, bool verbose)
3640 if (TYPE_P (arg))
3641 return type_to_string (arg, verbose);
3642 else
3643 return expr_to_string (arg);
3646 /* Subroutine to type_to_string_with_compare and
3647 print_template_tree_comparison.
3649 Print a representation of ARG (an expression or type) to PP,
3650 colorizing it as "type-diff" if PP->show_color. */
3652 static void
3653 print_nonequal_arg (pretty_printer *pp, tree arg, bool verbose)
3655 pp_printf (pp, "%r%s%R",
3656 "type-diff",
3657 (arg
3658 ? arg_to_string (arg, verbose)
3659 : G_("(no argument)")));
3662 /* Recursively print template TYPE_A to PP, as compared to template TYPE_B.
3664 The types must satisfy comparable_template_types_p.
3666 If INDENT is 0, then this is equivalent to type_to_string (TYPE_A), but
3667 potentially colorizing/eliding in comparison with TYPE_B.
3669 For example given types:
3670 vector<map<int,double>>
3672 vector<map<int,float>>
3673 then the result on PP would be:
3674 vector<map<[...],double>>
3675 with type elision, and:
3676 vector<map<int,double>>
3677 without type elision.
3679 In both cases the parts of TYPE that differ from PEER will be colorized
3680 if pp_show_color (pp) is true. In the above example, this would be
3681 "double".
3683 If INDENT is non-zero, then the types are printed in a tree-like form
3684 which shows both types. In the above example, the result on PP would be:
3686 vector<
3687 map<
3688 [...],
3689 [double != float]>>
3691 and without type-elision would be:
3693 vector<
3694 map<
3695 int,
3696 [double != float]>>
3698 As before, the differing parts of the types are colorized if
3699 pp_show_color (pp) is true ("double" and "float" in this example).
3701 Template arguments in which both types are using the default arguments
3702 are not printed; if at least one of the two types is using a non-default
3703 argument, then that argument is printed (or both arguments for the
3704 tree-like print format). */
3706 static void
3707 print_template_differences (pretty_printer *pp, tree type_a, tree type_b,
3708 bool verbose, int indent)
3710 if (indent)
3711 newline_and_indent (pp, indent);
3713 tree tinfo_a = TYPE_TEMPLATE_INFO (type_a);
3714 tree tinfo_b = TYPE_TEMPLATE_INFO (type_b);
3716 pp_printf (pp, "%s<",
3717 IDENTIFIER_POINTER (DECL_NAME (TI_TEMPLATE (tinfo_a))));
3719 tree args_a = TI_ARGS (tinfo_a);
3720 tree args_b = TI_ARGS (tinfo_b);
3721 gcc_assert (TREE_CODE (args_a) == TREE_VEC);
3722 gcc_assert (TREE_CODE (args_b) == TREE_VEC);
3723 int flags = 0;
3724 int len_a = get_non_default_template_args_count (args_a, flags);
3725 args_a = INNERMOST_TEMPLATE_ARGS (args_a);
3726 int len_b = get_non_default_template_args_count (args_b, flags);
3727 args_b = INNERMOST_TEMPLATE_ARGS (args_b);
3728 /* Determine the maximum range of args for which non-default template args
3729 were used; beyond this, only default args (if any) were used, and so
3730 they will be equal from this point onwards.
3731 One of the two peers might have used default arguments within this
3732 range, but the other will be using non-default arguments, and so
3733 it's more readable to print both within this range, to highlight
3734 the differences. */
3735 int len_max = MAX (len_a, len_b);
3736 gcc_assert (TREE_CODE (args_a) == TREE_VEC);
3737 gcc_assert (TREE_CODE (args_b) == TREE_VEC);
3738 for (int idx = 0; idx < len_max; idx++)
3740 if (idx)
3741 pp_character (pp, ',');
3743 tree arg_a = TREE_VEC_ELT (args_a, idx);
3744 tree arg_b = TREE_VEC_ELT (args_b, idx);
3745 if (arg_a == arg_b)
3747 if (indent)
3748 newline_and_indent (pp, indent + 2);
3749 /* Can do elision here, printing "[...]". */
3750 if (flag_elide_type)
3751 pp_string (pp, G_("[...]"));
3752 else
3753 pp_string (pp, arg_to_string (arg_a, verbose));
3755 else
3757 int new_indent = indent ? indent + 2 : 0;
3758 if (comparable_template_types_p (arg_a, arg_b))
3759 print_template_differences (pp, arg_a, arg_b, verbose, new_indent);
3760 else
3761 if (indent)
3763 newline_and_indent (pp, indent + 2);
3764 pp_character (pp, '[');
3765 print_nonequal_arg (pp, arg_a, verbose);
3766 pp_string (pp, " != ");
3767 print_nonequal_arg (pp, arg_b, verbose);
3768 pp_character (pp, ']');
3770 else
3771 print_nonequal_arg (pp, arg_a, verbose);
3774 pp_printf (pp, ">");
3777 /* As type_to_string, but for a template, potentially colorizing/eliding
3778 in comparison with PEER.
3779 For example, if TYPE is map<int,double> and PEER is map<int,int>,
3780 then the resulting string would be:
3781 map<[...],double>
3782 with type elision, and:
3783 map<int,double>
3784 without type elision.
3786 In both cases the parts of TYPE that differ from PEER will be colorized
3787 if SHOW_COLOR is true. In the above example, this would be "double".
3789 Template arguments in which both types are using the default arguments
3790 are not printed; if at least one of the two types is using a non-default
3791 argument, then both arguments are printed.
3793 The resulting string is in a GC-allocated buffer. */
3795 static const char *
3796 type_to_string_with_compare (tree type, tree peer, bool verbose,
3797 bool show_color)
3799 pretty_printer inner_pp;
3800 pretty_printer *pp = &inner_pp;
3801 pp_show_color (pp) = show_color;
3803 print_template_differences (pp, type, peer, verbose, 0);
3804 return pp_ggc_formatted_text (pp);
3807 /* Recursively print a tree-like comparison of TYPE_A and TYPE_B to PP,
3808 indented by INDENT spaces.
3810 For example given types:
3812 vector<map<int,double>>
3816 vector<map<double,float>>
3818 the output with type elision would be:
3820 vector<
3821 map<
3822 [...],
3823 [double != float]>>
3825 and without type-elision would be:
3827 vector<
3828 map<
3829 int,
3830 [double != float]>>
3832 TYPE_A and TYPE_B must both be comparable template types
3833 (as per comparable_template_types_p).
3835 Template arguments in which both types are using the default arguments
3836 are not printed; if at least one of the two types is using a non-default
3837 argument, then both arguments are printed. */
3839 static void
3840 print_template_tree_comparison (pretty_printer *pp, tree type_a, tree type_b,
3841 bool verbose, int indent)
3843 print_template_differences (pp, type_a, type_b, verbose, indent);
3846 /* Subroutine for use in a format_postprocessor::handle
3847 implementation. Adds a chunk to the end of
3848 formatted output, so that it will be printed
3849 by pp_output_formatted_text. */
3851 static void
3852 append_formatted_chunk (pretty_printer *pp, const char *content)
3854 output_buffer *buffer = pp_buffer (pp);
3855 struct chunk_info *chunk_array = buffer->cur_chunk_array;
3856 const char **args = chunk_array->args;
3858 unsigned int chunk_idx;
3859 for (chunk_idx = 0; args[chunk_idx]; chunk_idx++)
3861 args[chunk_idx++] = content;
3862 args[chunk_idx] = NULL;
3865 /* Create a copy of CONTENT, with quotes added, and,
3866 potentially, with colorization.
3867 No escaped is performed on CONTENT.
3868 The result is in a GC-allocated buffer. */
3870 static const char *
3871 add_quotes (const char *content, bool show_color)
3873 pretty_printer tmp_pp;
3874 pp_show_color (&tmp_pp) = show_color;
3876 /* We have to use "%<%s%>" rather than "%qs" here in order to avoid
3877 quoting colorization bytes within the results. */
3878 pp_printf (&tmp_pp, "%<%s%>", content);
3880 return pp_ggc_formatted_text (&tmp_pp);
3883 /* If we had %H and %I, and hence deferred printing them,
3884 print them now, storing the result into the chunk_info
3885 for pp_format. Quote them if 'q' was provided.
3886 Also print the difference in tree form, adding it as
3887 an additional chunk. */
3889 void
3890 cxx_format_postprocessor::handle (pretty_printer *pp)
3892 /* If we have one of %H and %I, the other should have
3893 been present. */
3894 if (m_type_a.m_tree || m_type_b.m_tree)
3896 /* Avoid reentrancy issues by working with a copy of
3897 m_type_a and m_type_b, resetting them now. */
3898 deferred_printed_type type_a = m_type_a;
3899 deferred_printed_type type_b = m_type_b;
3900 m_type_a = deferred_printed_type ();
3901 m_type_b = deferred_printed_type ();
3903 gcc_assert (type_a.m_buffer_ptr);
3904 gcc_assert (type_b.m_buffer_ptr);
3906 bool show_color = pp_show_color (pp);
3908 const char *type_a_text;
3909 const char *type_b_text;
3911 if (comparable_template_types_p (type_a.m_tree, type_b.m_tree))
3913 type_a_text
3914 = type_to_string_with_compare (type_a.m_tree, type_b.m_tree,
3915 type_a.m_verbose, show_color);
3916 type_b_text
3917 = type_to_string_with_compare (type_b.m_tree, type_a.m_tree,
3918 type_b.m_verbose, show_color);
3920 if (flag_diagnostics_show_template_tree)
3922 pretty_printer inner_pp;
3923 pp_show_color (&inner_pp) = pp_show_color (pp);
3924 print_template_tree_comparison
3925 (&inner_pp, type_a.m_tree, type_b.m_tree, type_a.m_verbose, 2);
3926 append_formatted_chunk (pp, pp_ggc_formatted_text (&inner_pp));
3929 else
3931 /* If the types were not comparable, they are printed normally,
3932 and no difference tree is printed. */
3933 type_a_text = type_to_string (type_a.m_tree, type_a.m_verbose);
3934 type_b_text = type_to_string (type_b.m_tree, type_b.m_verbose);
3937 if (type_a.m_quote)
3938 type_a_text = add_quotes (type_a_text, show_color);
3939 *type_a.m_buffer_ptr = type_a_text;
3941 if (type_b.m_quote)
3942 type_b_text = add_quotes (type_b_text, show_color);
3943 *type_b.m_buffer_ptr = type_b_text;
3947 /* Subroutine for handling %H and %I, to support i18n of messages like:
3949 error_at (loc, "could not convert %qE from %qH to %qI",
3950 expr, type_a, type_b);
3952 so that we can print things like:
3954 could not convert 'foo' from 'map<int,double>' to 'map<int,int>'
3956 and, with type-elision:
3958 could not convert 'foo' from 'map<[...],double>' to 'map<[...],int>'
3960 (with color-coding of the differences between the types).
3962 The %H and %I format codes are peers: both must be present,
3963 and they affect each other. Hence to handle them, we must
3964 delay printing until we have both, deferring the printing to
3965 pretty_printer's m_format_postprocessor hook.
3967 This is called in phase 2 of pp_format, when it is accumulating
3968 a series of formatted chunks. We stash the location of the chunk
3969 we're meant to have written to, so that we can write to it in the
3970 m_format_postprocessor hook.
3972 We also need to stash whether a 'q' prefix was provided (the QUOTE
3973 param) so that we can add the quotes when writing out the delayed
3974 chunk. */
3976 static void
3977 defer_phase_2_of_type_diff (deferred_printed_type *deferred,
3978 tree type, const char **buffer_ptr,
3979 bool verbose, bool quote)
3981 gcc_assert (deferred->m_tree == NULL_TREE);
3982 gcc_assert (deferred->m_buffer_ptr == NULL);
3983 *deferred = deferred_printed_type (type, buffer_ptr, verbose, quote);
3987 /* Called from output_format -- during diagnostic message processing --
3988 to handle C++ specific format specifier with the following meanings:
3989 %A function argument-list.
3990 %C tree code.
3991 %D declaration.
3992 %E expression.
3993 %F function declaration.
3994 %L language as used in extern "lang".
3995 %O binary operator.
3996 %P function parameter whose position is indicated by an integer.
3997 %Q assignment operator.
3998 %S substitution (template + args)
3999 %T type.
4000 %V cv-qualifier.
4001 %X exception-specification.
4002 %H type difference (from)
4003 %I type difference (to). */
4004 static bool
4005 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
4006 int precision, bool wide, bool set_locus, bool verbose,
4007 bool quoted, const char **buffer_ptr)
4009 gcc_assert (pp->m_format_postprocessor);
4010 cxx_format_postprocessor *postprocessor
4011 = static_cast <cxx_format_postprocessor *> (pp->m_format_postprocessor);
4013 const char *result;
4014 tree t = NULL;
4015 #define next_tree (t = va_arg (*text->args_ptr, tree))
4016 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
4017 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
4018 #define next_int va_arg (*text->args_ptr, int)
4020 if (precision != 0 || wide)
4021 return false;
4023 switch (*spec)
4025 case 'A': result = args_to_string (next_tree, verbose); break;
4026 case 'C': result = code_to_string (next_tcode); break;
4027 case 'D':
4029 tree temp = next_tree;
4030 if (VAR_P (temp)
4031 && DECL_HAS_DEBUG_EXPR_P (temp))
4033 temp = DECL_DEBUG_EXPR (temp);
4034 if (!DECL_P (temp))
4036 result = expr_to_string (temp);
4037 break;
4040 result = decl_to_string (temp, verbose);
4042 break;
4043 case 'E': result = expr_to_string (next_tree); break;
4044 case 'F': result = fndecl_to_string (next_tree, verbose); break;
4045 case 'L': result = language_to_string (next_lang); break;
4046 case 'O': result = op_to_string (next_tcode); break;
4047 case 'P': result = parm_to_string (next_int); break;
4048 case 'Q': result = assop_to_string (next_tcode); break;
4049 case 'S': result = subst_to_string (next_tree); break;
4050 case 'T': result = type_to_string (next_tree, verbose); break;
4051 case 'V': result = cv_to_string (next_tree, verbose); break;
4052 case 'X': result = eh_spec_to_string (next_tree, verbose); break;
4054 case 'G':
4055 percent_G_format (text);
4056 return true;
4058 case 'K':
4059 t = va_arg (*text->args_ptr, tree);
4060 percent_K_format (text, t);
4061 return true;
4063 case 'H':
4065 defer_phase_2_of_type_diff (&postprocessor->m_type_a, next_tree,
4066 buffer_ptr, verbose, quoted);
4067 return true;
4070 case 'I':
4072 defer_phase_2_of_type_diff (&postprocessor->m_type_b, next_tree,
4073 buffer_ptr, verbose, quoted);
4074 return true;
4077 default:
4078 return false;
4081 pp_string (pp, result);
4082 if (set_locus && t != NULL)
4083 text->set_location (0, location_of (t), true);
4084 return true;
4085 #undef next_tree
4086 #undef next_tcode
4087 #undef next_lang
4088 #undef next_int
4091 /* Warn about the use of C++0x features when appropriate. */
4092 void
4093 maybe_warn_cpp0x (cpp0x_warn_str str)
4095 if ((cxx_dialect == cxx98) && !in_system_header_at (input_location))
4096 /* We really want to suppress this warning in system headers,
4097 because libstdc++ uses variadic templates even when we aren't
4098 in C++0x mode. */
4099 switch (str)
4101 case CPP0X_INITIALIZER_LISTS:
4102 pedwarn (input_location, 0,
4103 "extended initializer lists "
4104 "only available with -std=c++11 or -std=gnu++11");
4105 break;
4106 case CPP0X_EXPLICIT_CONVERSION:
4107 pedwarn (input_location, 0,
4108 "explicit conversion operators "
4109 "only available with -std=c++11 or -std=gnu++11");
4110 break;
4111 case CPP0X_VARIADIC_TEMPLATES:
4112 pedwarn (input_location, 0,
4113 "variadic templates "
4114 "only available with -std=c++11 or -std=gnu++11");
4115 break;
4116 case CPP0X_LAMBDA_EXPR:
4117 pedwarn (input_location, 0,
4118 "lambda expressions "
4119 "only available with -std=c++11 or -std=gnu++11");
4120 break;
4121 case CPP0X_AUTO:
4122 pedwarn (input_location, 0,
4123 "C++11 auto only available with -std=c++11 or -std=gnu++11");
4124 break;
4125 case CPP0X_SCOPED_ENUMS:
4126 pedwarn (input_location, 0,
4127 "scoped enums only available with -std=c++11 or -std=gnu++11");
4128 break;
4129 case CPP0X_DEFAULTED_DELETED:
4130 pedwarn (input_location, 0,
4131 "defaulted and deleted functions "
4132 "only available with -std=c++11 or -std=gnu++11");
4133 break;
4134 case CPP0X_INLINE_NAMESPACES:
4135 pedwarn (input_location, OPT_Wpedantic,
4136 "inline namespaces "
4137 "only available with -std=c++11 or -std=gnu++11");
4138 break;
4139 case CPP0X_OVERRIDE_CONTROLS:
4140 pedwarn (input_location, 0,
4141 "override controls (override/final) "
4142 "only available with -std=c++11 or -std=gnu++11");
4143 break;
4144 case CPP0X_NSDMI:
4145 pedwarn (input_location, 0,
4146 "non-static data member initializers "
4147 "only available with -std=c++11 or -std=gnu++11");
4148 break;
4149 case CPP0X_USER_DEFINED_LITERALS:
4150 pedwarn (input_location, 0,
4151 "user-defined literals "
4152 "only available with -std=c++11 or -std=gnu++11");
4153 break;
4154 case CPP0X_DELEGATING_CTORS:
4155 pedwarn (input_location, 0,
4156 "delegating constructors "
4157 "only available with -std=c++11 or -std=gnu++11");
4158 break;
4159 case CPP0X_INHERITING_CTORS:
4160 pedwarn (input_location, 0,
4161 "inheriting constructors "
4162 "only available with -std=c++11 or -std=gnu++11");
4163 break;
4164 case CPP0X_ATTRIBUTES:
4165 pedwarn (input_location, 0,
4166 "c++11 attributes "
4167 "only available with -std=c++11 or -std=gnu++11");
4168 break;
4169 case CPP0X_REF_QUALIFIER:
4170 pedwarn (input_location, 0,
4171 "ref-qualifiers "
4172 "only available with -std=c++11 or -std=gnu++11");
4173 break;
4174 default:
4175 gcc_unreachable ();
4179 /* Warn about the use of variadic templates when appropriate. */
4180 void
4181 maybe_warn_variadic_templates (void)
4183 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
4187 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
4188 option OPT with text GMSGID. Use this function to report
4189 diagnostics for constructs that are invalid C++98, but valid
4190 C++0x. */
4191 bool
4192 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
4194 diagnostic_info diagnostic;
4195 va_list ap;
4196 bool ret;
4197 rich_location richloc (line_table, location);
4199 va_start (ap, gmsgid);
4200 diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc,
4201 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
4202 diagnostic.option_index = opt;
4203 ret = diagnostic_report_diagnostic (global_dc, &diagnostic);
4204 va_end (ap);
4205 return ret;
4208 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
4209 we found when we tried to do the lookup. LOCATION is the location of
4210 the NAME identifier. */
4212 void
4213 qualified_name_lookup_error (tree scope, tree name,
4214 tree decl, location_t location)
4216 if (scope == error_mark_node)
4217 ; /* We already complained. */
4218 else if (TYPE_P (scope))
4220 if (!COMPLETE_TYPE_P (scope))
4221 error_at (location, "incomplete type %qT used in nested name specifier",
4222 scope);
4223 else if (TREE_CODE (decl) == TREE_LIST)
4225 error_at (location, "reference to %<%T::%D%> is ambiguous",
4226 scope, name);
4227 print_candidates (decl);
4229 else
4230 error_at (location, "%qD is not a member of %qT", name, scope);
4232 else if (scope != global_namespace)
4234 error_at (location, "%qD is not a member of %qD", name, scope);
4235 if (!suggest_alternative_in_explicit_scope (location, name, scope))
4236 suggest_alternatives_for (location, name, false);
4238 else
4240 error_at (location, "%<::%D%> has not been declared", name);
4241 suggest_alternatives_for (location, name, true);