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