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