OSDN Git Service

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