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