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