gcc/cp/error.c

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