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