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
1490   flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME);
1491   if (TREE_CODE (t) == TEMPLATE_DECL)
1492     t = DECL_TEMPLATE_RESULT (t);
1493
1494   /* Save the exceptions, in case t is a specialization and we are
1495      emitting an error about incompatible specifications.  */
1496   exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1497
1498   /* Pretty print template instantiations only.  */
1499   if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1500       && flag_pretty_templates)
1501     {
1502       tree tmpl;
1503
1504       template_args = DECL_TI_ARGS (t);
1505       tmpl = most_general_template (t);
1506       if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1507         {
1508           template_parms = DECL_TEMPLATE_PARMS (tmpl);
1509           t = tmpl;
1510         }
1511     }
1512
1513   if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1514     return dump_lambda_function (pp, t, template_parms, template_args, flags);
1515
1516   fntype = TREE_TYPE (t);
1517   parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1518
1519   if (DECL_CLASS_SCOPE_P (t))
1520     cname = DECL_CONTEXT (t);
1521   /* This is for partially instantiated template methods.  */
1522   else if (TREE_CODE (fntype) == METHOD_TYPE)
1523     cname = TREE_TYPE (TREE_VALUE (parmtypes));
1524
1525   if (flags & TFF_DECL_SPECIFIERS)
1526     {
1527       if (DECL_STATIC_FUNCTION_P (t))
1528         pp_cxx_ws_string (pp, "static");
1529       else if (DECL_VIRTUAL_P (t))
1530         pp_cxx_ws_string (pp, "virtual");
1531
1532       if (DECL_DECLARED_CONSTEXPR_P (t))
1533         pp_cxx_ws_string (pp, "constexpr");
1534     }
1535
1536   /* Print the return type?  */
1537   if (show_return)
1538     show_return = !DECL_CONV_FN_P (t)  && !DECL_CONSTRUCTOR_P (t)
1539                   && !DECL_DESTRUCTOR_P (t);
1540   if (show_return)
1541     {
1542       tree ret = fndecl_declared_return_type (t);
1543       dump_type_prefix (pp, ret, flags);
1544     }
1545
1546   /* Print the function name.  */
1547   if (!do_outer_scope)
1548     /* Nothing.  */;
1549   else if (cname)
1550     {
1551       dump_type (pp, cname, flags);
1552       pp_cxx_colon_colon (pp);
1553     }
1554   else
1555     dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1556
1557   dump_function_name (pp, t, flags);
1558
1559   if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1560     {
1561       dump_parameters (pp, parmtypes, flags);
1562
1563       if (TREE_CODE (fntype) == METHOD_TYPE)
1564         {
1565           pp->padding = pp_before;
1566           pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype));
1567           dump_ref_qualifier (pp, fntype, flags);
1568         }
1569
1570       if (tx_safe_fn_type_p (fntype))
1571         {
1572           pp->padding = pp_before;
1573           pp_cxx_ws_string (pp, "transaction_safe");
1574         }
1575
1576       if (flags & TFF_EXCEPTION_SPECIFICATION)
1577         {
1578           pp->padding = pp_before;
1579           dump_exception_spec (pp, exceptions, flags);
1580         }
1581
1582       if (show_return)
1583         dump_type_suffix (pp, TREE_TYPE (fntype), flags);
1584
1585       if (flag_concepts)
1586         if (tree ci = get_constraints (t))
1587           if (tree reqs = CI_DECLARATOR_REQS (ci))
1588             pp_cxx_requires_clause (pp, reqs);
1589
1590       dump_substitution (pp, t, template_parms, template_args, flags);
1591     }
1592   else if (template_args)
1593     {
1594       bool need_comma = false;
1595       int i;
1596       pp_cxx_begin_template_argument_list (pp);
1597       template_args = INNERMOST_TEMPLATE_ARGS (template_args);
1598       for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
1599         {
1600           tree arg = TREE_VEC_ELT (template_args, i);
1601           if (need_comma)
1602             pp_separate_with_comma (pp);
1603           if (ARGUMENT_PACK_P (arg))
1604             pp_cxx_left_brace (pp);
1605           dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
1606           if (ARGUMENT_PACK_P (arg))
1607             pp_cxx_right_brace (pp);
1608           need_comma = true;
1609         }
1610       pp_cxx_end_template_argument_list (pp);
1611     }
1612 }
1613
1614 /* Print a parameter list. If this is for a member function, the
1615    member object ptr (and any other hidden args) should have
1616    already been removed.  */
1617
1618 static void
1619 dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags)
1620 {
1621   int first = 1;
1622   flags &= ~TFF_SCOPE;
1623   pp_cxx_left_paren (pp);
1624
1625   for (first = 1; parmtypes != void_list_node;
1626        parmtypes = TREE_CHAIN (parmtypes))
1627     {
1628       if (!first)
1629         pp_separate_with_comma (pp);
1630       first = 0;
1631       if (!parmtypes)
1632         {
1633           pp_cxx_ws_string (pp, "...");
1634           break;
1635         }
1636
1637       dump_type (pp, TREE_VALUE (parmtypes), flags);
1638
1639       if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1640         {
1641           pp_cxx_whitespace (pp);
1642           pp_equal (pp);
1643           pp_cxx_whitespace (pp);
1644           dump_expr (pp, TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1645         }
1646     }
1647
1648   pp_cxx_right_paren (pp);
1649 }
1650
1651 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1652
1653 static void
1654 dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED)
1655 {
1656   if (FUNCTION_REF_QUALIFIED (t))
1657     {
1658       pp->padding = pp_before;
1659       if (FUNCTION_RVALUE_QUALIFIED (t))
1660         pp_cxx_ws_string (pp, "&&");
1661       else
1662         pp_cxx_ws_string (pp, "&");
1663     }
1664 }
1665
1666 /* Print an exception specification. T is the exception specification.  */
1667
1668 static void
1669 dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags)
1670 {
1671   if (t && TREE_PURPOSE (t))
1672     {
1673       pp_cxx_ws_string (pp, "noexcept");
1674       if (!integer_onep (TREE_PURPOSE (t)))
1675         {
1676           pp_cxx_whitespace (pp);
1677           pp_cxx_left_paren (pp);
1678           if (DEFERRED_NOEXCEPT_SPEC_P (t))
1679             pp_cxx_ws_string (pp, "<uninstantiated>");
1680           else
1681             dump_expr (pp, TREE_PURPOSE (t), flags);
1682           pp_cxx_right_paren (pp);
1683         }
1684     }
1685   else if (t)
1686     {
1687       pp_cxx_ws_string (pp, "throw");
1688       pp_cxx_whitespace (pp);
1689       pp_cxx_left_paren (pp);
1690       if (TREE_VALUE (t) != NULL_TREE)
1691         while (1)
1692           {
1693             dump_type (pp, TREE_VALUE (t), flags);
1694             t = TREE_CHAIN (t);
1695             if (!t)
1696               break;
1697             pp_separate_with_comma (pp);
1698           }
1699       pp_cxx_right_paren (pp);
1700     }
1701 }
1702
1703 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1704    and destructors properly.  */
1705
1706 static void
1707 dump_function_name (cxx_pretty_printer *pp, tree t, int flags)
1708 {
1709   tree name = DECL_NAME (t);
1710
1711   /* We can get here with a decl that was synthesized by language-
1712      independent machinery (e.g. coverage.c) in which case it won't
1713      have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1714      will crash.  In this case it is safe just to print out the
1715      literal name.  */
1716   if (!DECL_LANG_SPECIFIC (t))
1717     {
1718       pp_cxx_tree_identifier (pp, name);
1719       return;
1720     }
1721
1722   if (TREE_CODE (t) == TEMPLATE_DECL)
1723     t = DECL_TEMPLATE_RESULT (t);
1724
1725   /* Don't let the user see __comp_ctor et al.  */
1726   if (DECL_CONSTRUCTOR_P (t)
1727       || DECL_DESTRUCTOR_P (t))
1728     {
1729       if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1730         name = get_identifier ("<lambda>");
1731       else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t)))
1732         name = get_identifier ("<constructor>");
1733       else
1734         name = constructor_name (DECL_CONTEXT (t));
1735     }
1736
1737   if (DECL_DESTRUCTOR_P (t))
1738     {
1739       pp_cxx_complement (pp);
1740       dump_decl (pp, name, TFF_PLAIN_IDENTIFIER);
1741     }
1742   else if (DECL_CONV_FN_P (t))
1743     {
1744       /* This cannot use the hack that the operator's return
1745          type is stashed off of its name because it may be
1746          used for error reporting.  In the case of conflicting
1747          declarations, both will have the same name, yet
1748          the types will be different, hence the TREE_TYPE field
1749          of the first name will be clobbered by the second.  */
1750       pp_cxx_ws_string (pp, "operator");
1751       dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
1752     }
1753   else if (name && IDENTIFIER_OPNAME_P (name))
1754     pp_cxx_tree_identifier (pp, name);
1755   else if (name && UDLIT_OPER_P (name))
1756     pp_cxx_tree_identifier (pp, name);
1757   else
1758     dump_decl (pp, name, flags);
1759
1760   if (DECL_TEMPLATE_INFO (t)
1761       && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1762       && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1763           || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1764     dump_template_parms (pp, DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t),
1765                          flags);
1766 }
1767
1768 /* Dump the template parameters from the template info INFO under control of
1769    FLAGS. PRIMARY indicates whether this is a primary template decl, or
1770    specialization (partial or complete). For partial specializations we show
1771    the specialized parameter values. For a primary template we show no
1772    decoration.  */
1773
1774 static void
1775 dump_template_parms (cxx_pretty_printer *pp, tree info,
1776                      int primary, int flags)
1777 {
1778   tree args = info ? TI_ARGS (info) : NULL_TREE;
1779
1780   if (primary && flags & TFF_TEMPLATE_NAME)
1781     return;
1782   flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1783   pp_cxx_begin_template_argument_list (pp);
1784
1785   /* Be careful only to print things when we have them, so as not
1786      to crash producing error messages.  */
1787   if (args && !primary)
1788     {
1789       int len, ix;
1790       len = get_non_default_template_args_count (args, flags);
1791
1792       args = INNERMOST_TEMPLATE_ARGS (args);
1793       for (ix = 0; ix != len; ix++)
1794         {
1795           tree arg = TREE_VEC_ELT (args, ix);
1796
1797           /* Only print a comma if we know there is an argument coming. In
1798              the case of an empty template argument pack, no actual
1799              argument will be printed.  */
1800           if (ix
1801               && (!ARGUMENT_PACK_P (arg)
1802                   || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1803             pp_separate_with_comma (pp);
1804
1805           if (!arg)
1806             pp_string (pp, M_("<template parameter error>"));
1807           else
1808             dump_template_argument (pp, arg, flags);
1809         }
1810     }
1811   else if (primary)
1812     {
1813       tree tpl = TI_TEMPLATE (info);
1814       tree parms = DECL_TEMPLATE_PARMS (tpl);
1815       int len, ix;
1816
1817       parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1818       len = parms ? TREE_VEC_LENGTH (parms) : 0;
1819
1820       for (ix = 0; ix != len; ix++)
1821         {
1822           tree parm;
1823
1824           if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1825             {
1826               pp_string (pp, M_("<template parameter error>"));
1827               continue;
1828             }
1829
1830           parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1831
1832           if (ix)
1833             pp_separate_with_comma (pp);
1834
1835           dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS);
1836         }
1837     }
1838   pp_cxx_end_template_argument_list (pp);
1839 }
1840
1841 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1842    flags FLAGS.  Skip over the first argument if SKIPFIRST is true.  */
1843
1844 static void
1845 dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst)
1846 {
1847   tree arg;
1848   call_expr_arg_iterator iter;
1849
1850   pp_cxx_left_paren (pp);
1851   FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1852     {
1853       if (skipfirst)
1854         skipfirst = false;
1855       else
1856         {
1857           dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1858           if (more_call_expr_args_p (&iter))
1859             pp_separate_with_comma (pp);
1860         }
1861     }
1862   pp_cxx_right_paren (pp);
1863 }
1864
1865 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1866    using flags FLAGS.  Skip over the first argument if SKIPFIRST is
1867    true.  */
1868
1869 static void
1870 dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags,
1871                           bool skipfirst)
1872 {
1873   tree arg;
1874   aggr_init_expr_arg_iterator iter;
1875
1876   pp_cxx_left_paren (pp);
1877   FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1878     {
1879       if (skipfirst)
1880         skipfirst = false;
1881       else
1882         {
1883           dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1884           if (more_aggr_init_expr_args_p (&iter))
1885             pp_separate_with_comma (pp);
1886         }
1887     }
1888   pp_cxx_right_paren (pp);
1889 }
1890
1891 /* Print out a list of initializers (subr of dump_expr).  */
1892
1893 static void
1894 dump_expr_list (cxx_pretty_printer *pp, tree l, int flags)
1895 {
1896   while (l)
1897     {
1898       dump_expr (pp, TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1899       l = TREE_CHAIN (l);
1900       if (l)
1901         pp_separate_with_comma (pp);
1902     }
1903 }
1904
1905 /* Print out a vector of initializers (subr of dump_expr).  */
1906
1907 static void
1908 dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v,
1909                     int flags)
1910 {
1911   unsigned HOST_WIDE_INT idx;
1912   tree value;
1913
1914   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1915     {
1916       dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS);
1917       if (idx != v->length () - 1)
1918         pp_separate_with_comma (pp);
1919     }
1920 }
1921
1922
1923 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1924    function.  Resolve it to a close relative -- in the sense of static
1925    type -- variant being overridden.  That is close to what was written in
1926    the source code.  Subroutine of dump_expr.  */
1927
1928 static tree
1929 resolve_virtual_fun_from_obj_type_ref (tree ref)
1930 {
1931   tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1932   HOST_WIDE_INT index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref));
1933   tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1934   while (index)
1935     {
1936       fun = TREE_CHAIN (fun);
1937       index -= (TARGET_VTABLE_USES_DESCRIPTORS
1938                 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1939     }
1940
1941   return BV_FN (fun);
1942 }
1943
1944 /* Print out an expression E under control of FLAGS.  */
1945
1946 static void
1947 dump_expr (cxx_pretty_printer *pp, tree t, int flags)
1948 {
1949   tree op;
1950
1951   if (t == 0)
1952     return;
1953
1954   if (STATEMENT_CLASS_P (t))
1955     {
1956       pp_cxx_ws_string (pp, M_("<statement>"));
1957       return;
1958     }
1959
1960   switch (TREE_CODE (t))
1961     {
1962     case VAR_DECL:
1963     case PARM_DECL:
1964     case FIELD_DECL:
1965     case CONST_DECL:
1966     case FUNCTION_DECL:
1967     case TEMPLATE_DECL:
1968     case NAMESPACE_DECL:
1969     case LABEL_DECL:
1970     case OVERLOAD:
1971     case TYPE_DECL:
1972     case IDENTIFIER_NODE:
1973       dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
1974                                     |TFF_TEMPLATE_HEADER))
1975                          | TFF_NO_FUNCTION_ARGUMENTS));
1976       break;
1977
1978     case SSA_NAME:
1979       if (SSA_NAME_VAR (t)
1980           && !DECL_ARTIFICIAL (SSA_NAME_VAR (t)))
1981         dump_expr (pp, SSA_NAME_VAR (t), flags);
1982       else
1983         pp_cxx_ws_string (pp, M_("<unknown>"));
1984       break;
1985
1986     case VOID_CST:
1987     case INTEGER_CST:
1988     case REAL_CST:
1989     case STRING_CST:
1990     case COMPLEX_CST:
1991       pp->constant (t);
1992       break;
1993
1994     case USERDEF_LITERAL:
1995       pp_cxx_userdef_literal (pp, t);
1996       break;
1997
1998     case THROW_EXPR:
1999       /* While waiting for caret diagnostics, avoid printing
2000          __cxa_allocate_exception, __cxa_throw, and the like.  */
2001       pp_cxx_ws_string (pp, M_("<throw-expression>"));
2002       break;
2003
2004     case PTRMEM_CST:
2005       pp_ampersand (pp);
2006       dump_type (pp, PTRMEM_CST_CLASS (t), flags);
2007       pp_cxx_colon_colon (pp);
2008       pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
2009       break;
2010
2011     case COMPOUND_EXPR:
2012       pp_cxx_left_paren (pp);
2013       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2014       pp_separate_with_comma (pp);
2015       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2016       pp_cxx_right_paren (pp);
2017       break;
2018
2019     case COND_EXPR:
2020       pp_cxx_left_paren (pp);
2021       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2022       pp_string (pp, " ? ");
2023       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2024       pp_string (pp, " : ");
2025       dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
2026       pp_cxx_right_paren (pp);
2027       break;
2028
2029     case SAVE_EXPR:
2030       if (TREE_HAS_CONSTRUCTOR (t))
2031         {
2032           pp_cxx_ws_string (pp, "new");
2033           pp_cxx_whitespace (pp);
2034           dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
2035         }
2036       else
2037         dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2038       break;
2039
2040     case AGGR_INIT_EXPR:
2041       {
2042         tree fn = NULL_TREE;
2043
2044         if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
2045           fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
2046
2047         if (fn && TREE_CODE (fn) == FUNCTION_DECL)
2048           {
2049             if (DECL_CONSTRUCTOR_P (fn))
2050               dump_type (pp, DECL_CONTEXT (fn), flags);
2051             else
2052               dump_decl (pp, fn, 0);
2053           }
2054         else
2055           dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0);
2056       }
2057       dump_aggr_init_expr_args (pp, t, flags, true);
2058       break;
2059
2060     case CALL_EXPR:
2061       {
2062         tree fn = CALL_EXPR_FN (t);
2063         bool skipfirst = false;
2064
2065         /* Deal with internal functions.  */
2066         if (fn == NULL_TREE)
2067           {
2068             pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t)));
2069             dump_call_expr_args (pp, t, flags, skipfirst);
2070             break;
2071           }
2072
2073         if (TREE_CODE (fn) == ADDR_EXPR)
2074           fn = TREE_OPERAND (fn, 0);
2075
2076         /* Nobody is interested in seeing the guts of vcalls.  */
2077         if (TREE_CODE (fn) == OBJ_TYPE_REF)
2078           fn = resolve_virtual_fun_from_obj_type_ref (fn);
2079
2080         if (TREE_TYPE (fn) != NULL_TREE
2081             && NEXT_CODE (fn) == METHOD_TYPE
2082             && call_expr_nargs (t))
2083           {
2084             tree ob = CALL_EXPR_ARG (t, 0);
2085             if (TREE_CODE (ob) == ADDR_EXPR)
2086               {
2087                 dump_expr (pp, TREE_OPERAND (ob, 0),
2088                            flags | TFF_EXPR_IN_PARENS);
2089                 pp_cxx_dot (pp);
2090               }
2091             else if (TREE_CODE (ob) != PARM_DECL
2092                      || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
2093               {
2094                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2095                 pp_cxx_arrow (pp);
2096               }
2097             skipfirst = true;
2098           }
2099         if (flag_sanitize & SANITIZE_UNDEFINED
2100             && is_ubsan_builtin_p (fn))
2101           {
2102             pp_string (cxx_pp, M_("<ubsan routine call>"));
2103             break;
2104           }
2105         dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS);
2106         dump_call_expr_args (pp, t, flags, skipfirst);
2107       }
2108       break;
2109
2110     case TARGET_EXPR:
2111       /* Note that this only works for G++ target exprs.  If somebody
2112          builds a general TARGET_EXPR, there's no way to represent that
2113          it initializes anything other that the parameter slot for the
2114          default argument.  Note we may have cleared out the first
2115          operand in expand_expr, so don't go killing ourselves.  */
2116       if (TREE_OPERAND (t, 1))
2117         dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2118       break;
2119
2120     case POINTER_PLUS_EXPR:
2121       dump_binary_op (pp, "+", t, flags);
2122       break;
2123
2124     case INIT_EXPR:
2125     case MODIFY_EXPR:
2126       dump_binary_op (pp, assignment_operator_name_info[NOP_EXPR].name,
2127                       t, flags);
2128       break;
2129
2130     case PLUS_EXPR:
2131     case MINUS_EXPR:
2132     case MULT_EXPR:
2133     case TRUNC_DIV_EXPR:
2134     case TRUNC_MOD_EXPR:
2135     case MIN_EXPR:
2136     case MAX_EXPR:
2137     case LSHIFT_EXPR:
2138     case RSHIFT_EXPR:
2139     case BIT_IOR_EXPR:
2140     case BIT_XOR_EXPR:
2141     case BIT_AND_EXPR:
2142     case TRUTH_ANDIF_EXPR:
2143     case TRUTH_ORIF_EXPR:
2144     case LT_EXPR:
2145     case LE_EXPR:
2146     case GT_EXPR:
2147     case GE_EXPR:
2148     case EQ_EXPR:
2149     case NE_EXPR:
2150     case EXACT_DIV_EXPR:
2151       dump_binary_op (pp, operator_name_info[TREE_CODE (t)].name, t, flags);
2152       break;
2153
2154     case CEIL_DIV_EXPR:
2155     case FLOOR_DIV_EXPR:
2156     case ROUND_DIV_EXPR:
2157     case RDIV_EXPR:
2158       dump_binary_op (pp, "/", t, flags);
2159       break;
2160
2161     case CEIL_MOD_EXPR:
2162     case FLOOR_MOD_EXPR:
2163     case ROUND_MOD_EXPR:
2164       dump_binary_op (pp, "%", t, flags);
2165       break;
2166
2167     case COMPONENT_REF:
2168       {
2169         tree ob = TREE_OPERAND (t, 0);
2170         if (INDIRECT_REF_P (ob))
2171           {
2172             ob = TREE_OPERAND (ob, 0);
2173             if (TREE_CODE (ob) != PARM_DECL
2174                 || (DECL_NAME (ob)
2175                     && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
2176               {
2177                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2178                 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
2179                   pp_cxx_dot (pp);
2180                 else
2181                   pp_cxx_arrow (pp);
2182               }
2183           }
2184         else
2185           {
2186             dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2187             pp_cxx_dot (pp);
2188           }
2189         dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
2190       }
2191       break;
2192
2193     case ARRAY_REF:
2194       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2195       pp_cxx_left_bracket (pp);
2196       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2197       pp_cxx_right_bracket (pp);
2198       break;
2199
2200     case ARRAY_NOTATION_REF:
2201       dump_expr (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
2202       pp_cxx_left_bracket (pp);
2203       dump_expr (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
2204       pp_colon (pp);
2205       dump_expr (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
2206       pp_colon (pp);
2207       dump_expr (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
2208       pp_cxx_right_bracket (pp);
2209       break;
2210
2211     case UNARY_PLUS_EXPR:
2212       dump_unary_op (pp, "+", t, flags);
2213       break;
2214
2215     case ADDR_EXPR:
2216       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
2217           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
2218           /* An ADDR_EXPR can have reference type.  In that case, we
2219              shouldn't print the `&' doing so indicates to the user
2220              that the expression has pointer type.  */
2221           || (TREE_TYPE (t)
2222               && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
2223         dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2224       else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
2225         dump_unary_op (pp, "&&", t, flags);
2226       else
2227         dump_unary_op (pp, "&", t, flags);
2228       break;
2229
2230     case INDIRECT_REF:
2231       if (TREE_HAS_CONSTRUCTOR (t))
2232         {
2233           t = TREE_OPERAND (t, 0);
2234           gcc_assert (TREE_CODE (t) == CALL_EXPR);
2235           dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
2236           dump_call_expr_args (pp, t, flags, true);
2237         }
2238       else
2239         {
2240           if (TREE_OPERAND (t,0) != NULL_TREE
2241               && TREE_TYPE (TREE_OPERAND (t, 0))
2242               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
2243             dump_expr (pp, TREE_OPERAND (t, 0), flags);
2244           else
2245             dump_unary_op (pp, "*", t, flags);
2246         }
2247       break;
2248
2249     case MEM_REF:
2250       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
2251           && integer_zerop (TREE_OPERAND (t, 1)))
2252         dump_expr (pp, TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
2253       else
2254         {
2255           pp_cxx_star (pp);
2256           if (!integer_zerop (TREE_OPERAND (t, 1)))
2257             {
2258               pp_cxx_left_paren (pp);
2259               if (!integer_onep (TYPE_SIZE_UNIT
2260                                  (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
2261                 {
2262                   pp_cxx_left_paren (pp);
2263                   dump_type (pp, ptr_type_node, flags);
2264                   pp_cxx_right_paren (pp);
2265                 }
2266             }
2267           dump_expr (pp, TREE_OPERAND (t, 0), flags);
2268           if (!integer_zerop (TREE_OPERAND (t, 1)))
2269             {
2270               pp_cxx_ws_string (pp, "+");
2271               dump_expr (pp, fold_convert (ssizetype, TREE_OPERAND (t, 1)),
2272                          flags);
2273               pp_cxx_right_paren (pp);
2274             }
2275         }
2276       break;
2277
2278     case NEGATE_EXPR:
2279     case BIT_NOT_EXPR:
2280     case TRUTH_NOT_EXPR:
2281     case PREDECREMENT_EXPR:
2282     case PREINCREMENT_EXPR:
2283       dump_unary_op (pp, operator_name_info [TREE_CODE (t)].name, t, flags);
2284       break;
2285
2286     case POSTDECREMENT_EXPR:
2287     case POSTINCREMENT_EXPR:
2288       pp_cxx_left_paren (pp);
2289       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2290       pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2291       pp_cxx_right_paren (pp);
2292       break;
2293
2294     case NON_LVALUE_EXPR:
2295       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
2296          should be another level of INDIRECT_REF so that I don't have to do
2297          this.  */
2298       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2299         {
2300           tree next = TREE_TYPE (TREE_TYPE (t));
2301
2302           while (TYPE_PTR_P (next))
2303             next = TREE_TYPE (next);
2304
2305           if (TREE_CODE (next) == FUNCTION_TYPE)
2306             {
2307               if (flags & TFF_EXPR_IN_PARENS)
2308                 pp_cxx_left_paren (pp);
2309               pp_cxx_star (pp);
2310               dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2311               if (flags & TFF_EXPR_IN_PARENS)
2312                 pp_cxx_right_paren (pp);
2313               break;
2314             }
2315           /* Else fall through.  */
2316         }
2317       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2318       break;
2319
2320     CASE_CONVERT:
2321     case IMPLICIT_CONV_EXPR:
2322     case VIEW_CONVERT_EXPR:
2323       {
2324         tree op = TREE_OPERAND (t, 0);
2325         tree ttype = TREE_TYPE (t);
2326         tree optype = TREE_TYPE (op);
2327
2328         if (TREE_CODE (ttype) != TREE_CODE (optype)
2329             && POINTER_TYPE_P (ttype)
2330             && POINTER_TYPE_P (optype)
2331             && same_type_p (TREE_TYPE (optype),
2332                             TREE_TYPE (ttype)))
2333           {
2334             if (TREE_CODE (ttype) == REFERENCE_TYPE)
2335               {
2336                 STRIP_NOPS (op);
2337                 if (TREE_CODE (op) == ADDR_EXPR)
2338                   dump_expr (pp, TREE_OPERAND (op, 0), flags);
2339                 else
2340                   dump_unary_op (pp, "*", t, flags);
2341               }
2342             else
2343               dump_unary_op (pp, "&", t, flags);
2344           }
2345         else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2346           {
2347             /* It is a cast, but we cannot tell whether it is a
2348                reinterpret or static cast. Use the C style notation.  */
2349             if (flags & TFF_EXPR_IN_PARENS)
2350               pp_cxx_left_paren (pp);
2351             pp_cxx_left_paren (pp);
2352             dump_type (pp, TREE_TYPE (t), flags);
2353             pp_cxx_right_paren (pp);
2354             dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS);
2355             if (flags & TFF_EXPR_IN_PARENS)
2356               pp_cxx_right_paren (pp);
2357           }
2358         else
2359           dump_expr (pp, op, flags);
2360         break;
2361       }
2362
2363     case CONSTRUCTOR:
2364       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2365         {
2366           tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2367
2368           if (integer_zerop (idx))
2369             {
2370               /* A NULL pointer-to-member constant.  */
2371               pp_cxx_left_paren (pp);
2372               pp_cxx_left_paren (pp);
2373               dump_type (pp, TREE_TYPE (t), flags);
2374               pp_cxx_right_paren (pp);
2375               pp_character (pp, '0');
2376               pp_cxx_right_paren (pp);
2377               break;
2378             }
2379           else if (tree_fits_shwi_p (idx))
2380             {
2381               tree virtuals;
2382               unsigned HOST_WIDE_INT n;
2383
2384               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2385               t = TYPE_METHOD_BASETYPE (t);
2386               virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2387
2388               n = tree_to_shwi (idx);
2389
2390               /* Map vtable index back one, to allow for the null pointer to
2391                  member.  */
2392               --n;
2393
2394               while (n > 0 && virtuals)
2395                 {
2396                   --n;
2397                   virtuals = TREE_CHAIN (virtuals);
2398                 }
2399               if (virtuals)
2400                 {
2401                   dump_expr (pp, BV_FN (virtuals),
2402                              flags | TFF_EXPR_IN_PARENS);
2403                   break;
2404                 }
2405             }
2406         }
2407       if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t)))
2408         pp_string (pp, "<lambda closure object>");
2409       if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2410         {
2411           dump_type (pp, TREE_TYPE (t), 0);
2412           pp_cxx_left_paren (pp);
2413           pp_cxx_right_paren (pp);
2414         }
2415       else
2416         {
2417           if (!BRACE_ENCLOSED_INITIALIZER_P (t))
2418             dump_type (pp, TREE_TYPE (t), 0);
2419           pp_cxx_left_brace (pp);
2420           dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags);
2421           pp_cxx_right_brace (pp);
2422         }
2423
2424       break;
2425
2426     case OFFSET_REF:
2427       {
2428         tree ob = TREE_OPERAND (t, 0);
2429         if (is_dummy_object (ob))
2430           {
2431             t = TREE_OPERAND (t, 1);
2432             if (TREE_CODE (t) == FUNCTION_DECL)
2433               /* A::f */
2434               dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS);
2435             else if (BASELINK_P (t))
2436               dump_expr (pp, OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2437                          flags | TFF_EXPR_IN_PARENS);
2438             else
2439               dump_decl (pp, t, flags);
2440           }
2441         else
2442           {
2443             if (INDIRECT_REF_P (ob))
2444               {
2445                 dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2446                 pp_cxx_arrow (pp);
2447                 pp_cxx_star (pp);
2448               }
2449             else
2450               {
2451                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2452                 pp_cxx_dot (pp);
2453                 pp_cxx_star (pp);
2454               }
2455             dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2456           }
2457         break;
2458       }
2459
2460     case TEMPLATE_PARM_INDEX:
2461       dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2462       break;
2463
2464     case CAST_EXPR:
2465       if (TREE_OPERAND (t, 0) == NULL_TREE
2466           || TREE_CHAIN (TREE_OPERAND (t, 0)))
2467         {
2468           dump_type (pp, TREE_TYPE (t), flags);
2469           pp_cxx_left_paren (pp);
2470           dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2471           pp_cxx_right_paren (pp);
2472         }
2473       else
2474         {
2475           pp_cxx_left_paren (pp);
2476           dump_type (pp, TREE_TYPE (t), flags);
2477           pp_cxx_right_paren (pp);
2478           pp_cxx_left_paren (pp);
2479           dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2480           pp_cxx_right_paren (pp);
2481         }
2482       break;
2483
2484     case STATIC_CAST_EXPR:
2485       pp_cxx_ws_string (pp, "static_cast");
2486       goto cast;
2487     case REINTERPRET_CAST_EXPR:
2488       pp_cxx_ws_string (pp, "reinterpret_cast");
2489       goto cast;
2490     case CONST_CAST_EXPR:
2491       pp_cxx_ws_string (pp, "const_cast");
2492       goto cast;
2493     case DYNAMIC_CAST_EXPR:
2494       pp_cxx_ws_string (pp, "dynamic_cast");
2495     cast:
2496       pp_cxx_begin_template_argument_list (pp);
2497       dump_type (pp, TREE_TYPE (t), flags);
2498       pp_cxx_end_template_argument_list (pp);
2499       pp_cxx_left_paren (pp);
2500       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2501       pp_cxx_right_paren (pp);
2502       break;
2503
2504     case ARROW_EXPR:
2505       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2506       pp_cxx_arrow (pp);
2507       break;
2508
2509     case SIZEOF_EXPR:
2510     case ALIGNOF_EXPR:
2511       if (TREE_CODE (t) == SIZEOF_EXPR)
2512         pp_cxx_ws_string (pp, "sizeof");
2513       else
2514         {
2515           gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2516           pp_cxx_ws_string (pp, "__alignof__");
2517         }
2518       op = TREE_OPERAND (t, 0);
2519       if (PACK_EXPANSION_P (op))
2520         {
2521           pp_string (pp, "...");
2522           op = PACK_EXPANSION_PATTERN (op);
2523         }
2524       pp_cxx_whitespace (pp);
2525       pp_cxx_left_paren (pp);
2526       if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
2527         dump_type (pp, TREE_TYPE (op), flags);
2528       else if (TYPE_P (TREE_OPERAND (t, 0)))
2529         dump_type (pp, op, flags);
2530       else
2531         dump_expr (pp, op, flags);
2532       pp_cxx_right_paren (pp);
2533       break;
2534
2535     case AT_ENCODE_EXPR:
2536       pp_cxx_ws_string (pp, "@encode");
2537       pp_cxx_whitespace (pp);
2538       pp_cxx_left_paren (pp);
2539       dump_type (pp, TREE_OPERAND (t, 0), flags);
2540       pp_cxx_right_paren (pp);
2541       break;
2542
2543     case NOEXCEPT_EXPR:
2544       pp_cxx_ws_string (pp, "noexcept");
2545       pp_cxx_whitespace (pp);
2546       pp_cxx_left_paren (pp);
2547       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2548       pp_cxx_right_paren (pp);
2549       break;
2550
2551     case REALPART_EXPR:
2552     case IMAGPART_EXPR:
2553       pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2554       pp_cxx_whitespace (pp);
2555       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2556       break;
2557
2558     case DEFAULT_ARG:
2559       pp_string (pp, M_("<unparsed>"));
2560       break;
2561
2562     case TRY_CATCH_EXPR:
2563     case WITH_CLEANUP_EXPR:
2564     case CLEANUP_POINT_EXPR:
2565       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2566       break;
2567
2568     case PSEUDO_DTOR_EXPR:
2569       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2570       pp_cxx_dot (pp);
2571       if (TREE_OPERAND (t, 1))
2572         {
2573           dump_type (pp, TREE_OPERAND (t, 1), flags);
2574           pp_cxx_colon_colon (pp);
2575         }
2576       pp_cxx_complement (pp);
2577       dump_type (pp, TREE_OPERAND (t, 2), flags);
2578       break;
2579
2580     case TEMPLATE_ID_EXPR:
2581       dump_decl (pp, t, flags);
2582       break;
2583
2584     case BIND_EXPR:
2585     case STMT_EXPR:
2586     case EXPR_STMT:
2587     case STATEMENT_LIST:
2588       /* We don't yet have a way of dumping statements in a
2589          human-readable format.  */
2590       pp_string (pp, "({...})");
2591       break;
2592
2593     case LOOP_EXPR:
2594       pp_string (pp, "while (1) { ");
2595       dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2596       pp_cxx_right_brace (pp);
2597       break;
2598
2599     case EXIT_EXPR:
2600       pp_string (pp, "if (");
2601       dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2602       pp_string (pp, ") break; ");
2603       break;
2604
2605     case BASELINK:
2606       dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
2607       break;
2608
2609     case EMPTY_CLASS_EXPR:
2610       dump_type (pp, TREE_TYPE (t), flags);
2611       pp_cxx_left_paren (pp);
2612       pp_cxx_right_paren (pp);
2613       break;
2614
2615     case NON_DEPENDENT_EXPR:
2616       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2617       break;
2618
2619     case ARGUMENT_PACK_SELECT:
2620       dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2621       break;
2622
2623     case RECORD_TYPE:
2624     case UNION_TYPE:
2625     case ENUMERAL_TYPE:
2626     case REAL_TYPE:
2627     case VOID_TYPE:
2628     case BOOLEAN_TYPE:
2629     case INTEGER_TYPE:
2630     case COMPLEX_TYPE:
2631     case VECTOR_TYPE:
2632       pp_type_specifier_seq (pp, t);
2633       break;
2634
2635     case TYPENAME_TYPE:
2636       /* We get here when we want to print a dependent type as an
2637          id-expression, without any disambiguator decoration.  */
2638       pp->id_expression (t);
2639       break;
2640
2641     case TEMPLATE_TYPE_PARM:
2642     case TEMPLATE_TEMPLATE_PARM:
2643     case BOUND_TEMPLATE_TEMPLATE_PARM:
2644       dump_type (pp, t, flags);
2645       break;
2646
2647     case TRAIT_EXPR:
2648       pp_cxx_trait_expression (pp, t);
2649       break;
2650
2651     case VA_ARG_EXPR:
2652       pp_cxx_va_arg_expression (pp, t);
2653       break;
2654
2655     case OFFSETOF_EXPR:
2656       pp_cxx_offsetof_expression (pp, t);
2657       break;
2658
2659     case SCOPE_REF:
2660       dump_decl (pp, t, flags);
2661       break;
2662
2663     case EXPR_PACK_EXPANSION:
2664     case TYPEID_EXPR:
2665     case MEMBER_REF:
2666     case DOTSTAR_EXPR:
2667     case NEW_EXPR:
2668     case VEC_NEW_EXPR:
2669     case DELETE_EXPR:
2670     case VEC_DELETE_EXPR:
2671     case MODOP_EXPR:
2672     case ABS_EXPR:
2673     case CONJ_EXPR:
2674     case VECTOR_CST:
2675     case FIXED_CST:
2676     case UNORDERED_EXPR:
2677     case ORDERED_EXPR:
2678     case UNLT_EXPR:
2679     case UNLE_EXPR:
2680     case UNGT_EXPR:
2681     case UNGE_EXPR:
2682     case UNEQ_EXPR:
2683     case LTGT_EXPR:
2684     case COMPLEX_EXPR:
2685     case BIT_FIELD_REF:
2686     case FIX_TRUNC_EXPR:
2687     case FLOAT_EXPR:
2688       pp->expression (t);
2689       break;
2690
2691     case TRUTH_AND_EXPR:
2692     case TRUTH_OR_EXPR:
2693     case TRUTH_XOR_EXPR:
2694       if (flags & TFF_EXPR_IN_PARENS)
2695         pp_cxx_left_paren (pp);
2696       pp->expression (t);
2697       if (flags & TFF_EXPR_IN_PARENS)
2698         pp_cxx_right_paren (pp);
2699       break;
2700
2701     case OBJ_TYPE_REF:
2702       dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
2703       break;
2704
2705     case LAMBDA_EXPR:
2706       pp_string (pp, M_("<lambda>"));
2707       break;
2708
2709     case PAREN_EXPR:
2710       pp_cxx_left_paren (pp);
2711       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2712       pp_cxx_right_paren (pp);
2713       break;
2714
2715     case REQUIRES_EXPR:
2716       pp_cxx_requires_expr (cxx_pp, t);
2717       break;
2718
2719     case SIMPLE_REQ:
2720       pp_cxx_simple_requirement (cxx_pp, t);
2721       break;
2722
2723     case TYPE_REQ:
2724       pp_cxx_type_requirement (cxx_pp, t);
2725       break;
2726
2727     case COMPOUND_REQ:
2728       pp_cxx_compound_requirement (cxx_pp, t);
2729       break;
2730
2731     case NESTED_REQ:
2732       pp_cxx_nested_requirement (cxx_pp, t);
2733       break;
2734
2735     case PRED_CONSTR:
2736     case EXPR_CONSTR:
2737     case TYPE_CONSTR:
2738     case ICONV_CONSTR:
2739     case DEDUCT_CONSTR:
2740     case EXCEPT_CONSTR:
2741     case PARM_CONSTR:
2742     case CONJ_CONSTR:
2743     case DISJ_CONSTR:
2744       pp_cxx_constraint (cxx_pp, t);
2745       break;
2746
2747     case PLACEHOLDER_EXPR:
2748       pp_string (pp, M_("*this"));
2749       break;
2750
2751       /*  This list is incomplete, but should suffice for now.
2752           It is very important that `sorry' does not call
2753           `report_error_function'.  That could cause an infinite loop.  */
2754     default:
2755       pp_unsupported_tree (pp, t);
2756       /* fall through to ERROR_MARK...  */
2757     case ERROR_MARK:
2758       pp_string (pp, M_("<expression error>"));
2759       break;
2760     }
2761 }
2762
2763 static void
2764 dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
2765                 int flags)
2766 {
2767   pp_cxx_left_paren (pp);
2768   dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2769   pp_cxx_whitespace (pp);
2770   if (opstring)
2771     pp_cxx_ws_string (pp, opstring);
2772   else
2773     pp_string (pp, M_("<unknown operator>"));
2774   pp_cxx_whitespace (pp);
2775   dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2776   pp_cxx_right_paren (pp);
2777 }
2778
2779 static void
2780 dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
2781 {
2782   if (flags & TFF_EXPR_IN_PARENS)
2783     pp_cxx_left_paren (pp);
2784   pp_cxx_ws_string (pp, opstring);
2785   dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2786   if (flags & TFF_EXPR_IN_PARENS)
2787     pp_cxx_right_paren (pp);
2788 }
2789
2790 static void
2791 reinit_cxx_pp (void)
2792 {
2793   pp_clear_output_area (cxx_pp);
2794   cxx_pp->padding = pp_none;
2795   pp_indentation (cxx_pp) = 0;
2796   pp_needs_newline (cxx_pp) = false;
2797   cxx_pp->enclosing_scope = current_function_decl;
2798 }
2799
2800 /* Same as pp_formatted_text, except the return string is a separate
2801    copy and has a GGC storage duration, e.g. an indefinite lifetime.  */
2802
2803 inline const char *
2804 pp_ggc_formatted_text (pretty_printer *pp)
2805 {
2806   return ggc_strdup (pp_formatted_text (pp));
2807 }
2808
2809 /* Exported interface to stringifying types, exprs and decls under TFF_*
2810    control.  */
2811
2812 const char *
2813 type_as_string (tree typ, int flags)
2814 {
2815   reinit_cxx_pp ();
2816   pp_translate_identifiers (cxx_pp) = false;
2817   dump_type (cxx_pp, typ, flags);
2818   return pp_ggc_formatted_text (cxx_pp);
2819 }
2820
2821 const char *
2822 type_as_string_translate (tree typ, int flags)
2823 {
2824   reinit_cxx_pp ();
2825   dump_type (cxx_pp, typ, flags);
2826   return pp_ggc_formatted_text (cxx_pp);
2827 }
2828
2829 const char *
2830 expr_as_string (tree decl, int flags)
2831 {
2832   reinit_cxx_pp ();
2833   pp_translate_identifiers (cxx_pp) = false;
2834   dump_expr (cxx_pp, decl, flags);
2835   return pp_ggc_formatted_text (cxx_pp);
2836 }
2837
2838 /* Wrap decl_as_string with options appropriate for dwarf.  */
2839
2840 const char *
2841 decl_as_dwarf_string (tree decl, int flags)
2842 {
2843   const char *name;
2844   /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2845      here will be adequate to get the desired behavior.  */
2846   cxx_pp->flags |= pp_c_flag_gnu_v3;
2847   name = decl_as_string (decl, flags);
2848   /* Subsequent calls to the pretty printer shouldn't use this style.  */
2849   cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2850   return name;
2851 }
2852
2853 const char *
2854 decl_as_string (tree decl, int flags)
2855 {
2856   reinit_cxx_pp ();
2857   pp_translate_identifiers (cxx_pp) = false;
2858   dump_decl (cxx_pp, decl, flags);
2859   return pp_ggc_formatted_text (cxx_pp);
2860 }
2861
2862 const char *
2863 decl_as_string_translate (tree decl, int flags)
2864 {
2865   reinit_cxx_pp ();
2866   dump_decl (cxx_pp, decl, flags);
2867   return pp_ggc_formatted_text (cxx_pp);
2868 }
2869
2870 /* Wrap lang_decl_name with options appropriate for dwarf.  */
2871
2872 const char *
2873 lang_decl_dwarf_name (tree decl, int v, bool translate)
2874 {
2875   const char *name;
2876   /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2877      here will be adequate to get the desired behavior.  */
2878   cxx_pp->flags |= pp_c_flag_gnu_v3;
2879   name = lang_decl_name (decl, v, translate);
2880   /* Subsequent calls to the pretty printer shouldn't use this style.  */
2881   cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2882   return name;
2883 }
2884
2885 /* Generate the three forms of printable names for cxx_printable_name.  */
2886
2887 const char *
2888 lang_decl_name (tree decl, int v, bool translate)
2889 {
2890   if (v >= 2)
2891     return (translate
2892             ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2893             : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2894
2895   reinit_cxx_pp ();
2896   pp_translate_identifiers (cxx_pp) = translate;
2897   if (v == 1
2898       && (DECL_CLASS_SCOPE_P (decl)
2899           || (DECL_NAMESPACE_SCOPE_P (decl)
2900               && CP_DECL_CONTEXT (decl) != global_namespace)))
2901     {
2902       dump_type (cxx_pp, CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2903       pp_cxx_colon_colon (cxx_pp);
2904     }
2905
2906   if (TREE_CODE (decl) == FUNCTION_DECL)
2907     dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER);
2908   else if ((DECL_NAME (decl) == NULL_TREE)
2909            && TREE_CODE (decl) == NAMESPACE_DECL)
2910     dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER | TFF_UNQUALIFIED_NAME);
2911   else
2912     dump_decl (cxx_pp, DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2913
2914   return pp_ggc_formatted_text (cxx_pp);
2915 }
2916
2917 /* Return the location of a tree passed to %+ formats.  */
2918
2919 location_t
2920 location_of (tree t)
2921 {
2922   if (TYPE_P (t))
2923     {
2924       t = TYPE_MAIN_DECL (t);
2925       if (t == NULL_TREE)
2926         return input_location;
2927     }
2928   else if (TREE_CODE (t) == OVERLOAD)
2929     t = OVL_FUNCTION (t);
2930
2931   if (DECL_P (t))
2932     return DECL_SOURCE_LOCATION (t);
2933   return EXPR_LOC_OR_LOC (t, input_location);
2934 }
2935
2936 /* Now the interfaces from error et al to dump_type et al. Each takes an
2937    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2938    function.  */
2939
2940 static const char *
2941 decl_to_string (tree decl, int verbose)
2942 {
2943   int flags = 0;
2944
2945   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2946       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2947     flags = TFF_CLASS_KEY_OR_ENUM;
2948   if (verbose)
2949     flags |= TFF_DECL_SPECIFIERS;
2950   else if (TREE_CODE (decl) == FUNCTION_DECL)
2951     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2952   flags |= TFF_TEMPLATE_HEADER;
2953
2954   reinit_cxx_pp ();
2955   dump_decl (cxx_pp, decl, flags);
2956   return pp_ggc_formatted_text (cxx_pp);
2957 }
2958
2959 static const char *
2960 expr_to_string (tree decl)
2961 {
2962   reinit_cxx_pp ();
2963   dump_expr (cxx_pp, decl, 0);
2964   return pp_ggc_formatted_text (cxx_pp);
2965 }
2966
2967 static const char *
2968 fndecl_to_string (tree fndecl, int verbose)
2969 {
2970   int flags;
2971
2972   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2973     | TFF_TEMPLATE_HEADER;
2974   if (verbose)
2975     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2976   reinit_cxx_pp ();
2977   dump_decl (cxx_pp, fndecl, flags);
2978   return pp_ggc_formatted_text (cxx_pp);
2979 }
2980
2981
2982 static const char *
2983 code_to_string (enum tree_code c)
2984 {
2985   return get_tree_code_name (c);
2986 }
2987
2988 const char *
2989 language_to_string (enum languages c)
2990 {
2991   switch (c)
2992     {
2993     case lang_c:
2994       return "C";
2995
2996     case lang_cplusplus:
2997       return "C++";
2998
2999     case lang_java:
3000       return "Java";
3001
3002     default:
3003       gcc_unreachable ();
3004     }
3005   return NULL;
3006 }
3007
3008 /* Return the proper printed version of a parameter to a C++ function.  */
3009
3010 static const char *
3011 parm_to_string (int p)
3012 {
3013   reinit_cxx_pp ();
3014   if (p < 0)
3015     pp_string (cxx_pp, "'this'");
3016   else
3017     pp_decimal_int (cxx_pp, p + 1);
3018   return pp_ggc_formatted_text (cxx_pp);
3019 }
3020
3021 static const char *
3022 op_to_string (enum tree_code p)
3023 {
3024   tree id = operator_name_info[p].identifier;
3025   return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
3026 }
3027
3028 static const char *
3029 type_to_string (tree typ, int verbose)
3030 {
3031   int flags = 0;
3032   if (verbose)
3033     flags |= TFF_CLASS_KEY_OR_ENUM;
3034   flags |= TFF_TEMPLATE_HEADER;
3035
3036   reinit_cxx_pp ();
3037   dump_type (cxx_pp, typ, flags);
3038   /* If we're printing a type that involves typedefs, also print the
3039      stripped version.  But sometimes the stripped version looks
3040      exactly the same, so we don't want it after all.  To avoid printing
3041      it in that case, we play ugly obstack games.  */
3042   if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
3043       && !uses_template_parms (typ))
3044     {
3045       int aka_start, aka_len; char *p;
3046       struct obstack *ob = pp_buffer (cxx_pp)->obstack;
3047       /* Remember the end of the initial dump.  */
3048       int len = obstack_object_size (ob);
3049       tree aka = strip_typedefs (typ);
3050       pp_string (cxx_pp, " {aka");
3051       pp_cxx_whitespace (cxx_pp);
3052       /* And remember the start of the aka dump.  */
3053       aka_start = obstack_object_size (ob);
3054       dump_type (cxx_pp, aka, flags);
3055       aka_len = obstack_object_size (ob) - aka_start;
3056       pp_right_brace (cxx_pp);
3057       p = (char*)obstack_base (ob);
3058       /* If they are identical, cut off the aka with a NUL.  */
3059       if (len == aka_len && memcmp (p, p+aka_start, len) == 0)
3060         p[len] = '\0';
3061     }
3062   return pp_ggc_formatted_text (cxx_pp);
3063 }
3064
3065 static const char *
3066 assop_to_string (enum tree_code p)
3067 {
3068   tree id = assignment_operator_name_info[(int) p].identifier;
3069   return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
3070 }
3071
3072 static const char *
3073 args_to_string (tree p, int verbose)
3074 {
3075   int flags = 0;
3076   if (verbose)
3077     flags |= TFF_CLASS_KEY_OR_ENUM;
3078
3079   if (p == NULL_TREE)
3080     return "";
3081
3082   if (TYPE_P (TREE_VALUE (p)))
3083     return type_as_string_translate (p, flags);
3084
3085   reinit_cxx_pp ();
3086   for (; p; p = TREE_CHAIN (p))
3087     {
3088       if (TREE_VALUE (p) == null_node)
3089         pp_cxx_ws_string (cxx_pp, "NULL");
3090       else
3091         dump_type (cxx_pp, error_type (TREE_VALUE (p)), flags);
3092       if (TREE_CHAIN (p))
3093         pp_separate_with_comma (cxx_pp);
3094     }
3095   return pp_ggc_formatted_text (cxx_pp);
3096 }
3097
3098 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype).  P
3099    is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3100    arguments.  */
3101
3102 static const char *
3103 subst_to_string (tree p)
3104 {
3105   tree decl = TREE_PURPOSE (p);
3106   tree targs = TREE_VALUE (p);
3107   tree tparms = DECL_TEMPLATE_PARMS (decl);
3108   int flags = (TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER
3109                |TFF_NO_TEMPLATE_BINDINGS);
3110
3111   if (p == NULL_TREE)
3112     return "";
3113
3114   reinit_cxx_pp ();
3115   dump_template_decl (cxx_pp, TREE_PURPOSE (p), flags);
3116   dump_substitution (cxx_pp, NULL, tparms, targs, /*flags=*/0);
3117   return pp_ggc_formatted_text (cxx_pp);
3118 }
3119
3120 static const char *
3121 cv_to_string (tree p, int v)
3122 {
3123   reinit_cxx_pp ();
3124   cxx_pp->padding = v ? pp_before : pp_none;
3125   pp_cxx_cv_qualifier_seq (cxx_pp, p);
3126   return pp_ggc_formatted_text (cxx_pp);
3127 }
3128
3129 static const char *
3130 eh_spec_to_string (tree p, int /*v*/)
3131 {
3132   int flags = 0;
3133   reinit_cxx_pp ();
3134   dump_exception_spec (cxx_pp, p, flags);
3135   return pp_ggc_formatted_text (cxx_pp);
3136 }
3137
3138 /* Langhook for print_error_function.  */
3139 void
3140 cxx_print_error_function (diagnostic_context *context, const char *file,
3141                           diagnostic_info *diagnostic)
3142 {
3143   lhd_print_error_function (context, file, diagnostic);
3144   pp_set_prefix (context->printer, file);
3145   maybe_print_instantiation_context (context);
3146 }
3147
3148 static void
3149 cp_diagnostic_starter (diagnostic_context *context,
3150                        diagnostic_info *diagnostic)
3151 {
3152   diagnostic_report_current_module (context, diagnostic_location (diagnostic));
3153   cp_print_error_function (context, diagnostic);
3154   maybe_print_instantiation_context (context);
3155   maybe_print_constexpr_context (context);
3156   pp_set_prefix (context->printer, diagnostic_build_prefix (context,
3157                                                                  diagnostic));
3158 }
3159
3160 /* Print current function onto BUFFER, in the process of reporting
3161    a diagnostic message.  Called from cp_diagnostic_starter.  */
3162 static void
3163 cp_print_error_function (diagnostic_context *context,
3164                          diagnostic_info *diagnostic)
3165 {
3166   /* If we are in an instantiation context, current_function_decl is likely
3167      to be wrong, so just rely on print_instantiation_full_context.  */
3168   if (current_instantiation ())
3169     return;
3170   if (diagnostic_last_function_changed (context, diagnostic))
3171     {
3172       const char *old_prefix = context->printer->prefix;
3173       const char *file = LOCATION_FILE (diagnostic_location (diagnostic));
3174       tree abstract_origin = diagnostic_abstract_origin (diagnostic);
3175       char *new_prefix = (file && abstract_origin == NULL)
3176                          ? file_name_as_prefix (context, file) : NULL;
3177
3178       pp_set_prefix (context->printer, new_prefix);
3179
3180       if (current_function_decl == NULL)
3181         pp_string (context->printer, _("At global scope:"));
3182       else
3183         {
3184           tree fndecl, ao;
3185
3186           if (abstract_origin)
3187             {
3188               ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
3189               while (TREE_CODE (ao) == BLOCK
3190                      && BLOCK_ABSTRACT_ORIGIN (ao)
3191                      && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3192                 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3193               gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
3194               fndecl = ao;
3195             }
3196           else
3197             fndecl = current_function_decl;
3198
3199           pp_printf (context->printer, function_category (fndecl),
3200                      cxx_printable_name_translate (fndecl, 2));
3201
3202           while (abstract_origin)
3203             {
3204               location_t *locus;
3205               tree block = abstract_origin;
3206
3207               locus = &BLOCK_SOURCE_LOCATION (block);
3208               fndecl = NULL;
3209               block = BLOCK_SUPERCONTEXT (block);
3210               while (block && TREE_CODE (block) == BLOCK
3211                      && BLOCK_ABSTRACT_ORIGIN (block))
3212                 {
3213                   ao = BLOCK_ABSTRACT_ORIGIN (block);
3214
3215                   while (TREE_CODE (ao) == BLOCK
3216                          && BLOCK_ABSTRACT_ORIGIN (ao)
3217                          && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3218                     ao = BLOCK_ABSTRACT_ORIGIN (ao);
3219
3220                   if (TREE_CODE (ao) == FUNCTION_DECL)
3221                     {
3222                       fndecl = ao;
3223                       break;
3224                     }
3225                   else if (TREE_CODE (ao) != BLOCK)
3226                     break;
3227
3228                   block = BLOCK_SUPERCONTEXT (block);
3229                 }
3230               if (fndecl)
3231                 abstract_origin = block;
3232               else
3233                 {
3234                   while (block && TREE_CODE (block) == BLOCK)
3235                     block = BLOCK_SUPERCONTEXT (block);
3236
3237                   if (block && TREE_CODE (block) == FUNCTION_DECL)
3238                     fndecl = block;
3239                   abstract_origin = NULL;
3240                 }
3241               if (fndecl)
3242                 {
3243                   expanded_location s = expand_location (*locus);
3244                   pp_character (context->printer, ',');
3245                   pp_newline (context->printer);
3246                   if (s.file != NULL)
3247                     {
3248                       if (context->show_column && s.column != 0)
3249                         pp_printf (context->printer,
3250                                    _("    inlined from %qs at %r%s:%d:%d%R"),
3251                                    cxx_printable_name_translate (fndecl, 2),
3252                                    "locus", s.file, s.line, s.column);
3253                       else
3254                         pp_printf (context->printer,
3255                                    _("    inlined from %qs at %r%s:%d%R"),
3256                                    cxx_printable_name_translate (fndecl, 2),
3257                                    "locus", s.file, s.line);
3258
3259                     }
3260                   else
3261                     pp_printf (context->printer, _("    inlined from %qs"),
3262                                cxx_printable_name_translate (fndecl, 2));
3263                 }
3264             }
3265           pp_character (context->printer, ':');
3266         }
3267       pp_newline (context->printer);
3268
3269       diagnostic_set_last_function (context, diagnostic);
3270       pp_destroy_prefix (context->printer);
3271       context->printer->prefix = old_prefix;
3272     }
3273 }
3274
3275 /* Returns a description of FUNCTION using standard terminology.  The
3276    result is a format string of the form "In CATEGORY %qs".  */
3277 static const char *
3278 function_category (tree fn)
3279 {
3280   /* We can get called from the middle-end for diagnostics of function
3281      clones.  Make sure we have language specific information before
3282      dereferencing it.  */
3283   if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
3284       && DECL_FUNCTION_MEMBER_P (fn))
3285     {
3286       if (DECL_STATIC_FUNCTION_P (fn))
3287         return _("In static member function %qs");
3288       else if (DECL_COPY_CONSTRUCTOR_P (fn))
3289         return _("In copy constructor %qs");
3290       else if (DECL_CONSTRUCTOR_P (fn))
3291         return _("In constructor %qs");
3292       else if (DECL_DESTRUCTOR_P (fn))
3293         return _("In destructor %qs");
3294       else if (LAMBDA_FUNCTION_P (fn))
3295         return _("In lambda function");
3296       else
3297         return _("In member function %qs");
3298     }
3299   else
3300     return _("In function %qs");
3301 }
3302
3303 /* Report the full context of a current template instantiation,
3304    onto BUFFER.  */
3305 static void
3306 print_instantiation_full_context (diagnostic_context *context)
3307 {
3308   struct tinst_level *p = current_instantiation ();
3309   location_t location = input_location;
3310
3311   if (p)
3312     {
3313       pp_verbatim (context->printer,
3314                    TREE_CODE (p->decl) == TREE_LIST
3315                    ? _("%s: In substitution of %qS:\n")
3316                    : _("%s: In instantiation of %q#D:\n"),
3317                    LOCATION_FILE (location),
3318                    p->decl);
3319
3320       location = p->locus;
3321       p = p->next;
3322     }
3323
3324   print_instantiation_partial_context (context, p, location);
3325 }
3326
3327 /* Helper function of print_instantiation_partial_context() that
3328    prints a single line of instantiation context.  */
3329
3330 static void
3331 print_instantiation_partial_context_line (diagnostic_context *context,
3332                                           const struct tinst_level *t,
3333                                           location_t loc, bool recursive_p)
3334 {
3335   if (loc == UNKNOWN_LOCATION)
3336     return;
3337
3338   expanded_location xloc = expand_location (loc);
3339
3340   if (context->show_column)
3341     pp_verbatim (context->printer, _("%r%s:%d:%d:%R   "),
3342                  "locus", xloc.file, xloc.line, xloc.column);
3343   else
3344     pp_verbatim (context->printer, _("%r%s:%d:%R   "),
3345                  "locus", xloc.file, xloc.line);
3346
3347   if (t != NULL)
3348     {
3349       if (TREE_CODE (t->decl) == TREE_LIST)
3350         pp_verbatim (context->printer,
3351                      recursive_p
3352                      ? _("recursively required by substitution of %qS\n")
3353                      : _("required by substitution of %qS\n"),
3354                      t->decl);
3355       else
3356         pp_verbatim (context->printer,
3357                      recursive_p
3358                      ? _("recursively required from %q#D\n")
3359                      : _("required from %q#D\n"),
3360                      t->decl);
3361     }
3362   else
3363     {
3364       pp_verbatim (context->printer,
3365                    recursive_p
3366                    ? _("recursively required from here\n")
3367                    : _("required from here\n"));
3368     }
3369 }
3370
3371 /* Same as print_instantiation_full_context but less verbose.  */
3372
3373 static void
3374 print_instantiation_partial_context (diagnostic_context *context,
3375                                      struct tinst_level *t0, location_t loc)
3376 {
3377   struct tinst_level *t;
3378   int n_total = 0;
3379   int n;
3380   location_t prev_loc = loc;
3381
3382   for (t = t0; t != NULL; t = t->next)
3383     if (prev_loc != t->locus)
3384       {
3385         prev_loc = t->locus;
3386         n_total++;
3387       }
3388
3389   t = t0;
3390
3391   if (template_backtrace_limit
3392       && n_total > template_backtrace_limit)
3393     {
3394       int skip = n_total - template_backtrace_limit;
3395       int head = template_backtrace_limit / 2;
3396
3397       /* Avoid skipping just 1.  If so, skip 2.  */
3398       if (skip == 1)
3399        {
3400          skip = 2;
3401          head = (template_backtrace_limit - 1) / 2;
3402        }
3403
3404       for (n = 0; n < head; n++)
3405         {
3406           gcc_assert (t != NULL);
3407           if (loc != t->locus)
3408             print_instantiation_partial_context_line (context, t, loc,
3409                                                       /*recursive_p=*/false);
3410           loc = t->locus;
3411           t = t->next;
3412         }
3413       if (t != NULL && skip > 0)
3414         {
3415           expanded_location xloc;
3416           xloc = expand_location (loc);
3417           if (context->show_column)
3418             pp_verbatim (context->printer,
3419                          _("%r%s:%d:%d:%R   [ skipping %d instantiation "
3420                            "contexts, use -ftemplate-backtrace-limit=0 to "
3421                            "disable ]\n"),
3422                          "locus", xloc.file, xloc.line, xloc.column, skip);
3423           else
3424             pp_verbatim (context->printer,
3425                          _("%r%s:%d:%R   [ skipping %d instantiation "
3426                            "contexts, use -ftemplate-backtrace-limit=0 to "
3427                            "disable ]\n"),
3428                          "locus", xloc.file, xloc.line, skip);
3429
3430           do {
3431             loc = t->locus;
3432             t = t->next;
3433           } while (t != NULL && --skip > 0);
3434         }
3435     }
3436
3437   while (t != NULL)
3438     {
3439       while (t->next != NULL && t->locus == t->next->locus)
3440         {
3441           loc = t->locus;
3442           t = t->next;
3443         }
3444       print_instantiation_partial_context_line (context, t, loc,
3445                                                 t->locus == loc);
3446       loc = t->locus;
3447       t = t->next;
3448     }
3449   print_instantiation_partial_context_line (context, NULL, loc,
3450                                             /*recursive_p=*/false);
3451 }
3452
3453 /* Called from cp_thing to print the template context for an error.  */
3454 static void
3455 maybe_print_instantiation_context (diagnostic_context *context)
3456 {
3457   if (!problematic_instantiation_changed () || current_instantiation () == 0)
3458     return;
3459
3460   record_last_problematic_instantiation ();
3461   print_instantiation_full_context (context);
3462 }
3463 \f
3464 /* Report what constexpr call(s) we're trying to expand, if any.  */
3465
3466 void
3467 maybe_print_constexpr_context (diagnostic_context *context)
3468 {
3469   vec<tree> call_stack = cx_error_context ();
3470   unsigned ix;
3471   tree t;
3472
3473   FOR_EACH_VEC_ELT (call_stack, ix, t)
3474     {
3475       expanded_location xloc = expand_location (EXPR_LOCATION (t));
3476       const char *s = expr_as_string (t, 0);
3477       if (context->show_column)
3478         pp_verbatim (context->printer,
3479                      _("%r%s:%d:%d:%R   in constexpr expansion of %qs"),
3480                      "locus", xloc.file, xloc.line, xloc.column, s);
3481       else
3482         pp_verbatim (context->printer,
3483                      _("%r%s:%d:%R   in constexpr expansion of %qs"),
3484                      "locus", xloc.file, xloc.line, s);
3485       pp_newline (context->printer);
3486     }
3487 }
3488 \f
3489 /* Called from output_format -- during diagnostic message processing --
3490    to handle C++ specific format specifier with the following meanings:
3491    %A   function argument-list.
3492    %C   tree code.
3493    %D   declaration.
3494    %E   expression.
3495    %F   function declaration.
3496    %L   language as used in extern "lang".
3497    %O   binary operator.
3498    %P   function parameter whose position is indicated by an integer.
3499    %Q   assignment operator.
3500    %S   substitution (template + args)
3501    %T   type.
3502    %V   cv-qualifier.
3503    %X   exception-specification.  */
3504 static bool
3505 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
3506             int precision, bool wide, bool set_locus, bool verbose)
3507 {
3508   const char *result;
3509   tree t = NULL;
3510 #define next_tree    (t = va_arg (*text->args_ptr, tree))
3511 #define next_tcode   ((enum tree_code) va_arg (*text->args_ptr, int))
3512 #define next_lang    ((enum languages) va_arg (*text->args_ptr, int))
3513 #define next_int     va_arg (*text->args_ptr, int)
3514
3515   if (precision != 0 || wide)
3516     return false;
3517
3518   switch (*spec)
3519     {
3520     case 'A': result = args_to_string (next_tree, verbose);     break;
3521     case 'C': result = code_to_string (next_tcode);             break;
3522     case 'D':
3523       {
3524         tree temp = next_tree;
3525         if (VAR_P (temp)
3526             && DECL_HAS_DEBUG_EXPR_P (temp))
3527           {
3528             temp = DECL_DEBUG_EXPR (temp);
3529             if (!DECL_P (temp))
3530               {
3531                 result = expr_to_string (temp);
3532                 break;
3533               }
3534           }
3535         result = decl_to_string (temp, verbose);
3536       }
3537       break;
3538     case 'E': result = expr_to_string (next_tree);              break;
3539     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
3540     case 'L': result = language_to_string (next_lang);          break;
3541     case 'O': result = op_to_string (next_tcode);               break;
3542     case 'P': result = parm_to_string (next_int);               break;
3543     case 'Q': result = assop_to_string (next_tcode);            break;
3544     case 'S': result = subst_to_string (next_tree);             break;
3545     case 'T': result = type_to_string (next_tree, verbose);     break;
3546     case 'V': result = cv_to_string (next_tree, verbose);       break;
3547     case 'X': result = eh_spec_to_string (next_tree, verbose);  break;
3548
3549     case 'K':
3550       percent_K_format (text);
3551       return true;
3552
3553     default:
3554       return false;
3555     }
3556
3557   pp_string (pp, result);
3558   if (set_locus && t != NULL)
3559     text->set_location (0, location_of (t), true);
3560   return true;
3561 #undef next_tree
3562 #undef next_tcode
3563 #undef next_lang
3564 #undef next_int
3565 }
3566 \f
3567 /* Warn about the use of C++0x features when appropriate.  */
3568 void
3569 maybe_warn_cpp0x (cpp0x_warn_str str)
3570 {
3571   if ((cxx_dialect == cxx98) && !in_system_header_at (input_location))
3572     /* We really want to suppress this warning in system headers,
3573        because libstdc++ uses variadic templates even when we aren't
3574        in C++0x mode. */
3575     switch (str)
3576       {
3577       case CPP0X_INITIALIZER_LISTS:
3578         pedwarn (input_location, 0,
3579                  "extended initializer lists "
3580                  "only available with -std=c++11 or -std=gnu++11");
3581         break;
3582       case CPP0X_EXPLICIT_CONVERSION:
3583         pedwarn (input_location, 0,
3584                  "explicit conversion operators "
3585                  "only available with -std=c++11 or -std=gnu++11");
3586         break;
3587       case CPP0X_VARIADIC_TEMPLATES:
3588         pedwarn (input_location, 0,
3589                  "variadic templates "
3590                  "only available with -std=c++11 or -std=gnu++11");
3591         break;
3592       case CPP0X_LAMBDA_EXPR:
3593         pedwarn (input_location, 0,
3594                  "lambda expressions "
3595                   "only available with -std=c++11 or -std=gnu++11");
3596         break;
3597       case CPP0X_AUTO:
3598         pedwarn (input_location, 0,
3599                  "C++11 auto only available with -std=c++11 or -std=gnu++11");
3600         break;
3601       case CPP0X_SCOPED_ENUMS:
3602         pedwarn (input_location, 0,
3603                  "scoped enums only available with -std=c++11 or -std=gnu++11");
3604         break;
3605       case CPP0X_DEFAULTED_DELETED:
3606         pedwarn (input_location, 0,
3607                  "defaulted and deleted functions "
3608                  "only available with -std=c++11 or -std=gnu++11");
3609         break;
3610       case CPP0X_INLINE_NAMESPACES:
3611         pedwarn (input_location, OPT_Wpedantic,
3612                  "inline namespaces "
3613                  "only available with -std=c++11 or -std=gnu++11");
3614         break;
3615       case CPP0X_OVERRIDE_CONTROLS:
3616         pedwarn (input_location, 0,
3617                  "override controls (override/final) "
3618                  "only available with -std=c++11 or -std=gnu++11");
3619         break;
3620       case CPP0X_NSDMI:
3621         pedwarn (input_location, 0,
3622                  "non-static data member initializers "
3623                  "only available with -std=c++11 or -std=gnu++11");
3624         break;
3625       case CPP0X_USER_DEFINED_LITERALS:
3626         pedwarn (input_location, 0,
3627                  "user-defined literals "
3628                  "only available with -std=c++11 or -std=gnu++11");
3629         break;
3630       case CPP0X_DELEGATING_CTORS:
3631         pedwarn (input_location, 0,
3632                  "delegating constructors "
3633                  "only available with -std=c++11 or -std=gnu++11");
3634         break;
3635       case CPP0X_INHERITING_CTORS:
3636         pedwarn (input_location, 0,
3637                  "inheriting constructors "
3638                  "only available with -std=c++11 or -std=gnu++11");
3639         break;
3640       case CPP0X_ATTRIBUTES:
3641         pedwarn (input_location, 0,
3642                  "c++11 attributes "
3643                  "only available with -std=c++11 or -std=gnu++11");
3644         break;
3645       case CPP0X_REF_QUALIFIER:
3646         pedwarn (input_location, 0,
3647                  "ref-qualifiers "
3648                  "only available with -std=c++11 or -std=gnu++11");
3649         break;
3650       default:
3651         gcc_unreachable ();
3652       }
3653 }
3654
3655 /* Warn about the use of variadic templates when appropriate.  */
3656 void
3657 maybe_warn_variadic_templates (void)
3658 {
3659   maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3660 }
3661
3662
3663 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3664    option OPT with text GMSGID.  Use this function to report
3665    diagnostics for constructs that are invalid C++98, but valid
3666    C++0x.  */
3667 bool
3668 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3669 {
3670   diagnostic_info diagnostic;
3671   va_list ap;
3672   bool ret;
3673   rich_location richloc (line_table, location);
3674
3675   va_start (ap, gmsgid);
3676   diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc,
3677                        (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3678   diagnostic.option_index = opt;
3679   ret = report_diagnostic (&diagnostic);
3680   va_end (ap);
3681   return ret;
3682 }
3683
3684 /* Issue a diagnostic that NAME cannot be found in SCOPE.  DECL is what
3685    we found when we tried to do the lookup.  LOCATION is the location of
3686    the NAME identifier.  */
3687
3688 void
3689 qualified_name_lookup_error (tree scope, tree name,
3690                              tree decl, location_t location)
3691 {
3692   if (scope == error_mark_node)
3693     ; /* We already complained.  */
3694   else if (TYPE_P (scope))
3695     {
3696       if (!COMPLETE_TYPE_P (scope))
3697         error_at (location, "incomplete type %qT used in nested name specifier",
3698                   scope);
3699       else if (TREE_CODE (decl) == TREE_LIST)
3700         {
3701           error_at (location, "reference to %<%T::%D%> is ambiguous",
3702                     scope, name);
3703           print_candidates (decl);
3704         }
3705       else
3706         error_at (location, "%qD is not a member of %qT", name, scope);
3707     }
3708   else if (scope != global_namespace)
3709     {
3710       error_at (location, "%qD is not a member of %qD", name, scope);
3711       suggest_alternatives_for (location, name);
3712     }
3713   else
3714     {
3715       error_at (location, "%<::%D%> has not been declared", name);
3716       suggest_alternatives_for (location, name);
3717     }
3718 }