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