gcc/cp/error.c

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