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