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