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