OSDN Git Service

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