gcc/cp/error.c

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