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