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