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       pp_expression (cxx_pp, t);
2075       break;
2076
2077     case TRUTH_AND_EXPR:
2078     case TRUTH_OR_EXPR:
2079     case TRUTH_XOR_EXPR:
2080       if (flags & TFF_EXPR_IN_PARENS)
2081         pp_cxx_left_paren (cxx_pp);
2082       pp_expression (cxx_pp, t);
2083       if (flags & TFF_EXPR_IN_PARENS)
2084         pp_cxx_right_paren (cxx_pp);
2085       break;
2086
2087     case OBJ_TYPE_REF:
2088       dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2089       break;
2090
2091       /*  This list is incomplete, but should suffice for now.
2092           It is very important that `sorry' does not call
2093           `report_error_function'.  That could cause an infinite loop.  */
2094     default:
2095       pp_unsupported_tree (cxx_pp, t);
2096       /* fall through to ERROR_MARK...  */
2097     case ERROR_MARK:
2098       pp_identifier (cxx_pp, "<expression error>");
2099       break;
2100     }
2101 }
2102
2103 static void
2104 dump_binary_op (const char *opstring, tree t, int flags)
2105 {
2106   pp_cxx_left_paren (cxx_pp);
2107   dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2108   pp_cxx_whitespace (cxx_pp);
2109   if (opstring)
2110     pp_cxx_identifier (cxx_pp, opstring);
2111   else
2112     pp_identifier (cxx_pp, "<unknown operator>");
2113   pp_cxx_whitespace (cxx_pp);
2114   dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2115   pp_cxx_right_paren (cxx_pp);
2116 }
2117
2118 static void
2119 dump_unary_op (const char *opstring, tree t, int flags)
2120 {
2121   if (flags & TFF_EXPR_IN_PARENS)
2122     pp_cxx_left_paren (cxx_pp);
2123   pp_cxx_identifier (cxx_pp, opstring);
2124   dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2125   if (flags & TFF_EXPR_IN_PARENS)
2126     pp_cxx_right_paren (cxx_pp);
2127 }
2128
2129 static void
2130 reinit_cxx_pp (void)
2131 {
2132   pp_clear_output_area (cxx_pp);
2133   pp_base (cxx_pp)->padding = pp_none;
2134   pp_indentation (cxx_pp) = 0;
2135   pp_needs_newline (cxx_pp) = false;
2136   cxx_pp->enclosing_scope = current_function_decl;
2137 }
2138
2139
2140 /* Exported interface to stringifying types, exprs and decls under TFF_*
2141    control.  */
2142
2143 const char *
2144 type_as_string (tree typ, int flags)
2145 {
2146   reinit_cxx_pp ();
2147   dump_type (typ, flags);
2148   return pp_formatted_text (cxx_pp);
2149 }
2150
2151 const char *
2152 expr_as_string (tree decl, int flags)
2153 {
2154   reinit_cxx_pp ();
2155   dump_expr (decl, flags);
2156   return pp_formatted_text (cxx_pp);
2157 }
2158
2159 const char *
2160 decl_as_string (tree decl, int flags)
2161 {
2162   reinit_cxx_pp ();
2163   dump_decl (decl, flags);
2164   return pp_formatted_text (cxx_pp);
2165 }
2166
2167 /* Generate the three forms of printable names for cxx_printable_name.  */
2168
2169 const char *
2170 lang_decl_name (tree decl, int v)
2171 {
2172   if (v >= 2)
2173     return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2174
2175   reinit_cxx_pp ();
2176   if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2177     {
2178       dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2179       pp_cxx_colon_colon (cxx_pp);
2180     }
2181
2182   if (TREE_CODE (decl) == FUNCTION_DECL)
2183     dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2184   else
2185     dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2186
2187   return pp_formatted_text (cxx_pp);
2188 }
2189
2190 /* Return the location of a tree passed to %+ formats.  */
2191
2192 static location_t
2193 location_of (tree t)
2194 {
2195   if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2196     t = DECL_CONTEXT (t);
2197   else if (TYPE_P (t))
2198     t = TYPE_MAIN_DECL (t);
2199   else if (TREE_CODE (t) == OVERLOAD)
2200     t = OVL_FUNCTION (t);
2201
2202   return DECL_SOURCE_LOCATION (t);
2203 }
2204
2205 /* Now the interfaces from error et al to dump_type et al. Each takes an
2206    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2207    function.  */
2208
2209 static const char *
2210 decl_to_string (tree decl, int verbose)
2211 {
2212   int flags = 0;
2213
2214   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2215       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2216     flags = TFF_CLASS_KEY_OR_ENUM;
2217   if (verbose)
2218     flags |= TFF_DECL_SPECIFIERS;
2219   else if (TREE_CODE (decl) == FUNCTION_DECL)
2220     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2221   flags |= TFF_TEMPLATE_HEADER;
2222
2223   reinit_cxx_pp ();
2224   dump_decl (decl, flags);
2225   return pp_formatted_text (cxx_pp);
2226 }
2227
2228 static const char *
2229 expr_to_string (tree decl)
2230 {
2231   reinit_cxx_pp ();
2232   dump_expr (decl, 0);
2233   return pp_formatted_text (cxx_pp);
2234 }
2235
2236 static const char *
2237 fndecl_to_string (tree fndecl, int verbose)
2238 {
2239   int flags;
2240
2241   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2242     | TFF_TEMPLATE_HEADER;
2243   if (verbose)
2244     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2245   reinit_cxx_pp ();
2246   dump_decl (fndecl, flags);
2247   return pp_formatted_text (cxx_pp);
2248 }
2249
2250
2251 static const char *
2252 code_to_string (enum tree_code c)
2253 {
2254   return tree_code_name [c];
2255 }
2256
2257 const char *
2258 language_to_string (enum languages c)
2259 {
2260   switch (c)
2261     {
2262     case lang_c:
2263       return "C";
2264
2265     case lang_cplusplus:
2266       return "C++";
2267
2268     case lang_java:
2269       return "Java";
2270
2271     default:
2272       gcc_unreachable ();
2273     }
2274   return NULL;
2275 }
2276
2277 /* Return the proper printed version of a parameter to a C++ function.  */
2278
2279 static const char *
2280 parm_to_string (int p)
2281 {
2282   reinit_cxx_pp ();
2283   if (p < 0)
2284     pp_string (cxx_pp, "'this'");
2285   else
2286     pp_decimal_int (cxx_pp, p + 1);
2287   return pp_formatted_text (cxx_pp);
2288 }
2289
2290 static const char *
2291 op_to_string (enum tree_code p)
2292 {
2293   tree id = operator_name_info[(int) p].identifier;
2294   return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2295 }
2296
2297 static const char *
2298 type_to_string (tree typ, int verbose)
2299 {
2300   int flags = 0;
2301   if (verbose)
2302     flags |= TFF_CLASS_KEY_OR_ENUM;
2303   flags |= TFF_TEMPLATE_HEADER;
2304
2305   reinit_cxx_pp ();
2306   dump_type (typ, flags);
2307   return pp_formatted_text (cxx_pp);
2308 }
2309
2310 static const char *
2311 assop_to_string (enum tree_code p)
2312 {
2313   tree id = assignment_operator_name_info[(int) p].identifier;
2314   return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2315 }
2316
2317 static const char *
2318 args_to_string (tree p, int verbose)
2319 {
2320   int flags = 0;
2321   if (verbose)
2322     flags |= TFF_CLASS_KEY_OR_ENUM;
2323
2324   if (p == NULL_TREE)
2325     return "";
2326
2327   if (TYPE_P (TREE_VALUE (p)))
2328     return type_as_string (p, flags);
2329
2330   reinit_cxx_pp ();
2331   for (; p; p = TREE_CHAIN (p))
2332     {
2333       if (TREE_VALUE (p) == null_node)
2334         pp_cxx_identifier (cxx_pp, "NULL");
2335       else
2336         dump_type (error_type (TREE_VALUE (p)), flags);
2337       if (TREE_CHAIN (p))
2338         pp_separate_with_comma (cxx_pp);
2339     }
2340   return pp_formatted_text (cxx_pp);
2341 }
2342
2343 static const char *
2344 cv_to_string (tree p, int v)
2345 {
2346   reinit_cxx_pp ();
2347   pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2348   pp_cxx_cv_qualifier_seq (cxx_pp, p);
2349   return pp_formatted_text (cxx_pp);
2350 }
2351
2352 /* Langhook for print_error_function.  */
2353 void
2354 cxx_print_error_function (diagnostic_context *context, const char *file,
2355                           diagnostic_info *diagnostic)
2356 {
2357   lhd_print_error_function (context, file, diagnostic);
2358   pp_base_set_prefix (context->printer, file);
2359   maybe_print_instantiation_context (context);
2360 }
2361
2362 static void
2363 cp_diagnostic_starter (diagnostic_context *context,
2364                        diagnostic_info *diagnostic)
2365 {
2366   diagnostic_report_current_module (context);
2367   cp_print_error_function (context, diagnostic);
2368   maybe_print_instantiation_context (context);
2369   pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2370 }
2371
2372 static void
2373 cp_diagnostic_finalizer (diagnostic_context *context,
2374                          diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2375 {
2376   pp_base_destroy_prefix (context->printer);
2377 }
2378
2379 /* Print current function onto BUFFER, in the process of reporting
2380    a diagnostic message.  Called from cp_diagnostic_starter.  */
2381 static void
2382 cp_print_error_function (diagnostic_context *context,
2383                          diagnostic_info *diagnostic)
2384 {
2385   if (diagnostic_last_function_changed (context, diagnostic))
2386     {
2387       const char *old_prefix = context->printer->prefix;
2388       const char *file = LOCATION_FILE (diagnostic->location);
2389       tree abstract_origin = diagnostic->abstract_origin;
2390       char *new_prefix = (file && abstract_origin == NULL)
2391                          ? file_name_as_prefix (file) : NULL;
2392
2393       pp_base_set_prefix (context->printer, new_prefix);
2394
2395       if (current_function_decl == NULL)
2396         pp_base_string (context->printer, "At global scope:");
2397       else
2398         {
2399           tree fndecl, ao;
2400
2401           if (abstract_origin)
2402             {
2403               ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2404               while (TREE_CODE (ao) == BLOCK
2405                      && BLOCK_ABSTRACT_ORIGIN (ao)
2406                      && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2407                 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2408               gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2409               fndecl = ao;
2410             }
2411           else
2412             fndecl = current_function_decl;
2413
2414           pp_printf (context->printer, "In %s %qs",
2415                      function_category (fndecl),
2416                      cxx_printable_name (fndecl, 2));
2417
2418           while (abstract_origin)
2419             {
2420               location_t *locus;
2421               tree block = abstract_origin;
2422
2423               locus = &BLOCK_SOURCE_LOCATION (block);
2424               fndecl = NULL;
2425               block = BLOCK_SUPERCONTEXT (block);
2426               while (block && TREE_CODE (block) == BLOCK
2427                      && BLOCK_ABSTRACT_ORIGIN (block))
2428                 {
2429                   ao = BLOCK_ABSTRACT_ORIGIN (block);
2430
2431                   while (TREE_CODE (ao) == BLOCK
2432                          && BLOCK_ABSTRACT_ORIGIN (ao)
2433                          && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2434                     ao = BLOCK_ABSTRACT_ORIGIN (ao);
2435
2436                   if (TREE_CODE (ao) == FUNCTION_DECL)
2437                     {
2438                       fndecl = ao;
2439                       break;
2440                     }
2441                   else if (TREE_CODE (ao) != BLOCK)
2442                     break;
2443
2444                   block = BLOCK_SUPERCONTEXT (block);
2445                 }
2446               if (fndecl)
2447                 abstract_origin = block;
2448               else
2449                 {
2450                   while (block && TREE_CODE (block) == BLOCK)
2451                     block = BLOCK_SUPERCONTEXT (block);
2452
2453                   if (TREE_CODE (block) == FUNCTION_DECL)
2454                     fndecl = block;
2455                   abstract_origin = NULL;
2456                 }
2457               if (fndecl)
2458                 {
2459                   expanded_location s = expand_location (*locus);
2460                   pp_base_character (context->printer, ',');
2461                   pp_base_newline (context->printer);
2462                   if (s.file != NULL)
2463                     {
2464                       if (flag_show_column && s.column != 0)
2465                         pp_printf (context->printer,
2466                                    "    inlined from %qs at %s:%d:%d",
2467                                    cxx_printable_name (fndecl, 2),
2468                                    s.file, s.line, s.column);
2469                       else
2470                         pp_printf (context->printer,
2471                                    "    inlined from %qs at %s:%d",
2472                                    cxx_printable_name (fndecl, 2),
2473                                    s.file, s.line);
2474
2475                     }
2476                   else
2477                     pp_printf (context->printer, "    inlined from %qs",
2478                                cxx_printable_name (fndecl, 2));
2479                 }
2480             }
2481           pp_base_character (context->printer, ':');
2482         }
2483       pp_base_newline (context->printer);
2484
2485       diagnostic_set_last_function (context, diagnostic);
2486       pp_base_destroy_prefix (context->printer);
2487       context->printer->prefix = old_prefix;
2488     }
2489 }
2490
2491 /* Returns a description of FUNCTION using standard terminology.  */
2492 static const char *
2493 function_category (tree fn)
2494 {
2495   if (DECL_FUNCTION_MEMBER_P (fn))
2496     {
2497       if (DECL_STATIC_FUNCTION_P (fn))
2498         return "static member function";
2499       else if (DECL_COPY_CONSTRUCTOR_P (fn))
2500         return "copy constructor";
2501       else if (DECL_CONSTRUCTOR_P (fn))
2502         return "constructor";
2503       else if (DECL_DESTRUCTOR_P (fn))
2504         return "destructor";
2505       else
2506         return "member function";
2507     }
2508   else
2509     return "function";
2510 }
2511
2512 /* Report the full context of a current template instantiation,
2513    onto BUFFER.  */
2514 static void
2515 print_instantiation_full_context (diagnostic_context *context)
2516 {
2517   struct tinst_level *p = current_instantiation ();
2518   location_t location = input_location;
2519
2520   if (p)
2521     {
2522       if (current_function_decl != p->decl
2523           && current_function_decl != NULL_TREE)
2524         /* We can get here during the processing of some synthesized
2525            method.  Then, P->DECL will be the function that's causing
2526            the synthesis.  */
2527         ;
2528       else
2529         {
2530           if (current_function_decl == p->decl)
2531             /* Avoid redundancy with the "In function" line.  */;
2532           else
2533             pp_verbatim (context->printer,
2534                          "%s: In instantiation of %qs:\n",
2535                          LOCATION_FILE (location),
2536                          decl_as_string (p->decl,
2537                                          TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2538
2539           location = p->locus;
2540           p = p->next;
2541         }
2542     }
2543
2544   print_instantiation_partial_context (context, p, location);
2545 }
2546
2547 /* Same as above but less verbose.  */
2548 static void
2549 print_instantiation_partial_context (diagnostic_context *context,
2550                                      struct tinst_level *t, location_t loc)
2551 {
2552   expanded_location xloc;
2553   for (; ; t = t->next)
2554     {
2555       xloc = expand_location (loc);
2556       if (t == NULL)
2557         break;
2558       pp_verbatim (context->printer, "%s:%d:   instantiated from %qs\n",
2559                    xloc.file, xloc.line,
2560                    decl_as_string (t->decl,
2561                                    TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2562       loc = t->locus;
2563     }
2564   pp_verbatim (context->printer, "%s:%d:   instantiated from here",
2565                xloc.file, xloc.line);
2566   pp_base_newline (context->printer);
2567 }
2568
2569 /* Called from cp_thing to print the template context for an error.  */
2570 static void
2571 maybe_print_instantiation_context (diagnostic_context *context)
2572 {
2573   if (!problematic_instantiation_changed () || current_instantiation () == 0)
2574     return;
2575
2576   record_last_problematic_instantiation ();
2577   print_instantiation_full_context (context);
2578 }
2579
2580 /* Report the bare minimum context of a template instantiation.  */
2581 void
2582 print_instantiation_context (void)
2583 {
2584   print_instantiation_partial_context
2585     (global_dc, current_instantiation (), input_location);
2586   diagnostic_flush_buffer (global_dc);
2587 }
2588 \f
2589 /* Called from output_format -- during diagnostic message processing --
2590    to handle C++ specific format specifier with the following meanings:
2591    %A   function argument-list.
2592    %C   tree code.
2593    %D   declaration.
2594    %E   expression.
2595    %F   function declaration.
2596    %L   language as used in extern "lang".
2597    %O   binary operator.
2598    %P   function parameter whose position is indicated by an integer.
2599    %Q   assignment operator.
2600    %T   type.
2601    %V   cv-qualifier.  */
2602 static bool
2603 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2604             int precision, bool wide, bool set_locus, bool verbose)
2605 {
2606   const char *result;
2607   tree t = NULL;
2608 #define next_tree    (t = va_arg (*text->args_ptr, tree))
2609 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
2610 #define next_lang    va_arg (*text->args_ptr, enum languages)
2611 #define next_int     va_arg (*text->args_ptr, int)
2612
2613   if (precision != 0 || wide)
2614     return false;
2615
2616   if (text->locus == NULL)
2617     set_locus = false;
2618
2619   switch (*spec)
2620     {
2621     case 'A': result = args_to_string (next_tree, verbose);     break;
2622     case 'C': result = code_to_string (next_tcode);             break;
2623     case 'D':
2624       {
2625         tree temp = next_tree;
2626         if (DECL_P (temp)
2627             && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2628           {
2629             temp = DECL_DEBUG_EXPR (temp);
2630             if (!DECL_P (temp))
2631               {
2632                 result = expr_to_string (temp);
2633                 break;
2634               }
2635           }
2636         result = decl_to_string (temp, verbose);
2637       }
2638       break;
2639     case 'E': result = expr_to_string (next_tree);              break;
2640     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
2641     case 'L': result = language_to_string (next_lang);          break;
2642     case 'O': result = op_to_string (next_tcode);               break;
2643     case 'P': result = parm_to_string (next_int);               break;
2644     case 'Q': result = assop_to_string (next_tcode);            break;
2645     case 'T': result = type_to_string (next_tree, verbose);     break;
2646     case 'V': result = cv_to_string (next_tree, verbose);       break;
2647
2648     default:
2649       return false;
2650     }
2651
2652   pp_base_string (pp, result);
2653   if (set_locus && t != NULL)
2654     *text->locus = location_of (t);
2655   return true;
2656 #undef next_tree
2657 #undef next_tcode
2658 #undef next_lang
2659 #undef next_int
2660 }
2661 \f
2662 /* Callback from cpp_error for PFILE to print diagnostics arising from
2663    interpreting strings.  The diagnostic is of type LEVEL; MSG is the
2664    translated message and AP the arguments.  */
2665
2666 void
2667 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2668               const char *msg, va_list *ap)
2669 {
2670   diagnostic_info diagnostic;
2671   diagnostic_t dlevel;
2672   switch (level)
2673     {
2674     case CPP_DL_WARNING:
2675     case CPP_DL_WARNING_SYSHDR:
2676       dlevel = DK_WARNING;
2677       break;
2678     case CPP_DL_PEDWARN:
2679       dlevel = DK_PEDWARN;
2680       break;
2681     case CPP_DL_ERROR:
2682       dlevel = DK_ERROR;
2683       break;
2684     case CPP_DL_ICE:
2685       dlevel = DK_ICE;
2686       break;
2687     default:
2688       gcc_unreachable ();
2689     }
2690   diagnostic_set_info_translated (&diagnostic, msg, ap,
2691                                   input_location, dlevel);
2692   report_diagnostic (&diagnostic);
2693 }
2694
2695 /* Warn about the use of C++0x features when appropriate.  */
2696 void
2697 maybe_warn_cpp0x (const char* str)
2698 {
2699   if ((cxx_dialect == cxx98) && !in_system_header)
2700     /* We really want to suppress this warning in system headers,
2701        because libstdc++ uses variadic templates even when we aren't
2702        in C++0x mode. */
2703     pedwarn (input_location, 0, "%s only available with -std=c++0x or -std=gnu++0x", str);
2704 }
2705
2706 /* Warn about the use of variadic templates when appropriate.  */
2707 void
2708 maybe_warn_variadic_templates (void)
2709 {
2710   maybe_warn_cpp0x ("variadic templates");
2711 }