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_CONVERT:
1751     case VIEW_CONVERT_EXPR:
1752       {
1753         tree op = TREE_OPERAND (t, 0);
1754
1755         if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
1756           {
1757             /* It is a cast, but we cannot tell whether it is a
1758                reinterpret or static cast. Use the C style notation.  */
1759             if (flags & TFF_EXPR_IN_PARENS)
1760               pp_cxx_left_paren (cxx_pp);
1761             pp_cxx_left_paren (cxx_pp);
1762             dump_type (TREE_TYPE (t), flags);
1763             pp_cxx_right_paren (cxx_pp);
1764             dump_expr (op, flags | TFF_EXPR_IN_PARENS);
1765             if (flags & TFF_EXPR_IN_PARENS)
1766               pp_cxx_right_paren (cxx_pp);
1767           }
1768         else
1769           dump_expr (op, flags);
1770         break;
1771       }
1772
1773     case CONSTRUCTOR:
1774       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
1775         {
1776           tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
1777
1778           if (integer_zerop (idx))
1779             {
1780               /* A NULL pointer-to-member constant.  */
1781               pp_cxx_left_paren (cxx_pp);
1782               pp_cxx_left_paren (cxx_pp);
1783               dump_type (TREE_TYPE (t), flags);
1784               pp_cxx_right_paren (cxx_pp);
1785               pp_character (cxx_pp, '0');
1786               pp_cxx_right_paren (cxx_pp);
1787               break;
1788             }
1789           else if (host_integerp (idx, 0))
1790             {
1791               tree virtuals;
1792               unsigned HOST_WIDE_INT n;
1793
1794               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
1795               t = TYPE_METHOD_BASETYPE (t);
1796               virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
1797
1798               n = tree_low_cst (idx, 0);
1799
1800               /* Map vtable index back one, to allow for the null pointer to
1801                  member.  */
1802               --n;
1803
1804               while (n > 0 && virtuals)
1805                 {
1806                   --n;
1807                   virtuals = TREE_CHAIN (virtuals);
1808                 }
1809               if (virtuals)
1810                 {
1811                   dump_expr (BV_FN (virtuals),
1812                              flags | TFF_EXPR_IN_PARENS);
1813                   break;
1814                 }
1815             }
1816         }
1817       if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
1818         {
1819           dump_type (TREE_TYPE (t), 0);
1820           pp_cxx_left_paren (cxx_pp);
1821           pp_cxx_right_paren (cxx_pp);
1822         }
1823       else
1824         {
1825           pp_cxx_left_brace (cxx_pp);
1826           dump_expr_init_vec (CONSTRUCTOR_ELTS (t), flags);
1827           pp_cxx_right_brace (cxx_pp);
1828         }
1829
1830       break;
1831
1832     case OFFSET_REF:
1833       {
1834         tree ob = TREE_OPERAND (t, 0);
1835         if (is_dummy_object (ob))
1836           {
1837             t = TREE_OPERAND (t, 1);
1838             if (TREE_CODE (t) == FUNCTION_DECL)
1839               /* A::f */
1840               dump_expr (t, flags | TFF_EXPR_IN_PARENS);
1841             else if (BASELINK_P (t))
1842               dump_expr (OVL_CURRENT (BASELINK_FUNCTIONS (t)),
1843                          flags | TFF_EXPR_IN_PARENS);
1844             else
1845               dump_decl (t, flags);
1846           }
1847         else
1848           {
1849             if (TREE_CODE (ob) == INDIRECT_REF)
1850               {
1851                 dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
1852                 pp_cxx_arrow (cxx_pp);
1853                 pp_cxx_star (cxx_pp);
1854               }
1855             else
1856               {
1857                 dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
1858                 pp_cxx_dot (cxx_pp);
1859                 pp_cxx_star (cxx_pp);
1860               }
1861             dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1862           }
1863         break;
1864       }
1865
1866     case TEMPLATE_PARM_INDEX:
1867       dump_decl (TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
1868       break;
1869
1870     case CAST_EXPR:
1871       if (TREE_OPERAND (t, 0) == NULL_TREE
1872           || TREE_CHAIN (TREE_OPERAND (t, 0)))
1873         {
1874           dump_type (TREE_TYPE (t), flags);
1875           pp_cxx_left_paren (cxx_pp);
1876           dump_expr_list (TREE_OPERAND (t, 0), flags);
1877           pp_cxx_right_paren (cxx_pp);
1878         }
1879       else
1880         {
1881           pp_cxx_left_paren (cxx_pp);
1882           dump_type (TREE_TYPE (t), flags);
1883           pp_cxx_right_paren (cxx_pp);
1884           pp_cxx_left_paren (cxx_pp);
1885           dump_expr_list (TREE_OPERAND (t, 0), flags);
1886           pp_cxx_right_paren (cxx_pp);
1887         }
1888       break;
1889
1890     case STATIC_CAST_EXPR:
1891       pp_cxx_identifier (cxx_pp, "static_cast");
1892       goto cast;
1893     case REINTERPRET_CAST_EXPR:
1894       pp_cxx_identifier (cxx_pp, "reinterpret_cast");
1895       goto cast;
1896     case CONST_CAST_EXPR:
1897       pp_cxx_identifier (cxx_pp, "const_cast");
1898       goto cast;
1899     case DYNAMIC_CAST_EXPR:
1900       pp_cxx_identifier (cxx_pp, "dynamic_cast");
1901     cast:
1902       pp_cxx_begin_template_argument_list (cxx_pp);
1903       dump_type (TREE_TYPE (t), flags);
1904       pp_cxx_end_template_argument_list (cxx_pp);
1905       pp_cxx_left_paren (cxx_pp);
1906       dump_expr (TREE_OPERAND (t, 0), flags);
1907       pp_cxx_right_paren (cxx_pp);
1908       break;
1909
1910     case ARROW_EXPR:
1911       dump_expr (TREE_OPERAND (t, 0), flags);
1912       pp_cxx_arrow (cxx_pp);
1913       break;
1914
1915     case SIZEOF_EXPR:
1916     case ALIGNOF_EXPR:
1917       if (TREE_CODE (t) == SIZEOF_EXPR)
1918         pp_cxx_identifier (cxx_pp, "sizeof");
1919       else
1920         {
1921           gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
1922           pp_cxx_identifier (cxx_pp, "__alignof__");
1923         }
1924       pp_cxx_whitespace (cxx_pp);
1925       pp_cxx_left_paren (cxx_pp);
1926       if (TYPE_P (TREE_OPERAND (t, 0)))
1927         dump_type (TREE_OPERAND (t, 0), flags);
1928       else
1929         dump_expr (TREE_OPERAND (t, 0), flags);
1930       pp_cxx_right_paren (cxx_pp);
1931       break;
1932
1933     case REALPART_EXPR:
1934     case IMAGPART_EXPR:
1935       pp_cxx_identifier (cxx_pp, operator_name_info[TREE_CODE (t)].name);
1936       pp_cxx_whitespace (cxx_pp);
1937       dump_expr (TREE_OPERAND (t, 0), flags);
1938       break;
1939
1940     case DEFAULT_ARG:
1941       pp_identifier (cxx_pp, "<unparsed>");
1942       break;
1943
1944     case TRY_CATCH_EXPR:
1945     case WITH_CLEANUP_EXPR:
1946     case CLEANUP_POINT_EXPR:
1947       dump_expr (TREE_OPERAND (t, 0), flags);
1948       break;
1949
1950     case PSEUDO_DTOR_EXPR:
1951       dump_expr (TREE_OPERAND (t, 2), flags);
1952       pp_cxx_dot (cxx_pp);
1953       dump_type (TREE_OPERAND (t, 0), flags);
1954       pp_cxx_colon_colon (cxx_pp);
1955       pp_cxx_complement (cxx_pp);
1956       dump_type (TREE_OPERAND (t, 1), flags);
1957       break;
1958
1959     case TEMPLATE_ID_EXPR:
1960       dump_decl (t, flags);
1961       break;
1962
1963     case BIND_EXPR:
1964     case STMT_EXPR:
1965     case STATEMENT_LIST:
1966       /* We don't yet have a way of dumping statements in a
1967          human-readable format.  */
1968       pp_string (cxx_pp, "({...})");
1969       break;
1970
1971     case LOOP_EXPR:
1972       pp_string (cxx_pp, "while (1) { ");
1973       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1974       pp_cxx_right_brace (cxx_pp);
1975       break;
1976
1977     case EXIT_EXPR:
1978       pp_string (cxx_pp, "if (");
1979       dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
1980       pp_string (cxx_pp, ") break; ");
1981       break;
1982
1983     case BASELINK:
1984       dump_expr (get_first_fn (t), flags & ~TFF_EXPR_IN_PARENS);
1985       break;
1986
1987     case EMPTY_CLASS_EXPR:
1988       dump_type (TREE_TYPE (t), flags);
1989       pp_cxx_left_paren (cxx_pp);
1990       pp_cxx_right_paren (cxx_pp);
1991       break;
1992
1993     case NON_DEPENDENT_EXPR:
1994       dump_expr (TREE_OPERAND (t, 0), flags);
1995       break;
1996
1997     case ARGUMENT_PACK_SELECT:
1998       dump_template_argument (ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
1999       break;
2000
2001     case RECORD_TYPE:
2002     case UNION_TYPE:
2003     case ENUMERAL_TYPE:
2004     case REAL_TYPE:
2005     case VOID_TYPE:
2006     case BOOLEAN_TYPE:
2007     case INTEGER_TYPE:
2008     case COMPLEX_TYPE:
2009     case VECTOR_TYPE:
2010       pp_type_specifier_seq (cxx_pp, t);
2011       break;
2012
2013     case TYPENAME_TYPE:
2014       /* We get here when we want to print a dependent type as an
2015          id-expression, without any disambiguator decoration.  */
2016       pp_id_expression (cxx_pp, t);
2017       break;
2018
2019     case TEMPLATE_TYPE_PARM:
2020     case BOUND_TEMPLATE_TEMPLATE_PARM:
2021       dump_type (t, flags);
2022       break;
2023
2024     case TRAIT_EXPR:
2025       pp_cxx_trait_expression (cxx_pp, t);
2026       break;
2027
2028     case VA_ARG_EXPR:
2029       pp_cxx_va_arg_expression (cxx_pp, t);
2030       break;
2031
2032     case OFFSETOF_EXPR:
2033       pp_cxx_offsetof_expression (cxx_pp, t);
2034       break;
2035
2036     case SCOPE_REF:
2037     case EXPR_PACK_EXPANSION:
2038     case TYPEID_EXPR:
2039     case MEMBER_REF:
2040     case DOTSTAR_EXPR:
2041     case NEW_EXPR:
2042     case VEC_NEW_EXPR:
2043     case DELETE_EXPR:
2044     case VEC_DELETE_EXPR:
2045     case MODOP_EXPR:
2046     case ABS_EXPR:
2047     case CONJ_EXPR:
2048     case VECTOR_CST:
2049     case FIXED_CST:
2050     case UNORDERED_EXPR:
2051     case ORDERED_EXPR:
2052     case UNLT_EXPR:
2053     case UNLE_EXPR:
2054     case UNGT_EXPR:
2055     case UNGE_EXPR:
2056     case UNEQ_EXPR:
2057     case LTGT_EXPR:
2058       pp_expression (cxx_pp, t);
2059       break;
2060
2061     case TRUTH_AND_EXPR:
2062     case TRUTH_OR_EXPR:
2063     case TRUTH_XOR_EXPR:
2064       if (flags & TFF_EXPR_IN_PARENS)
2065         pp_cxx_left_paren (cxx_pp);
2066       pp_expression (cxx_pp, t);
2067       if (flags & TFF_EXPR_IN_PARENS)
2068         pp_cxx_right_paren (cxx_pp);
2069       break;
2070
2071     case OBJ_TYPE_REF:
2072       dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2073       break;
2074
2075       /*  This list is incomplete, but should suffice for now.
2076           It is very important that `sorry' does not call
2077           `report_error_function'.  That could cause an infinite loop.  */
2078     default:
2079       pp_unsupported_tree (cxx_pp, t);
2080       /* fall through to ERROR_MARK...  */
2081     case ERROR_MARK:
2082       pp_identifier (cxx_pp, "<expression error>");
2083       break;
2084     }
2085 }
2086
2087 static void
2088 dump_binary_op (const char *opstring, tree t, int flags)
2089 {
2090   pp_cxx_left_paren (cxx_pp);
2091   dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2092   pp_cxx_whitespace (cxx_pp);
2093   if (opstring)
2094     pp_cxx_identifier (cxx_pp, opstring);
2095   else
2096     pp_identifier (cxx_pp, "<unknown operator>");
2097   pp_cxx_whitespace (cxx_pp);
2098   dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2099   pp_cxx_right_paren (cxx_pp);
2100 }
2101
2102 static void
2103 dump_unary_op (const char *opstring, tree t, int flags)
2104 {
2105   if (flags & TFF_EXPR_IN_PARENS)
2106     pp_cxx_left_paren (cxx_pp);
2107   pp_cxx_identifier (cxx_pp, opstring);
2108   dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2109   if (flags & TFF_EXPR_IN_PARENS)
2110     pp_cxx_right_paren (cxx_pp);
2111 }
2112
2113 static void
2114 reinit_cxx_pp (void)
2115 {
2116   pp_clear_output_area (cxx_pp);
2117   pp_base (cxx_pp)->padding = pp_none;
2118   pp_indentation (cxx_pp) = 0;
2119   pp_needs_newline (cxx_pp) = false;
2120   cxx_pp->enclosing_scope = current_function_decl;
2121 }
2122
2123
2124 /* Exported interface to stringifying types, exprs and decls under TFF_*
2125    control.  */
2126
2127 const char *
2128 type_as_string (tree typ, int flags)
2129 {
2130   reinit_cxx_pp ();
2131   dump_type (typ, flags);
2132   return pp_formatted_text (cxx_pp);
2133 }
2134
2135 const char *
2136 expr_as_string (tree decl, int flags)
2137 {
2138   reinit_cxx_pp ();
2139   dump_expr (decl, flags);
2140   return pp_formatted_text (cxx_pp);
2141 }
2142
2143 const char *
2144 decl_as_string (tree decl, int flags)
2145 {
2146   reinit_cxx_pp ();
2147   dump_decl (decl, flags);
2148   return pp_formatted_text (cxx_pp);
2149 }
2150
2151 /* Generate the three forms of printable names for cxx_printable_name.  */
2152
2153 const char *
2154 lang_decl_name (tree decl, int v)
2155 {
2156   if (v >= 2)
2157     return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2158
2159   reinit_cxx_pp ();
2160   if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2161     {
2162       dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2163       pp_cxx_colon_colon (cxx_pp);
2164     }
2165
2166   if (TREE_CODE (decl) == FUNCTION_DECL)
2167     dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2168   else
2169     dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2170
2171   return pp_formatted_text (cxx_pp);
2172 }
2173
2174 /* Return the location of a tree passed to %+ formats.  */
2175
2176 static location_t
2177 location_of (tree t)
2178 {
2179   if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2180     t = DECL_CONTEXT (t);
2181   else if (TYPE_P (t))
2182     t = TYPE_MAIN_DECL (t);
2183   else if (TREE_CODE (t) == OVERLOAD)
2184     t = OVL_FUNCTION (t);
2185
2186   return DECL_SOURCE_LOCATION (t);
2187 }
2188
2189 /* Now the interfaces from error et al to dump_type et al. Each takes an
2190    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2191    function.  */
2192
2193 static const char *
2194 decl_to_string (tree decl, int verbose)
2195 {
2196   int flags = 0;
2197
2198   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2199       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2200     flags = TFF_CLASS_KEY_OR_ENUM;
2201   if (verbose)
2202     flags |= TFF_DECL_SPECIFIERS;
2203   else if (TREE_CODE (decl) == FUNCTION_DECL)
2204     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2205   flags |= TFF_TEMPLATE_HEADER;
2206
2207   reinit_cxx_pp ();
2208   dump_decl (decl, flags);
2209   return pp_formatted_text (cxx_pp);
2210 }
2211
2212 static const char *
2213 expr_to_string (tree decl)
2214 {
2215   reinit_cxx_pp ();
2216   dump_expr (decl, 0);
2217   return pp_formatted_text (cxx_pp);
2218 }
2219
2220 static const char *
2221 fndecl_to_string (tree fndecl, int verbose)
2222 {
2223   int flags;
2224
2225   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2226     | TFF_TEMPLATE_HEADER;
2227   if (verbose)
2228     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2229   reinit_cxx_pp ();
2230   dump_decl (fndecl, flags);
2231   return pp_formatted_text (cxx_pp);
2232 }
2233
2234
2235 static const char *
2236 code_to_string (enum tree_code c)
2237 {
2238   return tree_code_name [c];
2239 }
2240
2241 const char *
2242 language_to_string (enum languages c)
2243 {
2244   switch (c)
2245     {
2246     case lang_c:
2247       return "C";
2248
2249     case lang_cplusplus:
2250       return "C++";
2251
2252     case lang_java:
2253       return "Java";
2254
2255     default:
2256       gcc_unreachable ();
2257     }
2258   return NULL;
2259 }
2260
2261 /* Return the proper printed version of a parameter to a C++ function.  */
2262
2263 static const char *
2264 parm_to_string (int p)
2265 {
2266   reinit_cxx_pp ();
2267   if (p < 0)
2268     pp_string (cxx_pp, "'this'");
2269   else
2270     pp_decimal_int (cxx_pp, p + 1);
2271   return pp_formatted_text (cxx_pp);
2272 }
2273
2274 static const char *
2275 op_to_string (enum tree_code p)
2276 {
2277   tree id = operator_name_info[(int) p].identifier;
2278   return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2279 }
2280
2281 static const char *
2282 type_to_string (tree typ, int verbose)
2283 {
2284   int flags = 0;
2285   if (verbose)
2286     flags |= TFF_CLASS_KEY_OR_ENUM;
2287   flags |= TFF_TEMPLATE_HEADER;
2288
2289   reinit_cxx_pp ();
2290   dump_type (typ, flags);
2291   return pp_formatted_text (cxx_pp);
2292 }
2293
2294 static const char *
2295 assop_to_string (enum tree_code p)
2296 {
2297   tree id = assignment_operator_name_info[(int) p].identifier;
2298   return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2299 }
2300
2301 static const char *
2302 args_to_string (tree p, int verbose)
2303 {
2304   int flags = 0;
2305   if (verbose)
2306     flags |= TFF_CLASS_KEY_OR_ENUM;
2307
2308   if (p == NULL_TREE)
2309     return "";
2310
2311   if (TYPE_P (TREE_VALUE (p)))
2312     return type_as_string (p, flags);
2313
2314   reinit_cxx_pp ();
2315   for (; p; p = TREE_CHAIN (p))
2316     {
2317       if (TREE_VALUE (p) == null_node)
2318         pp_cxx_identifier (cxx_pp, "NULL");
2319       else
2320         dump_type (error_type (TREE_VALUE (p)), flags);
2321       if (TREE_CHAIN (p))
2322         pp_separate_with_comma (cxx_pp);
2323     }
2324   return pp_formatted_text (cxx_pp);
2325 }
2326
2327 static const char *
2328 cv_to_string (tree p, int v)
2329 {
2330   reinit_cxx_pp ();
2331   pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2332   pp_cxx_cv_qualifier_seq (cxx_pp, p);
2333   return pp_formatted_text (cxx_pp);
2334 }
2335
2336 /* Langhook for print_error_function.  */
2337 void
2338 cxx_print_error_function (diagnostic_context *context, const char *file,
2339                           diagnostic_info *diagnostic)
2340 {
2341   lhd_print_error_function (context, file, diagnostic);
2342   pp_base_set_prefix (context->printer, file);
2343   maybe_print_instantiation_context (context);
2344 }
2345
2346 static void
2347 cp_diagnostic_starter (diagnostic_context *context,
2348                        diagnostic_info *diagnostic)
2349 {
2350   diagnostic_report_current_module (context);
2351   cp_print_error_function (context, diagnostic);
2352   maybe_print_instantiation_context (context);
2353   pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2354 }
2355
2356 static void
2357 cp_diagnostic_finalizer (diagnostic_context *context,
2358                          diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2359 {
2360   pp_base_destroy_prefix (context->printer);
2361 }
2362
2363 /* Print current function onto BUFFER, in the process of reporting
2364    a diagnostic message.  Called from cp_diagnostic_starter.  */
2365 static void
2366 cp_print_error_function (diagnostic_context *context,
2367                          diagnostic_info *diagnostic)
2368 {
2369   if (diagnostic_last_function_changed (context, diagnostic))
2370     {
2371       const char *old_prefix = context->printer->prefix;
2372       const char *file = LOCATION_FILE (diagnostic->location);
2373       tree abstract_origin = diagnostic->abstract_origin;
2374       char *new_prefix = (file && abstract_origin == NULL)
2375                          ? file_name_as_prefix (file) : NULL;
2376
2377       pp_base_set_prefix (context->printer, new_prefix);
2378
2379       if (current_function_decl == NULL)
2380         pp_base_string (context->printer, "At global scope:");
2381       else
2382         {
2383           tree fndecl, ao;
2384
2385           if (abstract_origin)
2386             {
2387               ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2388               while (TREE_CODE (ao) == BLOCK && BLOCK_ABSTRACT_ORIGIN (ao))
2389                 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2390               gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2391               fndecl = ao;
2392             }
2393           else
2394             fndecl = current_function_decl;
2395
2396           pp_printf (context->printer, "In %s %qs",
2397                      function_category (fndecl),
2398                      cxx_printable_name (fndecl, 2));
2399
2400           while (abstract_origin)
2401             {
2402               location_t *locus;
2403               tree block = abstract_origin;
2404
2405               locus = &BLOCK_SOURCE_LOCATION (block);
2406               fndecl = NULL;
2407               block = BLOCK_SUPERCONTEXT (block);
2408               while (block && TREE_CODE (block) == BLOCK
2409                      && BLOCK_ABSTRACT_ORIGIN (block))
2410                 {
2411                   ao = BLOCK_ABSTRACT_ORIGIN (block);
2412
2413                   while (TREE_CODE (ao) == BLOCK
2414                          && BLOCK_ABSTRACT_ORIGIN (ao)
2415                          && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2416                     ao = BLOCK_ABSTRACT_ORIGIN (ao);
2417
2418                   if (TREE_CODE (ao) == FUNCTION_DECL)
2419                     {
2420                       fndecl = ao;
2421                       break;
2422                     }
2423                   else if (TREE_CODE (ao) != BLOCK)
2424                     break;
2425
2426                   block = BLOCK_SUPERCONTEXT (block);
2427                 }
2428               if (fndecl)
2429                 abstract_origin = block;
2430               else
2431                 {
2432                   while (block && TREE_CODE (block) == BLOCK)
2433                     block = BLOCK_SUPERCONTEXT (block);
2434
2435                   if (TREE_CODE (block) == FUNCTION_DECL)
2436                     fndecl = block;
2437                   abstract_origin = NULL;
2438                 }
2439               if (fndecl)
2440                 {
2441                   expanded_location s = expand_location (*locus);
2442                   pp_base_character (context->printer, ',');
2443                   pp_base_newline (context->printer);
2444                   if (s.file != NULL)
2445                     {
2446                       if (flag_show_column && s.column != 0)
2447                         pp_printf (context->printer,
2448                                    "    inlined from %qs at %s:%d:%d",
2449                                    cxx_printable_name (fndecl, 2),
2450                                    s.file, s.line, s.column);
2451                       else
2452                         pp_printf (context->printer,
2453                                    "    inlined from %qs at %s:%d",
2454                                    cxx_printable_name (fndecl, 2),
2455                                    s.file, s.line);
2456
2457                     }
2458                   else
2459                     pp_printf (context->printer, "    inlined from %qs",
2460                                cxx_printable_name (fndecl, 2));
2461                 }
2462             }
2463           pp_base_character (context->printer, ':');
2464         }
2465       pp_base_newline (context->printer);
2466
2467       diagnostic_set_last_function (context, diagnostic);
2468       pp_base_destroy_prefix (context->printer);
2469       context->printer->prefix = old_prefix;
2470     }
2471 }
2472
2473 /* Returns a description of FUNCTION using standard terminology.  */
2474 static const char *
2475 function_category (tree fn)
2476 {
2477   if (DECL_FUNCTION_MEMBER_P (fn))
2478     {
2479       if (DECL_STATIC_FUNCTION_P (fn))
2480         return "static member function";
2481       else if (DECL_COPY_CONSTRUCTOR_P (fn))
2482         return "copy constructor";
2483       else if (DECL_CONSTRUCTOR_P (fn))
2484         return "constructor";
2485       else if (DECL_DESTRUCTOR_P (fn))
2486         return "destructor";
2487       else
2488         return "member function";
2489     }
2490   else
2491     return "function";
2492 }
2493
2494 /* Report the full context of a current template instantiation,
2495    onto BUFFER.  */
2496 static void
2497 print_instantiation_full_context (diagnostic_context *context)
2498 {
2499   struct tinst_level *p = current_instantiation ();
2500   location_t location = input_location;
2501
2502   if (p)
2503     {
2504       if (current_function_decl != p->decl
2505           && current_function_decl != NULL_TREE)
2506         /* We can get here during the processing of some synthesized
2507            method.  Then, P->DECL will be the function that's causing
2508            the synthesis.  */
2509         ;
2510       else
2511         {
2512           if (current_function_decl == p->decl)
2513             /* Avoid redundancy with the "In function" line.  */;
2514           else
2515             pp_verbatim (context->printer,
2516                          "%s: In instantiation of %qs:\n",
2517                          LOCATION_FILE (location),
2518                          decl_as_string (p->decl,
2519                                          TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2520
2521           location = p->locus;
2522           p = p->next;
2523         }
2524     }
2525
2526   print_instantiation_partial_context (context, p, location);
2527 }
2528
2529 /* Same as above but less verbose.  */
2530 static void
2531 print_instantiation_partial_context (diagnostic_context *context,
2532                                      struct tinst_level *t, location_t loc)
2533 {
2534   expanded_location xloc;
2535   for (; ; t = t->next)
2536     {
2537       xloc = expand_location (loc);
2538       if (t == NULL)
2539         break;
2540       pp_verbatim (context->printer, "%s:%d:   instantiated from %qs\n",
2541                    xloc.file, xloc.line,
2542                    decl_as_string (t->decl,
2543                                    TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2544       loc = t->locus;
2545     }
2546   pp_verbatim (context->printer, "%s:%d:   instantiated from here",
2547                xloc.file, xloc.line);
2548   pp_base_newline (context->printer);
2549 }
2550
2551 /* Called from cp_thing to print the template context for an error.  */
2552 static void
2553 maybe_print_instantiation_context (diagnostic_context *context)
2554 {
2555   if (!problematic_instantiation_changed () || current_instantiation () == 0)
2556     return;
2557
2558   record_last_problematic_instantiation ();
2559   print_instantiation_full_context (context);
2560 }
2561
2562 /* Report the bare minimum context of a template instantiation.  */
2563 void
2564 print_instantiation_context (void)
2565 {
2566   print_instantiation_partial_context
2567     (global_dc, current_instantiation (), input_location);
2568   diagnostic_flush_buffer (global_dc);
2569 }
2570 \f
2571 /* Called from output_format -- during diagnostic message processing --
2572    to handle C++ specific format specifier with the following meanings:
2573    %A   function argument-list.
2574    %C   tree code.
2575    %D   declaration.
2576    %E   expression.
2577    %F   function declaration.
2578    %L   language as used in extern "lang".
2579    %O   binary operator.
2580    %P   function parameter whose position is indicated by an integer.
2581    %Q   assignment operator.
2582    %T   type.
2583    %V   cv-qualifier.  */
2584 static bool
2585 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2586             int precision, bool wide, bool set_locus, bool verbose)
2587 {
2588   const char *result;
2589   tree t = NULL;
2590 #define next_tree    (t = va_arg (*text->args_ptr, tree))
2591 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
2592 #define next_lang    va_arg (*text->args_ptr, enum languages)
2593 #define next_int     va_arg (*text->args_ptr, int)
2594
2595   if (precision != 0 || wide)
2596     return false;
2597
2598   if (text->locus == NULL)
2599     set_locus = false;
2600
2601   switch (*spec)
2602     {
2603     case 'A': result = args_to_string (next_tree, verbose);     break;
2604     case 'C': result = code_to_string (next_tcode);             break;
2605     case 'D':
2606       {
2607         tree temp = next_tree;
2608         if (DECL_P (temp)
2609             && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2610           {
2611             temp = DECL_DEBUG_EXPR (temp);
2612             if (!DECL_P (temp))
2613               {
2614                 result = expr_to_string (temp);
2615                 break;
2616               }
2617           }
2618         result = decl_to_string (temp, verbose);
2619       }
2620       break;
2621     case 'E': result = expr_to_string (next_tree);              break;
2622     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
2623     case 'L': result = language_to_string (next_lang);          break;
2624     case 'O': result = op_to_string (next_tcode);               break;
2625     case 'P': result = parm_to_string (next_int);               break;
2626     case 'Q': result = assop_to_string (next_tcode);            break;
2627     case 'T': result = type_to_string (next_tree, verbose);     break;
2628     case 'V': result = cv_to_string (next_tree, verbose);       break;
2629
2630     default:
2631       return false;
2632     }
2633
2634   pp_base_string (pp, result);
2635   if (set_locus && t != NULL)
2636     *text->locus = location_of (t);
2637   return true;
2638 #undef next_tree
2639 #undef next_tcode
2640 #undef next_lang
2641 #undef next_int
2642 }
2643 \f
2644 /* Callback from cpp_error for PFILE to print diagnostics arising from
2645    interpreting strings.  The diagnostic is of type LEVEL; MSG is the
2646    translated message and AP the arguments.  */
2647
2648 void
2649 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2650               const char *msg, va_list *ap)
2651 {
2652   diagnostic_info diagnostic;
2653   diagnostic_t dlevel;
2654   switch (level)
2655     {
2656     case CPP_DL_WARNING:
2657     case CPP_DL_WARNING_SYSHDR:
2658       dlevel = DK_WARNING;
2659       break;
2660     case CPP_DL_PEDWARN:
2661       dlevel = pedantic_warning_kind ();
2662       break;
2663     case CPP_DL_ERROR:
2664       dlevel = DK_ERROR;
2665       break;
2666     case CPP_DL_ICE:
2667       dlevel = DK_ICE;
2668       break;
2669     default:
2670       gcc_unreachable ();
2671     }
2672   diagnostic_set_info_translated (&diagnostic, msg, ap,
2673                                   input_location, dlevel);
2674   report_diagnostic (&diagnostic);
2675 }
2676
2677 /* Warn about the use of variadic templates when appropriate.  */
2678 void
2679 maybe_warn_variadic_templates (void)
2680 {
2681   if ((cxx_dialect == cxx98) && !in_system_header)
2682     /* We really want to suppress this warning in system headers,
2683        because libstdc++ uses variadic templates even when we aren't
2684        in C++0x mode. */
2685     pedwarn ("ISO C++ does not include variadic templates");
2686 }