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