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