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