gcc/cp/error.c

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