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