gcc/cp/error.c

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