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