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