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