gcc/cp/error.c

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