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