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.
5
6GCC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 3, or (at your option)
9any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
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"
34
35#define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
36#define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
37
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__. */
43static cxx_pretty_printer actual_pretty_printer;
44static cxx_pretty_printer * const cxx_pp = &actual_pretty_printer;
45
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))
49
50# define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
51
52static const char *args_to_string (tree, int);
53static const char *code_to_string (enum tree_code);
54static const char *cv_to_string (tree, int);
55static const char *decl_to_string (tree, int);
56static const char *expr_to_string (tree);
57static const char *fndecl_to_string (tree, int);
58static const char *op_to_string (bool, enum tree_code);
59static const char *parm_to_string (int);
60static const char *type_to_string (tree, int, bool, bool *, bool);
61
62static void dump_alias_template_specialization (cxx_pretty_printer *, tree, int);
63static void dump_type (cxx_pretty_printer *, tree, int);
64static void dump_typename (cxx_pretty_printer *, tree, int);
65static void dump_simple_decl (cxx_pretty_printer *, tree, tree, int);
66static void dump_decl (cxx_pretty_printer *, tree, int);
67static void dump_template_decl (cxx_pretty_printer *, tree, int);
68static void dump_function_decl (cxx_pretty_printer *, tree, int);
69static void dump_expr (cxx_pretty_printer *, tree, int);
70static void dump_unary_op (cxx_pretty_printer *, const char *, tree, int);
71static void dump_binary_op (cxx_pretty_printer *, const char *, tree, int);
72static void dump_aggr_type (cxx_pretty_printer *, tree, int);
73static void dump_type_prefix (cxx_pretty_printer *, tree, int);
74static void dump_type_suffix (cxx_pretty_printer *, tree, int);
75static void dump_function_name (cxx_pretty_printer *, tree, int);
76static void dump_call_expr_args (cxx_pretty_printer *, tree, int, bool);
77static void dump_aggr_init_expr_args (cxx_pretty_printer *, tree, int, bool);
78static void dump_expr_list (cxx_pretty_printer *, tree, int);
79static void dump_global_iord (cxx_pretty_printer *, tree);
80static void dump_parameters (cxx_pretty_printer *, tree, int);
81static void dump_ref_qualifier (cxx_pretty_printer *, tree, int);
82static void dump_exception_spec (cxx_pretty_printer *, tree, int);
83static void dump_template_argument (cxx_pretty_printer *, tree, int);
84static void dump_template_argument_list (cxx_pretty_printer *, tree, int);
85static void dump_template_parameter (cxx_pretty_printer *, tree, int);
86static void dump_template_bindings (cxx_pretty_printer *, tree, tree,
87 vec<tree, va_gc> *);
88static void dump_scope (cxx_pretty_printer *, tree, int);
89static void dump_template_parms (cxx_pretty_printer *, tree, int, int);
90static int get_non_default_template_args_count (tree, int);
91static const char *function_category (tree);
92static void maybe_print_constexpr_context (diagnostic_context *);
93static void maybe_print_instantiation_context (diagnostic_context *);
94static void print_instantiation_full_context (diagnostic_context *);
95static void print_instantiation_partial_context (diagnostic_context *,
96 struct tinst_level *,
97 location_t);
98static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
99static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
100
101static bool cp_printer (pretty_printer *, text_info *, const char *,
102 int, bool, bool, bool, bool *, const char **);
103
104/* Struct for handling %H or %I, which require delaying printing the
105 type until a postprocessing stage. */
106
107struct deferred_printed_type
108{
109 deferred_printed_type ()
110 : m_tree (NULL_TREE), m_buffer_ptr (NULL), m_verbose (false), m_quote (false)
111 {}
112
113 deferred_printed_type (tree type, const char **buffer_ptr, bool verbose,
114 bool quote)
115 : m_tree (type), m_buffer_ptr (buffer_ptr), m_verbose (verbose),
116 m_quote (quote)
117 {
118 gcc_assert (type);
119 gcc_assert (buffer_ptr);
120 }
121
122 /* The tree is not GTY-marked: they are only non-NULL within a
123 call to pp_format. */
124 tree m_tree;
125 const char **m_buffer_ptr;
126 bool m_verbose;
127 bool m_quote;
128};
129
130/* Subclass of format_postprocessor for the C++ frontend.
131 This handles the %H and %I formatting codes, printing them
132 in a postprocessing phase (since they affect each other). */
133
134class cxx_format_postprocessor : public format_postprocessor
135{
136 public:
137 cxx_format_postprocessor ()
138 : m_type_a (), m_type_b ()
139 {}
140
141 void handle (pretty_printer *pp) FINAL OVERRIDE;
142
143 deferred_printed_type m_type_a;
144 deferred_printed_type m_type_b;
145};
146
147/* CONTEXT->printer is a basic pretty printer that was constructed
148 presumably by diagnostic_initialize(), called early in the
149 compiler's initialization process (in general_init) Before the FE
150 is initialized. This (C++) FE-specific diagnostic initializer is
151 thus replacing the basic pretty printer with one that has C++-aware
152 capacities. */
153
154void
155cxx_initialize_diagnostics (diagnostic_context *context)
156{
157 pretty_printer *base = context->printer;
158 cxx_pretty_printer *pp = XNEW (cxx_pretty_printer);
159 context->printer = new (pp) cxx_pretty_printer ();
160
161 /* It is safe to free this object because it was previously XNEW()'d. */
162 base->~pretty_printer ();
163 XDELETE (base);
164
165 c_common_diagnostics_set_defaults (context);
166 diagnostic_starter (context) = cp_diagnostic_starter;
167 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
168 diagnostic_format_decoder (context) = cp_printer;
169 pp->m_format_postprocessor = new cxx_format_postprocessor ();
170}
171
172/* Dump a scope, if deemed necessary. */
173
174static void
175dump_scope (cxx_pretty_printer *pp, tree scope, int flags)
176{
177 int f = flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF);
178
179 if (scope == NULL_TREE)
180 return;
181
182 if (TREE_CODE (scope) == NAMESPACE_DECL)
183 {
184 if (scope != global_namespace)
185 {
186 dump_decl (pp, scope, f);
187 pp_cxx_colon_colon (pp);
188 }
189 }
190 else if (AGGREGATE_TYPE_P (scope))
191 {
192 dump_type (pp, scope, f);
193 pp_cxx_colon_colon (pp);
194 }
195 else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
196 {
197 dump_function_decl (pp, scope, f);
198 pp_cxx_colon_colon (pp);
199 }
200}
201
202/* Dump the template ARGument under control of FLAGS. */
203
204static void
205dump_template_argument (cxx_pretty_printer *pp, tree arg, int flags)
206{
207 if (ARGUMENT_PACK_P (arg))
208 dump_template_argument_list (pp, ARGUMENT_PACK_ARGS (arg),
209 /* No default args in argument packs. */
210 flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
211 else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
212 dump_type (pp, arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
213 else
214 {
215 if (TREE_CODE (arg) == TREE_LIST)
216 arg = TREE_VALUE (arg);
217
218 /* Strip implicit conversions. */
219 while (CONVERT_EXPR_P (arg))
220 arg = TREE_OPERAND (arg, 0);
221
222 dump_expr (pp, arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
223 }
224}
225
226/* Count the number of template arguments ARGS whose value does not
227 match the (optional) default template parameter in PARAMS */
228
229static int
230get_non_default_template_args_count (tree args, int flags)
231{
232 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
233
234 if (/* We use this flag when generating debug information. We don't
235 want to expand templates at this point, for this may generate
236 new decls, which gets decl counts out of sync, which may in
237 turn cause codegen differences between compilations with and
238 without -g. */
239 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
240 || !flag_pretty_templates)
241 return n;
242
243 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
244}
245
246/* Dump a template-argument-list ARGS (always a TREE_VEC) under control
247 of FLAGS. */
248
249static void
250dump_template_argument_list (cxx_pretty_printer *pp, tree args, int flags)
251{
252 int n = get_non_default_template_args_count (args, flags);
253 int need_comma = 0;
254 int i;
255
256 for (i = 0; i < n; ++i)
257 {
258 tree arg = TREE_VEC_ELT (args, i);
259
260 /* Only print a comma if we know there is an argument coming. In
261 the case of an empty template argument pack, no actual
262 argument will be printed. */
263 if (need_comma
264 && (!ARGUMENT_PACK_P (arg)
265 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
266 pp_separate_with_comma (pp);
267
268 dump_template_argument (pp, arg, flags);
269 need_comma = 1;
270 }
271}
272
273/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
274
275static void
276dump_template_parameter (cxx_pretty_printer *pp, tree parm, int flags)
277{
278 tree p;
279 tree a;
280
281 if (parm == error_mark_node)
282 return;
283
284 p = TREE_VALUE (parm);
285 a = TREE_PURPOSE (parm);
286
287 if (TREE_CODE (p) == TYPE_DECL)
288 {
289 if (flags & TFF_DECL_SPECIFIERS)
290 {
291 pp_cxx_ws_string (pp, "class");
292 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
293 pp_cxx_ws_string (pp, "...");
294 if (DECL_NAME (p))
295 pp_cxx_tree_identifier (pp, DECL_NAME (p));
296 }
297 else if (DECL_NAME (p))
298 pp_cxx_tree_identifier (pp, DECL_NAME (p));
299 else
300 pp_cxx_canonical_template_parameter (pp, TREE_TYPE (p));
301 }
302 else
303 dump_decl (pp, p, flags | TFF_DECL_SPECIFIERS);
304
305 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
306 {
307 pp_cxx_whitespace (pp);
308 pp_equal (pp);
309 pp_cxx_whitespace (pp);
310 if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
311 dump_type (pp, a, flags & ~TFF_CHASE_TYPEDEF);
312 else
313 dump_expr (pp, a, flags | TFF_EXPR_IN_PARENS);
314 }
315}
316
317/* Dump, under control of FLAGS, a template-parameter-list binding.
318 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
319 TREE_VEC. */
320
321static void
322dump_template_bindings (cxx_pretty_printer *pp, tree parms, tree args,
323 vec<tree, va_gc> *typenames)
324{
325 bool need_semicolon = false;
326 int i;
327 tree t;
328
329 while (parms)
330 {
331 tree p = TREE_VALUE (parms);
332 int lvl = TMPL_PARMS_DEPTH (parms);
333 int arg_idx = 0;
334 int i;
335 tree lvl_args = NULL_TREE;
336
337 /* Don't crash if we had an invalid argument list. */
338 if (TMPL_ARGS_DEPTH (args) >= lvl)
339 lvl_args = TMPL_ARGS_LEVEL (args, lvl);
340
341 for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
342 {
343 tree arg = NULL_TREE;
344
345 /* Don't crash if we had an invalid argument list. */
346 if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
347 arg = TREE_VEC_ELT (lvl_args, arg_idx);
348
349 if (need_semicolon)
350 pp_separate_with_semicolon (pp);
351 dump_template_parameter (pp, TREE_VEC_ELT (p, i),
352 TFF_PLAIN_IDENTIFIER);
353 pp_cxx_whitespace (pp);
354 pp_equal (pp);
355 pp_cxx_whitespace (pp);
356 if (arg)
357 {
358 if (ARGUMENT_PACK_P (arg))
359 pp_cxx_left_brace (pp);
360 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
361 if (ARGUMENT_PACK_P (arg))
362 pp_cxx_right_brace (pp);
363 }
364 else
365 pp_string (pp, M_("<missing>"));
366
367 ++arg_idx;
368 need_semicolon = true;
369 }
370
371 parms = TREE_CHAIN (parms);
372 }
373
374 /* Don't bother with typenames for a partial instantiation. */
375 if (vec_safe_is_empty (typenames) || uses_template_parms (args))
376 return;
377
378 /* Don't try to print typenames when we're processing a clone. */
379 if (current_function_decl
380 && !DECL_LANG_SPECIFIC (current_function_decl))
381 return;
382
383 /* Don't try to do this once cgraph starts throwing away front-end
384 information. */
385 if (at_eof >= 2)
386 return;
387
388 FOR_EACH_VEC_SAFE_ELT (typenames, i, t)
389 {
390 if (need_semicolon)
391 pp_separate_with_semicolon (pp);
392 dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
393 pp_cxx_whitespace (pp);
394 pp_equal (pp);
395 pp_cxx_whitespace (pp);
396 push_deferring_access_checks (dk_no_check);
397 t = tsubst (t, args, tf_none, NULL_TREE);
398 pop_deferring_access_checks ();
399 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
400 pp_simple_type_specifier doesn't know about it. */
401 t = strip_typedefs (t);
402 dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
403 }
404}
405
406/* Dump a human-readable equivalent of the alias template
407 specialization of T. */
408
409static void
410dump_alias_template_specialization (cxx_pretty_printer *pp, tree t, int flags)
411{
412 gcc_assert (alias_template_specialization_p (t));
413
414 tree decl = TYPE_NAME (t);
415 if (!(flags & TFF_UNQUALIFIED_NAME))
416 dump_scope (pp, CP_DECL_CONTEXT (decl), flags);
417 pp_cxx_tree_identifier (pp, DECL_NAME (decl));
418 dump_template_parms (pp, DECL_TEMPLATE_INFO (decl),
419 /*primary=*/false,
420 flags & ~TFF_TEMPLATE_HEADER);
421}
422
423/* Dump a human-readable equivalent of TYPE. FLAGS controls the
424 format. */
425
426static void
427dump_type (cxx_pretty_printer *pp, tree t, int flags)
428{
429 if (t == NULL_TREE)
430 return;
431
432 /* Don't print e.g. "struct mytypedef". */
433 if (TYPE_P (t) && typedef_variant_p (t))
434 {
435 tree decl = TYPE_NAME (t);
436 if ((flags & TFF_CHASE_TYPEDEF)
437 || DECL_SELF_REFERENCE_P (decl)
438 || (!flag_pretty_templates
439 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)))
440 t = strip_typedefs (t);
441 else if (alias_template_specialization_p (t))
442 {
443 dump_alias_template_specialization (pp, t, flags);
444 return;
445 }
446 else if (same_type_p (t, TREE_TYPE (decl)))
447 t = decl;
448 else
449 {
450 pp_cxx_cv_qualifier_seq (pp, t);
451 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
452 return;
453 }
454 }
455
456 if (TYPE_PTRMEMFUNC_P (t))
457 goto offset_type;
458
459 switch (TREE_CODE (t))
460 {
461 case LANG_TYPE:
462 if (t == init_list_type_node)
463 pp_string (pp, M_("<brace-enclosed initializer list>"));
464 else if (t == unknown_type_node)
465 pp_string (pp, M_("<unresolved overloaded function type>"));
466 else
467 {
468 pp_cxx_cv_qualifier_seq (pp, t);
469 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
470 }
471 break;
472
473 case TREE_LIST:
474 /* A list of function parms. */
475 dump_parameters (pp, t, flags);
476 break;
477
478 case IDENTIFIER_NODE:
479 pp_cxx_tree_identifier (pp, t);
480 break;
481
482 case TREE_BINFO:
483 dump_type (pp, BINFO_TYPE (t), flags);
484 break;
485
486 case RECORD_TYPE:
487 case UNION_TYPE:
488 case ENUMERAL_TYPE:
489 dump_aggr_type (pp, t, flags);
490 break;
491
492 case TYPE_DECL:
493 if (flags & TFF_CHASE_TYPEDEF)
494 {
495 dump_type (pp, DECL_ORIGINAL_TYPE (t)
496 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
497 break;
498 }
499 /* Fall through. */
500
501 case TEMPLATE_DECL:
502 case NAMESPACE_DECL:
503 dump_decl (pp, t, flags & ~TFF_DECL_SPECIFIERS);
504 break;
505
506 case INTEGER_TYPE:
507 case REAL_TYPE:
508 case VOID_TYPE:
509 case BOOLEAN_TYPE:
510 case COMPLEX_TYPE:
511 case VECTOR_TYPE:
512 case FIXED_POINT_TYPE:
513 pp_type_specifier_seq (pp, t);
514 break;
515
516 case TEMPLATE_TEMPLATE_PARM:
517 /* For parameters inside template signature. */
518 if (TYPE_IDENTIFIER (t))
519 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
520 else
521 pp_cxx_canonical_template_parameter (pp, t);
522 break;
523
524 case BOUND_TEMPLATE_TEMPLATE_PARM:
525 {
526 tree args = TYPE_TI_ARGS (t);
527 pp_cxx_cv_qualifier_seq (pp, t);
528 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
529 pp_cxx_begin_template_argument_list (pp);
530 dump_template_argument_list (pp, args, flags);
531 pp_cxx_end_template_argument_list (pp);
532 }
533 break;
534
535 case TEMPLATE_TYPE_PARM:
536 pp_cxx_cv_qualifier_seq (pp, t);
537 if (tree c = PLACEHOLDER_TYPE_CONSTRAINTS (t))
538 pp_cxx_constrained_type_spec (pp, c);
539 else if (TYPE_IDENTIFIER (t))
540 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
541 else
542 pp_cxx_canonical_template_parameter
543 (pp, TEMPLATE_TYPE_PARM_INDEX (t));
544 break;
545
546 /* This is not always necessary for pointers and such, but doing this
547 reduces code size. */
548 case ARRAY_TYPE:
549 case POINTER_TYPE:
550 case REFERENCE_TYPE:
551 case OFFSET_TYPE:
552 offset_type:
553 case FUNCTION_TYPE:
554 case METHOD_TYPE:
555 {
556 dump_type_prefix (pp, t, flags);
557 dump_type_suffix (pp, t, flags);
558 break;
559 }
560 case TYPENAME_TYPE:
561 if (! (flags & TFF_CHASE_TYPEDEF)
562 && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
563 {
564 dump_decl (pp, TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
565 break;
566 }
567 pp_cxx_cv_qualifier_seq (pp, t);
568 pp_cxx_ws_string (pp,
569 TYPENAME_IS_ENUM_P (t) ? "enum"
570 : TYPENAME_IS_CLASS_P (t) ? "class"
571 : "typename");
572 dump_typename (pp, t, flags);
573 break;
574
575 case UNBOUND_CLASS_TEMPLATE:
576 if (! (flags & TFF_UNQUALIFIED_NAME))
577 {
578 dump_type (pp, TYPE_CONTEXT (t), flags);
579 pp_cxx_colon_colon (pp);
580 }
581 pp_cxx_ws_string (pp, "template");
582 dump_type (pp, TYPE_IDENTIFIER (t), flags);
583 break;
584
585 case TYPEOF_TYPE:
586 pp_cxx_ws_string (pp, "__typeof__");
587 pp_cxx_whitespace (pp);
588 pp_cxx_left_paren (pp);
589 dump_expr (pp, TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
590 pp_cxx_right_paren (pp);
591 break;
592
593 case UNDERLYING_TYPE:
594 pp_cxx_ws_string (pp, "__underlying_type");
595 pp_cxx_whitespace (pp);
596 pp_cxx_left_paren (pp);
597 dump_expr (pp, UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
598 pp_cxx_right_paren (pp);
599 break;
600
601 case TYPE_PACK_EXPANSION:
602 dump_type (pp, PACK_EXPANSION_PATTERN (t), flags);
603 pp_cxx_ws_string (pp, "...");
604 break;
605
606 case TYPE_ARGUMENT_PACK:
607 dump_template_argument (pp, t, flags);
608 break;
609
610 case DECLTYPE_TYPE:
611 pp_cxx_ws_string (pp, "decltype");
612 pp_cxx_whitespace (pp);
613 pp_cxx_left_paren (pp);
614 dump_expr (pp, DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
615 pp_cxx_right_paren (pp);
616 break;
617
618 case NULLPTR_TYPE:
619 pp_string (pp, "std::nullptr_t");
620 break;
621
622 default:
623 pp_unsupported_tree (pp, t);
624 /* Fall through. */
625
626 case ERROR_MARK:
627 pp_string (pp, M_("<type error>"));
628 break;
629 }
630}
631
632/* Dump a TYPENAME_TYPE. We need to notice when the context is itself
633 a TYPENAME_TYPE. */
634
635static void
636dump_typename (cxx_pretty_printer *pp, tree t, int flags)
637{
638 tree ctx = TYPE_CONTEXT (t);
639
640 if (TREE_CODE (ctx) == TYPENAME_TYPE)
641 dump_typename (pp, ctx, flags);
642 else
643 dump_type (pp, ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
644 pp_cxx_colon_colon (pp);
645 dump_decl (pp, TYPENAME_TYPE_FULLNAME (t), flags);
646}
647
648/* Return the name of the supplied aggregate, or enumeral type. */
649
650const char *
651class_key_or_enum_as_string (tree t)
652{
653 if (TREE_CODE (t) == ENUMERAL_TYPE)
654 {
655 if (SCOPED_ENUM_P (t))
656 return "enum class";
657 else
658 return "enum";
659 }
660 else if (TREE_CODE (t) == UNION_TYPE)
661 return "union";
662 else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
663 return "class";
664 else
665 return "struct";
666}
667
668/* Print out a class declaration T under the control of FLAGS,
669 in the form `class foo'. */
670
671static void
672dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags)
673{
674 tree name;
675 const char *variety = class_key_or_enum_as_string (t);
676 int typdef = 0;
677 int tmplate = 0;
678
679 pp_cxx_cv_qualifier_seq (pp, t);
680
681 if (flags & TFF_CLASS_KEY_OR_ENUM)
682 pp_cxx_ws_string (pp, variety);
683
684 name = TYPE_NAME (t);
685
686 if (name)
687 {
688 typdef = (!DECL_ARTIFICIAL (name)
689 /* An alias specialization is not considered to be a
690 typedef. */
691 && !alias_template_specialization_p (t));
692
693 if ((typdef
694 && ((flags & TFF_CHASE_TYPEDEF)
695 || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
696 && DECL_TEMPLATE_INFO (name))))
697 || DECL_SELF_REFERENCE_P (name))
698 {
699 t = TYPE_MAIN_VARIANT (t);
700 name = TYPE_NAME (t);
701 typdef = 0;
702 }
703
704 tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
705 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
706 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
707 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
708
709 if (! (flags & TFF_UNQUALIFIED_NAME))
710 dump_scope (pp, CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
711 flags &= ~TFF_UNQUALIFIED_NAME;
712 if (tmplate)
713 {
714 /* Because the template names are mangled, we have to locate
715 the most general template, and use that name. */
716 tree tpl = TYPE_TI_TEMPLATE (t);
717
718 while (DECL_TEMPLATE_INFO (tpl))
719 tpl = DECL_TI_TEMPLATE (tpl);
720 name = tpl;
721 }
722 name = DECL_NAME (name);
723 }
724
725 if (name == 0 || anon_aggrname_p (name))
726 {
727 if (flags & TFF_CLASS_KEY_OR_ENUM)
728 pp_string (pp, M_("<unnamed>"));
729 else
730 pp_printf (pp, M_("<unnamed %s>"), variety);
731 }
732 else if (LAMBDA_TYPE_P (t))
733 {
734 /* A lambda's "type" is essentially its signature. */
735 pp_string (pp, M_("<lambda"));
736 if (lambda_function (t))
737 dump_parameters (pp,
738 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
739 flags);
740 pp_greater (pp);
741 }
742 else
743 pp_cxx_tree_identifier (pp, name);
744 if (tmplate)
745 dump_template_parms (pp, TYPE_TEMPLATE_INFO (t),
746 !CLASSTYPE_USE_TEMPLATE (t),
747 flags & ~TFF_TEMPLATE_HEADER);
748}
749
750/* Dump into the obstack the initial part of the output for a given type.
751 This is necessary when dealing with things like functions returning
752 functions. Examples:
753
754 return type of `int (* fee ())()': pointer -> function -> int. Both
755 pointer (and reference and offset) and function (and member) types must
756 deal with prefix and suffix.
757
758 Arrays must also do this for DECL nodes, like int a[], and for things like
759 int *[]&. */
760
761static void
762dump_type_prefix (cxx_pretty_printer *pp, tree t, int flags)
763{
764 if (TYPE_PTRMEMFUNC_P (t))
765 {
766 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
767 goto offset_type;
768 }
769
770 switch (TREE_CODE (t))
771 {
772 case POINTER_TYPE:
773 case REFERENCE_TYPE:
774 {
775 tree sub = TREE_TYPE (t);
776
777 dump_type_prefix (pp, sub, flags);
778 if (TREE_CODE (sub) == ARRAY_TYPE
779 || TREE_CODE (sub) == FUNCTION_TYPE)
780 {
781 pp_cxx_whitespace (pp);
782 pp_cxx_left_paren (pp);
783 pp_c_attributes_display (pp, TYPE_ATTRIBUTES (sub));
784 }
785 if (TYPE_PTR_P (t))
786 pp_star (pp);
787 else if (TREE_CODE (t) == REFERENCE_TYPE)
788 {
789 if (TYPE_REF_IS_RVALUE (t))
790 pp_ampersand_ampersand (pp);
791 else
792 pp_ampersand (pp);
793 }
794 pp->padding = pp_before;
795 pp_cxx_cv_qualifier_seq (pp, t);
796 }
797 break;
798
799 case OFFSET_TYPE:
800 offset_type:
801 dump_type_prefix (pp, TREE_TYPE (t), flags);
802 if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
803 {
804 pp_maybe_space (pp);
805 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
806 pp_cxx_left_paren (pp);
807 dump_type (pp, TYPE_OFFSET_BASETYPE (t), flags);
808 pp_cxx_colon_colon (pp);
809 }
810 pp_cxx_star (pp);
811 pp_cxx_cv_qualifier_seq (pp, t);
812 pp->padding = pp_before;
813 break;
814
815 /* This can be reached without a pointer when dealing with
816 templates, e.g. std::is_function. */
817 case FUNCTION_TYPE:
818 dump_type_prefix (pp, TREE_TYPE (t), flags);
819 break;
820
821 case METHOD_TYPE:
822 dump_type_prefix (pp, TREE_TYPE (t), flags);
823 pp_maybe_space (pp);
824 pp_cxx_left_paren (pp);
825 dump_aggr_type (pp, TYPE_METHOD_BASETYPE (t), flags);
826 pp_cxx_colon_colon (pp);
827 break;
828
829 case ARRAY_TYPE:
830 dump_type_prefix (pp, TREE_TYPE (t), flags);
831 break;
832
833 case ENUMERAL_TYPE:
834 case IDENTIFIER_NODE:
835 case INTEGER_TYPE:
836 case BOOLEAN_TYPE:
837 case REAL_TYPE:
838 case RECORD_TYPE:
839 case TEMPLATE_TYPE_PARM:
840 case TEMPLATE_TEMPLATE_PARM:
841 case BOUND_TEMPLATE_TEMPLATE_PARM:
842 case TREE_LIST:
843 case TYPE_DECL:
844 case TREE_VEC:
845 case UNION_TYPE:
846 case LANG_TYPE:
847 case VOID_TYPE:
848 case TYPENAME_TYPE:
849 case COMPLEX_TYPE:
850 case VECTOR_TYPE:
851 case TYPEOF_TYPE:
852 case UNDERLYING_TYPE:
853 case DECLTYPE_TYPE:
854 case TYPE_PACK_EXPANSION:
855 case FIXED_POINT_TYPE:
856 case NULLPTR_TYPE:
857 dump_type (pp, t, flags);
858 pp->padding = pp_before;
859 break;
860
861 default:
862 pp_unsupported_tree (pp, t);
863 /* fall through. */
864 case ERROR_MARK:
865 pp_string (pp, M_("<typeprefixerror>"));
866 break;
867 }
868}
869
870/* Dump the suffix of type T, under control of FLAGS. This is the part
871 which appears after the identifier (or function parms). */
872
873static void
874dump_type_suffix (cxx_pretty_printer *pp, tree t, int flags)
875{
876 if (TYPE_PTRMEMFUNC_P (t))
877 t = TYPE_PTRMEMFUNC_FN_TYPE (t);
878
879 switch (TREE_CODE (t))
880 {
881 case POINTER_TYPE:
882 case REFERENCE_TYPE:
883 case OFFSET_TYPE:
884 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
885 || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
886 pp_cxx_right_paren (pp);
887 if (TREE_CODE (t) == POINTER_TYPE)
888 flags |= TFF_POINTER;
889 dump_type_suffix (pp, TREE_TYPE (t), flags);
890 break;
891
892 case FUNCTION_TYPE:
893 case METHOD_TYPE:
894 {
895 tree arg;
896 if (TREE_CODE (t) == METHOD_TYPE)
897 /* Can only be reached through a pointer. */
898 pp_cxx_right_paren (pp);
899 arg = TYPE_ARG_TYPES (t);
900 if (TREE_CODE (t) == METHOD_TYPE)
901 arg = TREE_CHAIN (arg);
902
903 /* Function pointers don't have default args. Not in standard C++,
904 anyway; they may in g++, but we'll just pretend otherwise. */
905 dump_parameters (pp, arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
906
907 pp->padding = pp_before;
908 pp_cxx_cv_qualifiers (pp, type_memfn_quals (t),
909 TREE_CODE (t) == FUNCTION_TYPE
910 && (flags & TFF_POINTER));
911 dump_ref_qualifier (pp, t, flags);
912 if (tx_safe_fn_type_p (t))
913 pp_cxx_ws_string (pp, "transaction_safe");
914 dump_exception_spec (pp, TYPE_RAISES_EXCEPTIONS (t), flags);
915 dump_type_suffix (pp, TREE_TYPE (t), flags);
916 break;
917 }
918
919 case ARRAY_TYPE:
920 pp_maybe_space (pp);
921 pp_cxx_left_bracket (pp);
922 if (tree dtype = TYPE_DOMAIN (t))
923 {
924 tree max = TYPE_MAX_VALUE (dtype);
925 /* Zero-length arrays have an upper bound of SIZE_MAX. */
926 if (integer_all_onesp (max))
927 pp_character (pp, '0');
928 else if (tree_fits_shwi_p (max))
929 pp_wide_integer (pp, tree_to_shwi (max) + 1);
930 else
931 {
932 STRIP_NOPS (max);
933 if (TREE_CODE (max) == SAVE_EXPR)
934 max = TREE_OPERAND (max, 0);
935 if (TREE_CODE (max) == MINUS_EXPR
936 || TREE_CODE (max) == PLUS_EXPR)
937 {
938 max = TREE_OPERAND (max, 0);
939 while (CONVERT_EXPR_P (max))
940 max = TREE_OPERAND (max, 0);
941 }
942 else
943 max = fold_build2_loc (input_location,
944 PLUS_EXPR, dtype, max,
945 build_int_cst (dtype, 1));
946 dump_expr (pp, max, flags & ~TFF_EXPR_IN_PARENS);
947 }
948 }
949 pp_cxx_right_bracket (pp);
950 dump_type_suffix (pp, TREE_TYPE (t), flags);
951 break;
952
953 case ENUMERAL_TYPE:
954 case IDENTIFIER_NODE:
955 case INTEGER_TYPE:
956 case BOOLEAN_TYPE:
957 case REAL_TYPE:
958 case RECORD_TYPE:
959 case TEMPLATE_TYPE_PARM:
960 case TEMPLATE_TEMPLATE_PARM:
961 case BOUND_TEMPLATE_TEMPLATE_PARM:
962 case TREE_LIST:
963 case TYPE_DECL:
964 case TREE_VEC:
965 case UNION_TYPE:
966 case LANG_TYPE:
967 case VOID_TYPE:
968 case TYPENAME_TYPE:
969 case COMPLEX_TYPE:
970 case VECTOR_TYPE:
971 case TYPEOF_TYPE:
972 case UNDERLYING_TYPE:
973 case DECLTYPE_TYPE:
974 case TYPE_PACK_EXPANSION:
975 case FIXED_POINT_TYPE:
976 case NULLPTR_TYPE:
977 break;
978
979 default:
980 pp_unsupported_tree (pp, t);
981 case ERROR_MARK:
982 /* Don't mark it here, we should have already done in
983 dump_type_prefix. */
984 break;
985 }
986}
987
988static void
989dump_global_iord (cxx_pretty_printer *pp, tree t)
990{
991 const char *p = NULL;
992
993 if (DECL_GLOBAL_CTOR_P (t))
994 p = M_("(static initializers for %s)");
995 else if (DECL_GLOBAL_DTOR_P (t))
996 p = M_("(static destructors for %s)");
997 else
998 gcc_unreachable ();
999
1000 pp_printf (pp, p, DECL_SOURCE_FILE (t));
1001}
1002
1003static void
1004dump_simple_decl (cxx_pretty_printer *pp, tree t, tree type, int flags)
1005{
1006 if (flags & TFF_DECL_SPECIFIERS)
1007 {
1008 if (VAR_P (t) && DECL_DECLARED_CONSTEXPR_P (t))
1009 {
1010 if (DECL_LANG_SPECIFIC (t) && DECL_DECLARED_CONCEPT_P (t))
1011 pp_cxx_ws_string (pp, "concept");
1012 else
1013 pp_cxx_ws_string (pp, "constexpr");
1014 }
1015 dump_type_prefix (pp, type, flags & ~TFF_UNQUALIFIED_NAME);
1016 pp_maybe_space (pp);
1017 }
1018 if (! (flags & TFF_UNQUALIFIED_NAME)
1019 && TREE_CODE (t) != PARM_DECL
1020 && (!DECL_INITIAL (t)
1021 || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
1022 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1023 flags &= ~TFF_UNQUALIFIED_NAME;
1024 if ((flags & TFF_DECL_SPECIFIERS)
1025 && DECL_TEMPLATE_PARM_P (t)
1026 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
1027 pp_string (pp, "...");
1028 if (DECL_NAME (t))
1029 {
1030 if (TREE_CODE (t) == FIELD_DECL && DECL_NORMAL_CAPTURE_P (t))
1031 {
1032 pp_less (pp);
1033 pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t)) + 2);
1034 pp_string (pp, " capture>");
1035 }
1036 else
1037 dump_decl (pp, DECL_NAME (t), flags);
1038 }
1039 else if (DECL_DECOMPOSITION_P (t))
1040 pp_string (pp, M_("<structured bindings>"));
1041 else
1042 pp_string (pp, M_("<anonymous>"));
1043 if (flags & TFF_DECL_SPECIFIERS)
1044 dump_type_suffix (pp, type, flags);
1045}
1046
1047/* Print an IDENTIFIER_NODE that is the name of a declaration. */
1048
1049static void
1050dump_decl_name (cxx_pretty_printer *pp, tree t, int flags)
1051{
1052 /* These special cases are duplicated here so that other functions
1053 can feed identifiers to error and get them demangled properly. */
1054 if (IDENTIFIER_CONV_OP_P (t))
1055 {
1056 pp_cxx_ws_string (pp, "operator");
1057 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1058 dump_type (pp, TREE_TYPE (t), flags);
1059 return;
1060 }
1061 if (dguide_name_p (t))
1062 {
1063 dump_decl (pp, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t)),
1064 TFF_UNQUALIFIED_NAME);
1065 return;
1066 }
1067
1068 const char *str = IDENTIFIER_POINTER (t);
1069 if (!strncmp (str, "_ZGR", 3))
1070 {
1071 pp_cxx_ws_string (pp, "<temporary>");
1072 return;
1073 }
1074
1075 pp_cxx_tree_identifier (pp, t);
1076}
1077
1078/* Dump a human readable string for the decl T under control of FLAGS. */
1079
1080static void
1081dump_decl (cxx_pretty_printer *pp, tree t, int flags)
1082{
1083 if (t == NULL_TREE)
1084 return;
1085
1086 /* If doing Objective-C++, give Objective-C a chance to demangle
1087 Objective-C method names. */
1088 if (c_dialect_objc ())
1089 {
1090 const char *demangled = objc_maybe_printable_name (t, flags);
1091 if (demangled)
1092 {
1093 pp_string (pp, demangled);
1094 return;
1095 }
1096 }
1097
1098 switch (TREE_CODE (t))
1099 {
1100 case TYPE_DECL:
1101 /* Don't say 'typedef class A' */
1102 if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
1103 {
1104 if ((flags & TFF_DECL_SPECIFIERS)
1105 && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
1106 {
1107 /* Say `class T' not just `T'. */
1108 pp_cxx_ws_string (pp, "class");
1109
1110 /* Emit the `...' for a parameter pack. */
1111 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1112 pp_cxx_ws_string (pp, "...");
1113 }
1114
1115 dump_type (pp, TREE_TYPE (t), flags);
1116 break;
1117 }
1118 if (TYPE_DECL_ALIAS_P (t)
1119 && (flags & TFF_DECL_SPECIFIERS
1120 || flags & TFF_CLASS_KEY_OR_ENUM))
1121 {
1122 pp_cxx_ws_string (pp, "using");
1123 dump_decl (pp, DECL_NAME (t), flags);
1124 pp_cxx_whitespace (pp);
1125 pp_cxx_ws_string (pp, "=");
1126 pp_cxx_whitespace (pp);
1127 dump_type (pp, (DECL_ORIGINAL_TYPE (t)
1128 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t)),
1129 flags);
1130 break;
1131 }
1132 if ((flags & TFF_DECL_SPECIFIERS)
1133 && !DECL_SELF_REFERENCE_P (t))
1134 pp_cxx_ws_string (pp, "typedef");
1135 dump_simple_decl (pp, t, DECL_ORIGINAL_TYPE (t)
1136 ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
1137 flags);
1138 break;
1139
1140 case VAR_DECL:
1141 if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
1142 {
1143 pp_string (pp, M_("vtable for "));
1144 gcc_assert (TYPE_P (DECL_CONTEXT (t)));
1145 dump_type (pp, DECL_CONTEXT (t), flags);
1146 break;
1147 }
1148 /* Fall through. */
1149 case FIELD_DECL:
1150 case PARM_DECL:
1151 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1152
1153 /* Handle variable template specializations. */
1154 if (VAR_P (t)
1155 && DECL_LANG_SPECIFIC (t)
1156 && DECL_TEMPLATE_INFO (t)
1157 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))
1158 {
1159 pp_cxx_begin_template_argument_list (pp);
1160 tree args = INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t));
1161 dump_template_argument_list (pp, args, flags);
1162 pp_cxx_end_template_argument_list (pp);
1163 }
1164 break;
1165
1166 case RESULT_DECL:
1167 pp_string (pp, M_("<return value> "));
1168 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1169 break;
1170
1171 case NAMESPACE_DECL:
1172 if (flags & TFF_DECL_SPECIFIERS)
1173 pp->declaration (t);
1174 else
1175 {
1176 if (! (flags & TFF_UNQUALIFIED_NAME))
1177 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1178 flags &= ~TFF_UNQUALIFIED_NAME;
1179 if (DECL_NAME (t) == NULL_TREE)
1180 {
1181 if (!(pp->flags & pp_c_flag_gnu_v3))
1182 pp_cxx_ws_string (pp, M_("{anonymous}"));
1183 else
1184 pp_cxx_ws_string (pp, M_("(anonymous namespace)"));
1185 }
1186 else
1187 pp_cxx_tree_identifier (pp, DECL_NAME (t));
1188 }
1189 break;
1190
1191 case SCOPE_REF:
1192 dump_type (pp, TREE_OPERAND (t, 0), flags);
1193 pp_cxx_colon_colon (pp);
1194 dump_decl (pp, TREE_OPERAND (t, 1), TFF_UNQUALIFIED_NAME);
1195 break;
1196
1197 case ARRAY_REF:
1198 dump_decl (pp, TREE_OPERAND (t, 0), flags);
1199 pp_cxx_left_bracket (pp);
1200 dump_decl (pp, TREE_OPERAND (t, 1), flags);
1201 pp_cxx_right_bracket (pp);
1202 break;
1203
1204 /* So that we can do dump_decl on an aggr type. */
1205 case RECORD_TYPE:
1206 case UNION_TYPE:
1207 case ENUMERAL_TYPE:
1208 dump_type (pp, t, flags);
1209 break;
1210
1211 case BIT_NOT_EXPR:
1212 /* This is a pseudo destructor call which has not been folded into
1213 a PSEUDO_DTOR_EXPR yet. */
1214 pp_cxx_complement (pp);
1215 dump_type (pp, TREE_OPERAND (t, 0), flags);
1216 break;
1217
1218 case TYPE_EXPR:
1219 gcc_unreachable ();
1220 break;
1221
1222 case IDENTIFIER_NODE:
1223 dump_decl_name (pp, t, flags);
1224 break;
1225
1226 case OVERLOAD:
1227 if (!OVL_SINGLE_P (t))
1228 {
1229 tree ctx = ovl_scope (t);
1230 if (ctx != global_namespace)
1231 {
1232 if (TYPE_P (ctx))
1233 dump_type (pp, ctx, flags);
1234 else
1235 dump_decl (pp, ctx, flags);
1236 pp_cxx_colon_colon (pp);
1237 }
1238 dump_decl (pp, OVL_NAME (t), flags);
1239 break;
1240 }
1241
1242 /* If there's only one function, just treat it like an ordinary
1243 FUNCTION_DECL. */
1244 t = OVL_FIRST (t);
1245 /* Fall through. */
1246
1247 case FUNCTION_DECL:
1248 if (! DECL_LANG_SPECIFIC (t))
1249 {
1250 if (DECL_ABSTRACT_ORIGIN (t)
1251 && DECL_ABSTRACT_ORIGIN (t) != t)
1252 dump_decl (pp, DECL_ABSTRACT_ORIGIN (t), flags);
1253 else
1254 dump_function_name (pp, t, flags);
1255 }
1256 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1257 dump_global_iord (pp, t);
1258 else
1259 dump_function_decl (pp, t, flags);
1260 break;
1261
1262 case TEMPLATE_DECL:
1263 dump_template_decl (pp, t, flags);
1264 break;
1265
1266 case TEMPLATE_ID_EXPR:
1267 {
1268 tree name = TREE_OPERAND (t, 0);
1269 tree args = TREE_OPERAND (t, 1);
1270
1271 if (!identifier_p (name))
1272 name = OVL_NAME (name);
1273 dump_decl (pp, name, flags);
1274 pp_cxx_begin_template_argument_list (pp);
1275 if (args == error_mark_node)
1276 pp_string (pp, M_("<template arguments error>"));
1277 else if (args)
1278 dump_template_argument_list
1279 (pp, args, flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
1280 pp_cxx_end_template_argument_list (pp);
1281 }
1282 break;
1283
1284 case LABEL_DECL:
1285 pp_cxx_tree_identifier (pp, DECL_NAME (t));
1286 break;
1287
1288 case CONST_DECL:
1289 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1290 || (DECL_INITIAL (t) &&
1291 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1292 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1293 else if (DECL_NAME (t))
1294 dump_decl (pp, DECL_NAME (t), flags);
1295 else if (DECL_INITIAL (t))
1296 dump_expr (pp, DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1297 else
1298 pp_string (pp, M_("<enumerator>"));
1299 break;
1300
1301 case USING_DECL:
1302 {
1303 pp_cxx_ws_string (pp, "using");
1304 tree scope = USING_DECL_SCOPE (t);
1305 bool variadic = false;
1306 if (PACK_EXPANSION_P (scope))
1307 {
1308 scope = PACK_EXPANSION_PATTERN (scope);
1309 variadic = true;
1310 }
1311 dump_type (pp, scope, flags);
1312 pp_cxx_colon_colon (pp);
1313 dump_decl (pp, DECL_NAME (t), flags);
1314 if (variadic)
1315 pp_cxx_ws_string (pp, "...");
1316 }
1317 break;
1318
1319 case STATIC_ASSERT:
1320 pp->declaration (t);
1321 break;
1322
1323 case BASELINK:
1324 dump_decl (pp, BASELINK_FUNCTIONS (t), flags);
1325 break;
1326
1327 case NON_DEPENDENT_EXPR:
1328 dump_expr (pp, t, flags);
1329 break;
1330
1331 case TEMPLATE_TYPE_PARM:
1332 if (flags & TFF_DECL_SPECIFIERS)
1333 pp->declaration (t);
1334 else
1335 pp->type_id (t);
1336 break;
1337
1338 case UNBOUND_CLASS_TEMPLATE:
1339 case TYPE_PACK_EXPANSION:
1340 case TREE_BINFO:
1341 dump_type (pp, t, flags);
1342 break;
1343
1344 default:
1345 pp_unsupported_tree (pp, t);
1346 /* Fall through. */
1347
1348 case ERROR_MARK:
1349 pp_string (pp, M_("<declaration error>"));
1350 break;
1351 }
1352}
1353
1354/* Dump a template declaration T under control of FLAGS. This means the
1355 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1356
1357static void
1358dump_template_decl (cxx_pretty_printer *pp, tree t, int flags)
1359{
1360 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1361 tree parms;
1362 int i;
1363
1364 if (flags & TFF_TEMPLATE_HEADER)
1365 {
1366 for (parms = orig_parms = nreverse (orig_parms);
1367 parms;
1368 parms = TREE_CHAIN (parms))
1369 {
1370 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1371 int len = TREE_VEC_LENGTH (inner_parms);
1372
1373 if (len == 0)
1374 {
1375 /* Skip over the dummy template levels of a template template
1376 parm. */
1377 gcc_assert (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TEMPLATE_PARM);
1378 continue;
1379 }
1380
1381 pp_cxx_ws_string (pp, "template");
1382 pp_cxx_begin_template_argument_list (pp);
1383
1384 /* If we've shown the template prefix, we'd better show the
1385 parameters' and decl's type too. */
1386 flags |= TFF_DECL_SPECIFIERS;
1387
1388 for (i = 0; i < len; i++)
1389 {
1390 if (i)
1391 pp_separate_with_comma (pp);
1392 dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i),
1393 flags);
1394 }
1395 pp_cxx_end_template_argument_list (pp);
1396 pp_cxx_whitespace (pp);
1397 }
1398 nreverse(orig_parms);
1399
1400 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1401 {
1402 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1403 pp_cxx_ws_string (pp, "class");
1404
1405 /* If this is a parameter pack, print the ellipsis. */
1406 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1407 pp_cxx_ws_string (pp, "...");
1408 }
1409
1410 /* Only print the requirements if we're also printing
1411 the template header. */
1412 if (flag_concepts)
1413 if (tree ci = get_constraints (t))
1414 if (check_constraint_info (ci))
1415 if (tree reqs = CI_TEMPLATE_REQS (ci))
1416 {
1417 pp_cxx_requires_clause (pp, reqs);
1418 pp_cxx_whitespace (pp);
1419 }
1420 }
1421
1422
1423 if (DECL_CLASS_TEMPLATE_P (t))
1424 dump_type (pp, TREE_TYPE (t),
1425 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1426 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1427 else if (DECL_TEMPLATE_RESULT (t)
1428 && (VAR_P (DECL_TEMPLATE_RESULT (t))
1429 /* Alias template. */
1430 || DECL_TYPE_TEMPLATE_P (t)))
1431 dump_decl (pp, DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1432 else
1433 {
1434 gcc_assert (TREE_TYPE (t));
1435 switch (NEXT_CODE (t))
1436 {
1437 case METHOD_TYPE:
1438 case FUNCTION_TYPE:
1439 dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME);
1440 break;
1441 default:
1442 /* This case can occur with some invalid code. */
1443 dump_type (pp, TREE_TYPE (t),
1444 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1445 | (flags & TFF_DECL_SPECIFIERS
1446 ? TFF_CLASS_KEY_OR_ENUM : 0));
1447 }
1448 }
1449}
1450
1451/* find_typenames looks through the type of the function template T
1452 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1453 it finds. */
1454
1455struct find_typenames_t
1456{
1457 hash_set<tree> *p_set;
1458 vec<tree, va_gc> *typenames;
1459};
1460
1461static tree
1462find_typenames_r (tree *tp, int *walk_subtrees, void *data)
1463{
1464 struct find_typenames_t *d = (struct find_typenames_t *)data;
1465 tree mv = NULL_TREE;
1466
1467 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1468 /* Add the type of the typedef without any additional cv-quals. */
1469 mv = TREE_TYPE (TYPE_NAME (*tp));
1470 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1471 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1472 /* Add the typename without any cv-qualifiers. */
1473 mv = TYPE_MAIN_VARIANT (*tp);
1474
1475 if (TREE_CODE (*tp) == TYPE_PACK_EXPANSION)
1476 {
1477 /* Don't mess with parameter packs since we don't remember
1478 the pack expansion context for a particular typename. */
1479 *walk_subtrees = false;
1480 return NULL_TREE;
1481 }
1482
1483 if (mv && (mv == *tp || !d->p_set->add (mv)))
1484 vec_safe_push (d->typenames, mv);
1485
1486 /* Search into class template arguments, which cp_walk_subtrees
1487 doesn't do. */
1488 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1489 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1490 data, d->p_set);
1491
1492 return NULL_TREE;
1493}
1494
1495static vec<tree, va_gc> *
1496find_typenames (tree t)
1497{
1498 struct find_typenames_t ft;
1499 ft.p_set = new hash_set<tree>;
1500 ft.typenames = NULL;
1501 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1502 find_typenames_r, &ft, ft.p_set);
1503 delete ft.p_set;
1504 return ft.typenames;
1505}
1506
1507/* Output the "[with ...]" clause for a template instantiation T iff
1508 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1509 formatting a deduction/substitution diagnostic rather than an
1510 instantiation. */
1511
1512static void
1513dump_substitution (cxx_pretty_printer *pp,
1514 tree t, tree template_parms, tree template_args,
1515 int flags)
1516{
1517 if (template_parms != NULL_TREE && template_args != NULL_TREE
1518 && !(flags & TFF_NO_TEMPLATE_BINDINGS))
1519 {
1520 vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL;
1521 pp_cxx_whitespace (pp);
1522 pp_cxx_left_bracket (pp);
1523 pp->translate_string ("with");
1524 pp_cxx_whitespace (pp);
1525 dump_template_bindings (pp, template_parms, template_args, typenames);
1526 pp_cxx_right_bracket (pp);
1527 }
1528}
1529
1530/* Dump the lambda function FN including its 'mutable' qualifier and any
1531 template bindings. */
1532
1533static void
1534dump_lambda_function (cxx_pretty_printer *pp,
1535 tree fn, tree template_parms, tree template_args,
1536 int flags)
1537{
1538 /* A lambda's signature is essentially its "type". */
1539 dump_type (pp, DECL_CONTEXT (fn), flags);
1540 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST))
1541 {
1542 pp->padding = pp_before;
1543 pp_c_ws_string (pp, "mutable");
1544 }
1545 dump_substitution (pp, fn, template_parms, template_args, flags);
1546}
1547
1548/* Pretty print a function decl. There are several ways we want to print a
1549 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1550 As error can only apply the '#' flag once to give 0 and 1 for V, there
1551 is %D which doesn't print the throw specs, and %F which does. */
1552
1553static void
1554dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
1555{
1556 tree fntype;
1557 tree parmtypes;
1558 tree cname = NULL_TREE;
1559 tree template_args = NULL_TREE;
1560 tree template_parms = NULL_TREE;
1561 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1562 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1563 tree exceptions;
1564 bool constexpr_p;
1565 tree ret = NULL_TREE;
1566
1567 flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME);
1568 if (TREE_CODE (t) == TEMPLATE_DECL)
1569 t = DECL_TEMPLATE_RESULT (t);
1570
1571 /* Save the exceptions, in case t is a specialization and we are
1572 emitting an error about incompatible specifications. */
1573 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1574
1575 /* Likewise for the constexpr specifier, in case t is a specialization. */
1576 constexpr_p = DECL_DECLARED_CONSTEXPR_P (t);
1577
1578 /* Pretty print template instantiations only. */
1579 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1580 && !(flags & TFF_NO_TEMPLATE_BINDINGS)
1581 && flag_pretty_templates)
1582 {
1583 tree tmpl;
1584
1585 template_args = DECL_TI_ARGS (t);
1586 tmpl = most_general_template (t);
1587 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1588 {
1589 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1590 t = tmpl;
1591 }
1592 }
1593
1594 if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1595 return dump_lambda_function (pp, t, template_parms, template_args, flags);
1596
1597 fntype = TREE_TYPE (t);
1598 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1599
1600 if (DECL_CLASS_SCOPE_P (t))
1601 cname = DECL_CONTEXT (t);
1602 /* This is for partially instantiated template methods. */
1603 else if (TREE_CODE (fntype) == METHOD_TYPE)
1604 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1605
1606 if (flags & TFF_DECL_SPECIFIERS)
1607 {
1608 if (DECL_STATIC_FUNCTION_P (t))
1609 pp_cxx_ws_string (pp, "static");
1610 else if (DECL_VIRTUAL_P (t))
1611 pp_cxx_ws_string (pp, "virtual");
1612
1613 if (constexpr_p)
1614 {
1615 if (DECL_DECLARED_CONCEPT_P (t))
1616 pp_cxx_ws_string (pp, "concept");
1617 else
1618 pp_cxx_ws_string (pp, "constexpr");
1619 }
1620 }
1621
1622 /* Print the return type? */
1623 if (show_return)
1624 show_return = (!DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1625 && !DECL_DESTRUCTOR_P (t) && !deduction_guide_p (t));
1626 if (show_return)
1627 {
1628 ret = fndecl_declared_return_type (t);
1629 dump_type_prefix (pp, ret, flags);
1630 }
1631
1632 /* Print the function name. */
1633 if (!do_outer_scope)
1634 /* Nothing. */;
1635 else if (cname)
1636 {
1637 dump_type (pp, cname, flags);
1638 pp_cxx_colon_colon (pp);
1639 }
1640 else
1641 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1642
1643 dump_function_name (pp, t, flags);
1644
1645 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1646 {
1647 dump_parameters (pp, parmtypes, flags);
1648
1649 if (TREE_CODE (fntype) == METHOD_TYPE)
1650 {
1651 pp->padding = pp_before;
1652 pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype));
1653 dump_ref_qualifier (pp, fntype, flags);
1654 }
1655
1656 if (tx_safe_fn_type_p (fntype))
1657 {
1658 pp->padding = pp_before;
1659 pp_cxx_ws_string (pp, "transaction_safe");
1660 }
1661
1662 if (flags & TFF_EXCEPTION_SPECIFICATION)
1663 {
1664 pp->padding = pp_before;
1665 dump_exception_spec (pp, exceptions, flags);
1666 }
1667
1668 if (show_return)
1669 dump_type_suffix (pp, ret, flags);
1670 else if (deduction_guide_p (t))
1671 {
1672 pp_cxx_ws_string (pp, "->");
1673 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
1674 }
1675
1676 if (flag_concepts)
1677 if (tree ci = get_constraints (t))
1678 if (tree reqs = CI_DECLARATOR_REQS (ci))
1679 pp_cxx_requires_clause (pp, reqs);
1680
1681 dump_substitution (pp, t, template_parms, template_args, flags);
1682
1683 if (tree base = DECL_INHERITED_CTOR_BASE (t))
1684 {
1685 pp_cxx_ws_string (pp, "[inherited from");
1686 dump_type (pp, base, TFF_PLAIN_IDENTIFIER);
1687 pp_character (pp, ']');
1688 }
1689 }
1690 else if (template_args)
1691 {
1692 bool need_comma = false;
1693 int i;
1694 pp_cxx_begin_template_argument_list (pp);
1695 template_args = INNERMOST_TEMPLATE_ARGS (template_args);
1696 for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
1697 {
1698 tree arg = TREE_VEC_ELT (template_args, i);
1699 if (need_comma)
1700 pp_separate_with_comma (pp);
1701 if (ARGUMENT_PACK_P (arg))
1702 pp_cxx_left_brace (pp);
1703 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
1704 if (ARGUMENT_PACK_P (arg))
1705 pp_cxx_right_brace (pp);
1706 need_comma = true;
1707 }
1708 pp_cxx_end_template_argument_list (pp);
1709 }
1710}
1711
1712/* Print a parameter list. If this is for a member function, the
1713 member object ptr (and any other hidden args) should have
1714 already been removed. */
1715
1716static void
1717dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags)
1718{
1719 int first = 1;
1720 flags &= ~TFF_SCOPE;
1721 pp_cxx_left_paren (pp);
1722
1723 for (first = 1; parmtypes != void_list_node;
1724 parmtypes = TREE_CHAIN (parmtypes))
1725 {
1726 if (!first)
1727 pp_separate_with_comma (pp);
1728 first = 0;
1729 if (!parmtypes)
1730 {
1731 pp_cxx_ws_string (pp, "...");
1732 break;
1733 }
1734
1735 dump_type (pp, TREE_VALUE (parmtypes), flags);
1736
1737 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1738 {
1739 pp_cxx_whitespace (pp);
1740 pp_equal (pp);
1741 pp_cxx_whitespace (pp);
1742 dump_expr (pp, TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1743 }
1744 }
1745
1746 pp_cxx_right_paren (pp);
1747}
1748
1749/* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1750
1751static void
1752dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED)
1753{
1754 if (FUNCTION_REF_QUALIFIED (t))
1755 {
1756 pp->padding = pp_before;
1757 if (FUNCTION_RVALUE_QUALIFIED (t))
1758 pp_cxx_ws_string (pp, "&&");
1759 else
1760 pp_cxx_ws_string (pp, "&");
1761 }
1762}
1763
1764/* Print an exception specification. T is the exception specification. */
1765
1766static void
1767dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags)
1768{
1769 if (t && TREE_PURPOSE (t))
1770 {
1771 pp_cxx_ws_string (pp, "noexcept");
1772 if (!integer_onep (TREE_PURPOSE (t)))
1773 {
1774 pp_cxx_whitespace (pp);
1775 pp_cxx_left_paren (pp);
1776 if (DEFERRED_NOEXCEPT_SPEC_P (t))
1777 pp_cxx_ws_string (pp, "<uninstantiated>");
1778 else
1779 dump_expr (pp, TREE_PURPOSE (t), flags);
1780 pp_cxx_right_paren (pp);
1781 }
1782 }
1783 else if (t)
1784 {
1785 pp_cxx_ws_string (pp, "throw");
1786 pp_cxx_whitespace (pp);
1787 pp_cxx_left_paren (pp);
1788 if (TREE_VALUE (t) != NULL_TREE)
1789 while (1)
1790 {
1791 dump_type (pp, TREE_VALUE (t), flags);
1792 t = TREE_CHAIN (t);
1793 if (!t)
1794 break;
1795 pp_separate_with_comma (pp);
1796 }
1797 pp_cxx_right_paren (pp);
1798 }
1799}
1800
1801/* Handle the function name for a FUNCTION_DECL node, grokking operators
1802 and destructors properly. */
1803
1804static void
1805dump_function_name (cxx_pretty_printer *pp, tree t, int flags)
1806{
1807 tree name = DECL_NAME (t);
1808
1809 /* We can get here with a decl that was synthesized by language-
1810 independent machinery (e.g. coverage.c) in which case it won't
1811 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1812 will crash. In this case it is safe just to print out the
1813 literal name. */
1814 if (!DECL_LANG_SPECIFIC (t))
1815 {
1816 pp_cxx_tree_identifier (pp, name);
1817 return;
1818 }
1819
1820 if (TREE_CODE (t) == TEMPLATE_DECL)
1821 t = DECL_TEMPLATE_RESULT (t);
1822
1823 /* Don't let the user see __comp_ctor et al. */
1824 if (DECL_CONSTRUCTOR_P (t)
1825 || DECL_DESTRUCTOR_P (t))
1826 {
1827 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1828 name = get_identifier ("<lambda>");
1829 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t)))
1830 name = get_identifier ("<constructor>");
1831 else
1832 name = constructor_name (DECL_CONTEXT (t));
1833 }
1834
1835 if (DECL_DESTRUCTOR_P (t))
1836 {
1837 pp_cxx_complement (pp);
1838 dump_decl (pp, name, TFF_PLAIN_IDENTIFIER);
1839 }
1840 else if (DECL_CONV_FN_P (t))
1841 {
1842 /* This cannot use the hack that the operator's return
1843 type is stashed off of its name because it may be
1844 used for error reporting. In the case of conflicting
1845 declarations, both will have the same name, yet
1846 the types will be different, hence the TREE_TYPE field
1847 of the first name will be clobbered by the second. */
1848 pp_cxx_ws_string (pp, "operator");
1849 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
1850 }
1851 else
1852 dump_decl (pp, name, flags);
1853
1854 if (DECL_TEMPLATE_INFO (t)
1855 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1856 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1857 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1858 dump_template_parms (pp, DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t),
1859 flags);
1860}
1861
1862/* Dump the template parameters from the template info INFO under control of
1863 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1864 specialization (partial or complete). For partial specializations we show
1865 the specialized parameter values. For a primary template we show no
1866 decoration. */
1867
1868static void
1869dump_template_parms (cxx_pretty_printer *pp, tree info,
1870 int primary, int flags)
1871{
1872 tree args = info ? TI_ARGS (info) : NULL_TREE;
1873
1874 if (primary && flags & TFF_TEMPLATE_NAME)
1875 return;
1876 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1877 pp_cxx_begin_template_argument_list (pp);
1878
1879 /* Be careful only to print things when we have them, so as not
1880 to crash producing error messages. */
1881 if (args && !primary)
1882 {
1883 int len, ix;
1884 len = get_non_default_template_args_count (args, flags);
1885
1886 args = INNERMOST_TEMPLATE_ARGS (args);
1887 for (ix = 0; ix != len; ix++)
1888 {
1889 tree arg = TREE_VEC_ELT (args, ix);
1890
1891 /* Only print a comma if we know there is an argument coming. In
1892 the case of an empty template argument pack, no actual
1893 argument will be printed. */
1894 if (ix
1895 && (!ARGUMENT_PACK_P (arg)
1896 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1897 pp_separate_with_comma (pp);
1898
1899 if (!arg)
1900 pp_string (pp, M_("<template parameter error>"));
1901 else
1902 dump_template_argument (pp, arg, flags);
1903 }
1904 }
1905 else if (primary)
1906 {
1907 tree tpl = TI_TEMPLATE (info);
1908 tree parms = DECL_TEMPLATE_PARMS (tpl);
1909 int len, ix;
1910
1911 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1912 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1913
1914 for (ix = 0; ix != len; ix++)
1915 {
1916 tree parm;
1917
1918 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1919 {
1920 pp_string (pp, M_("<template parameter error>"));
1921 continue;
1922 }
1923
1924 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1925
1926 if (ix)
1927 pp_separate_with_comma (pp);
1928
1929 dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS);
1930 }
1931 }
1932 pp_cxx_end_template_argument_list (pp);
1933}
1934
1935/* Print out the arguments of CALL_EXPR T as a parenthesized list using
1936 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1937
1938static void
1939dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst)
1940{
1941 tree arg;
1942 call_expr_arg_iterator iter;
1943
1944 pp_cxx_left_paren (pp);
1945 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1946 {
1947 if (skipfirst)
1948 skipfirst = false;
1949 else
1950 {
1951 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1952 if (more_call_expr_args_p (&iter))
1953 pp_separate_with_comma (pp);
1954 }
1955 }
1956 pp_cxx_right_paren (pp);
1957}
1958
1959/* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1960 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1961 true. */
1962
1963static void
1964dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags,
1965 bool skipfirst)
1966{
1967 tree arg;
1968 aggr_init_expr_arg_iterator iter;
1969
1970 pp_cxx_left_paren (pp);
1971 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1972 {
1973 if (skipfirst)
1974 skipfirst = false;
1975 else
1976 {
1977 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1978 if (more_aggr_init_expr_args_p (&iter))
1979 pp_separate_with_comma (pp);
1980 }
1981 }
1982 pp_cxx_right_paren (pp);
1983}
1984
1985/* Print out a list of initializers (subr of dump_expr). */
1986
1987static void
1988dump_expr_list (cxx_pretty_printer *pp, tree l, int flags)
1989{
1990 while (l)
1991 {
1992 dump_expr (pp, TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1993 l = TREE_CHAIN (l);
1994 if (l)
1995 pp_separate_with_comma (pp);
1996 }
1997}
1998
1999/* Print out a vector of initializers (subr of dump_expr). */
2000
2001static void
2002dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v,
2003 int flags)
2004{
2005 unsigned HOST_WIDE_INT idx;
2006 tree value;
2007
2008 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
2009 {
2010 dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS);
2011 if (idx != v->length () - 1)
2012 pp_separate_with_comma (pp);
2013 }
2014}
2015
2016
2017/* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
2018 function. Resolve it to a close relative -- in the sense of static
2019 type -- variant being overridden. That is close to what was written in
2020 the source code. Subroutine of dump_expr. */
2021
2022static tree
2023resolve_virtual_fun_from_obj_type_ref (tree ref)
2024{
2025 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
2026 HOST_WIDE_INT index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref));
2027 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
2028 while (index)
2029 {
2030 fun = TREE_CHAIN (fun);
2031 index -= (TARGET_VTABLE_USES_DESCRIPTORS
2032 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
2033 }
2034
2035 return BV_FN (fun);
2036}
2037
2038/* Print out an expression E under control of FLAGS. */
2039
2040static void
2041dump_expr (cxx_pretty_printer *pp, tree t, int flags)
2042{
2043 tree op;
2044
2045 if (t == 0)
2046 return;
2047
2048 if (STATEMENT_CLASS_P (t))
2049 {
2050 pp_cxx_ws_string (pp, M_("<statement>"));
2051 return;
2052 }
2053
2054 switch (TREE_CODE (t))
2055 {
2056 case VAR_DECL:
2057 case PARM_DECL:
2058 case FIELD_DECL:
2059 case CONST_DECL:
2060 case FUNCTION_DECL:
2061 case TEMPLATE_DECL:
2062 case NAMESPACE_DECL:
2063 case LABEL_DECL:
2064 case OVERLOAD:
2065 case TYPE_DECL:
2066 case IDENTIFIER_NODE:
2067 dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
2068 |TFF_TEMPLATE_HEADER))
2069 | TFF_NO_TEMPLATE_BINDINGS
2070 | TFF_NO_FUNCTION_ARGUMENTS));
2071 break;
2072
2073 case SSA_NAME:
2074 if (SSA_NAME_VAR (t)
2075 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t)))
2076 dump_expr (pp, SSA_NAME_VAR (t), flags);
2077 else
2078 pp_cxx_ws_string (pp, M_("<unknown>"));
2079 break;
2080
2081 case VOID_CST:
2082 case INTEGER_CST:
2083 case REAL_CST:
2084 case STRING_CST:
2085 case COMPLEX_CST:
2086 pp->constant (t);
2087 break;
2088
2089 case USERDEF_LITERAL:
2090 pp_cxx_userdef_literal (pp, t);
2091 break;
2092
2093 case THROW_EXPR:
2094 /* While waiting for caret diagnostics, avoid printing
2095 __cxa_allocate_exception, __cxa_throw, and the like. */
2096 pp_cxx_ws_string (pp, M_("<throw-expression>"));
2097 break;
2098
2099 case PTRMEM_CST:
2100 pp_ampersand (pp);
2101 dump_type (pp, PTRMEM_CST_CLASS (t), flags);
2102 pp_cxx_colon_colon (pp);
2103 pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
2104 break;
2105
2106 case COMPOUND_EXPR:
2107 pp_cxx_left_paren (pp);
2108 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2109 pp_separate_with_comma (pp);
2110 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2111 pp_cxx_right_paren (pp);
2112 break;
2113
2114 case COND_EXPR:
2115 case VEC_COND_EXPR:
2116 pp_cxx_left_paren (pp);
2117 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2118 pp_string (pp, " ? ");
2119 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2120 pp_string (pp, " : ");
2121 dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
2122 pp_cxx_right_paren (pp);
2123 break;
2124
2125 case SAVE_EXPR:
2126 if (TREE_HAS_CONSTRUCTOR (t))
2127 {
2128 pp_cxx_ws_string (pp, "new");
2129 pp_cxx_whitespace (pp);
2130 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
2131 }
2132 else
2133 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2134 break;
2135
2136 case AGGR_INIT_EXPR:
2137 {
2138 tree fn = NULL_TREE;
2139
2140 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
2141 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
2142
2143 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
2144 {
2145 if (DECL_CONSTRUCTOR_P (fn))
2146 dump_type (pp, DECL_CONTEXT (fn), flags);
2147 else
2148 dump_decl (pp, fn, 0);
2149 }
2150 else
2151 dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0);
2152 }
2153 dump_aggr_init_expr_args (pp, t, flags, true);
2154 break;
2155
2156 case CALL_EXPR:
2157 {
2158 tree fn = CALL_EXPR_FN (t);
2159 bool skipfirst = false;
2160
2161 /* Deal with internal functions. */
2162 if (fn == NULL_TREE)
2163 {
2164 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t)));
2165 dump_call_expr_args (pp, t, flags, skipfirst);
2166 break;
2167 }
2168
2169 if (TREE_CODE (fn) == ADDR_EXPR)
2170 fn = TREE_OPERAND (fn, 0);
2171
2172 /* Nobody is interested in seeing the guts of vcalls. */
2173 if (TREE_CODE (fn) == OBJ_TYPE_REF)
2174 fn = resolve_virtual_fun_from_obj_type_ref (fn);
2175
2176 if (TREE_TYPE (fn) != NULL_TREE
2177 && NEXT_CODE (fn) == METHOD_TYPE
2178 && call_expr_nargs (t))
2179 {
2180 tree ob = CALL_EXPR_ARG (t, 0);
2181 if (TREE_CODE (ob) == ADDR_EXPR)
2182 {
2183 dump_expr (pp, TREE_OPERAND (ob, 0),
2184 flags | TFF_EXPR_IN_PARENS);
2185 pp_cxx_dot (pp);
2186 }
2187 else if (!is_this_parameter (ob))
2188 {
2189 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2190 pp_cxx_arrow (pp);
2191 }
2192 skipfirst = true;
2193 }
2194 if (flag_sanitize & SANITIZE_UNDEFINED
2195 && is_ubsan_builtin_p (fn))
2196 {
2197 pp_string (cxx_pp, M_("<ubsan routine call>"));
2198 break;
2199 }
2200 dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS);
2201 dump_call_expr_args (pp, t, flags, skipfirst);
2202 }
2203 break;
2204
2205 case TARGET_EXPR:
2206 /* Note that this only works for G++ target exprs. If somebody
2207 builds a general TARGET_EXPR, there's no way to represent that
2208 it initializes anything other that the parameter slot for the
2209 default argument. Note we may have cleared out the first
2210 operand in expand_expr, so don't go killing ourselves. */
2211 if (TREE_OPERAND (t, 1))
2212 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2213 break;
2214
2215 case POINTER_PLUS_EXPR:
2216 dump_binary_op (pp, "+", t, flags);
2217 break;
2218
2219 case POINTER_DIFF_EXPR:
2220 dump_binary_op (pp, "-", t, flags);
2221 break;
2222
2223 case INIT_EXPR:
2224 case MODIFY_EXPR:
2225 dump_binary_op (pp, OVL_OP_INFO (true, NOP_EXPR)->name, t, flags);
2226 break;
2227
2228 case PLUS_EXPR:
2229 case MINUS_EXPR:
2230 case MULT_EXPR:
2231 case TRUNC_DIV_EXPR:
2232 case TRUNC_MOD_EXPR:
2233 case MIN_EXPR:
2234 case MAX_EXPR:
2235 case LSHIFT_EXPR:
2236 case RSHIFT_EXPR:
2237 case BIT_IOR_EXPR:
2238 case BIT_XOR_EXPR:
2239 case BIT_AND_EXPR:
2240 case TRUTH_ANDIF_EXPR:
2241 case TRUTH_ORIF_EXPR:
2242 case LT_EXPR:
2243 case LE_EXPR:
2244 case GT_EXPR:
2245 case GE_EXPR:
2246 case EQ_EXPR:
2247 case NE_EXPR:
2248 case EXACT_DIV_EXPR:
2249 dump_binary_op (pp, OVL_OP_INFO (false, TREE_CODE (t))->name, t, flags);
2250 break;
2251
2252 case CEIL_DIV_EXPR:
2253 case FLOOR_DIV_EXPR:
2254 case ROUND_DIV_EXPR:
2255 case RDIV_EXPR:
2256 dump_binary_op (pp, "/", t, flags);
2257 break;
2258
2259 case CEIL_MOD_EXPR:
2260 case FLOOR_MOD_EXPR:
2261 case ROUND_MOD_EXPR:
2262 dump_binary_op (pp, "%", t, flags);
2263 break;
2264
2265 case COMPONENT_REF:
2266 {
2267 tree ob = TREE_OPERAND (t, 0);
2268 if (INDIRECT_REF_P (ob))
2269 {
2270 ob = TREE_OPERAND (ob, 0);
2271 if (!is_this_parameter (ob))
2272 {
2273 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2274 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
2275 pp_cxx_dot (pp);
2276 else
2277 pp_cxx_arrow (pp);
2278 }
2279 }
2280 else
2281 {
2282 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2283 if (TREE_CODE (ob) != ARROW_EXPR)
2284 pp_cxx_dot (pp);
2285 }
2286 dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
2287 }
2288 break;
2289
2290 case ARRAY_REF:
2291 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2292 pp_cxx_left_bracket (pp);
2293 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2294 pp_cxx_right_bracket (pp);
2295 break;
2296
2297 case UNARY_PLUS_EXPR:
2298 dump_unary_op (pp, "+", t, flags);
2299 break;
2300
2301 case ADDR_EXPR:
2302 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
2303 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
2304 /* An ADDR_EXPR can have reference type. In that case, we
2305 shouldn't print the `&' doing so indicates to the user
2306 that the expression has pointer type. */
2307 || (TREE_TYPE (t)
2308 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
2309 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2310 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
2311 dump_unary_op (pp, "&&", t, flags);
2312 else
2313 dump_unary_op (pp, "&", t, flags);
2314 break;
2315
2316 case INDIRECT_REF:
2317 if (TREE_HAS_CONSTRUCTOR (t))
2318 {
2319 t = TREE_OPERAND (t, 0);
2320 gcc_assert (TREE_CODE (t) == CALL_EXPR);
2321 dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
2322 dump_call_expr_args (pp, t, flags, true);
2323 }
2324 else
2325 {
2326 if (TREE_OPERAND (t,0) != NULL_TREE
2327 && TREE_TYPE (TREE_OPERAND (t, 0))
2328 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
2329 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2330 else
2331 dump_unary_op (pp, "*", t, flags);
2332 }
2333 break;
2334
2335 case MEM_REF:
2336 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
2337 && integer_zerop (TREE_OPERAND (t, 1)))
2338 dump_expr (pp, TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
2339 else
2340 {
2341 pp_cxx_star (pp);
2342 if (!integer_zerop (TREE_OPERAND (t, 1)))
2343 {
2344 pp_cxx_left_paren (pp);
2345 if (!integer_onep (TYPE_SIZE_UNIT
2346 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
2347 {
2348 pp_cxx_left_paren (pp);
2349 dump_type (pp, ptr_type_node, flags);
2350 pp_cxx_right_paren (pp);
2351 }
2352 }
2353 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2354 if (!integer_zerop (TREE_OPERAND (t, 1)))
2355 {
2356 pp_cxx_ws_string (pp, "+");
2357 dump_expr (pp, fold_convert (ssizetype, TREE_OPERAND (t, 1)),
2358 flags);
2359 pp_cxx_right_paren (pp);
2360 }
2361 }
2362 break;
2363
2364 case NEGATE_EXPR:
2365 case BIT_NOT_EXPR:
2366 case TRUTH_NOT_EXPR:
2367 case PREDECREMENT_EXPR:
2368 case PREINCREMENT_EXPR:
2369 dump_unary_op (pp, OVL_OP_INFO (false, TREE_CODE (t))->name, t, flags);
2370 break;
2371
2372 case POSTDECREMENT_EXPR:
2373 case POSTINCREMENT_EXPR:
2374 pp_cxx_left_paren (pp);
2375 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2376 pp_cxx_ws_string (pp, OVL_OP_INFO (false, TREE_CODE (t))->name);
2377 pp_cxx_right_paren (pp);
2378 break;
2379
2380 case NON_LVALUE_EXPR:
2381 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2382 should be another level of INDIRECT_REF so that I don't have to do
2383 this. */
2384 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2385 {
2386 tree next = TREE_TYPE (TREE_TYPE (t));
2387
2388 while (TYPE_PTR_P (next))
2389 next = TREE_TYPE (next);
2390
2391 if (TREE_CODE (next) == FUNCTION_TYPE)
2392 {
2393 if (flags & TFF_EXPR_IN_PARENS)
2394 pp_cxx_left_paren (pp);
2395 pp_cxx_star (pp);
2396 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2397 if (flags & TFF_EXPR_IN_PARENS)
2398 pp_cxx_right_paren (pp);
2399 break;
2400 }
2401 /* Else fall through. */
2402 }
2403 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2404 break;
2405
2406 CASE_CONVERT:
2407 case IMPLICIT_CONV_EXPR:
2408 case VIEW_CONVERT_EXPR:
2409 {
2410 tree op = TREE_OPERAND (t, 0);
2411 tree ttype = TREE_TYPE (t);
2412 tree optype = TREE_TYPE (op);
2413
2414 if (TREE_CODE (ttype) != TREE_CODE (optype)
2415 && POINTER_TYPE_P (ttype)
2416 && POINTER_TYPE_P (optype)
2417 && same_type_p (TREE_TYPE (optype),
2418 TREE_TYPE (ttype)))
2419 {
2420 if (TREE_CODE (ttype) == REFERENCE_TYPE)
2421 {
2422 STRIP_NOPS (op);
2423 if (TREE_CODE (op) == ADDR_EXPR)
2424 dump_expr (pp, TREE_OPERAND (op, 0), flags);
2425 else
2426 dump_unary_op (pp, "*", t, flags);
2427 }
2428 else
2429 dump_unary_op (pp, "&", t, flags);
2430 }
2431 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2432 {
2433 /* It is a cast, but we cannot tell whether it is a
2434 reinterpret or static cast. Use the C style notation. */
2435 if (flags & TFF_EXPR_IN_PARENS)
2436 pp_cxx_left_paren (pp);
2437 pp_cxx_left_paren (pp);
2438 dump_type (pp, TREE_TYPE (t), flags);
2439 pp_cxx_right_paren (pp);
2440 dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS);
2441 if (flags & TFF_EXPR_IN_PARENS)
2442 pp_cxx_right_paren (pp);
2443 }
2444 else
2445 dump_expr (pp, op, flags);
2446 break;
2447 }
2448
2449 case CONSTRUCTOR:
2450 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2451 {
2452 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2453
2454 if (integer_zerop (idx))
2455 {
2456 /* A NULL pointer-to-member constant. */
2457 pp_cxx_left_paren (pp);
2458 pp_cxx_left_paren (pp);
2459 dump_type (pp, TREE_TYPE (t), flags);
2460 pp_cxx_right_paren (pp);
2461 pp_character (pp, '0');
2462 pp_cxx_right_paren (pp);
2463 break;
2464 }
2465 else if (tree_fits_shwi_p (idx))
2466 {
2467 tree virtuals;
2468 unsigned HOST_WIDE_INT n;
2469
2470 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2471 t = TYPE_METHOD_BASETYPE (t);
2472 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2473
2474 n = tree_to_shwi (idx);
2475
2476 /* Map vtable index back one, to allow for the null pointer to
2477 member. */
2478 --n;
2479
2480 while (n > 0 && virtuals)
2481 {
2482 --n;
2483 virtuals = TREE_CHAIN (virtuals);
2484 }
2485 if (virtuals)
2486 {
2487 dump_expr (pp, BV_FN (virtuals),
2488 flags | TFF_EXPR_IN_PARENS);
2489 break;
2490 }
2491 }
2492 }
2493 if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t)))
2494 pp_string (pp, "<lambda closure object>");
2495 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2496 {
2497 dump_type (pp, TREE_TYPE (t), 0);
2498 pp_cxx_left_paren (pp);
2499 pp_cxx_right_paren (pp);
2500 }
2501 else
2502 {
2503 if (!BRACE_ENCLOSED_INITIALIZER_P (t))
2504 dump_type (pp, TREE_TYPE (t), 0);
2505 pp_cxx_left_brace (pp);
2506 dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags);
2507 pp_cxx_right_brace (pp);
2508 }
2509
2510 break;
2511
2512 case OFFSET_REF:
2513 {
2514 tree ob = TREE_OPERAND (t, 0);
2515 if (is_dummy_object (ob))
2516 {
2517 t = TREE_OPERAND (t, 1);
2518 if (TREE_CODE (t) == FUNCTION_DECL)
2519 /* A::f */
2520 dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS);
2521 else if (BASELINK_P (t))
2522 dump_expr (pp, OVL_FIRST (BASELINK_FUNCTIONS (t)),
2523 flags | TFF_EXPR_IN_PARENS);
2524 else
2525 dump_decl (pp, t, flags);
2526 }
2527 else
2528 {
2529 if (INDIRECT_REF_P (ob))
2530 {
2531 dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2532 pp_cxx_arrow (pp);
2533 pp_cxx_star (pp);
2534 }
2535 else
2536 {
2537 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2538 pp_cxx_dot (pp);
2539 pp_cxx_star (pp);
2540 }
2541 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2542 }
2543 break;
2544 }
2545
2546 case TEMPLATE_PARM_INDEX:
2547 dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2548 break;
2549
2550 case CAST_EXPR:
2551 if (TREE_OPERAND (t, 0) == NULL_TREE
2552 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2553 {
2554 dump_type (pp, TREE_TYPE (t), flags);
2555 pp_cxx_left_paren (pp);
2556 dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2557 pp_cxx_right_paren (pp);
2558 }
2559 else
2560 {
2561 pp_cxx_left_paren (pp);
2562 dump_type (pp, TREE_TYPE (t), flags);
2563 pp_cxx_right_paren (pp);
2564 pp_cxx_left_paren (pp);
2565 dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2566 pp_cxx_right_paren (pp);
2567 }
2568 break;
2569
2570 case STATIC_CAST_EXPR:
2571 pp_cxx_ws_string (pp, "static_cast");
2572 goto cast;
2573 case REINTERPRET_CAST_EXPR:
2574 pp_cxx_ws_string (pp, "reinterpret_cast");
2575 goto cast;
2576 case CONST_CAST_EXPR:
2577 pp_cxx_ws_string (pp, "const_cast");
2578 goto cast;
2579 case DYNAMIC_CAST_EXPR:
2580 pp_cxx_ws_string (pp, "dynamic_cast");
2581 cast:
2582 pp_cxx_begin_template_argument_list (pp);
2583 dump_type (pp, TREE_TYPE (t), flags);
2584 pp_cxx_end_template_argument_list (pp);
2585 pp_cxx_left_paren (pp);
2586 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2587 pp_cxx_right_paren (pp);
2588 break;
2589
2590 case ARROW_EXPR:
2591 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2592 pp_cxx_arrow (pp);
2593 break;
2594
2595 case SIZEOF_EXPR:
2596 case ALIGNOF_EXPR:
2597 if (TREE_CODE (t) == SIZEOF_EXPR)
2598 pp_cxx_ws_string (pp, "sizeof");
2599 else
2600 {
2601 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2602 pp_cxx_ws_string (pp, "__alignof__");
2603 }
2604 op = TREE_OPERAND (t, 0);
2605 if (PACK_EXPANSION_P (op))
2606 {
2607 pp_string (pp, "...");
2608 op = PACK_EXPANSION_PATTERN (op);
2609 }
2610 pp_cxx_whitespace (pp);
2611 pp_cxx_left_paren (pp);
2612 if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
2613 dump_type (pp, TREE_TYPE (op), flags);
2614 else if (TYPE_P (TREE_OPERAND (t, 0)))
2615 dump_type (pp, op, flags);
2616 else
2617 dump_expr (pp, op, flags);
2618 pp_cxx_right_paren (pp);
2619 break;
2620
2621 case AT_ENCODE_EXPR:
2622 pp_cxx_ws_string (pp, "@encode");
2623 pp_cxx_whitespace (pp);
2624 pp_cxx_left_paren (pp);
2625 dump_type (pp, TREE_OPERAND (t, 0), flags);
2626 pp_cxx_right_paren (pp);
2627 break;
2628
2629 case NOEXCEPT_EXPR:
2630 pp_cxx_ws_string (pp, "noexcept");
2631 pp_cxx_whitespace (pp);
2632 pp_cxx_left_paren (pp);
2633 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2634 pp_cxx_right_paren (pp);
2635 break;
2636
2637 case REALPART_EXPR:
2638 case IMAGPART_EXPR:
2639 pp_cxx_ws_string (pp, OVL_OP_INFO (false, TREE_CODE (t))->name);
2640 pp_cxx_whitespace (pp);
2641 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2642 break;
2643
2644 case DEFAULT_ARG:
2645 pp_string (pp, M_("<unparsed>"));
2646 break;
2647
2648 case TRY_CATCH_EXPR:
2649 case CLEANUP_POINT_EXPR:
2650 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2651 break;
2652
2653 case PSEUDO_DTOR_EXPR:
2654 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2655 pp_cxx_dot (pp);
2656 if (TREE_OPERAND (t, 1))
2657 {
2658 dump_type (pp, TREE_OPERAND (t, 1), flags);
2659 pp_cxx_colon_colon (pp);
2660 }
2661 pp_cxx_complement (pp);
2662 dump_type (pp, TREE_OPERAND (t, 2), flags);
2663 break;
2664
2665 case TEMPLATE_ID_EXPR:
2666 dump_decl (pp, t, flags);
2667 break;
2668
2669 case BIND_EXPR:
2670 case STMT_EXPR:
2671 case EXPR_STMT:
2672 case STATEMENT_LIST:
2673 /* We don't yet have a way of dumping statements in a
2674 human-readable format. */
2675 pp_string (pp, "({...})");
2676 break;
2677
2678 case LOOP_EXPR:
2679 pp_string (pp, "while (1) { ");
2680 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2681 pp_cxx_right_brace (pp);
2682 break;
2683
2684 case EXIT_EXPR:
2685 pp_string (pp, "if (");
2686 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2687 pp_string (pp, ") break; ");
2688 break;
2689
2690 case BASELINK:
2691 dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
2692 break;
2693
2694 case EMPTY_CLASS_EXPR:
2695 dump_type (pp, TREE_TYPE (t), flags);
2696 pp_cxx_left_paren (pp);
2697 pp_cxx_right_paren (pp);
2698 break;
2699
2700 case NON_DEPENDENT_EXPR:
2701 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2702 break;
2703
2704 case ARGUMENT_PACK_SELECT:
2705 dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2706 break;
2707
2708 case RECORD_TYPE:
2709 case UNION_TYPE:
2710 case ENUMERAL_TYPE:
2711 case REAL_TYPE:
2712 case VOID_TYPE:
2713 case BOOLEAN_TYPE:
2714 case INTEGER_TYPE:
2715 case COMPLEX_TYPE:
2716 case VECTOR_TYPE:
2717 pp_type_specifier_seq (pp, t);
2718 break;
2719
2720 case TYPENAME_TYPE:
2721 /* We get here when we want to print a dependent type as an
2722 id-expression, without any disambiguator decoration. */
2723 pp->id_expression (t);
2724 break;
2725
2726 case TEMPLATE_TYPE_PARM:
2727 case TEMPLATE_TEMPLATE_PARM:
2728 case BOUND_TEMPLATE_TEMPLATE_PARM:
2729 dump_type (pp, t, flags);
2730 break;
2731
2732 case TRAIT_EXPR:
2733 pp_cxx_trait_expression (pp, t);
2734 break;
2735
2736 case VA_ARG_EXPR:
2737 pp_cxx_va_arg_expression (pp, t);
2738 break;
2739
2740 case OFFSETOF_EXPR:
2741 pp_cxx_offsetof_expression (pp, t);
2742 break;
2743
2744 case ADDRESSOF_EXPR:
2745 pp_cxx_addressof_expression (pp, t);
2746 break;
2747
2748 case SCOPE_REF:
2749 dump_decl (pp, t, flags);
2750 break;
2751
2752 case EXPR_PACK_EXPANSION:
2753 case UNARY_LEFT_FOLD_EXPR:
2754 case UNARY_RIGHT_FOLD_EXPR:
2755 case BINARY_LEFT_FOLD_EXPR:
2756 case BINARY_RIGHT_FOLD_EXPR:
2757 case TYPEID_EXPR:
2758 case MEMBER_REF:
2759 case DOTSTAR_EXPR:
2760 case NEW_EXPR:
2761 case VEC_NEW_EXPR:
2762 case DELETE_EXPR:
2763 case VEC_DELETE_EXPR:
2764 case MODOP_EXPR:
2765 case ABS_EXPR:
2766 case CONJ_EXPR:
2767 case VECTOR_CST:
2768 case FIXED_CST:
2769 case UNORDERED_EXPR:
2770 case ORDERED_EXPR:
2771 case UNLT_EXPR:
2772 case UNLE_EXPR:
2773 case UNGT_EXPR:
2774 case UNGE_EXPR:
2775 case UNEQ_EXPR:
2776 case LTGT_EXPR:
2777 case COMPLEX_EXPR:
2778 case BIT_FIELD_REF:
2779 case FIX_TRUNC_EXPR:
2780 case FLOAT_EXPR:
2781 pp->expression (t);
2782 break;
2783
2784 case TRUTH_AND_EXPR:
2785 case TRUTH_OR_EXPR:
2786 case TRUTH_XOR_EXPR:
2787 if (flags & TFF_EXPR_IN_PARENS)
2788 pp_cxx_left_paren (pp);
2789 pp->expression (t);
2790 if (flags & TFF_EXPR_IN_PARENS)
2791 pp_cxx_right_paren (pp);
2792 break;
2793
2794 case OBJ_TYPE_REF:
2795 dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
2796 break;
2797
2798 case LAMBDA_EXPR:
2799 pp_string (pp, M_("<lambda>"));
2800 break;
2801
2802 case PAREN_EXPR:
2803 pp_cxx_left_paren (pp);
2804 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2805 pp_cxx_right_paren (pp);
2806 break;
2807
2808 case REQUIRES_EXPR:
2809 pp_cxx_requires_expr (cxx_pp, t);
2810 break;
2811
2812 case SIMPLE_REQ:
2813 pp_cxx_simple_requirement (cxx_pp, t);
2814 break;
2815
2816 case TYPE_REQ:
2817 pp_cxx_type_requirement (cxx_pp, t);
2818 break;
2819
2820 case COMPOUND_REQ:
2821 pp_cxx_compound_requirement (cxx_pp, t);
2822 break;
2823
2824 case NESTED_REQ:
2825 pp_cxx_nested_requirement (cxx_pp, t);
2826 break;
2827
2828 case PRED_CONSTR:
2829 case CHECK_CONSTR:
2830 case EXPR_CONSTR:
2831 case TYPE_CONSTR:
2832 case ICONV_CONSTR:
2833 case DEDUCT_CONSTR:
2834 case EXCEPT_CONSTR:
2835 case PARM_CONSTR:
2836 case CONJ_CONSTR:
2837 case DISJ_CONSTR:
2838 pp_cxx_constraint (cxx_pp, t);
2839 break;
2840
2841 case PLACEHOLDER_EXPR:
2842 pp_string (pp, M_("*this"));
2843 break;
2844
2845 case TREE_LIST:
2846 dump_expr_list (pp, t, flags);
2847 break;
2848
2849 /* This list is incomplete, but should suffice for now.
2850 It is very important that `sorry' does not call
2851 `report_error_function'. That could cause an infinite loop. */
2852 default:
2853 pp_unsupported_tree (pp, t);
2854 /* Fall through. */
2855 case ERROR_MARK:
2856 pp_string (pp, M_("<expression error>"));
2857 break;
2858 }
2859}
2860
2861static void
2862dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
2863 int flags)
2864{
2865 pp_cxx_left_paren (pp);
2866 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2867 pp_cxx_whitespace (pp);
2868 if (opstring)
2869 pp_cxx_ws_string (pp, opstring);
2870 else
2871 pp_string (pp, M_("<unknown operator>"));
2872 pp_cxx_whitespace (pp);
2873 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2874 pp_cxx_right_paren (pp);
2875}
2876
2877static void
2878dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
2879{
2880 if (flags & TFF_EXPR_IN_PARENS)
2881 pp_cxx_left_paren (pp);
2882 pp_cxx_ws_string (pp, opstring);
2883 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2884 if (flags & TFF_EXPR_IN_PARENS)
2885 pp_cxx_right_paren (pp);
2886}
2887
2888static void
2889reinit_cxx_pp (void)
2890{
2891 pp_clear_output_area (cxx_pp);
2892 cxx_pp->padding = pp_none;
2893 pp_indentation (cxx_pp) = 0;
2894 pp_needs_newline (cxx_pp) = false;
2895 cxx_pp->enclosing_scope = current_function_decl;
2896}
2897
2898/* Same as pp_formatted_text, except the return string is a separate
2899 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2900
2901inline const char *
2902pp_ggc_formatted_text (pretty_printer *pp)
2903{
2904 return ggc_strdup (pp_formatted_text (pp));
2905}
2906
2907/* Exported interface to stringifying types, exprs and decls under TFF_*
2908 control. */
2909
2910const char *
2911type_as_string (tree typ, int flags)
2912{
2913 reinit_cxx_pp ();
2914 pp_translate_identifiers (cxx_pp) = false;
2915 dump_type (cxx_pp, typ, flags);
2916 return pp_ggc_formatted_text (cxx_pp);
2917}
2918
2919const char *
2920type_as_string_translate (tree typ, int flags)
2921{
2922 reinit_cxx_pp ();
2923 dump_type (cxx_pp, typ, flags);
2924 return pp_ggc_formatted_text (cxx_pp);
2925}
2926
2927const char *
2928expr_as_string (tree decl, int flags)
2929{
2930 reinit_cxx_pp ();
2931 pp_translate_identifiers (cxx_pp) = false;
2932 dump_expr (cxx_pp, decl, flags);
2933 return pp_ggc_formatted_text (cxx_pp);
2934}
2935
2936/* Wrap decl_as_string with options appropriate for dwarf. */
2937
2938const char *
2939decl_as_dwarf_string (tree decl, int flags)
2940{
2941 const char *name;
2942 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2943 here will be adequate to get the desired behavior. */
2944 cxx_pp->flags |= pp_c_flag_gnu_v3;
2945 name = decl_as_string (decl, flags);
2946 /* Subsequent calls to the pretty printer shouldn't use this style. */
2947 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2948 return name;
2949}
2950
2951const char *
2952decl_as_string (tree decl, int flags)
2953{
2954 reinit_cxx_pp ();
2955 pp_translate_identifiers (cxx_pp) = false;
2956 dump_decl (cxx_pp, decl, flags);
2957 return pp_ggc_formatted_text (cxx_pp);
2958}
2959
2960const char *
2961decl_as_string_translate (tree decl, int flags)
2962{
2963 reinit_cxx_pp ();
2964 dump_decl (cxx_pp, decl, flags);
2965 return pp_ggc_formatted_text (cxx_pp);
2966}
2967
2968/* Wrap lang_decl_name with options appropriate for dwarf. */
2969
2970const char *
2971lang_decl_dwarf_name (tree decl, int v, bool translate)
2972{
2973 const char *name;
2974 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2975 here will be adequate to get the desired behavior. */
2976 cxx_pp->flags |= pp_c_flag_gnu_v3;
2977 name = lang_decl_name (decl, v, translate);
2978 /* Subsequent calls to the pretty printer shouldn't use this style. */
2979 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2980 return name;
2981}
2982
2983/* Generate the three forms of printable names for cxx_printable_name. */
2984
2985const char *
2986lang_decl_name (tree decl, int v, bool translate)
2987{
2988 if (v >= 2)
2989 return (translate
2990 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2991 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2992
2993 reinit_cxx_pp ();
2994 pp_translate_identifiers (cxx_pp) = translate;
2995 if (v == 1
2996 && (DECL_CLASS_SCOPE_P (decl)
2997 || (DECL_NAMESPACE_SCOPE_P (decl)
2998 && CP_DECL_CONTEXT (decl) != global_namespace)))
2999 {
3000 dump_type (cxx_pp, CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
3001 pp_cxx_colon_colon (cxx_pp);
3002 }
3003
3004 if (TREE_CODE (decl) == FUNCTION_DECL)
3005 dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER);
3006 else if ((DECL_NAME (decl) == NULL_TREE)
3007 && TREE_CODE (decl) == NAMESPACE_DECL)
3008 dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER | TFF_UNQUALIFIED_NAME);
3009 else
3010 dump_decl (cxx_pp, DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
3011
3012 return pp_ggc_formatted_text (cxx_pp);
3013}
3014
3015/* Return the location of a tree passed to %+ formats. */
3016
3017location_t
3018location_of (tree t)
3019{
3020 if (TYPE_P (t))
3021 {
3022 t = TYPE_MAIN_DECL (t);
3023 if (t == NULL_TREE)
3024 return input_location;
3025 }
3026 else if (TREE_CODE (t) == OVERLOAD)
3027 t = OVL_FIRST (t);
3028
3029 if (DECL_P (t))
3030 return DECL_SOURCE_LOCATION (t);
3031 if (TREE_CODE (t) == DEFAULT_ARG)
3032 return defarg_location (t);
3033 return EXPR_LOC_OR_LOC (t, input_location);
3034}
3035
3036/* Now the interfaces from error et al to dump_type et al. Each takes an
3037 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
3038 function. */
3039
3040static const char *
3041decl_to_string (tree decl, int verbose)
3042{
3043 int flags = 0;
3044
3045 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
3046 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
3047 flags = TFF_CLASS_KEY_OR_ENUM;
3048 if (verbose)
3049 flags |= TFF_DECL_SPECIFIERS;
3050 else if (TREE_CODE (decl) == FUNCTION_DECL)
3051 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
3052 flags |= TFF_TEMPLATE_HEADER;
3053
3054 reinit_cxx_pp ();
3055 dump_decl (cxx_pp, decl, flags);
3056 return pp_ggc_formatted_text (cxx_pp);
3057}
3058
3059static const char *
3060expr_to_string (tree decl)
3061{
3062 reinit_cxx_pp ();
3063 dump_expr (cxx_pp, decl, 0);
3064 return pp_ggc_formatted_text (cxx_pp);
3065}
3066
3067static const char *
3068fndecl_to_string (tree fndecl, int verbose)
3069{
3070 int flags;
3071
3072 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
3073 | TFF_TEMPLATE_HEADER;
3074 if (verbose)
3075 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
3076 reinit_cxx_pp ();
3077 dump_decl (cxx_pp, fndecl, flags);
3078 return pp_ggc_formatted_text (cxx_pp);
3079}
3080
3081
3082static const char *
3083code_to_string (enum tree_code c)
3084{
3085 return get_tree_code_name (c);
3086}
3087
3088const char *
3089language_to_string (enum languages c)
3090{
3091 switch (c)
3092 {
3093 case lang_c:
3094 return "C";
3095
3096 case lang_cplusplus:
3097 return "C++";
3098
3099 default:
3100 gcc_unreachable ();
3101 }
3102 return NULL;
3103}
3104
3105/* Return the proper printed version of a parameter to a C++ function. */
3106
3107static const char *
3108parm_to_string (int p)
3109{
3110 reinit_cxx_pp ();
3111 if (p < 0)
3112 pp_string (cxx_pp, "'this'");
3113 else
3114 pp_decimal_int (cxx_pp, p + 1);
3115 return pp_ggc_formatted_text (cxx_pp);
3116}
3117
3118static const char *
3119op_to_string (bool assop, enum tree_code p)
3120{
3121 tree id = ovl_op_identifier (assop, p);
3122 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
3123}
3124
3125/* Return a GC-allocated representation of type TYP, with verbosity VERBOSE.
3126
3127 If QUOTE is non-NULL and if *QUOTE is true, then quotes are added to the
3128 string in appropriate places, and *QUOTE is written to with false
3129 to suppress pp_format's trailing close quote so that e.g.
3130 foo_typedef {aka underlying_foo} {enum}
3131 can be printed by "%qT" as:
3132 `foo_typedef' {aka `underlying_foo'} {enum}
3133 rather than:
3134 `foo_typedef {aka underlying_foo} {enum}'
3135 When adding such quotes, if POSTPROCESSED is true (for handling %H and %I)
3136 then a leading open quote will be added, whereas if POSTPROCESSED is false
3137 (for handling %T) then any leading quote has already been added by
3138 pp_format, or is not needed due to QUOTE being NULL (for template arguments
3139 within %H and %I).
3140
3141 SHOW_COLOR is used to determine the colorization of any quotes that
3142 are added. */
3143
3144static const char *
3145type_to_string (tree typ, int verbose, bool postprocessed, bool *quote,
3146 bool show_color)
3147{
3148 int flags = 0;
3149 if (verbose)
3150 flags |= TFF_CLASS_KEY_OR_ENUM;
3151 flags |= TFF_TEMPLATE_HEADER;
3152
3153 reinit_cxx_pp ();
3154
3155 if (postprocessed && quote && *quote)
3156 pp_begin_quote (cxx_pp, show_color);
3157
3158 struct obstack *ob = pp_buffer (cxx_pp)->obstack;
3159 int type_start, type_len;
3160 type_start = obstack_object_size (ob);
3161
3162 dump_type (cxx_pp, typ, flags);
3163
3164 /* Remember the end of the initial dump. */
3165 type_len = obstack_object_size (ob) - type_start;
3166
3167 /* If we're printing a type that involves typedefs, also print the
3168 stripped version. But sometimes the stripped version looks
3169 exactly the same, so we don't want it after all. To avoid printing
3170 it in that case, we play ugly obstack games. */
3171 if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
3172 && !uses_template_parms (typ))
3173 {
3174 int aka_start, aka_len; char *p;
3175 tree aka = strip_typedefs (typ);
3176 if (quote && *quote)
3177 pp_end_quote (cxx_pp, show_color);
3178 pp_string (cxx_pp, " {aka");
3179 pp_cxx_whitespace (cxx_pp);
3180 if (quote && *quote)
3181 pp_begin_quote (cxx_pp, show_color);
3182 /* And remember the start of the aka dump. */
3183 aka_start = obstack_object_size (ob);
3184 dump_type (cxx_pp, aka, flags);
3185 aka_len = obstack_object_size (ob) - aka_start;
3186 if (quote && *quote)
3187 pp_end_quote (cxx_pp, show_color);
3188 pp_right_brace (cxx_pp);
3189 p = (char*)obstack_base (ob);
3190 /* If they are identical, cut off the aka by unwinding the obstack. */
3191 if (type_len == aka_len
3192 && memcmp (p + type_start, p+aka_start, type_len) == 0)
3193 {
3194 /* We can't add a '\0' here, since we may be adding a closing quote
3195 below, and it would be hidden by the '\0'.
3196 Instead, manually unwind the current object within the obstack
3197 so that the insertion point is at the end of the type, before
3198 the "' {aka". */
3199 int delta = type_start + type_len - obstack_object_size (ob);
3200 gcc_assert (delta <= 0);
3201 obstack_blank_fast (ob, delta);
3202 }
3203 else
3204 if (quote)
3205 /* No further closing quotes are needed. */
3206 *quote = false;
3207 }
3208
3209 if (quote && *quote)
3210 {
3211 pp_end_quote (cxx_pp, show_color);
3212 *quote = false;
3213 }
3214 return pp_ggc_formatted_text (cxx_pp);
3215}
3216
3217static const char *
3218args_to_string (tree p, int verbose)
3219{
3220 int flags = 0;
3221 if (verbose)
3222 flags |= TFF_CLASS_KEY_OR_ENUM;
3223
3224 if (p == NULL_TREE)
3225 return "";
3226
3227 if (TYPE_P (TREE_VALUE (p)))
3228 return type_as_string_translate (p, flags);
3229
3230 reinit_cxx_pp ();
3231 for (; p; p = TREE_CHAIN (p))
3232 {
3233 if (TREE_VALUE (p) == null_node)
3234 pp_cxx_ws_string (cxx_pp, "NULL");
3235 else
3236 dump_type (cxx_pp, error_type (TREE_VALUE (p)), flags);
3237 if (TREE_CHAIN (p))
3238 pp_separate_with_comma (cxx_pp);
3239 }
3240 return pp_ggc_formatted_text (cxx_pp);
3241}
3242
3243/* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3244 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3245 arguments. */
3246
3247static const char *
3248subst_to_string (tree p)
3249{
3250 tree decl = TREE_PURPOSE (p);
3251 tree targs = TREE_VALUE (p);
3252 tree tparms = DECL_TEMPLATE_PARMS (decl);
3253 int flags = (TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER
3254 |TFF_NO_TEMPLATE_BINDINGS);
3255
3256 if (p == NULL_TREE)
3257 return "";
3258
3259 reinit_cxx_pp ();
3260 dump_template_decl (cxx_pp, TREE_PURPOSE (p), flags);
3261 dump_substitution (cxx_pp, NULL, tparms, targs, /*flags=*/0);
3262 return pp_ggc_formatted_text (cxx_pp);
3263}
3264
3265static const char *
3266cv_to_string (tree p, int v)
3267{
3268 reinit_cxx_pp ();
3269 cxx_pp->padding = v ? pp_before : pp_none;
3270 pp_cxx_cv_qualifier_seq (cxx_pp, p);
3271 return pp_ggc_formatted_text (cxx_pp);
3272}
3273
3274static const char *
3275eh_spec_to_string (tree p, int /*v*/)
3276{
3277 int flags = 0;
3278 reinit_cxx_pp ();
3279 dump_exception_spec (cxx_pp, p, flags);
3280 return pp_ggc_formatted_text (cxx_pp);
3281}
3282
3283/* Langhook for print_error_function. */
3284void
3285cxx_print_error_function (diagnostic_context *context, const char *file,
3286 diagnostic_info *diagnostic)
3287{
3288 lhd_print_error_function (context, file, diagnostic);
3289 pp_set_prefix (context->printer, file);
3290 maybe_print_instantiation_context (context);
3291}
3292
3293static void
3294cp_diagnostic_starter (diagnostic_context *context,
3295 diagnostic_info *diagnostic)
3296{
3297 diagnostic_report_current_module (context, diagnostic_location (diagnostic));
3298 cp_print_error_function (context, diagnostic);
3299 maybe_print_instantiation_context (context);
3300 maybe_print_constexpr_context (context);
3301 pp_set_prefix (context->printer, diagnostic_build_prefix (context,
3302 diagnostic));
3303}
3304
3305/* Print current function onto BUFFER, in the process of reporting
3306 a diagnostic message. Called from cp_diagnostic_starter. */
3307static void
3308cp_print_error_function (diagnostic_context *context,
3309 diagnostic_info *diagnostic)
3310{
3311 /* If we are in an instantiation context, current_function_decl is likely
3312 to be wrong, so just rely on print_instantiation_full_context. */
3313 if (current_instantiation ())
3314 return;
3315 if (diagnostic_last_function_changed (context, diagnostic))
3316 {
3317 const char *old_prefix = context->printer->prefix;
3318 const char *file = LOCATION_FILE (diagnostic_location (diagnostic));
3319 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
3320 char *new_prefix = (file && abstract_origin == NULL)
3321 ? file_name_as_prefix (context, file) : NULL;
3322
3323 pp_set_prefix (context->printer, new_prefix);
3324
3325 if (current_function_decl == NULL)
3326 pp_string (context->printer, _("At global scope:"));
3327 else
3328 {
3329 tree fndecl, ao;
3330
3331 if (abstract_origin)
3332 {
3333 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
3334 while (TREE_CODE (ao) == BLOCK
3335 && BLOCK_ABSTRACT_ORIGIN (ao)
3336 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3337 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3338 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
3339 fndecl = ao;
3340 }
3341 else
3342 fndecl = current_function_decl;
3343
3344 pp_printf (context->printer, function_category (fndecl),
3345 cxx_printable_name_translate (fndecl, 2));
3346
3347 while (abstract_origin)
3348 {
3349 location_t *locus;
3350 tree block = abstract_origin;
3351
3352 locus = &BLOCK_SOURCE_LOCATION (block);
3353 fndecl = NULL;
3354 block = BLOCK_SUPERCONTEXT (block);
3355 while (block && TREE_CODE (block) == BLOCK
3356 && BLOCK_ABSTRACT_ORIGIN (block))
3357 {
3358 ao = BLOCK_ABSTRACT_ORIGIN (block);
3359
3360 while (TREE_CODE (ao) == BLOCK
3361 && BLOCK_ABSTRACT_ORIGIN (ao)
3362 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3363 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3364
3365 if (TREE_CODE (ao) == FUNCTION_DECL)
3366 {
3367 fndecl = ao;
3368 break;
3369 }
3370 else if (TREE_CODE (ao) != BLOCK)
3371 break;
3372
3373 block = BLOCK_SUPERCONTEXT (block);
3374 }
3375 if (fndecl)
3376 abstract_origin = block;
3377 else
3378 {
3379 while (block && TREE_CODE (block) == BLOCK)
3380 block = BLOCK_SUPERCONTEXT (block);
3381
3382 if (block && TREE_CODE (block) == FUNCTION_DECL)
3383 fndecl = block;
3384 abstract_origin = NULL;
3385 }
3386 if (fndecl)
3387 {
3388 expanded_location s = expand_location (*locus);
3389 pp_character (context->printer, ',');
3390 pp_newline (context->printer);
3391 if (s.file != NULL)
3392 {
3393 if (context->show_column && s.column != 0)
3394 pp_printf (context->printer,
3395 _(" inlined from %qs at %r%s:%d:%d%R"),
3396 cxx_printable_name_translate (fndecl, 2),
3397 "locus", s.file, s.line, s.column);
3398 else
3399 pp_printf (context->printer,
3400 _(" inlined from %qs at %r%s:%d%R"),
3401 cxx_printable_name_translate (fndecl, 2),
3402 "locus", s.file, s.line);
3403
3404 }
3405 else
3406 pp_printf (context->printer, _(" inlined from %qs"),
3407 cxx_printable_name_translate (fndecl, 2));
3408 }
3409 }
3410 pp_character (context->printer, ':');
3411 }
3412 pp_newline (context->printer);
3413
3414 diagnostic_set_last_function (context, diagnostic);
3415 pp_destroy_prefix (context->printer);
3416 context->printer->prefix = old_prefix;
3417 }
3418}
3419
3420/* Returns a description of FUNCTION using standard terminology. The
3421 result is a format string of the form "In CATEGORY %qs". */
3422static const char *
3423function_category (tree fn)
3424{
3425 /* We can get called from the middle-end for diagnostics of function
3426 clones. Make sure we have language specific information before
3427 dereferencing it. */
3428 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
3429 && DECL_FUNCTION_MEMBER_P (fn))
3430 {
3431 if (DECL_STATIC_FUNCTION_P (fn))
3432 return _("In static member function %qs");
3433 else if (DECL_COPY_CONSTRUCTOR_P (fn))
3434 return _("In copy constructor %qs");
3435 else if (DECL_CONSTRUCTOR_P (fn))
3436 return _("In constructor %qs");
3437 else if (DECL_DESTRUCTOR_P (fn))
3438 return _("In destructor %qs");
3439 else if (LAMBDA_FUNCTION_P (fn))
3440 return _("In lambda function");
3441 else
3442 return _("In member function %qs");
3443 }
3444 else
3445 return _("In function %qs");
3446}
3447
3448/* Report the full context of a current template instantiation,
3449 onto BUFFER. */
3450static void
3451print_instantiation_full_context (diagnostic_context *context)
3452{
3453 struct tinst_level *p = current_instantiation ();
3454 location_t location = input_location;
3455
3456 if (p)
3457 {
3458 pp_verbatim (context->printer,
3459 TREE_CODE (p->decl) == TREE_LIST
3460 ? _("%s: In substitution of %qS:\n")
3461 : _("%s: In instantiation of %q#D:\n"),
3462 LOCATION_FILE (location),
3463 p->decl);
3464
3465 location = p->locus;
3466 p = p->next;
3467 }
3468
3469 print_instantiation_partial_context (context, p, location);
3470}
3471
3472/* Helper function of print_instantiation_partial_context() that
3473 prints a single line of instantiation context. */
3474
3475static void
3476print_instantiation_partial_context_line (diagnostic_context *context,
3477 const struct tinst_level *t,
3478 location_t loc, bool recursive_p)
3479{
3480 if (loc == UNKNOWN_LOCATION)
3481 return;
3482
3483 expanded_location xloc = expand_location (loc);
3484
3485 if (context->show_column)
3486 pp_verbatim (context->printer, _("%r%s:%d:%d:%R "),
3487 "locus", xloc.file, xloc.line, xloc.column);
3488 else
3489 pp_verbatim (context->printer, _("%r%s:%d:%R "),
3490 "locus", xloc.file, xloc.line);
3491
3492 if (t != NULL)
3493 {
3494 if (TREE_CODE (t->decl) == TREE_LIST)
3495 pp_verbatim (context->printer,
3496 recursive_p
3497 ? _("recursively required by substitution of %qS\n")
3498 : _("required by substitution of %qS\n"),
3499 t->decl);
3500 else
3501 pp_verbatim (context->printer,
3502 recursive_p
3503 ? _("recursively required from %q#D\n")
3504 : _("required from %q#D\n"),
3505 t->decl);
3506 }
3507 else
3508 {
3509 pp_verbatim (context->printer,
3510 recursive_p
3511 ? _("recursively required from here\n")
3512 : _("required from here\n"));
3513 }
3514}
3515
3516/* Same as print_instantiation_full_context but less verbose. */
3517
3518static void
3519print_instantiation_partial_context (diagnostic_context *context,
3520 struct tinst_level *t0, location_t loc)
3521{
3522 struct tinst_level *t;
3523 int n_total = 0;
3524 int n;
3525 location_t prev_loc = loc;
3526
3527 for (t = t0; t != NULL; t = t->next)
3528 if (prev_loc != t->locus)
3529 {
3530 prev_loc = t->locus;
3531 n_total++;
3532 }
3533
3534 t = t0;
3535
3536 if (template_backtrace_limit
3537 && n_total > template_backtrace_limit)
3538 {
3539 int skip = n_total - template_backtrace_limit;
3540 int head = template_backtrace_limit / 2;
3541
3542 /* Avoid skipping just 1. If so, skip 2. */
3543 if (skip == 1)
3544 {
3545 skip = 2;
3546 head = (template_backtrace_limit - 1) / 2;
3547 }
3548
3549 for (n = 0; n < head; n++)
3550 {
3551 gcc_assert (t != NULL);
3552 if (loc != t->locus)
3553 print_instantiation_partial_context_line (context, t, loc,
3554 /*recursive_p=*/false);
3555 loc = t->locus;
3556 t = t->next;
3557 }
3558 if (t != NULL && skip > 0)
3559 {
3560 expanded_location xloc;
3561 xloc = expand_location (loc);
3562 if (context->show_column)
3563 pp_verbatim (context->printer,
3564 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3565 "contexts, use -ftemplate-backtrace-limit=0 to "
3566 "disable ]\n"),
3567 "locus", xloc.file, xloc.line, xloc.column, skip);
3568 else
3569 pp_verbatim (context->printer,
3570 _("%r%s:%d:%R [ skipping %d instantiation "
3571 "contexts, use -ftemplate-backtrace-limit=0 to "
3572 "disable ]\n"),
3573 "locus", xloc.file, xloc.line, skip);
3574
3575 do {
3576 loc = t->locus;
3577 t = t->next;
3578 } while (t != NULL && --skip > 0);
3579 }
3580 }
3581
3582 while (t != NULL)
3583 {
3584 while (t->next != NULL && t->locus == t->next->locus)
3585 {
3586 loc = t->locus;
3587 t = t->next;
3588 }
3589 print_instantiation_partial_context_line (context, t, loc,
3590 t->locus == loc);
3591 loc = t->locus;
3592 t = t->next;
3593 }
3594 print_instantiation_partial_context_line (context, NULL, loc,
3595 /*recursive_p=*/false);
3596}
3597
3598/* Called from cp_thing to print the template context for an error. */
3599static void
3600maybe_print_instantiation_context (diagnostic_context *context)
3601{
3602 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3603 return;
3604
3605 record_last_problematic_instantiation ();
3606 print_instantiation_full_context (context);
3607}
3608
3609/* Report what constexpr call(s) we're trying to expand, if any. */
3610
3611void
3612maybe_print_constexpr_context (diagnostic_context *context)
3613{
3614 vec<tree> call_stack = cx_error_context ();
3615 unsigned ix;
3616 tree t;
3617
3618 FOR_EACH_VEC_ELT (call_stack, ix, t)
3619 {
3620 expanded_location xloc = expand_location (EXPR_LOCATION (t));
3621 const char *s = expr_as_string (t, 0);
3622 if (context->show_column)
3623 pp_verbatim (context->printer,
3624 _("%r%s:%d:%d:%R in %<constexpr%> expansion of %qs"),
3625 "locus", xloc.file, xloc.line, xloc.column, s);
3626 else
3627 pp_verbatim (context->printer,
3628 _("%r%s:%d:%R in %<constexpr%> expansion of %qs"),
3629 "locus", xloc.file, xloc.line, s);
3630 pp_newline (context->printer);
3631 }
3632}
3633
3634
3635/* Return true iff TYPE_A and TYPE_B are template types that are
3636 meaningful to compare. */
3637
3638static bool
3639comparable_template_types_p (tree type_a, tree type_b)
3640{
3641 if (!CLASS_TYPE_P (type_a))
3642 return false;
3643 if (!CLASS_TYPE_P (type_b))
3644 return false;
3645
3646 tree tinfo_a = TYPE_TEMPLATE_INFO (type_a);
3647 tree tinfo_b = TYPE_TEMPLATE_INFO (type_b);
3648 if (!tinfo_a || !tinfo_b)
3649 return false;
3650
3651 return TI_TEMPLATE (tinfo_a) == TI_TEMPLATE (tinfo_b);
3652}
3653
3654/* Start a new line indented by SPC spaces on PP. */
3655
3656static void
3657newline_and_indent (pretty_printer *pp, int spc)
3658{
3659 pp_newline (pp);
3660 for (int i = 0; i < spc; i++)
3661 pp_space (pp);
3662}
3663
3664/* Generate a GC-allocated string for ARG, an expression or type. */
3665
3666static const char *
3667arg_to_string (tree arg, bool verbose)
3668{
3669 if (TYPE_P (arg))
3670 return type_to_string (arg, verbose, true, NULL, false);
3671 else
3672 return expr_to_string (arg);
3673}
3674
3675/* Subroutine to type_to_string_with_compare and
3676 print_template_tree_comparison.
3677
3678 Print a representation of ARG (an expression or type) to PP,
3679 colorizing it as "type-diff" if PP->show_color. */
3680
3681static void
3682print_nonequal_arg (pretty_printer *pp, tree arg, bool verbose)
3683{
3684 pp_printf (pp, "%r%s%R",
3685 "type-diff",
3686 (arg
3687 ? arg_to_string (arg, verbose)
3688 : G_("(no argument)")));
3689}
3690
3691/* Recursively print template TYPE_A to PP, as compared to template TYPE_B.
3692
3693 The types must satisfy comparable_template_types_p.
3694
3695 If INDENT is 0, then this is equivalent to type_to_string (TYPE_A), but
3696 potentially colorizing/eliding in comparison with TYPE_B.
3697
3698 For example given types:
3699 vector<map<int,double>>
3700 and
3701 vector<map<int,float>>
3702 then the result on PP would be:
3703 vector<map<[...],double>>
3704 with type elision, and:
3705 vector<map<int,double>>
3706 without type elision.
3707
3708 In both cases the parts of TYPE that differ from PEER will be colorized
3709 if pp_show_color (pp) is true. In the above example, this would be
3710 "double".
3711
3712 If INDENT is non-zero, then the types are printed in a tree-like form
3713 which shows both types. In the above example, the result on PP would be:
3714
3715 vector<
3716 map<
3717 [...],
3718 [double != float]>>
3719
3720 and without type-elision would be:
3721
3722 vector<
3723 map<
3724 int,
3725 [double != float]>>
3726
3727 As before, the differing parts of the types are colorized if
3728 pp_show_color (pp) is true ("double" and "float" in this example).
3729
3730 Template arguments in which both types are using the default arguments
3731 are not printed; if at least one of the two types is using a non-default
3732 argument, then that argument is printed (or both arguments for the
3733 tree-like print format). */
3734
3735static void
3736print_template_differences (pretty_printer *pp, tree type_a, tree type_b,
3737 bool verbose, int indent)
3738{
3739 if (indent)
3740 newline_and_indent (pp, indent);
3741
3742 tree tinfo_a = TYPE_TEMPLATE_INFO (type_a);
3743 tree tinfo_b = TYPE_TEMPLATE_INFO (type_b);
3744
3745 pp_printf (pp, "%s<",
3746 IDENTIFIER_POINTER (DECL_NAME (TI_TEMPLATE (tinfo_a))));
3747
3748 tree args_a = TI_ARGS (tinfo_a);
3749 tree args_b = TI_ARGS (tinfo_b);
3750 gcc_assert (TREE_CODE (args_a) == TREE_VEC);
3751 gcc_assert (TREE_CODE (args_b) == TREE_VEC);
3752 int flags = 0;
3753 int len_a = get_non_default_template_args_count (args_a, flags);
3754 args_a = INNERMOST_TEMPLATE_ARGS (args_a);
3755 int len_b = get_non_default_template_args_count (args_b, flags);
3756 args_b = INNERMOST_TEMPLATE_ARGS (args_b);
3757 /* Determine the maximum range of args for which non-default template args
3758 were used; beyond this, only default args (if any) were used, and so
3759 they will be equal from this point onwards.
3760 One of the two peers might have used default arguments within this
3761 range, but the other will be using non-default arguments, and so
3762 it's more readable to print both within this range, to highlight
3763 the differences. */
3764 int len_max = MAX (len_a, len_b);
3765 gcc_assert (TREE_CODE (args_a) == TREE_VEC);
3766 gcc_assert (TREE_CODE (args_b) == TREE_VEC);
3767 for (int idx = 0; idx < len_max; idx++)
3768 {
3769 if (idx)
3770 pp_character (pp, ',');
3771
3772 tree arg_a = TREE_VEC_ELT (args_a, idx);
3773 tree arg_b = TREE_VEC_ELT (args_b, idx);
3774 if (arg_a == arg_b)
3775 {
3776 if (indent)
3777 newline_and_indent (pp, indent + 2);
3778 /* Can do elision here, printing "[...]". */
3779 if (flag_elide_type)
3780 pp_string (pp, G_("[...]"));
3781 else
3782 pp_string (pp, arg_to_string (arg_a, verbose));
3783 }
3784 else
3785 {
3786 int new_indent = indent ? indent + 2 : 0;
3787 if (comparable_template_types_p (arg_a, arg_b))
3788 print_template_differences (pp, arg_a, arg_b, verbose, new_indent);
3789 else
3790 if (indent)
3791 {
3792 newline_and_indent (pp, indent + 2);
3793 pp_character (pp, '[');
3794