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