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