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