gcc/cp/error.c

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