gcc/cp/error.c

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