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