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