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