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