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     case UNORDERED_EXPR:
2052     case ORDERED_EXPR:
2053     case UNLT_EXPR:
2054     case UNLE_EXPR:
2055     case UNGT_EXPR:
2056     case UNGE_EXPR:
2057     case UNEQ_EXPR:
2058     case LTGT_EXPR:
2059       pp_expression (cxx_pp, t);
2060       break;
2061
2062     case TRUTH_AND_EXPR:
2063     case TRUTH_OR_EXPR:
2064     case TRUTH_XOR_EXPR:
2065       if (flags & TFF_EXPR_IN_PARENS)
2066         pp_cxx_left_paren (cxx_pp);
2067       pp_expression (cxx_pp, t);
2068       if (flags & TFF_EXPR_IN_PARENS)
2069         pp_cxx_right_paren (cxx_pp);
2070       break;
2071
2072     case OBJ_TYPE_REF:
2073       dump_expr (resolve_virtual_fun_from_obj_type_ref (t), flags);
2074       break;
2075
2076       /*  This list is incomplete, but should suffice for now.
2077           It is very important that `sorry' does not call
2078           `report_error_function'.  That could cause an infinite loop.  */
2079     default:
2080       pp_unsupported_tree (cxx_pp, t);
2081       /* fall through to ERROR_MARK...  */
2082     case ERROR_MARK:
2083       pp_identifier (cxx_pp, "<expression error>");
2084       break;
2085     }
2086 }
2087
2088 static void
2089 dump_binary_op (const char *opstring, tree t, int flags)
2090 {
2091   pp_cxx_left_paren (cxx_pp);
2092   dump_expr (TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2093   pp_cxx_whitespace (cxx_pp);
2094   if (opstring)
2095     pp_cxx_identifier (cxx_pp, opstring);
2096   else
2097     pp_identifier (cxx_pp, "<unknown operator>");
2098   pp_cxx_whitespace (cxx_pp);
2099   dump_expr (TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2100   pp_cxx_right_paren (cxx_pp);
2101 }
2102
2103 static void
2104 dump_unary_op (const char *opstring, tree t, int flags)
2105 {
2106   if (flags & TFF_EXPR_IN_PARENS)
2107     pp_cxx_left_paren (cxx_pp);
2108   pp_cxx_identifier (cxx_pp, opstring);
2109   dump_expr (TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2110   if (flags & TFF_EXPR_IN_PARENS)
2111     pp_cxx_right_paren (cxx_pp);
2112 }
2113
2114 static void
2115 reinit_cxx_pp (void)
2116 {
2117   pp_clear_output_area (cxx_pp);
2118   pp_base (cxx_pp)->padding = pp_none;
2119   pp_indentation (cxx_pp) = 0;
2120   pp_needs_newline (cxx_pp) = false;
2121   cxx_pp->enclosing_scope = current_function_decl;
2122 }
2123
2124
2125 /* Exported interface to stringifying types, exprs and decls under TFF_*
2126    control.  */
2127
2128 const char *
2129 type_as_string (tree typ, int flags)
2130 {
2131   reinit_cxx_pp ();
2132   dump_type (typ, flags);
2133   return pp_formatted_text (cxx_pp);
2134 }
2135
2136 const char *
2137 expr_as_string (tree decl, int flags)
2138 {
2139   reinit_cxx_pp ();
2140   dump_expr (decl, flags);
2141   return pp_formatted_text (cxx_pp);
2142 }
2143
2144 const char *
2145 decl_as_string (tree decl, int flags)
2146 {
2147   reinit_cxx_pp ();
2148   dump_decl (decl, flags);
2149   return pp_formatted_text (cxx_pp);
2150 }
2151
2152 /* Generate the three forms of printable names for cxx_printable_name.  */
2153
2154 const char *
2155 lang_decl_name (tree decl, int v)
2156 {
2157   if (v >= 2)
2158     return decl_as_string (decl, TFF_DECL_SPECIFIERS);
2159
2160   reinit_cxx_pp ();
2161   if (v == 1 && DECL_CLASS_SCOPE_P (decl))
2162     {
2163       dump_type (CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2164       pp_cxx_colon_colon (cxx_pp);
2165     }
2166
2167   if (TREE_CODE (decl) == FUNCTION_DECL)
2168     dump_function_name (decl, TFF_PLAIN_IDENTIFIER);
2169   else
2170     dump_decl (DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2171
2172   return pp_formatted_text (cxx_pp);
2173 }
2174
2175 /* Return the location of a tree passed to %+ formats.  */
2176
2177 static location_t
2178 location_of (tree t)
2179 {
2180   if (TREE_CODE (t) == PARM_DECL && DECL_CONTEXT (t))
2181     t = DECL_CONTEXT (t);
2182   else if (TYPE_P (t))
2183     t = TYPE_MAIN_DECL (t);
2184   else if (TREE_CODE (t) == OVERLOAD)
2185     t = OVL_FUNCTION (t);
2186
2187   return DECL_SOURCE_LOCATION (t);
2188 }
2189
2190 /* Now the interfaces from error et al to dump_type et al. Each takes an
2191    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2192    function.  */
2193
2194 static const char *
2195 decl_to_string (tree decl, int verbose)
2196 {
2197   int flags = 0;
2198
2199   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2200       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2201     flags = TFF_CLASS_KEY_OR_ENUM;
2202   if (verbose)
2203     flags |= TFF_DECL_SPECIFIERS;
2204   else if (TREE_CODE (decl) == FUNCTION_DECL)
2205     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2206   flags |= TFF_TEMPLATE_HEADER;
2207
2208   reinit_cxx_pp ();
2209   dump_decl (decl, flags);
2210   return pp_formatted_text (cxx_pp);
2211 }
2212
2213 static const char *
2214 expr_to_string (tree decl)
2215 {
2216   reinit_cxx_pp ();
2217   dump_expr (decl, 0);
2218   return pp_formatted_text (cxx_pp);
2219 }
2220
2221 static const char *
2222 fndecl_to_string (tree fndecl, int verbose)
2223 {
2224   int flags;
2225
2226   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2227     | TFF_TEMPLATE_HEADER;
2228   if (verbose)
2229     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2230   reinit_cxx_pp ();
2231   dump_decl (fndecl, flags);
2232   return pp_formatted_text (cxx_pp);
2233 }
2234
2235
2236 static const char *
2237 code_to_string (enum tree_code c)
2238 {
2239   return tree_code_name [c];
2240 }
2241
2242 const char *
2243 language_to_string (enum languages c)
2244 {
2245   switch (c)
2246     {
2247     case lang_c:
2248       return "C";
2249
2250     case lang_cplusplus:
2251       return "C++";
2252
2253     case lang_java:
2254       return "Java";
2255
2256     default:
2257       gcc_unreachable ();
2258     }
2259   return NULL;
2260 }
2261
2262 /* Return the proper printed version of a parameter to a C++ function.  */
2263
2264 static const char *
2265 parm_to_string (int p)
2266 {
2267   reinit_cxx_pp ();
2268   if (p < 0)
2269     pp_string (cxx_pp, "'this'");
2270   else
2271     pp_decimal_int (cxx_pp, p + 1);
2272   return pp_formatted_text (cxx_pp);
2273 }
2274
2275 static const char *
2276 op_to_string (enum tree_code p)
2277 {
2278   tree id = operator_name_info[(int) p].identifier;
2279   return id ? IDENTIFIER_POINTER (id) : "<unknown>";
2280 }
2281
2282 static const char *
2283 type_to_string (tree typ, int verbose)
2284 {
2285   int flags = 0;
2286   if (verbose)
2287     flags |= TFF_CLASS_KEY_OR_ENUM;
2288   flags |= TFF_TEMPLATE_HEADER;
2289
2290   reinit_cxx_pp ();
2291   dump_type (typ, flags);
2292   return pp_formatted_text (cxx_pp);
2293 }
2294
2295 static const char *
2296 assop_to_string (enum tree_code p)
2297 {
2298   tree id = assignment_operator_name_info[(int) p].identifier;
2299   return id ? IDENTIFIER_POINTER (id) : "{unknown}";
2300 }
2301
2302 static const char *
2303 args_to_string (tree p, int verbose)
2304 {
2305   int flags = 0;
2306   if (verbose)
2307     flags |= TFF_CLASS_KEY_OR_ENUM;
2308
2309   if (p == NULL_TREE)
2310     return "";
2311
2312   if (TYPE_P (TREE_VALUE (p)))
2313     return type_as_string (p, flags);
2314
2315   reinit_cxx_pp ();
2316   for (; p; p = TREE_CHAIN (p))
2317     {
2318       if (TREE_VALUE (p) == null_node)
2319         pp_cxx_identifier (cxx_pp, "NULL");
2320       else
2321         dump_type (error_type (TREE_VALUE (p)), flags);
2322       if (TREE_CHAIN (p))
2323         pp_separate_with_comma (cxx_pp);
2324     }
2325   return pp_formatted_text (cxx_pp);
2326 }
2327
2328 static const char *
2329 cv_to_string (tree p, int v)
2330 {
2331   reinit_cxx_pp ();
2332   pp_base (cxx_pp)->padding = v ? pp_before : pp_none;
2333   pp_cxx_cv_qualifier_seq (cxx_pp, p);
2334   return pp_formatted_text (cxx_pp);
2335 }
2336
2337 /* Langhook for print_error_function.  */
2338 void
2339 cxx_print_error_function (diagnostic_context *context, const char *file,
2340                           diagnostic_info *diagnostic)
2341 {
2342   lhd_print_error_function (context, file, diagnostic);
2343   pp_base_set_prefix (context->printer, file);
2344   maybe_print_instantiation_context (context);
2345 }
2346
2347 static void
2348 cp_diagnostic_starter (diagnostic_context *context,
2349                        diagnostic_info *diagnostic)
2350 {
2351   diagnostic_report_current_module (context);
2352   cp_print_error_function (context, diagnostic);
2353   maybe_print_instantiation_context (context);
2354   pp_base_set_prefix (context->printer, diagnostic_build_prefix (diagnostic));
2355 }
2356
2357 static void
2358 cp_diagnostic_finalizer (diagnostic_context *context,
2359                          diagnostic_info *diagnostic ATTRIBUTE_UNUSED)
2360 {
2361   pp_base_destroy_prefix (context->printer);
2362 }
2363
2364 /* Print current function onto BUFFER, in the process of reporting
2365    a diagnostic message.  Called from cp_diagnostic_starter.  */
2366 static void
2367 cp_print_error_function (diagnostic_context *context,
2368                          diagnostic_info *diagnostic)
2369 {
2370   if (diagnostic_last_function_changed (context, diagnostic))
2371     {
2372       const char *old_prefix = context->printer->prefix;
2373       const char *file = LOCATION_FILE (diagnostic->location);
2374       tree abstract_origin = diagnostic->abstract_origin;
2375       char *new_prefix = (file && abstract_origin == NULL)
2376                          ? file_name_as_prefix (file) : NULL;
2377
2378       pp_base_set_prefix (context->printer, new_prefix);
2379
2380       if (current_function_decl == NULL)
2381         pp_base_string (context->printer, "At global scope:");
2382       else
2383         {
2384           tree fndecl, ao;
2385
2386           if (abstract_origin)
2387             {
2388               ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
2389               while (TREE_CODE (ao) == BLOCK && BLOCK_ABSTRACT_ORIGIN (ao))
2390                 ao = BLOCK_ABSTRACT_ORIGIN (ao);
2391               gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
2392               fndecl = ao;
2393             }
2394           else
2395             fndecl = current_function_decl;
2396
2397           pp_printf (context->printer, "In %s %qs",
2398                      function_category (fndecl),
2399                      cxx_printable_name (fndecl, 2));
2400
2401           while (abstract_origin)
2402             {
2403               location_t *locus;
2404               tree block = abstract_origin;
2405
2406               locus = &BLOCK_SOURCE_LOCATION (block);
2407               fndecl = NULL;
2408               block = BLOCK_SUPERCONTEXT (block);
2409               while (block && TREE_CODE (block) == BLOCK
2410                      && BLOCK_ABSTRACT_ORIGIN (block))
2411                 {
2412                   ao = BLOCK_ABSTRACT_ORIGIN (block);
2413
2414                   while (TREE_CODE (ao) == BLOCK
2415                          && BLOCK_ABSTRACT_ORIGIN (ao)
2416                          && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
2417                     ao = BLOCK_ABSTRACT_ORIGIN (ao);
2418
2419                   if (TREE_CODE (ao) == FUNCTION_DECL)
2420                     {
2421                       fndecl = ao;
2422                       break;
2423                     }
2424                   else if (TREE_CODE (ao) != BLOCK)
2425                     break;
2426
2427                   block = BLOCK_SUPERCONTEXT (block);
2428                 }
2429               if (fndecl)
2430                 abstract_origin = block;
2431               else
2432                 {
2433                   while (block && TREE_CODE (block) == BLOCK)
2434                     block = BLOCK_SUPERCONTEXT (block);
2435
2436                   if (TREE_CODE (block) == FUNCTION_DECL)
2437                     fndecl = block;
2438                   abstract_origin = NULL;
2439                 }
2440               if (fndecl)
2441                 {
2442                   expanded_location s = expand_location (*locus);
2443                   pp_base_character (context->printer, ',');
2444                   pp_base_newline (context->printer);
2445                   if (s.file != NULL)
2446                     {
2447                       if (flag_show_column && s.column != 0)
2448                         pp_printf (context->printer,
2449                                    "    inlined from %qs at %s:%d:%d",
2450                                    cxx_printable_name (fndecl, 2),
2451                                    s.file, s.line, s.column);
2452                       else
2453                         pp_printf (context->printer,
2454                                    "    inlined from %qs at %s:%d",
2455                                    cxx_printable_name (fndecl, 2),
2456                                    s.file, s.line);
2457
2458                     }
2459                   else
2460                     pp_printf (context->printer, "    inlined from %qs",
2461                                cxx_printable_name (fndecl, 2));
2462                 }
2463             }
2464           pp_base_character (context->printer, ':');
2465         }
2466       pp_base_newline (context->printer);
2467
2468       diagnostic_set_last_function (context, diagnostic);
2469       pp_base_destroy_prefix (context->printer);
2470       context->printer->prefix = old_prefix;
2471     }
2472 }
2473
2474 /* Returns a description of FUNCTION using standard terminology.  */
2475 static const char *
2476 function_category (tree fn)
2477 {
2478   if (DECL_FUNCTION_MEMBER_P (fn))
2479     {
2480       if (DECL_STATIC_FUNCTION_P (fn))
2481         return "static member function";
2482       else if (DECL_COPY_CONSTRUCTOR_P (fn))
2483         return "copy constructor";
2484       else if (DECL_CONSTRUCTOR_P (fn))
2485         return "constructor";
2486       else if (DECL_DESTRUCTOR_P (fn))
2487         return "destructor";
2488       else
2489         return "member function";
2490     }
2491   else
2492     return "function";
2493 }
2494
2495 /* Report the full context of a current template instantiation,
2496    onto BUFFER.  */
2497 static void
2498 print_instantiation_full_context (diagnostic_context *context)
2499 {
2500   struct tinst_level *p = current_instantiation ();
2501   location_t location = input_location;
2502
2503   if (p)
2504     {
2505       if (current_function_decl != p->decl
2506           && current_function_decl != NULL_TREE)
2507         /* We can get here during the processing of some synthesized
2508            method.  Then, P->DECL will be the function that's causing
2509            the synthesis.  */
2510         ;
2511       else
2512         {
2513           if (current_function_decl == p->decl)
2514             /* Avoid redundancy with the "In function" line.  */;
2515           else
2516             pp_verbatim (context->printer,
2517                          "%s: In instantiation of %qs:\n",
2518                          LOCATION_FILE (location),
2519                          decl_as_string (p->decl,
2520                                          TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2521
2522           location = p->locus;
2523           p = p->next;
2524         }
2525     }
2526
2527   print_instantiation_partial_context (context, p, location);
2528 }
2529
2530 /* Same as above but less verbose.  */
2531 static void
2532 print_instantiation_partial_context (diagnostic_context *context,
2533                                      struct tinst_level *t, location_t loc)
2534 {
2535   expanded_location xloc;
2536   for (; ; t = t->next)
2537     {
2538       xloc = expand_location (loc);
2539       if (t == NULL)
2540         break;
2541       pp_verbatim (context->printer, "%s:%d:   instantiated from %qs\n",
2542                    xloc.file, xloc.line,
2543                    decl_as_string (t->decl,
2544                                    TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE));
2545       loc = t->locus;
2546     }
2547   pp_verbatim (context->printer, "%s:%d:   instantiated from here",
2548                xloc.file, xloc.line);
2549   pp_base_newline (context->printer);
2550 }
2551
2552 /* Called from cp_thing to print the template context for an error.  */
2553 static void
2554 maybe_print_instantiation_context (diagnostic_context *context)
2555 {
2556   if (!problematic_instantiation_changed () || current_instantiation () == 0)
2557     return;
2558
2559   record_last_problematic_instantiation ();
2560   print_instantiation_full_context (context);
2561 }
2562
2563 /* Report the bare minimum context of a template instantiation.  */
2564 void
2565 print_instantiation_context (void)
2566 {
2567   print_instantiation_partial_context
2568     (global_dc, current_instantiation (), input_location);
2569   diagnostic_flush_buffer (global_dc);
2570 }
2571 \f
2572 /* Called from output_format -- during diagnostic message processing --
2573    to handle C++ specific format specifier with the following meanings:
2574    %A   function argument-list.
2575    %C   tree code.
2576    %D   declaration.
2577    %E   expression.
2578    %F   function declaration.
2579    %L   language as used in extern "lang".
2580    %O   binary operator.
2581    %P   function parameter whose position is indicated by an integer.
2582    %Q   assignment operator.
2583    %T   type.
2584    %V   cv-qualifier.  */
2585 static bool
2586 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
2587             int precision, bool wide, bool set_locus, bool verbose)
2588 {
2589   const char *result;
2590   tree t = NULL;
2591 #define next_tree    (t = va_arg (*text->args_ptr, tree))
2592 #define next_tcode   va_arg (*text->args_ptr, enum tree_code)
2593 #define next_lang    va_arg (*text->args_ptr, enum languages)
2594 #define next_int     va_arg (*text->args_ptr, int)
2595
2596   if (precision != 0 || wide)
2597     return false;
2598
2599   if (text->locus == NULL)
2600     set_locus = false;
2601
2602   switch (*spec)
2603     {
2604     case 'A': result = args_to_string (next_tree, verbose);     break;
2605     case 'C': result = code_to_string (next_tcode);             break;
2606     case 'D':
2607       {
2608         tree temp = next_tree;
2609         if (DECL_P (temp)
2610             && DECL_DEBUG_EXPR_IS_FROM (temp) && DECL_DEBUG_EXPR (temp))
2611           {
2612             temp = DECL_DEBUG_EXPR (temp);
2613             if (!DECL_P (temp))
2614               {
2615                 result = expr_to_string (temp);
2616                 break;
2617               }
2618           }
2619         result = decl_to_string (temp, verbose);
2620       }
2621       break;
2622     case 'E': result = expr_to_string (next_tree);              break;
2623     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
2624     case 'L': result = language_to_string (next_lang);          break;
2625     case 'O': result = op_to_string (next_tcode);               break;
2626     case 'P': result = parm_to_string (next_int);               break;
2627     case 'Q': result = assop_to_string (next_tcode);            break;
2628     case 'T': result = type_to_string (next_tree, verbose);     break;
2629     case 'V': result = cv_to_string (next_tree, verbose);       break;
2630
2631     default:
2632       return false;
2633     }
2634
2635   pp_base_string (pp, result);
2636   if (set_locus && t != NULL)
2637     *text->locus = location_of (t);
2638   return true;
2639 #undef next_tree
2640 #undef next_tcode
2641 #undef next_lang
2642 #undef next_int
2643 }
2644 \f
2645 /* Callback from cpp_error for PFILE to print diagnostics arising from
2646    interpreting strings.  The diagnostic is of type LEVEL; MSG is the
2647    translated message and AP the arguments.  */
2648
2649 void
2650 cp_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
2651               const char *msg, va_list *ap)
2652 {
2653   diagnostic_info diagnostic;
2654   diagnostic_t dlevel;
2655   switch (level)
2656     {
2657     case CPP_DL_WARNING:
2658     case CPP_DL_WARNING_SYSHDR:
2659       dlevel = DK_WARNING;
2660       break;
2661     case CPP_DL_PEDWARN:
2662       dlevel = pedantic_warning_kind ();
2663       break;
2664     case CPP_DL_ERROR:
2665       dlevel = DK_ERROR;
2666       break;
2667     case CPP_DL_ICE:
2668       dlevel = DK_ICE;
2669       break;
2670     default:
2671       gcc_unreachable ();
2672     }
2673   diagnostic_set_info_translated (&diagnostic, msg, ap,
2674                                   input_location, dlevel);
2675   report_diagnostic (&diagnostic);
2676 }
2677
2678 /* Warn about the use of variadic templates when appropriate.  */
2679 void
2680 maybe_warn_variadic_templates (void)
2681 {
2682   if ((cxx_dialect == cxx98) && !in_system_header)
2683     /* We really want to suppress this warning in system headers,
2684        because libstdc++ uses variadic templates even when we aren't
2685        in C++0x mode. */
2686     pedwarn ("ISO C++ does not include variadic templates");
2687 }