OSDN Git Service

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