gcc/cp/error.c

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