?  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
blob31ce59ab3aac3f771cb4bced0876c9a7a3a417cd
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 {
1150 if (DECL_ABSTRACT_ORIGIN (t))
1151 dump_decl (pp, DECL_ABSTRACT_ORIGIN (t), flags);
1152 else
1153 pp_string (pp, M_("<built-in>"));
1154 }
1155 else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1156 dump_global_iord (pp, t);
1157 else
1158 dump_function_decl (pp, t, flags);
1159 break;
1160
1161 case TEMPLATE_DECL:
1162 dump_template_decl (pp, t, flags);
1163 break;
1164
1165 case TEMPLATE_ID_EXPR:
1166 {
1167 tree name = TREE_OPERAND (t, 0);
1168 tree args = TREE_OPERAND (t, 1);
1169
1170 if (is_overloaded_fn (name))
1171 name = DECL_NAME (get_first_fn (name));
1172 dump_decl (pp, name, flags);
1173 pp_cxx_begin_template_argument_list (pp);
1174 if (args == error_mark_node)
1175 pp_string (pp, M_("<template arguments error>"));
1176 else if (args)
1177 dump_template_argument_list (pp, args, flags);
1178 pp_cxx_end_template_argument_list (pp);
1179 }
1180 break;
1181
1182 case LABEL_DECL:
1183 pp_cxx_tree_identifier (pp, DECL_NAME (t));
1184 break;
1185
1186 case CONST_DECL:
1187 if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1188 || (DECL_INITIAL (t) &&
1189 TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1190 dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1191 else if (DECL_NAME (t))
1192 dump_decl (pp, DECL_NAME (t), flags);
1193 else if (DECL_INITIAL (t))
1194 dump_expr (pp, DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1195 else
1196 pp_string (pp, M_("<enumerator>"));
1197 break;
1198
1199 case USING_DECL:
1200 pp_cxx_ws_string (pp, "using");
1201 dump_type (pp, USING_DECL_SCOPE (t), flags);
1202 pp_cxx_colon_colon (pp);
1203 dump_decl (pp, DECL_NAME (t), flags);
1204 break;
1205
1206 case STATIC_ASSERT:
1207 pp->declaration (t);
1208 break;
1209
1210 case BASELINK:
1211 dump_decl (pp, BASELINK_FUNCTIONS (t), flags);
1212 break;
1213
1214 case NON_DEPENDENT_EXPR:
1215 dump_expr (pp, t, flags);
1216 break;
1217
1218 case TEMPLATE_TYPE_PARM:
1219 if (flags & TFF_DECL_SPECIFIERS)
1220 pp->declaration (t);
1221 else
1222 pp->type_id (t);
1223 break;
1224
1225 case UNBOUND_CLASS_TEMPLATE:
1226 case TYPE_PACK_EXPANSION:
1227 case TREE_BINFO:
1228 dump_type (pp, t, flags);
1229 break;
1230
1231 default:
1232 pp_unsupported_tree (pp, t);
1233 /* Fall through to error. */
1234
1235 case ERROR_MARK:
1236 pp_string (pp, M_("<declaration error>"));
1237 break;
1238 }
1239 }
1240
1241 /* Dump a template declaration T under control of FLAGS. This means the
1242 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1243
1244 static void
1245 dump_template_decl (cxx_pretty_printer *pp, tree t, int flags)
1246 {
1247 tree orig_parms = DECL_TEMPLATE_PARMS (t);
1248 tree parms;
1249 int i;
1250
1251 if (flags & TFF_TEMPLATE_HEADER)
1252 {
1253 for (parms = orig_parms = nreverse (orig_parms);
1254 parms;
1255 parms = TREE_CHAIN (parms))
1256 {
1257 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1258 int len = TREE_VEC_LENGTH (inner_parms);
1259
1260 pp_cxx_ws_string (pp, "template");
1261 pp_cxx_begin_template_argument_list (pp);
1262
1263 /* If we've shown the template prefix, we'd better show the
1264 parameters' and decl's type too. */
1265 flags |= TFF_DECL_SPECIFIERS;
1266
1267 for (i = 0; i < len; i++)
1268 {
1269 if (i)
1270 pp_separate_with_comma (pp);
1271 dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i),
1272 flags);
1273 }
1274 pp_cxx_end_template_argument_list (pp);
1275 pp_cxx_whitespace (pp);
1276 }
1277 nreverse(orig_parms);
1278
1279 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1280 {
1281 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1282 pp_cxx_ws_string (pp, "class");
1283
1284 /* If this is a parameter pack, print the ellipsis. */
1285 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1286 pp_cxx_ws_string (pp, "...");
1287 }
1288 }
1289
1290 if (DECL_CLASS_TEMPLATE_P (t))
1291 dump_type (pp, TREE_TYPE (t),
1292 ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1293 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1294 else if (DECL_TEMPLATE_RESULT (t)
1295 && (VAR_P (DECL_TEMPLATE_RESULT (t))
1296 /* Alias template. */
1297 || DECL_TYPE_TEMPLATE_P (t)))
1298 dump_decl (pp, DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1299 else
1300 {
1301 gcc_assert (TREE_TYPE (t));
1302 switch (NEXT_CODE (t))
1303 {
1304 case METHOD_TYPE:
1305 case FUNCTION_TYPE:
1306 dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME);
1307 break;
1308 default:
1309 /* This case can occur with some invalid code. */
1310 dump_type (pp, TREE_TYPE (t),
1311 (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1312 | (flags & TFF_DECL_SPECIFIERS
1313 ? TFF_CLASS_KEY_OR_ENUM : 0));
1314 }
1315 }
1316 }
1317
1318 /* find_typenames looks through the type of the function template T
1319 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1320 it finds. */
1321
1322 struct find_typenames_t
1323 {
1324 struct pointer_set_t *p_set;
1325 vec<tree, va_gc> *typenames;
1326 };
1327
1328 static tree
1329 find_typenames_r (tree *tp, int *walk_subtrees, void *data)
1330 {
1331 struct find_typenames_t *d = (struct find_typenames_t *)data;
1332 tree mv = NULL_TREE;
1333
1334 if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1335 /* Add the type of the typedef without any additional cv-quals. */
1336 mv = TREE_TYPE (TYPE_NAME (*tp));
1337 else if (TREE_CODE (*tp) == TYPENAME_TYPE
1338 || TREE_CODE (*tp) == DECLTYPE_TYPE)
1339 /* Add the typename without any cv-qualifiers. */
1340 mv = TYPE_MAIN_VARIANT (*tp);
1341
1342 if (TREE_CODE (*tp) == TYPE_PACK_EXPANSION)
1343 {
1344 /* Don't mess with parameter packs since we don't remember
1345 the pack expansion context for a particular typename. */
1346 *walk_subtrees = false;
1347 return NULL_TREE;
1348 }
1349
1350 if (mv && (mv == *tp || !pointer_set_insert (d->p_set, mv)))
1351 vec_safe_push (d->typenames, mv);
1352
1353 /* Search into class template arguments, which cp_walk_subtrees
1354 doesn't do. */
1355 if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1356 cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1357 data, d->p_set);
1358
1359 return NULL_TREE;
1360 }
1361
1362 static vec<tree, va_gc> *
1363 find_typenames (tree t)
1364 {
1365 struct find_typenames_t ft;
1366 ft.p_set = pointer_set_create ();
1367 ft.typenames = NULL;
1368 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1369 find_typenames_r, &ft, ft.p_set);
1370 pointer_set_destroy (ft.p_set);
1371 return ft.typenames;
1372 }
1373
1374 /* Output the "[with ...]" clause for a template instantiation T iff
1375 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1376 formatting a deduction/substitution diagnostic rather than an
1377 instantiation. */
1378
1379 static void
1380 dump_substitution (cxx_pretty_printer *pp,
1381 tree t, tree template_parms, tree template_args,
1382 int flags)
1383 {
1384 if (template_parms != NULL_TREE && template_args != NULL_TREE
1385 && !(flags & TFF_NO_TEMPLATE_BINDINGS))
1386 {
1387 vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL;
1388 pp_cxx_whitespace (pp);
1389 pp_cxx_left_bracket (pp);
1390 pp->translate_string ("with");
1391 pp_cxx_whitespace (pp);
1392 dump_template_bindings (pp, template_parms, template_args, typenames);
1393 pp_cxx_right_bracket (pp);
1394 }
1395 }
1396
1397 /* Dump the lambda function FN including its 'mutable' qualifier and any
1398 template bindings. */
1399
1400 static void
1401 dump_lambda_function (cxx_pretty_printer *pp,
1402 tree fn, tree template_parms, tree template_args,
1403 int flags)
1404 {
1405 /* A lambda's signature is essentially its "type". */
1406 dump_type (pp, DECL_CONTEXT (fn), flags);
1407 if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST))
1408 {
1409 pp->padding = pp_before;
1410 pp_c_ws_string (pp, "mutable");
1411 }
1412 dump_substitution (pp, fn, template_parms, template_args, flags);
1413 }
1414
1415 /* Pretty print a function decl. There are several ways we want to print a
1416 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1417 As error can only apply the '#' flag once to give 0 and 1 for V, there
1418 is %D which doesn't print the throw specs, and %F which does. */
1419
1420 static void
1421 dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
1422 {
1423 tree fntype;
1424 tree parmtypes;
1425 tree cname = NULL_TREE;
1426 tree template_args = NULL_TREE;
1427 tree template_parms = NULL_TREE;
1428 int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1429 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1430 tree exceptions;
1431
1432 flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME);
1433 if (TREE_CODE (t) == TEMPLATE_DECL)
1434 t = DECL_TEMPLATE_RESULT (t);
1435
1436 /* Save the exceptions, in case t is a specialization and we are
1437 emitting an error about incompatible specifications. */
1438 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1439
1440 /* Pretty print template instantiations only. */
1441 if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1442 && flag_pretty_templates)
1443 {
1444 tree tmpl;
1445
1446 template_args = DECL_TI_ARGS (t);
1447 tmpl = most_general_template (t);
1448 if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1449 {
1450 template_parms = DECL_TEMPLATE_PARMS (tmpl);
1451 t = tmpl;
1452 }
1453 }
1454
1455 if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1456 return dump_lambda_function (pp, t, template_parms, template_args, flags);
1457
1458 fntype = TREE_TYPE (t);
1459 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1460
1461 if (DECL_CLASS_SCOPE_P (t))
1462 cname = DECL_CONTEXT (t);
1463 /* This is for partially instantiated template methods. */
1464 else if (TREE_CODE (fntype) == METHOD_TYPE)
1465 cname = TREE_TYPE (TREE_VALUE (parmtypes));
1466
1467 if (flags & TFF_DECL_SPECIFIERS)
1468 {
1469 if (DECL_STATIC_FUNCTION_P (t))
1470 pp_cxx_ws_string (pp, "static");
1471 else if (DECL_VIRTUAL_P (t))
1472 pp_cxx_ws_string (pp, "virtual");
1473
1474 if (DECL_DECLARED_CONSTEXPR_P (t))
1475 pp_cxx_ws_string (pp, "constexpr");
1476 }
1477
1478 /* Print the return type? */
1479 if (show_return)
1480 show_return = !DECL_CONV_FN_P (t) && !DECL_CONSTRUCTOR_P (t)
1481 && !DECL_DESTRUCTOR_P (t);
1482 if (show_return)
1483 {
1484 tree ret = fndecl_declared_return_type (t);
1485 dump_type_prefix (pp, ret, flags);
1486 }
1487
1488 /* Print the function name. */
1489 if (!do_outer_scope)
1490 /* Nothing. */;
1491 else if (cname)
1492 {
1493 dump_type (pp, cname, flags);
1494 pp_cxx_colon_colon (pp);
1495 }
1496 else
1497 dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1498
1499 dump_function_name (pp, t, flags);
1500
1501 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1502 {
1503 dump_parameters (pp, parmtypes, flags);
1504
1505 if (TREE_CODE (fntype) == METHOD_TYPE)
1506 {
1507 pp->padding = pp_before;
1508 pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype));
1509 dump_ref_qualifier (pp, fntype, flags);
1510 }
1511
1512 if (flags & TFF_EXCEPTION_SPECIFICATION)
1513 {
1514 pp->padding = pp_before;
1515 dump_exception_spec (pp, exceptions, flags);
1516 }
1517
1518 if (show_return)
1519 dump_type_suffix (pp, TREE_TYPE (fntype), flags);
1520
1521 dump_substitution (pp, t, template_parms, template_args, flags);
1522 }
1523 else if (template_args)
1524 {
1525 bool need_comma = false;
1526 int i;
1527 pp_cxx_begin_template_argument_list (pp);
1528 template_args = INNERMOST_TEMPLATE_ARGS (template_args);
1529 for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
1530 {
1531 tree arg = TREE_VEC_ELT (template_args, i);
1532 if (need_comma)
1533 pp_separate_with_comma (pp);
1534 if (ARGUMENT_PACK_P (arg))
1535 pp_cxx_left_brace (pp);
1536 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
1537 if (ARGUMENT_PACK_P (arg))
1538 pp_cxx_right_brace (pp);
1539 need_comma = true;
1540 }
1541 pp_cxx_end_template_argument_list (pp);
1542 }
1543 }
1544
1545 /* Print a parameter list. If this is for a member function, the
1546 member object ptr (and any other hidden args) should have
1547 already been removed. */
1548
1549 static void
1550 dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags)
1551 {
1552 int first = 1;
1553 flags &= ~TFF_SCOPE;
1554 pp_cxx_left_paren (pp);
1555
1556 for (first = 1; parmtypes != void_list_node;
1557 parmtypes = TREE_CHAIN (parmtypes))
1558 {
1559 if (!first)
1560 pp_separate_with_comma (pp);
1561 first = 0;
1562 if (!parmtypes)
1563 {
1564 pp_cxx_ws_string (pp, "...");
1565 break;
1566 }
1567
1568 dump_type (pp, TREE_VALUE (parmtypes), flags);
1569
1570 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1571 {
1572 pp_cxx_whitespace (pp);
1573 pp_equal (pp);
1574 pp_cxx_whitespace (pp);
1575 dump_expr (pp, TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1576 }
1577 }
1578
1579 pp_cxx_right_paren (pp);
1580 }
1581
1582 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1583
1584 static void
1585 dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED)
1586 {
1587 if (FUNCTION_REF_QUALIFIED (t))
1588 {
1589 pp->padding = pp_before;
1590 if (FUNCTION_RVALUE_QUALIFIED (t))
1591 pp_cxx_ws_string (pp, "&&");
1592 else
1593 pp_cxx_ws_string (pp, "&");
1594 }
1595 }
1596
1597 /* Print an exception specification. T is the exception specification. */
1598
1599 static void
1600 dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags)
1601 {
1602 if (t && TREE_PURPOSE (t))
1603 {
1604 pp_cxx_ws_string (pp, "noexcept");
1605 if (!integer_onep (TREE_PURPOSE (t)))
1606 {
1607 pp_cxx_whitespace (pp);
1608 pp_cxx_left_paren (pp);
1609 if (DEFERRED_NOEXCEPT_SPEC_P (t))
1610 pp_cxx_ws_string (pp, "<uninstantiated>");
1611 else
1612 dump_expr (pp, TREE_PURPOSE (t), flags);
1613 pp_cxx_right_paren (pp);
1614 }
1615 }
1616 else if (t)
1617 {
1618 pp_cxx_ws_string (pp, "throw");
1619 pp_cxx_whitespace (pp);
1620 pp_cxx_left_paren (pp);
1621 if (TREE_VALUE (t) != NULL_TREE)
1622 while (1)
1623 {
1624 dump_type (pp, TREE_VALUE (t), flags);
1625 t = TREE_CHAIN (t);
1626 if (!t)
1627 break;
1628 pp_separate_with_comma (pp);
1629 }
1630 pp_cxx_right_paren (pp);
1631 }
1632 }
1633
1634 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1635 and destructors properly. */
1636
1637 static void
1638 dump_function_name (cxx_pretty_printer *pp, tree t, int flags)
1639 {
1640 tree name = DECL_NAME (t);
1641
1642 /* We can get here with a decl that was synthesized by language-
1643 independent machinery (e.g. coverage.c) in which case it won't
1644 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1645 will crash. In this case it is safe just to print out the
1646 literal name. */
1647 if (!DECL_LANG_SPECIFIC (t))
1648 {
1649 pp_cxx_tree_identifier (pp, name);
1650 return;
1651 }
1652
1653 if (TREE_CODE (t) == TEMPLATE_DECL)
1654 t = DECL_TEMPLATE_RESULT (t);
1655
1656 /* Don't let the user see __comp_ctor et al. */
1657 if (DECL_CONSTRUCTOR_P (t)
1658 || DECL_DESTRUCTOR_P (t))
1659 {
1660 if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1661 name = get_identifier ("<lambda>");
1662 else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t)))
1663 name = get_identifier ("<constructor>");
1664 else
1665 name = constructor_name (DECL_CONTEXT (t));
1666 }
1667
1668 if (DECL_DESTRUCTOR_P (t))
1669 {
1670 pp_cxx_complement (pp);
1671 dump_decl (pp, name, TFF_PLAIN_IDENTIFIER);
1672 }
1673 else if (DECL_CONV_FN_P (t))
1674 {
1675 /* This cannot use the hack that the operator's return
1676 type is stashed off of its name because it may be
1677 used for error reporting. In the case of conflicting
1678 declarations, both will have the same name, yet
1679 the types will be different, hence the TREE_TYPE field
1680 of the first name will be clobbered by the second. */
1681 pp_cxx_ws_string (pp, "operator");
1682 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
1683 }
1684 else if (name && IDENTIFIER_OPNAME_P (name))
1685 pp_cxx_tree_identifier (pp, name);
1686 else if (name && UDLIT_OPER_P (name))
1687 pp_cxx_tree_identifier (pp, name);
1688 else
1689 dump_decl (pp, name, flags);
1690
1691 if (DECL_TEMPLATE_INFO (t)
1692 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1693 && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1694 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1695 dump_template_parms (pp, DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t),
1696 flags);
1697 }
1698
1699 /* Dump the template parameters from the template info INFO under control of
1700 FLAGS. PRIMARY indicates whether this is a primary template decl, or
1701 specialization (partial or complete). For partial specializations we show
1702 the specialized parameter values. For a primary template we show no
1703 decoration. */
1704
1705 static void
1706 dump_template_parms (cxx_pretty_printer *pp, tree info,
1707 int primary, int flags)
1708 {
1709 tree args = info ? TI_ARGS (info) : NULL_TREE;
1710
1711 if (primary && flags & TFF_TEMPLATE_NAME)
1712 return;
1713 flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1714 pp_cxx_begin_template_argument_list (pp);
1715
1716 /* Be careful only to print things when we have them, so as not
1717 to crash producing error messages. */
1718 if (args && !primary)
1719 {
1720 int len, ix;
1721 len = get_non_default_template_args_count (args, flags);
1722
1723 args = INNERMOST_TEMPLATE_ARGS (args);
1724 for (ix = 0; ix != len; ix++)
1725 {
1726 tree arg = TREE_VEC_ELT (args, ix);
1727
1728 /* Only print a comma if we know there is an argument coming. In
1729 the case of an empty template argument pack, no actual
1730 argument will be printed. */
1731 if (ix
1732 && (!ARGUMENT_PACK_P (arg)
1733 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1734 pp_separate_with_comma (pp);
1735
1736 if (!arg)
1737 pp_string (pp, M_("<template parameter error>"));
1738 else
1739 dump_template_argument (pp, arg, flags);
1740 }
1741 }
1742 else if (primary)
1743 {
1744 tree tpl = TI_TEMPLATE (info);
1745 tree parms = DECL_TEMPLATE_PARMS (tpl);
1746 int len, ix;
1747
1748 parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1749 len = parms ? TREE_VEC_LENGTH (parms) : 0;
1750
1751 for (ix = 0; ix != len; ix++)
1752 {
1753 tree parm;
1754
1755 if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1756 {
1757 pp_string (pp, M_("<template parameter error>"));
1758 continue;
1759 }
1760
1761 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1762
1763 if (ix)
1764 pp_separate_with_comma (pp);
1765
1766 dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS);
1767 }
1768 }
1769 pp_cxx_end_template_argument_list (pp);
1770 }
1771
1772 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1773 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
1774
1775 static void
1776 dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst)
1777 {
1778 tree arg;
1779 call_expr_arg_iterator iter;
1780
1781 pp_cxx_left_paren (pp);
1782 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1783 {
1784 if (skipfirst)
1785 skipfirst = false;
1786 else
1787 {
1788 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1789 if (more_call_expr_args_p (&iter))
1790 pp_separate_with_comma (pp);
1791 }
1792 }
1793 pp_cxx_right_paren (pp);
1794 }
1795
1796 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1797 using flags FLAGS. Skip over the first argument if SKIPFIRST is
1798 true. */
1799
1800 static void
1801 dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags,
1802 bool skipfirst)
1803 {
1804 tree arg;
1805 aggr_init_expr_arg_iterator iter;
1806
1807 pp_cxx_left_paren (pp);
1808 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1809 {
1810 if (skipfirst)
1811 skipfirst = false;
1812 else
1813 {
1814 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1815 if (more_aggr_init_expr_args_p (&iter))
1816 pp_separate_with_comma (pp);
1817 }
1818 }
1819 pp_cxx_right_paren (pp);
1820 }
1821
1822 /* Print out a list of initializers (subr of dump_expr). */
1823
1824 static void
1825 dump_expr_list (cxx_pretty_printer *pp, tree l, int flags)
1826 {
1827 while (l)
1828 {
1829 dump_expr (pp, TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1830 l = TREE_CHAIN (l);
1831 if (l)
1832 pp_separate_with_comma (pp);
1833 }
1834 }
1835
1836 /* Print out a vector of initializers (subr of dump_expr). */
1837
1838 static void
1839 dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v,
1840 int flags)
1841 {
1842 unsigned HOST_WIDE_INT idx;
1843 tree value;
1844
1845 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1846 {
1847 dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS);
1848 if (idx != v->length () - 1)
1849 pp_separate_with_comma (pp);
1850 }
1851 }
1852
1853
1854 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1855 function. Resolve it to a close relative -- in the sense of static
1856 type -- variant being overridden. That is close to what was written in
1857 the source code. Subroutine of dump_expr. */
1858
1859 static tree
1860 resolve_virtual_fun_from_obj_type_ref (tree ref)
1861 {
1862 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1863 HOST_WIDE_INT index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref));
1864 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1865 while (index)
1866 {
1867 fun = TREE_CHAIN (fun);
1868 index -= (TARGET_VTABLE_USES_DESCRIPTORS
1869 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1870 }
1871
1872 return BV_FN (fun);
1873 }
1874
1875 /* Print out an expression E under control of FLAGS. */
1876
1877 static void
1878 dump_expr (cxx_pretty_printer *pp, tree t, int flags)
1879 {
1880 tree op;
1881
1882 if (t == 0)
1883 return;
1884
1885 if (STATEMENT_CLASS_P (t))
1886 {
1887 pp_cxx_ws_string (pp, M_("<statement>"));
1888 return;
1889 }
1890
1891 switch (TREE_CODE (t))
1892 {
1893 case VAR_DECL:
1894 case PARM_DECL:
1895 case FIELD_DECL:
1896 case CONST_DECL:
1897 case FUNCTION_DECL:
1898 case TEMPLATE_DECL:
1899 case NAMESPACE_DECL:
1900 case LABEL_DECL:
1901 case OVERLOAD:
1902 case TYPE_DECL:
1903 case IDENTIFIER_NODE:
1904 dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
1905 |TFF_TEMPLATE_HEADER))
1906 | TFF_NO_FUNCTION_ARGUMENTS));
1907 break;
1908
1909 case SSA_NAME:
1910 if (SSA_NAME_VAR (t)
1911 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t)))
1912 dump_expr (pp, SSA_NAME_VAR (t), flags);
1913 else
1914 pp_cxx_ws_string (pp, M_("<unknown>"));
1915 break;
1916
1917 case VOID_CST:
1918 case INTEGER_CST:
1919 case REAL_CST:
1920 case STRING_CST:
1921 case COMPLEX_CST:
1922 pp->constant (t);
1923 break;
1924
1925 case USERDEF_LITERAL:
1926 pp_cxx_userdef_literal (pp, t);
1927 break;
1928
1929 case THROW_EXPR:
1930 /* While waiting for caret diagnostics, avoid printing
1931 __cxa_allocate_exception, __cxa_throw, and the like. */
1932 pp_cxx_ws_string (pp, M_("<throw-expression>"));
1933 break;
1934
1935 case PTRMEM_CST:
1936 pp_ampersand (pp);
1937 dump_type (pp, PTRMEM_CST_CLASS (t), flags);
1938 pp_cxx_colon_colon (pp);
1939 pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1940 break;
1941
1942 case COMPOUND_EXPR:
1943 pp_cxx_left_paren (pp);
1944 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1945 pp_separate_with_comma (pp);
1946 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1947 pp_cxx_right_paren (pp);
1948 break;
1949
1950 case COND_EXPR:
1951 pp_cxx_left_paren (pp);
1952 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1953 pp_string (pp, " ? ");
1954 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1955 pp_string (pp, " : ");
1956 dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1957 pp_cxx_right_paren (pp);
1958 break;
1959
1960 case SAVE_EXPR:
1961 if (TREE_HAS_CONSTRUCTOR (t))
1962 {
1963 pp_cxx_ws_string (pp, "new");
1964 pp_cxx_whitespace (pp);
1965 dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
1966 }
1967 else
1968 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1969 break;
1970
1971 case AGGR_INIT_EXPR:
1972 {
1973 tree fn = NULL_TREE;
1974
1975 if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
1976 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
1977
1978 if (fn && TREE_CODE (fn) == FUNCTION_DECL)
1979 {
1980 if (DECL_CONSTRUCTOR_P (fn))
1981 dump_type (pp, DECL_CONTEXT (fn), flags);
1982 else
1983 dump_decl (pp, fn, 0);
1984 }
1985 else
1986 dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0);
1987 }
1988 dump_aggr_init_expr_args (pp, t, flags, true);
1989 break;
1990
1991 case CALL_EXPR:
1992 {
1993 tree fn = CALL_EXPR_FN (t);
1994 bool skipfirst = false;
1995
1996 if (TREE_CODE (fn) == ADDR_EXPR)
1997 fn = TREE_OPERAND (fn, 0);
1998
1999 /* Nobody is interested in seeing the guts of vcalls. */
2000 if (TREE_CODE (fn) == OBJ_TYPE_REF)
2001 fn = resolve_virtual_fun_from_obj_type_ref (fn);
2002
2003 if (TREE_TYPE (fn) != NULL_TREE
2004 && NEXT_CODE (fn) == METHOD_TYPE
2005 && call_expr_nargs (t))
2006 {
2007 tree ob = CALL_EXPR_ARG (t, 0);
2008 if (TREE_CODE (ob) == ADDR_EXPR)
2009 {
2010 dump_expr (pp, TREE_OPERAND (ob, 0),
2011 flags | TFF_EXPR_IN_PARENS);
2012 pp_cxx_dot (pp);
2013 }
2014 else if (TREE_CODE (ob) != PARM_DECL
2015 || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
2016 {
2017 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2018 pp_cxx_arrow (pp);
2019 }
2020 skipfirst = true;
2021 }
2022 if (flag_sanitize & SANITIZE_UNDEFINED
2023 && is_ubsan_builtin_p (fn))
2024 {
2025 pp_string (cxx_pp, M_("<ubsan routine call>"));
2026 break;
2027 }
2028 dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS);
2029 dump_call_expr_args (pp, t, flags, skipfirst);
2030 }
2031 break;
2032
2033 case TARGET_EXPR:
2034 /* Note that this only works for G++ target exprs. If somebody
2035 builds a general TARGET_EXPR, there's no way to represent that
2036 it initializes anything other that the parameter slot for the
2037 default argument. Note we may have cleared out the first
2038 operand in expand_expr, so don't go killing ourselves. */
2039 if (TREE_OPERAND (t, 1))
2040 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2041 break;
2042
2043 case POINTER_PLUS_EXPR:
2044 dump_binary_op (pp, "+", t, flags);
2045 break;
2046
2047 case INIT_EXPR:
2048 case MODIFY_EXPR:
2049 dump_binary_op (pp, assignment_operator_name_info[NOP_EXPR].name,
2050 t, flags);
2051 break;
2052
2053 case PLUS_EXPR:
2054 case MINUS_EXPR:
2055 case MULT_EXPR:
2056 case TRUNC_DIV_EXPR:
2057 case TRUNC_MOD_EXPR:
2058 case MIN_EXPR:
2059 case MAX_EXPR:
2060 case LSHIFT_EXPR:
2061 case RSHIFT_EXPR:
2062 case BIT_IOR_EXPR:
2063 case BIT_XOR_EXPR:
2064 case BIT_AND_EXPR:
2065 case TRUTH_ANDIF_EXPR:
2066 case TRUTH_ORIF_EXPR:
2067 case LT_EXPR:
2068 case LE_EXPR:
2069 case GT_EXPR:
2070 case GE_EXPR:
2071 case EQ_EXPR:
2072 case NE_EXPR:
2073 case EXACT_DIV_EXPR:
2074 dump_binary_op (pp, operator_name_info[TREE_CODE (t)].name, t, flags);
2075 break;
2076
2077 case CEIL_DIV_EXPR:
2078 case FLOOR_DIV_EXPR:
2079 case ROUND_DIV_EXPR:
2080 case RDIV_EXPR:
2081 dump_binary_op (pp, "/", t, flags);
2082 break;
2083
2084 case CEIL_MOD_EXPR:
2085 case FLOOR_MOD_EXPR:
2086 case ROUND_MOD_EXPR:
2087 dump_binary_op (pp, "%", t, flags);
2088 break;
2089
2090 case COMPONENT_REF:
2091 {
2092 tree ob = TREE_OPERAND (t, 0);
2093 if (INDIRECT_REF_P (ob))
2094 {
2095 ob = TREE_OPERAND (ob, 0);
2096 if (TREE_CODE (ob) != PARM_DECL
2097 || (DECL_NAME (ob)
2098 && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
2099 {
2100 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2101 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
2102 pp_cxx_dot (pp);
2103 else
2104 pp_cxx_arrow (pp);
2105 }
2106 }
2107 else
2108 {
2109 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2110 pp_cxx_dot (pp);
2111 }
2112 dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
2113 }
2114 break;
2115
2116 case ARRAY_REF:
2117 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2118 pp_cxx_left_bracket (pp);
2119 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2120 pp_cxx_right_bracket (pp);
2121 break;
2122
2123 case ARRAY_NOTATION_REF:
2124 dump_expr (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
2125 pp_cxx_left_bracket (pp);
2126 dump_expr (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
2127 pp_colon (pp);
2128 dump_expr (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
2129 pp_colon (pp);
2130 dump_expr (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
2131 pp_cxx_right_bracket (pp);
2132 break;
2133
2134 case UNARY_PLUS_EXPR:
2135 dump_unary_op (pp, "+", t, flags);
2136 break;
2137
2138 case ADDR_EXPR:
2139 if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
2140 || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
2141 /* An ADDR_EXPR can have reference type. In that case, we
2142 shouldn't print the `&' doing so indicates to the user
2143 that the expression has pointer type. */
2144 || (TREE_TYPE (t)
2145 && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
2146 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2147 else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
2148 dump_unary_op (pp, "&&", t, flags);
2149 else
2150 dump_unary_op (pp, "&", t, flags);
2151 break;
2152
2153 case INDIRECT_REF:
2154 if (TREE_HAS_CONSTRUCTOR (t))
2155 {
2156 t = TREE_OPERAND (t, 0);
2157 gcc_assert (TREE_CODE (t) == CALL_EXPR);
2158 dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
2159 dump_call_expr_args (pp, t, flags, true);
2160 }
2161 else
2162 {
2163 if (TREE_OPERAND (t,0) != NULL_TREE
2164 && TREE_TYPE (TREE_OPERAND (t, 0))
2165 && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
2166 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2167 else
2168 dump_unary_op (pp, "*", t, flags);
2169 }
2170 break;
2171
2172 case MEM_REF:
2173 if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
2174 && integer_zerop (TREE_OPERAND (t, 1)))
2175 dump_expr (pp, TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
2176 else
2177 {
2178 pp_cxx_star (pp);
2179 if (!integer_zerop (TREE_OPERAND (t, 1)))
2180 {
2181 pp_cxx_left_paren (pp);
2182 if (!integer_onep (TYPE_SIZE_UNIT
2183 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
2184 {
2185 pp_cxx_left_paren (pp);
2186 dump_type (pp, ptr_type_node, flags);
2187 pp_cxx_right_paren (pp);
2188 }
2189 }
2190 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2191 if (!integer_zerop (TREE_OPERAND (t, 1)))
2192 {
2193 pp_cxx_ws_string (pp, "+");
2194 dump_expr (pp, fold_convert (ssizetype, TREE_OPERAND (t, 1)),
2195 flags);
2196 pp_cxx_right_paren (pp);
2197 }
2198 }
2199 break;
2200
2201 case NEGATE_EXPR:
2202 case BIT_NOT_EXPR:
2203 case TRUTH_NOT_EXPR:
2204 case PREDECREMENT_EXPR:
2205 case PREINCREMENT_EXPR:
2206 dump_unary_op (pp, operator_name_info [TREE_CODE (t)].name, t, flags);
2207 break;
2208
2209 case POSTDECREMENT_EXPR:
2210 case POSTINCREMENT_EXPR:
2211 pp_cxx_left_paren (pp);
2212 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2213 pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2214 pp_cxx_right_paren (pp);
2215 break;
2216
2217 case NON_LVALUE_EXPR:
2218 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2219 should be another level of INDIRECT_REF so that I don't have to do
2220 this. */
2221 if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2222 {
2223 tree next = TREE_TYPE (TREE_TYPE (t));
2224
2225 while (TYPE_PTR_P (next))
2226 next = TREE_TYPE (next);
2227
2228 if (TREE_CODE (next) == FUNCTION_TYPE)
2229 {
2230 if (flags & TFF_EXPR_IN_PARENS)
2231 pp_cxx_left_paren (pp);
2232 pp_cxx_star (pp);
2233 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2234 if (flags & TFF_EXPR_IN_PARENS)
2235 pp_cxx_right_paren (pp);
2236 break;
2237 }
2238 /* Else fall through. */
2239 }
2240 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2241 break;
2242
2243 CASE_CONVERT:
2244 case IMPLICIT_CONV_EXPR:
2245 case VIEW_CONVERT_EXPR:
2246 {
2247 tree op = TREE_OPERAND (t, 0);
2248 tree ttype = TREE_TYPE (t);
2249 tree optype = TREE_TYPE (op);
2250
2251 if (TREE_CODE (ttype) != TREE_CODE (optype)
2252 && POINTER_TYPE_P (ttype)
2253 && POINTER_TYPE_P (optype)
2254 && same_type_p (TREE_TYPE (optype),
2255 TREE_TYPE (ttype)))
2256 {
2257 if (TREE_CODE (ttype) == REFERENCE_TYPE)
2258 dump_unary_op (pp, "*", t, flags);
2259 else
2260 dump_unary_op (pp, "&", t, flags);
2261 }
2262 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2263 {
2264 /* It is a cast, but we cannot tell whether it is a
2265 reinterpret or static cast. Use the C style notation. */
2266 if (flags & TFF_EXPR_IN_PARENS)
2267 pp_cxx_left_paren (pp);
2268 pp_cxx_left_paren (pp);
2269 dump_type (pp, TREE_TYPE (t), flags);
2270 pp_cxx_right_paren (pp);
2271 dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS);
2272 if (flags & TFF_EXPR_IN_PARENS)
2273 pp_cxx_right_paren (pp);
2274 }
2275 else
2276 dump_expr (pp, op, flags);
2277 break;
2278 }
2279
2280 case CONSTRUCTOR:
2281 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2282 {
2283 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2284
2285 if (integer_zerop (idx))
2286 {
2287 /* A NULL pointer-to-member constant. */
2288 pp_cxx_left_paren (pp);
2289 pp_cxx_left_paren (pp);
2290 dump_type (pp, TREE_TYPE (t), flags);
2291 pp_cxx_right_paren (pp);
2292 pp_character (pp, '0');
2293 pp_cxx_right_paren (pp);
2294 break;
2295 }
2296 else if (tree_fits_shwi_p (idx))
2297 {
2298 tree virtuals;
2299 unsigned HOST_WIDE_INT n;
2300
2301 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2302 t = TYPE_METHOD_BASETYPE (t);
2303 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2304
2305 n = tree_to_shwi (idx);
2306
2307 /* Map vtable index back one, to allow for the null pointer to
2308 member. */
2309 --n;
2310
2311 while (n > 0 && virtuals)
2312 {
2313 --n;
2314 virtuals = TREE_CHAIN (virtuals);
2315 }
2316 if (virtuals)
2317 {
2318 dump_expr (pp, BV_FN (virtuals),
2319 flags | TFF_EXPR_IN_PARENS);
2320 break;
2321 }
2322 }
2323 }
2324 if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t)))
2325 pp_string (pp, "<lambda closure object>");
2326 if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2327 {
2328 dump_type (pp, TREE_TYPE (t), 0);
2329 pp_cxx_left_paren (pp);
2330 pp_cxx_right_paren (pp);
2331 }
2332 else
2333 {
2334 if (!BRACE_ENCLOSED_INITIALIZER_P (t))
2335 dump_type (pp, TREE_TYPE (t), 0);
2336 pp_cxx_left_brace (pp);
2337 dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags);
2338 pp_cxx_right_brace (pp);
2339 }
2340
2341 break;
2342
2343 case OFFSET_REF:
2344 {
2345 tree ob = TREE_OPERAND (t, 0);
2346 if (is_dummy_object (ob))
2347 {
2348 t = TREE_OPERAND (t, 1);
2349 if (TREE_CODE (t) == FUNCTION_DECL)
2350 /* A::f */
2351 dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS);
2352 else if (BASELINK_P (t))
2353 dump_expr (pp, OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2354 flags | TFF_EXPR_IN_PARENS);
2355 else
2356 dump_decl (pp, t, flags);
2357 }
2358 else
2359 {
2360 if (INDIRECT_REF_P (ob))
2361 {
2362 dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2363 pp_cxx_arrow (pp);
2364 pp_cxx_star (pp);
2365 }
2366 else
2367 {
2368 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2369 pp_cxx_dot (pp);
2370 pp_cxx_star (pp);
2371 }
2372 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2373 }
2374 break;
2375 }
2376
2377 case TEMPLATE_PARM_INDEX:
2378 dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2379 break;
2380
2381 case CAST_EXPR:
2382 if (TREE_OPERAND (t, 0) == NULL_TREE
2383 || TREE_CHAIN (TREE_OPERAND (t, 0)))
2384 {
2385 dump_type (pp, TREE_TYPE (t), flags);
2386 pp_cxx_left_paren (pp);
2387 dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2388 pp_cxx_right_paren (pp);
2389 }
2390 else
2391 {
2392 pp_cxx_left_paren (pp);
2393 dump_type (pp, TREE_TYPE (t), flags);
2394 pp_cxx_right_paren (pp);
2395 pp_cxx_left_paren (pp);
2396 dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2397 pp_cxx_right_paren (pp);
2398 }
2399 break;
2400
2401 case STATIC_CAST_EXPR:
2402 pp_cxx_ws_string (pp, "static_cast");
2403 goto cast;
2404 case REINTERPRET_CAST_EXPR:
2405 pp_cxx_ws_string (pp, "reinterpret_cast");
2406 goto cast;
2407 case CONST_CAST_EXPR:
2408 pp_cxx_ws_string (pp, "const_cast");
2409 goto cast;
2410 case DYNAMIC_CAST_EXPR:
2411 pp_cxx_ws_string (pp, "dynamic_cast");
2412 cast:
2413 pp_cxx_begin_template_argument_list (pp);
2414 dump_type (pp, TREE_TYPE (t), flags);
2415 pp_cxx_end_template_argument_list (pp);
2416 pp_cxx_left_paren (pp);
2417 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2418 pp_cxx_right_paren (pp);
2419 break;
2420
2421 case ARROW_EXPR:
2422 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2423 pp_cxx_arrow (pp);
2424 break;
2425
2426 case SIZEOF_EXPR:
2427 case ALIGNOF_EXPR:
2428 if (TREE_CODE (t) == SIZEOF_EXPR)
2429 pp_cxx_ws_string (pp, "sizeof");
2430 else
2431 {
2432 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2433 pp_cxx_ws_string (pp, "__alignof__");
2434 }
2435 op = TREE_OPERAND (t, 0);
2436 if (PACK_EXPANSION_P (op))
2437 {
2438 pp_string (pp, "...");
2439 op = PACK_EXPANSION_PATTERN (op);
2440 }
2441 pp_cxx_whitespace (pp);
2442 pp_cxx_left_paren (pp);
2443 if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
2444 dump_type (pp, TREE_TYPE (op), flags);
2445 else if (TYPE_P (TREE_OPERAND (t, 0)))
2446 dump_type (pp, op, flags);
2447 else
2448 dump_expr (pp, op, flags);
2449 pp_cxx_right_paren (pp);
2450 break;
2451
2452 case AT_ENCODE_EXPR:
2453 pp_cxx_ws_string (pp, "@encode");
2454 pp_cxx_whitespace (pp);
2455 pp_cxx_left_paren (pp);
2456 dump_type (pp, TREE_OPERAND (t, 0), flags);
2457 pp_cxx_right_paren (pp);
2458 break;
2459
2460 case NOEXCEPT_EXPR:
2461 pp_cxx_ws_string (pp, "noexcept");
2462 pp_cxx_whitespace (pp);
2463 pp_cxx_left_paren (pp);
2464 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2465 pp_cxx_right_paren (pp);
2466 break;
2467
2468 case REALPART_EXPR:
2469 case IMAGPART_EXPR:
2470 pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2471 pp_cxx_whitespace (pp);
2472 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2473 break;
2474
2475 case DEFAULT_ARG:
2476 pp_string (pp, M_("<unparsed>"));
2477 break;
2478
2479 case TRY_CATCH_EXPR:
2480 case WITH_CLEANUP_EXPR:
2481 case CLEANUP_POINT_EXPR:
2482 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2483 break;
2484
2485 case PSEUDO_DTOR_EXPR:
2486 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2487 pp_cxx_dot (pp);
2488 if (TREE_OPERAND (t, 1))
2489 {
2490 dump_type (pp, TREE_OPERAND (t, 1), flags);
2491 pp_cxx_colon_colon (pp);
2492 }
2493 pp_cxx_complement (pp);
2494 dump_type (pp, TREE_OPERAND (t, 2), flags);
2495 break;
2496
2497 case TEMPLATE_ID_EXPR:
2498 dump_decl (pp, t, flags);
2499 break;
2500
2501 case BIND_EXPR:
2502 case STMT_EXPR:
2503 case EXPR_STMT:
2504 case STATEMENT_LIST:
2505 /* We don't yet have a way of dumping statements in a
2506 human-readable format. */
2507 pp_string (pp, "({...})");
2508 break;
2509
2510 case LOOP_EXPR:
2511 pp_string (pp, "while (1) { ");
2512 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2513 pp_cxx_right_brace (pp);
2514 break;
2515
2516 case EXIT_EXPR:
2517 pp_string (pp, "if (");
2518 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2519 pp_string (pp, ") break; ");
2520 break;
2521
2522 case BASELINK:
2523 dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
2524 break;
2525
2526 case EMPTY_CLASS_EXPR:
2527 dump_type (pp, TREE_TYPE (t), flags);
2528 pp_cxx_left_paren (pp);
2529 pp_cxx_right_paren (pp);
2530 break;
2531
2532 case NON_DEPENDENT_EXPR:
2533 dump_expr (pp, TREE_OPERAND (t, 0), flags);
2534 break;
2535
2536 case ARGUMENT_PACK_SELECT:
2537 dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2538 break;
2539
2540 case RECORD_TYPE:
2541 case UNION_TYPE:
2542 case ENUMERAL_TYPE:
2543 case REAL_TYPE:
2544 case VOID_TYPE:
2545 case BOOLEAN_TYPE:
2546 case INTEGER_TYPE:
2547 case COMPLEX_TYPE:
2548 case VECTOR_TYPE:
2549 pp_type_specifier_seq (pp, t);
2550 break;
2551
2552 case TYPENAME_TYPE:
2553 /* We get here when we want to print a dependent type as an
2554 id-expression, without any disambiguator decoration. */
2555 pp->id_expression (t);
2556 break;
2557
2558 case TEMPLATE_TYPE_PARM:
2559 case TEMPLATE_TEMPLATE_PARM:
2560 case BOUND_TEMPLATE_TEMPLATE_PARM:
2561 dump_type (pp, t, flags);
2562 break;
2563
2564 case TRAIT_EXPR:
2565 pp_cxx_trait_expression (pp, t);
2566 break;
2567
2568 case VA_ARG_EXPR:
2569 pp_cxx_va_arg_expression (pp, t);
2570 break;
2571
2572 case OFFSETOF_EXPR:
2573 pp_cxx_offsetof_expression (pp, t);
2574 break;
2575
2576 case SCOPE_REF:
2577 dump_decl (pp, t, flags);
2578 break;
2579
2580 case EXPR_PACK_EXPANSION:
2581 case TYPEID_EXPR:
2582 case MEMBER_REF:
2583 case DOTSTAR_EXPR:
2584 case NEW_EXPR:
2585 case VEC_NEW_EXPR:
2586 case DELETE_EXPR:
2587 case VEC_DELETE_EXPR:
2588 case MODOP_EXPR:
2589 case ABS_EXPR:
2590 case CONJ_EXPR:
2591 case VECTOR_CST:
2592 case FIXED_CST:
2593 case UNORDERED_EXPR:
2594 case ORDERED_EXPR:
2595 case UNLT_EXPR:
2596 case UNLE_EXPR:
2597 case UNGT_EXPR:
2598 case UNGE_EXPR:
2599 case UNEQ_EXPR:
2600 case LTGT_EXPR:
2601 case COMPLEX_EXPR:
2602 case BIT_FIELD_REF:
2603 case FIX_TRUNC_EXPR:
2604 case FLOAT_EXPR:
2605 pp->expression (t);
2606 break;
2607
2608 case TRUTH_AND_EXPR:
2609 case TRUTH_OR_EXPR:
2610 case TRUTH_XOR_EXPR:
2611 if (flags & TFF_EXPR_IN_PARENS)
2612 pp_cxx_left_paren (pp);
2613 pp->expression (t);
2614 if (flags & TFF_EXPR_IN_PARENS)
2615 pp_cxx_right_paren (pp);
2616 break;
2617
2618 case OBJ_TYPE_REF:
2619 dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
2620 break;
2621
2622 case LAMBDA_EXPR:
2623 pp_string (pp, M_("<lambda>"));
2624 break;
2625
2626 case PAREN_EXPR:
2627 pp_cxx_left_paren (pp);
2628 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2629 pp_cxx_right_paren (pp);
2630 break;
2631
2632 case REQUIRES_EXPR:
2633 pp_cxx_requires_expr (cxx_pp, t);
2634 break;
2635
2636 case EXPR_REQ:
2637 pp_cxx_expr_requirement (cxx_pp, t);
2638 break;
2639
2640 case TYPE_REQ:
2641 pp_cxx_type_requirement (cxx_pp, t);
2642 break;
2643
2644 case NESTED_REQ:
2645 pp_cxx_nested_requirement (cxx_pp, t);
2646 break;
2647
2648 case VALIDEXPR_EXPR:
2649 pp_cxx_validexpr_expr (cxx_pp, t);
2650 break;
2651
2652 case VALIDTYPE_EXPR:
2653 pp_cxx_validtype_expr (cxx_pp, t);
2654 break;
2655
2656 case CONSTEXPR_EXPR:
2657 pp_cxx_constexpr_expr (cxx_pp, t);
2658
2659 /* This list is incomplete, but should suffice for now.
2660 It is very important that `sorry' does not call
2661 `report_error_function'. That could cause an infinite loop. */
2662 default:
2663 pp_unsupported_tree (pp, t);
2664 /* fall through to ERROR_MARK... */
2665 case ERROR_MARK:
2666 pp_string (pp, M_("<expression error>"));
2667 break;
2668 }
2669 }
2670
2671 static void
2672 dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
2673 int flags)
2674 {
2675 pp_cxx_left_paren (pp);
2676 dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2677 pp_cxx_whitespace (pp);
2678 if (opstring)
2679 pp_cxx_ws_string (pp, opstring);
2680 else
2681 pp_string (pp, M_("<unknown operator>"));
2682 pp_cxx_whitespace (pp);
2683 dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2684 pp_cxx_right_paren (pp);
2685 }
2686
2687 static void
2688 dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
2689 {
2690 if (flags & TFF_EXPR_IN_PARENS)
2691 pp_cxx_left_paren (pp);
2692 pp_cxx_ws_string (pp, opstring);
2693 dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2694 if (flags & TFF_EXPR_IN_PARENS)
2695 pp_cxx_right_paren (pp);
2696 }
2697
2698 static void
2699 reinit_cxx_pp (void)
2700 {
2701 pp_clear_output_area (cxx_pp);
2702 cxx_pp->padding = pp_none;
2703 pp_indentation (cxx_pp) = 0;
2704 pp_needs_newline (cxx_pp) = false;
2705 cxx_pp->enclosing_scope = current_function_decl;
2706 }
2707
2708 /* Same as pp_formatted_text, except the return string is a separate
2709 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
2710
2711 inline const char *
2712 pp_ggc_formatted_text (pretty_printer *pp)
2713 {
2714 return ggc_strdup (pp_formatted_text (pp));
2715 }
2716
2717 /* Exported interface to stringifying types, exprs and decls under TFF_*
2718 control. */
2719
2720 const char *
2721 type_as_string (tree typ, int flags)
2722 {
2723 reinit_cxx_pp ();
2724 pp_translate_identifiers (cxx_pp) = false;
2725 dump_type (cxx_pp, typ, flags);
2726 return pp_ggc_formatted_text (cxx_pp);
2727 }
2728
2729 const char *
2730 type_as_string_translate (tree typ, int flags)
2731 {
2732 reinit_cxx_pp ();
2733 dump_type (cxx_pp, typ, flags);
2734 return pp_ggc_formatted_text (cxx_pp);
2735 }
2736
2737 const char *
2738 expr_as_string (tree decl, int flags)
2739 {
2740 reinit_cxx_pp ();
2741 pp_translate_identifiers (cxx_pp) = false;
2742 dump_expr (cxx_pp, decl, flags);
2743 return pp_ggc_formatted_text (cxx_pp);
2744 }
2745
2746 /* Wrap decl_as_string with options appropriate for dwarf. */
2747
2748 const char *
2749 decl_as_dwarf_string (tree decl, int flags)
2750 {
2751 const char *name;
2752 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2753 here will be adequate to get the desired behaviour. */
2754 cxx_pp->flags |= pp_c_flag_gnu_v3;
2755 name = decl_as_string (decl, flags);
2756 /* Subsequent calls to the pretty printer shouldn't use this style. */
2757 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2758 return name;
2759 }
2760
2761 const char *
2762 decl_as_string (tree decl, int flags)
2763 {
2764 reinit_cxx_pp ();
2765 pp_translate_identifiers (cxx_pp) = false;
2766 dump_decl (cxx_pp, decl, flags);
2767 return pp_ggc_formatted_text (cxx_pp);
2768 }
2769
2770 const char *
2771 decl_as_string_translate (tree decl, int flags)
2772 {
2773 reinit_cxx_pp ();
2774 dump_decl (cxx_pp, decl, flags);
2775 return pp_ggc_formatted_text (cxx_pp);
2776 }
2777
2778 /* Wrap lang_decl_name with options appropriate for dwarf. */
2779
2780 const char *
2781 lang_decl_dwarf_name (tree decl, int v, bool translate)
2782 {
2783 const char *name;
2784 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2785 here will be adequate to get the desired behaviour. */
2786 cxx_pp->flags |= pp_c_flag_gnu_v3;
2787 name = lang_decl_name (decl, v, translate);
2788 /* Subsequent calls to the pretty printer shouldn't use this style. */
2789 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2790 return name;
2791 }
2792
2793 /* Generate the three forms of printable names for cxx_printable_name. */
2794
2795 const char *
2796 lang_decl_name (tree decl, int v, bool translate)
2797 {
2798 if (v >= 2)
2799 return (translate
2800 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2801 : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2802
2803 reinit_cxx_pp ();
2804 pp_translate_identifiers (cxx_pp) = translate;
2805 if (v == 1
2806 && (DECL_CLASS_SCOPE_P (decl)
2807 || (DECL_NAMESPACE_SCOPE_P (decl)
2808 && CP_DECL_CONTEXT (decl) != global_namespace)))
2809 {
2810 dump_type (cxx_pp, CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2811 pp_cxx_colon_colon (cxx_pp);
2812 }
2813
2814 if (TREE_CODE (decl) == FUNCTION_DECL)
2815 dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER);
2816 else if ((DECL_NAME (decl) == NULL_TREE)
2817 && TREE_CODE (decl) == NAMESPACE_DECL)
2818 dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER | TFF_UNQUALIFIED_NAME);
2819 else
2820 dump_decl (cxx_pp, DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2821
2822 return pp_ggc_formatted_text (cxx_pp);
2823 }
2824
2825 /* Return the location of a tree passed to %+ formats. */
2826
2827 location_t
2828 location_of (tree t)
2829 {
2830 if (TYPE_P (t))
2831 {
2832 t = TYPE_MAIN_DECL (t);
2833 if (t == NULL_TREE)
2834 return input_location;
2835 }
2836 else if (TREE_CODE (t) == OVERLOAD)
2837 t = OVL_FUNCTION (t);
2838
2839 if (DECL_P (t))
2840 return DECL_SOURCE_LOCATION (t);
2841 return EXPR_LOC_OR_LOC (t, input_location);
2842 }
2843
2844 /* Now the interfaces from error et al to dump_type et al. Each takes an
2845 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2846 function. */
2847
2848 static const char *
2849 decl_to_string (tree decl, int verbose)
2850 {
2851 int flags = 0;
2852
2853 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2854 || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2855 flags = TFF_CLASS_KEY_OR_ENUM;
2856 if (verbose)
2857 flags |= TFF_DECL_SPECIFIERS;
2858 else if (TREE_CODE (decl) == FUNCTION_DECL)
2859 flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2860 flags |= TFF_TEMPLATE_HEADER;
2861
2862 reinit_cxx_pp ();
2863 dump_decl (cxx_pp, decl, flags);
2864 return pp_ggc_formatted_text (cxx_pp);
2865 }
2866
2867 static const char *
2868 expr_to_string (tree decl)
2869 {
2870 reinit_cxx_pp ();
2871 dump_expr (cxx_pp, decl, 0);
2872 return pp_ggc_formatted_text (cxx_pp);
2873 }
2874
2875 static const char *
2876 fndecl_to_string (tree fndecl, int verbose)
2877 {
2878 int flags;
2879
2880 flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2881 | TFF_TEMPLATE_HEADER;
2882 if (verbose)
2883 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2884 reinit_cxx_pp ();
2885 dump_decl (cxx_pp, fndecl, flags);
2886 return pp_ggc_formatted_text (cxx_pp);
2887 }
2888
2889
2890 static const char *
2891 code_to_string (enum tree_code c)
2892 {
2893 return get_tree_code_name (c);
2894 }
2895
2896 const char *
2897 language_to_string (enum languages c)
2898 {
2899 switch (c)
2900 {
2901 case lang_c:
2902 return "C";
2903
2904 case lang_cplusplus:
2905 return "C++";
2906
2907 case lang_java:
2908 return "Java";
2909
2910 default:
2911 gcc_unreachable ();
2912 }
2913 return NULL;
2914 }
2915
2916 /* Return the proper printed version of a parameter to a C++ function. */
2917
2918 static const char *
2919 parm_to_string (int p)
2920 {
2921 reinit_cxx_pp ();
2922 if (p < 0)
2923 pp_string (cxx_pp, "'this'");
2924 else
2925 pp_decimal_int (cxx_pp, p + 1);
2926 return pp_ggc_formatted_text (cxx_pp);
2927 }
2928
2929 static const char *
2930 op_to_string (enum tree_code p)
2931 {
2932 tree id = operator_name_info[p].identifier;
2933 return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2934 }
2935
2936 static const char *
2937 type_to_string (tree typ, int verbose)
2938 {
2939 int flags = 0;
2940 if (verbose)
2941 flags |= TFF_CLASS_KEY_OR_ENUM;
2942 flags |= TFF_TEMPLATE_HEADER;
2943
2944 reinit_cxx_pp ();
2945 dump_type (cxx_pp, typ, flags);
2946 /* If we're printing a type that involves typedefs, also print the
2947 stripped version. But sometimes the stripped version looks
2948 exactly the same, so we don't want it after all. To avoid printing
2949 it in that case, we play ugly obstack games. */
2950 if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
2951 && !uses_template_parms (typ))
2952 {
2953 int aka_start; char *p;
2954 struct obstack *ob = pp_buffer (cxx_pp)->obstack;
2955 /* Remember the end of the initial dump. */
2956 int len = obstack_object_size (ob);
2957 tree aka = strip_typedefs (typ);
2958 pp_string (cxx_pp, " {aka");
2959 pp_cxx_whitespace (cxx_pp);
2960 /* And remember the start of the aka dump. */
2961 aka_start = obstack_object_size (ob);
2962 dump_type (cxx_pp, aka, flags);
2963 pp_right_brace (cxx_pp);
2964 p = (char*)obstack_base (ob);
2965 /* If they are identical, cut off the aka with a NUL. */
2966 if (memcmp (p, p+aka_start, len) == 0)
2967 p[len] = '\0';
2968 }
2969 return pp_ggc_formatted_text (cxx_pp);
2970 }
2971
2972 static const char *
2973 assop_to_string (enum tree_code p)
2974 {
2975 tree id = assignment_operator_name_info[(int) p].identifier;
2976 return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
2977 }
2978
2979 static const char *
2980 args_to_string (tree p, int verbose)
2981 {
2982 int flags = 0;
2983 if (verbose)
2984 flags |= TFF_CLASS_KEY_OR_ENUM;
2985
2986 if (p == NULL_TREE)
2987 return "";
2988
2989 if (TYPE_P (TREE_VALUE (p)))
2990 return type_as_string_translate (p, flags);
2991
2992 reinit_cxx_pp ();
2993 for (; p; p = TREE_CHAIN (p))
2994 {
2995 if (TREE_VALUE (p) == null_node)
2996 pp_cxx_ws_string (cxx_pp, "NULL");
2997 else
2998 dump_type (cxx_pp, error_type (TREE_VALUE (p)), flags);
2999 if (TREE_CHAIN (p))
3000 pp_separate_with_comma (cxx_pp);
3001 }
3002 return pp_ggc_formatted_text (cxx_pp);
3003 }
3004
3005 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3006 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3007 arguments. Alternatively, the purpose of P may be null and the template
3008 parameters passed directly in the type field. */
3009
3010 static const char *
3011 subst_to_string (tree p)
3012 {
3013 tree decl = TREE_PURPOSE (p);
3014 tree targs = TREE_VALUE (p);
3015 tree tparms = decl ? DECL_TEMPLATE_PARMS (decl) : TREE_TYPE (p);
3016 int flags = (TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER
3017 |TFF_NO_TEMPLATE_BINDINGS);
3018
3019 if (p == NULL_TREE)
3020 return "";
3021
3022 reinit_cxx_pp ();
3023 if (decl)
3024 {
3025 dump_template_decl (cxx_pp, decl, flags);
3026 pp_cxx_whitespace (cxx_pp);
3027 }
3028 dump_substitution (cxx_pp, NULL, tparms, targs, /*flags=*/0);
3029 return pp_ggc_formatted_text (cxx_pp);
3030 }
3031
3032 static const char *
3033 cv_to_string (tree p, int v)
3034 {
3035 reinit_cxx_pp ();
3036 cxx_pp->padding = v ? pp_before : pp_none;
3037 pp_cxx_cv_qualifier_seq (cxx_pp, p);
3038 return pp_ggc_formatted_text (cxx_pp);
3039 }
3040
3041 static const char *
3042 parms_to_string (tree p)
3043 {
3044 reinit_cxx_pp ();
3045 pp_cxx_parameter_declaration_clause (cxx_pp, p);
3046 return pp_formatted_text (cxx_pp);
3047 }
3048
3049
3050 static const char *
3051 eh_spec_to_string (tree p, int /*v*/)
3052 {
3053 int flags = 0;
3054 reinit_cxx_pp ();
3055 dump_exception_spec (cxx_pp, p, flags);
3056 return pp_ggc_formatted_text (cxx_pp);
3057 }
3058
3059 /* Langhook for print_error_function. */
3060 void
3061 cxx_print_error_function (diagnostic_context *context, const char *file,
3062 diagnostic_info *diagnostic)
3063 {
3064 lhd_print_error_function (context, file, diagnostic);
3065 pp_set_prefix (context->printer, file);
3066 maybe_print_instantiation_context (context);
3067 }
3068
3069 static void
3070 cp_diagnostic_starter (diagnostic_context *context,
3071 diagnostic_info *diagnostic)
3072 {
3073 diagnostic_report_current_module (context, diagnostic->location);
3074 cp_print_error_function (context, diagnostic);
3075 maybe_print_instantiation_context (context);
3076 maybe_print_constexpr_context (context);
3077 pp_set_prefix (context->printer, diagnostic_build_prefix (context,
3078 diagnostic));
3079 }
3080
3081 static void
3082 cp_diagnostic_finalizer (diagnostic_context *context,
3083 diagnostic_info *diagnostic)
3084 {
3085 virt_loc_aware_diagnostic_finalizer (context, diagnostic);
3086 pp_destroy_prefix (context->printer);
3087 }
3088
3089 /* Print current function onto BUFFER, in the process of reporting
3090 a diagnostic message. Called from cp_diagnostic_starter. */
3091 static void
3092 cp_print_error_function (diagnostic_context *context,
3093 diagnostic_info *diagnostic)
3094 {
3095 /* If we are in an instantiation context, current_function_decl is likely
3096 to be wrong, so just rely on print_instantiation_full_context. */
3097 if (current_instantiation ())
3098 return;
3099 if (diagnostic_last_function_changed (context, diagnostic))
3100 {
3101 const char *old_prefix = context->printer->prefix;
3102 const char *file = LOCATION_FILE (diagnostic->location);
3103 tree abstract_origin = diagnostic_abstract_origin (diagnostic);
3104 char *new_prefix = (file && abstract_origin == NULL)
3105 ? file_name_as_prefix (context, file) : NULL;
3106
3107 pp_set_prefix (context->printer, new_prefix);
3108
3109 if (current_function_decl == NULL)
3110 pp_string (context->printer, _("At global scope:"));
3111 else
3112 {
3113 tree fndecl, ao;
3114
3115 if (abstract_origin)
3116 {
3117 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
3118 while (TREE_CODE (ao) == BLOCK
3119 && BLOCK_ABSTRACT_ORIGIN (ao)
3120 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3121 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3122 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
3123 fndecl = ao;
3124 }
3125 else
3126 fndecl = current_function_decl;
3127
3128 pp_printf (context->printer, function_category (fndecl),
3129 cxx_printable_name_translate (fndecl, 2));
3130
3131 while (abstract_origin)
3132 {
3133 location_t *locus;
3134 tree block = abstract_origin;
3135
3136 locus = &BLOCK_SOURCE_LOCATION (block);
3137 fndecl = NULL;
3138 block = BLOCK_SUPERCONTEXT (block);
3139 while (block && TREE_CODE (block) == BLOCK
3140 && BLOCK_ABSTRACT_ORIGIN (block))
3141 {
3142 ao = BLOCK_ABSTRACT_ORIGIN (block);
3143
3144 while (TREE_CODE (ao) == BLOCK
3145 && BLOCK_ABSTRACT_ORIGIN (ao)
3146 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3147 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3148
3149 if (TREE_CODE (ao) == FUNCTION_DECL)
3150 {
3151 fndecl = ao;
3152 break;
3153 }
3154 else if (TREE_CODE (ao) != BLOCK)
3155 break;
3156
3157 block = BLOCK_SUPERCONTEXT (block);
3158 }
3159 if (fndecl)
3160 abstract_origin = block;
3161 else
3162 {
3163 while (block && TREE_CODE (block) == BLOCK)
3164 block = BLOCK_SUPERCONTEXT (block);
3165
3166 if (block && TREE_CODE (block) == FUNCTION_DECL)
3167 fndecl = block;
3168 abstract_origin = NULL;
3169 }
3170 if (fndecl)
3171 {
3172 expanded_location s = expand_location (*locus);
3173 pp_character (context->printer, ',');
3174 pp_newline (context->printer);
3175 if (s.file != NULL)
3176 {
3177 if (context->show_column && s.column != 0)
3178 pp_printf (context->printer,
3179 _(" inlined from %qs at %r%s:%d:%d%R"),
3180 cxx_printable_name_translate (fndecl, 2),
3181 "locus", s.file, s.line, s.column);
3182 else
3183 pp_printf (context->printer,
3184 _(" inlined from %qs at %r%s:%d%R"),
3185 cxx_printable_name_translate (fndecl, 2),
3186 "locus", s.file, s.line);
3187
3188 }
3189 else
3190 pp_printf (context->printer, _(" inlined from %qs"),
3191 cxx_printable_name_translate (fndecl, 2));
3192 }
3193 }
3194 pp_character (context->printer, ':');
3195 }
3196 pp_newline (context->printer);
3197
3198 diagnostic_set_last_function (context, diagnostic);
3199 pp_destroy_prefix (context->printer);
3200 context->printer->prefix = old_prefix;
3201 }
3202 }
3203
3204 /* Returns a description of FUNCTION using standard terminology. The
3205 result is a format string of the form "In CATEGORY %qs". */
3206 static const char *
3207 function_category (tree fn)
3208 {
3209 /* We can get called from the middle-end for diagnostics of function
3210 clones. Make sure we have language specific information before
3211 dereferencing it. */
3212 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
3213 && DECL_FUNCTION_MEMBER_P (fn))
3214 {
3215 if (DECL_STATIC_FUNCTION_P (fn))
3216 return _("In static member function %qs");
3217 else if (DECL_COPY_CONSTRUCTOR_P (fn))
3218 return _("In copy constructor %qs");
3219 else if (DECL_CONSTRUCTOR_P (fn))
3220 return _("In constructor %qs");
3221 else if (DECL_DESTRUCTOR_P (fn))
3222 return _("In destructor %qs");
3223 else if (LAMBDA_FUNCTION_P (fn))
3224 return _("In lambda function");
3225 else
3226 return _("In member function %qs");
3227 }
3228 else
3229 return _("In function %qs");
3230 }
3231
3232 /* Report the full context of a current template instantiation,
3233 onto BUFFER. */
3234 static void
3235 print_instantiation_full_context (diagnostic_context *context)
3236 {
3237 struct tinst_level *p = current_instantiation ();
3238 location_t location = input_location;
3239
3240 if (p)
3241 {
3242 pp_verbatim (context->printer,
3243 TREE_CODE (p->decl) == TREE_LIST
3244 ? _("%s: In substitution of %qS:\n")
3245 : _("%s: In instantiation of %q#D:\n"),
3246 LOCATION_FILE (location),
3247 p->decl);
3248
3249 location = p->locus;
3250 p = p->next;
3251 }
3252
3253 print_instantiation_partial_context (context, p, location);
3254 }
3255
3256 /* Helper function of print_instantiation_partial_context() that
3257 prints a single line of instantiation context. */
3258
3259 static void
3260 print_instantiation_partial_context_line (diagnostic_context *context,
3261 const struct tinst_level *t,
3262 location_t loc, bool recursive_p)
3263 {
3264 if (loc == UNKNOWN_LOCATION)
3265 return;
3266
3267 expanded_location xloc = expand_location (loc);
3268
3269 if (context->show_column)
3270 pp_verbatim (context->printer, _("%r%s:%d:%d:%R "),
3271 "locus", xloc.file, xloc.line, xloc.column);
3272 else
3273 pp_verbatim (context->printer, _("%r%s:%d:%R "),
3274 "locus", xloc.file, xloc.line);
3275
3276 if (t != NULL)
3277 {
3278 if (TREE_CODE (t->decl) == TREE_LIST)
3279 pp_verbatim (context->printer,
3280 recursive_p
3281 ? _("recursively required by substitution of %qS\n")
3282 : _("required by substitution of %qS\n"),
3283 t->decl);
3284 else
3285 pp_verbatim (context->printer,
3286 recursive_p
3287 ? _("recursively required from %q#D\n")
3288 : _("required from %q#D\n"),
3289 t->decl);
3290 }
3291 else
3292 {
3293 pp_verbatim (context->printer,
3294 recursive_p
3295 ? _("recursively required from here")
3296 : _("required from here"));
3297 }
3298 }
3299
3300 /* Same as print_instantiation_full_context but less verbose. */
3301
3302 static void
3303 print_instantiation_partial_context (diagnostic_context *context,
3304 struct tinst_level *t0, location_t loc)
3305 {
3306 struct tinst_level *t;
3307 int n_total = 0;
3308 int n;
3309 location_t prev_loc = loc;
3310
3311 for (t = t0; t != NULL; t = t->next)
3312 if (prev_loc != t->locus)
3313 {
3314 prev_loc = t->locus;
3315 n_total++;
3316 }
3317
3318 t = t0;
3319
3320 if (template_backtrace_limit
3321 && n_total > template_backtrace_limit)
3322 {
3323 int skip = n_total - template_backtrace_limit;
3324 int head = template_backtrace_limit / 2;
3325
3326 /* Avoid skipping just 1. If so, skip 2. */
3327 if (skip == 1)
3328 {
3329 skip = 2;
3330 head = (template_backtrace_limit - 1) / 2;
3331 }
3332
3333 for (n = 0; n < head; n++)
3334 {
3335 gcc_assert (t != NULL);
3336 if (loc != t->locus)
3337 print_instantiation_partial_context_line (context, t, loc,
3338 /*recursive_p=*/false);
3339 loc = t->locus;
3340 t = t->next;
3341 }
3342 if (t != NULL && skip > 0)
3343 {
3344 expanded_location xloc;
3345 xloc = expand_location (loc);
3346 if (context->show_column)
3347 pp_verbatim (context->printer,
3348 _("%r%s:%d:%d:%R [ skipping %d instantiation "
3349 "contexts, use -ftemplate-backtrace-limit=0 to "
3350 "disable ]\n"),
3351 "locus", xloc.file, xloc.line, xloc.column, skip);
3352 else
3353 pp_verbatim (context->printer,
3354 _("%r%s:%d:%R [ skipping %d instantiation "
3355 "contexts, use -ftemplate-backtrace-limit=0 to "
3356 "disable ]\n"),
3357 "locus", xloc.file, xloc.line, skip);
3358
3359 do {
3360 loc = t->locus;
3361 t = t->next;
3362 } while (t != NULL && --skip > 0);
3363 }
3364 }
3365
3366 while (t != NULL)
3367 {
3368 while (t->next != NULL && t->locus == t->next->locus)
3369 {
3370 loc = t->locus;
3371 t = t->next;
3372 }
3373 print_instantiation_partial_context_line (context, t, loc,
3374 t->locus == loc);
3375 loc = t->locus;
3376 t = t->next;
3377 }
3378 print_instantiation_partial_context_line (context, NULL, loc,
3379 /*recursive_p=*/false);
3380 pp_newline (context->printer);
3381 }
3382
3383 /* Called from cp_thing to print the template context for an error. */
3384 static void
3385 maybe_print_instantiation_context (diagnostic_context *context)
3386 {
3387 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3388 return;
3389
3390 record_last_problematic_instantiation ();
3391 print_instantiation_full_context (context);
3392 }
3393
3394 /* Report the bare minimum context of a template instantiation. */
3395 void
3396 print_instantiation_context (void)
3397 {
3398 print_instantiation_partial_context
3399 (global_dc, current_instantiation (), input_location);
3400 pp_newline (global_dc->printer);
3401 diagnostic_flush_buffer (global_dc);
3402 }
3403 \f
3404 /* Report what constexpr call(s) we're trying to expand, if any. */
3405
3406 void
3407 maybe_print_constexpr_context (diagnostic_context *context)
3408 {
3409 vec<tree> call_stack = cx_error_context ();
3410 unsigned ix;
3411 tree t;
3412
3413 FOR_EACH_VEC_ELT (call_stack, ix, t)
3414 {
3415 expanded_location xloc = expand_location (EXPR_LOCATION (t));
3416 const char *s = expr_as_string (t, 0);
3417 if (context->show_column)
3418 pp_verbatim (context->printer,
3419 _("%r%s:%d:%d:%R in constexpr expansion of %qs"),
3420 "locus", xloc.file, xloc.line, xloc.column, s);
3421 else
3422 pp_verbatim (context->printer,
3423 _("%r%s:%d:%R in constexpr expansion of %qs"),
3424 "locus", xloc.file, xloc.line, s);
3425 pp_newline (context->printer);
3426 }
3427 }
3428 \f
3429 /* Called from output_format -- during diagnostic message processing --
3430 to handle C++ specific format specifier with the following meanings:
3431 %A function argument-list.
3432 %C tree code.
3433 %D declaration.
3434 %E expression.
3435 %F function declaration.
3436 %L language as used in extern "lang".
3437 %O binary operator.
3438 %P function parameter whose position is indicated by an integer.
3439 %Q assignment operator.
3440 %S substitution (template + args)
3441 %T type.
3442 %V cv-qualifier.
3443 %X exception-specification. */
3444 static bool
3445 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
3446 int precision, bool wide, bool set_locus, bool verbose)
3447 {
3448 const char *result;
3449 tree t = NULL;
3450 #define next_tree (t = va_arg (*text->args_ptr, tree))
3451 #define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int))
3452 #define next_lang ((enum languages) va_arg (*text->args_ptr, int))
3453 #define next_int va_arg (*text->args_ptr, int)
3454
3455 if (precision != 0 || wide)
3456 return false;
3457
3458 if (text->locus == NULL)
3459 set_locus = false;
3460
3461 switch (*spec)
3462 {
3463 case 'A': result = args_to_string (next_tree, verbose); break;
3464 case 'C': result = code_to_string (next_tcode); break;
3465 case 'D':
3466 {
3467 tree temp = next_tree;
3468 if (VAR_P (temp)
3469 && DECL_HAS_DEBUG_EXPR_P (temp))
3470 {
3471 temp = DECL_DEBUG_EXPR (temp);
3472 if (!DECL_P (temp))
3473 {
3474 result = expr_to_string (temp);
3475 break;
3476 }
3477 }
3478 result = decl_to_string (temp, verbose);
3479 }
3480 break;
3481 case 'E': result = expr_to_string (next_tree); break;
3482 case 'F': result = fndecl_to_string (next_tree, verbose); break;
3483 case 'L': result = language_to_string (next_lang); break;
3484 case 'O': result = op_to_string (next_tcode); break;
3485 case 'P': result = parm_to_string (next_int); break;
3486 case 'Q': result = assop_to_string (next_tcode); break;
3487 case 'S': result = subst_to_string (next_tree); break;
3488 case 'T': result = type_to_string (next_tree, verbose); break;
3489 case 'V': result = cv_to_string (next_tree, verbose); break;
3490 case 'X': result = eh_spec_to_string (next_tree, verbose); break;
3491
3492 case 'K':
3493 percent_K_format (text);
3494 return true;
3495 case 'Z': result = parms_to_string (next_tree); break;
3496
3497 default:
3498 return false;
3499 }
3500
3501 pp_string (pp, result);
3502 if (set_locus && t != NULL)
3503 *text->locus = location_of (t);
3504 return true;
3505 #undef next_tree
3506 #undef next_tcode
3507 #undef next_lang
3508 #undef next_int
3509 }
3510 \f
3511 /* Warn about the use of C++0x features when appropriate. */
3512 void
3513 maybe_warn_cpp0x (cpp0x_warn_str str)
3514 {
3515 if ((cxx_dialect == cxx98) && !in_system_header_at (input_location))
3516 /* We really want to suppress this warning in system headers,
3517 because libstdc++ uses variadic templates even when we aren't
3518 in C++0x mode. */
3519 switch (str)
3520 {
3521 case CPP0X_INITIALIZER_LISTS:
3522 pedwarn (input_location, 0,
3523 "extended initializer lists "
3524 "only available with -std=c++11 or -std=gnu++11");
3525 break;
3526 case CPP0X_EXPLICIT_CONVERSION:
3527 pedwarn (input_location, 0,
3528 "explicit conversion operators "
3529 "only available with -std=c++11 or -std=gnu++11");
3530 break;
3531 case CPP0X_VARIADIC_TEMPLATES:
3532 pedwarn (input_location, 0,
3533 "variadic templates "
3534 "only available with -std=c++11 or -std=gnu++11");
3535 break;
3536 case CPP0X_LAMBDA_EXPR:
3537 pedwarn (input_location, 0,
3538 "lambda expressions "
3539 "only available with -std=c++11 or -std=gnu++11");
3540 break;
3541 case CPP0X_AUTO:
3542 pedwarn (input_location, 0,
3543 "C++11 auto only available with -std=c++11 or -std=gnu++11");
3544 break;
3545 case CPP0X_SCOPED_ENUMS:
3546 pedwarn (input_location, 0,
3547 "scoped enums only available with -std=c++11 or -std=gnu++11");
3548 break;
3549 case CPP0X_DEFAULTED_DELETED:
3550 pedwarn (input_location, 0,
3551 "defaulted and deleted functions "
3552 "only available with -std=c++11 or -std=gnu++11");
3553 break;
3554 case CPP0X_INLINE_NAMESPACES:
3555 pedwarn (input_location, OPT_Wpedantic,
3556 "inline namespaces "
3557 "only available with -std=c++11 or -std=gnu++11");
3558 break;
3559 case CPP0X_OVERRIDE_CONTROLS:
3560 pedwarn (input_location, 0,
3561 "override controls (override/final) "
3562 "only available with -std=c++11 or -std=gnu++11");
3563 break;
3564 case CPP0X_NSDMI:
3565 pedwarn (input_location, 0,
3566 "non-static data member initializers "
3567 "only available with -std=c++11 or -std=gnu++11");
3568 break;
3569 case CPP0X_USER_DEFINED_LITERALS:
3570 pedwarn (input_location, 0,
3571 "user-defined literals "
3572 "only available with -std=c++11 or -std=gnu++11");
3573 break;
3574 case CPP0X_DELEGATING_CTORS:
3575 pedwarn (input_location, 0,
3576 "delegating constructors "
3577 "only available with -std=c++11 or -std=gnu++11");
3578 break;
3579 case CPP0X_INHERITING_CTORS:
3580 pedwarn (input_location, 0,
3581 "inheriting constructors "
3582 "only available with -std=c++11 or -std=gnu++11");
3583 break;
3584 case CPP0X_ATTRIBUTES:
3585 pedwarn (input_location, 0,
3586 "c++11 attributes "
3587 "only available with -std=c++11 or -std=gnu++11");
3588 break;
3589 case CPP0X_REF_QUALIFIER:
3590 pedwarn (input_location, 0,
3591 "ref-qualifiers "
3592 "only available with -std=c++11 or -std=gnu++11");
3593 break;
3594 default:
3595 gcc_unreachable ();
3596 }
3597 }
3598
3599 /* Warn about the use of variadic templates when appropriate. */
3600 void
3601 maybe_warn_variadic_templates (void)
3602 {
3603 maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3604 }
3605
3606
3607 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3608 option OPT with text GMSGID. Use this function to report
3609 diagnostics for constructs that are invalid C++98, but valid
3610 C++0x. */
3611 bool
3612 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3613 {
3614 diagnostic_info diagnostic;
3615 va_list ap;
3616 bool ret;
3617
3618 va_start (ap, gmsgid);
3619 diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
3620 (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3621 diagnostic.option_index = opt;
3622 ret = report_diagnostic (&diagnostic);
3623 va_end (ap);
3624 return ret;
3625 }
3626
3627 /* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is what
3628 we found when we tried to do the lookup. LOCATION is the location of
3629 the NAME identifier. */
3630
3631 void
3632 qualified_name_lookup_error (tree scope, tree name,
3633 tree decl, location_t location)
3634 {
3635 if (scope == error_mark_node)
3636 ; /* We already complained. */
3637 else if (TYPE_P (scope))
3638 {
3639 if (!COMPLETE_TYPE_P (scope))
3640 error_at (location, "incomplete type %qT used in nested name specifier",
3641 scope);
3642 else if (TREE_CODE (decl) == TREE_LIST)
3643 {
3644 error_at (location, "reference to %<%T::%D%> is ambiguous",
3645 scope, name);
3646 print_candidates (decl);
3647 }
3648 else
3649 error_at (location, "%qD is not a member of %qT", name, scope);
3650 }
3651 else if (scope != global_namespace)
3652 {
3653 error_at (location, "%qD is not a member of %qD", name, scope);
3654 suggest_alternatives_for (location, name);
3655 }
3656 else
3657 {
3658 error_at (location, "%<::%D%> has not been declared", name);
3659 suggest_alternatives_for (location, name);
3660 }
3661 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org