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