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