gcc/cp/error.c

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