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       /* 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.  */
 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_("<unnamed>"));
 683       else
 684         pp_printf (pp, M_("<unnamed %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) && DECL_DECLARED_CONSTEXPR_P (t))
 963         {
 964           if (DECL_LANG_SPECIFIC (t) && DECL_DECLARED_CONCEPT_P (t))
 965             pp_cxx_ws_string (pp, "concept");
 966           else
 967             pp_cxx_ws_string (pp, "constexpr");
 968         }
 969       dump_type_prefix (pp, type, flags & ~TFF_UNQUALIFIED_NAME);
 970       pp_maybe_space (pp);
 971     }
 972   if (! (flags & TFF_UNQUALIFIED_NAME)
 973       && TREE_CODE (t) != PARM_DECL
 974       && (!DECL_INITIAL (t)
 975           || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
 976     dump_scope (pp, CP_DECL_CONTEXT (t), flags);
 977   flags &= ~TFF_UNQUALIFIED_NAME;
 978   if ((flags & TFF_DECL_SPECIFIERS)
 979       && DECL_TEMPLATE_PARM_P (t)
 980       && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
 981     pp_string (pp, "...");
 982   if (DECL_NAME (t))
 983     {
 984       if (TREE_CODE (t) == FIELD_DECL && DECL_NORMAL_CAPTURE_P (t))
 985         {
 986           pp_less (pp);
 987           pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t)) + 2);
 988           pp_string (pp, " capture>");
 989         }
 990       else
 991         dump_decl (pp, DECL_NAME (t), flags);
 992     }
 993   else
 994     pp_string (pp, M_("<anonymous>"));
 995   if (flags & TFF_DECL_SPECIFIERS)
 996     dump_type_suffix (pp, type, flags);
 997 }
 998
 999 /* Dump a human readable string for the decl T under control of FLAGS.  */
1000
1001 static void
1002 dump_decl (cxx_pretty_printer *pp, tree t, int flags)
1003 {
1004   if (t == NULL_TREE)
1005     return;
1006
1007   /* If doing Objective-C++, give Objective-C a chance to demangle
1008      Objective-C method names.  */
1009   if (c_dialect_objc ())
1010     {
1011       const char *demangled = objc_maybe_printable_name (t, flags);
1012       if (demangled)
1013         {
1014           pp_string (pp, demangled);
1015           return;
1016         }
1017     }
1018
1019   switch (TREE_CODE (t))
1020     {
1021     case TYPE_DECL:
1022       /* Don't say 'typedef class A' */
1023       if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
1024         {
1025           if ((flags & TFF_DECL_SPECIFIERS)
1026               && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
1027             {
1028               /* Say `class T' not just `T'.  */
1029               pp_cxx_ws_string (pp, "class");
1030
1031               /* Emit the `...' for a parameter pack.  */
1032               if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1033                 pp_cxx_ws_string (pp, "...");
1034             }
1035
1036           dump_type (pp, TREE_TYPE (t), flags);
1037           break;
1038         }
1039       if (TYPE_DECL_ALIAS_P (t)
1040           && (flags & TFF_DECL_SPECIFIERS
1041               || flags & TFF_CLASS_KEY_OR_ENUM))
1042         {
1043           pp_cxx_ws_string (pp, "using");
1044           dump_decl (pp, DECL_NAME (t), flags);
1045           pp_cxx_whitespace (pp);
1046           pp_cxx_ws_string (pp, "=");
1047           pp_cxx_whitespace (pp);
1048           dump_type (pp, DECL_ORIGINAL_TYPE (t), flags);
1049           break;
1050         }
1051       if ((flags & TFF_DECL_SPECIFIERS)
1052           && !DECL_SELF_REFERENCE_P (t))
1053         pp_cxx_ws_string (pp, "typedef");
1054       dump_simple_decl (pp, t, DECL_ORIGINAL_TYPE (t)
1055                         ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
1056                         flags);
1057       break;
1058
1059     case VAR_DECL:
1060       if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
1061         {
1062           pp_string (pp, M_("vtable for "));
1063           gcc_assert (TYPE_P (DECL_CONTEXT (t)));
1064           dump_type (pp, DECL_CONTEXT (t), flags);
1065           break;
1066         }
1067       /* Fall through.  */
1068     case FIELD_DECL:
1069     case PARM_DECL:
1070       dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1071
1072       /* Handle variable template specializations.  */
1073       if (VAR_P (t)
1074           && DECL_LANG_SPECIFIC (t)
1075           && DECL_TEMPLATE_INFO (t)
1076           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))
1077         {
1078           pp_cxx_begin_template_argument_list (pp);
1079           tree args = INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t));
1080           dump_template_argument_list (pp, args, flags);
1081           pp_cxx_end_template_argument_list (pp);
1082         }
1083       break;
1084
1085     case RESULT_DECL:
1086       pp_string (pp, M_("<return value> "));
1087       dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1088       break;
1089
1090     case NAMESPACE_DECL:
1091       if (flags & TFF_DECL_SPECIFIERS)
1092         pp->declaration (t);
1093       else
1094         {
1095           if (! (flags & TFF_UNQUALIFIED_NAME))
1096             dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1097           flags &= ~TFF_UNQUALIFIED_NAME;
1098           if (DECL_NAME (t) == NULL_TREE)
1099             {
1100               if (!(pp->flags & pp_c_flag_gnu_v3))
1101                 pp_cxx_ws_string (pp, M_("{anonymous}"));
1102               else
1103                 pp_cxx_ws_string (pp, M_("(anonymous namespace)"));
1104             }
1105           else
1106             pp_cxx_tree_identifier (pp, DECL_NAME (t));
1107         }
1108       break;
1109
1110     case SCOPE_REF:
1111       dump_type (pp, TREE_OPERAND (t, 0), flags);
1112       pp_colon_colon (pp);
1113       dump_decl (pp, TREE_OPERAND (t, 1), TFF_UNQUALIFIED_NAME);
1114       break;
1115
1116     case ARRAY_REF:
1117       dump_decl (pp, TREE_OPERAND (t, 0), flags);
1118       pp_cxx_left_bracket (pp);
1119       dump_decl (pp, TREE_OPERAND (t, 1), flags);
1120       pp_cxx_right_bracket (pp);
1121       break;
1122
1123     case ARRAY_NOTATION_REF:
1124       dump_decl (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
1125       pp_cxx_left_bracket (pp);
1126       dump_decl (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
1127       pp_colon (pp);
1128       dump_decl (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
1129       pp_colon (pp);
1130       dump_decl (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
1131       pp_cxx_right_bracket (pp);
1132       break;
1133
1134       /* So that we can do dump_decl on an aggr type.  */
1135     case RECORD_TYPE:
1136     case UNION_TYPE:
1137     case ENUMERAL_TYPE:
1138       dump_type (pp, t, flags);
1139       break;
1140
1141     case BIT_NOT_EXPR:
1142       /* This is a pseudo destructor call which has not been folded into
1143          a PSEUDO_DTOR_EXPR yet.  */
1144       pp_cxx_complement (pp);
1145       dump_type (pp, TREE_OPERAND (t, 0), flags);
1146       break;
1147
1148     case TYPE_EXPR:
1149       gcc_unreachable ();
1150       break;
1151
1152       /* These special cases are duplicated here so that other functions
1153          can feed identifiers to error and get them demangled properly.  */
1154     case IDENTIFIER_NODE:
1155       if (IDENTIFIER_TYPENAME_P (t))
1156         {
1157           pp_cxx_ws_string (pp, "operator");
1158           /* Not exactly IDENTIFIER_TYPE_VALUE.  */
1159           dump_type (pp, TREE_TYPE (t), flags);
1160           break;
1161         }
1162       else
1163         pp_cxx_tree_identifier (pp, t);
1164       break;
1165
1166     case OVERLOAD:
1167       if (OVL_CHAIN (t))
1168         {
1169           t = OVL_CURRENT (t);
1170           if (DECL_CLASS_SCOPE_P (t))
1171             {
1172               dump_type (pp, DECL_CONTEXT (t), flags);
1173               pp_cxx_colon_colon (pp);
1174             }
1175           else if (!DECL_FILE_SCOPE_P (t))
1176             {
1177               dump_decl (pp, DECL_CONTEXT (t), flags);
1178               pp_cxx_colon_colon (pp);
1179             }
1180           dump_decl (pp, DECL_NAME (t), flags);
1181           break;
1182         }
1183
1184       /* If there's only one function, just treat it like an ordinary
1185          FUNCTION_DECL.  */
1186       t = OVL_CURRENT (t);
1187       /* Fall through.  */
1188
1189     case FUNCTION_DECL:
1190       if (! DECL_LANG_SPECIFIC (t))
1191         {
1192           if (DECL_ABSTRACT_ORIGIN (t))
1193             dump_decl (pp, DECL_ABSTRACT_ORIGIN (t), flags);
1194           else
1195             pp_string (pp, M_("<built-in>"));
1196         }
1197       else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
1198         dump_global_iord (pp, t);
1199       else
1200         dump_function_decl (pp, t, flags);
1201       break;
1202
1203     case TEMPLATE_DECL:
1204       dump_template_decl (pp, t, flags);
1205       break;
1206
1207     case TEMPLATE_ID_EXPR:
1208       {
1209         tree name = TREE_OPERAND (t, 0);
1210         tree args = TREE_OPERAND (t, 1);
1211
1212         if (is_overloaded_fn (name))
1213           name = get_first_fn (name);
1214         if (DECL_P (name))
1215           name = DECL_NAME (name);
1216         dump_decl (pp, name, flags);
1217         pp_cxx_begin_template_argument_list (pp);
1218         if (args == error_mark_node)
1219           pp_string (pp, M_("<template arguments error>"));
1220         else if (args)
1221           dump_template_argument_list
1222             (pp, args, flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
1223         pp_cxx_end_template_argument_list (pp);
1224       }
1225       break;
1226
1227     case LABEL_DECL:
1228       pp_cxx_tree_identifier (pp, DECL_NAME (t));
1229       break;
1230
1231     case CONST_DECL:
1232       if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
1233           || (DECL_INITIAL (t) &&
1234               TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
1235         dump_simple_decl (pp, t, TREE_TYPE (t), flags);
1236       else if (DECL_NAME (t))
1237         dump_decl (pp, DECL_NAME (t), flags);
1238       else if (DECL_INITIAL (t))
1239         dump_expr (pp, DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
1240       else
1241         pp_string (pp, M_("<enumerator>"));
1242       break;
1243
1244     case USING_DECL:
1245       pp_cxx_ws_string (pp, "using");
1246       dump_type (pp, USING_DECL_SCOPE (t), flags);
1247       pp_cxx_colon_colon (pp);
1248       dump_decl (pp, DECL_NAME (t), flags);
1249       break;
1250
1251     case STATIC_ASSERT:
1252       pp->declaration (t);
1253       break;
1254
1255     case BASELINK:
1256       dump_decl (pp, BASELINK_FUNCTIONS (t), flags);
1257       break;
1258
1259     case NON_DEPENDENT_EXPR:
1260       dump_expr (pp, t, flags);
1261       break;
1262
1263     case TEMPLATE_TYPE_PARM:
1264       if (flags & TFF_DECL_SPECIFIERS)
1265         pp->declaration (t);
1266       else
1267         pp->type_id (t);
1268       break;
1269
1270     case UNBOUND_CLASS_TEMPLATE:
1271     case TYPE_PACK_EXPANSION:
1272     case TREE_BINFO:
1273       dump_type (pp, t, flags);
1274       break;
1275
1276     default:
1277       pp_unsupported_tree (pp, t);
1278       /* Fall through.  */
1279
1280     case ERROR_MARK:
1281       pp_string (pp, M_("<declaration error>"));
1282       break;
1283     }
1284 }
1285
1286 /* Dump a template declaration T under control of FLAGS. This means the
1287    'template <...> leaders plus the 'class X' or 'void fn(...)' part.  */
1288
1289 static void
1290 dump_template_decl (cxx_pretty_printer *pp, tree t, int flags)
1291 {
1292   tree orig_parms = DECL_TEMPLATE_PARMS (t);
1293   tree parms;
1294   int i;
1295
1296   if (flags & TFF_TEMPLATE_HEADER)
1297     {
1298       for (parms = orig_parms = nreverse (orig_parms);
1299            parms;
1300            parms = TREE_CHAIN (parms))
1301         {
1302           tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
1303           int len = TREE_VEC_LENGTH (inner_parms);
1304
1305           if (len == 0)
1306             {
1307               /* Skip over the dummy template levels of a template template
1308                  parm.  */
1309               gcc_assert (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TEMPLATE_PARM);
1310               continue;
1311             }
1312
1313           pp_cxx_ws_string (pp, "template");
1314           pp_cxx_begin_template_argument_list (pp);
1315
1316           /* If we've shown the template prefix, we'd better show the
1317              parameters' and decl's type too.  */
1318             flags |= TFF_DECL_SPECIFIERS;
1319
1320           for (i = 0; i < len; i++)
1321             {
1322               if (i)
1323                 pp_separate_with_comma (pp);
1324               dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i),
1325                                        flags);
1326             }
1327           pp_cxx_end_template_argument_list (pp);
1328           pp_cxx_whitespace (pp);
1329         }
1330       nreverse(orig_parms);
1331
1332       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1333         {
1334           /* Say `template<arg> class TT' not just `template<arg> TT'.  */
1335           pp_cxx_ws_string (pp, "class");
1336
1337           /* If this is a parameter pack, print the ellipsis.  */
1338           if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1339             pp_cxx_ws_string (pp, "...");
1340         }
1341
1342       /* Only print the requirements if we're also printing
1343          the template header.  */
1344       if (flag_concepts)
1345         if (tree ci = get_constraints (t))
1346           if (check_constraint_info (ci))
1347             if (tree reqs = CI_TEMPLATE_REQS (ci))
1348               {
1349                 pp_cxx_requires_clause (pp, reqs);
1350                 pp_cxx_whitespace (pp);
1351               }
1352     }
1353
1354
1355   if (DECL_CLASS_TEMPLATE_P (t))
1356     dump_type (pp, TREE_TYPE (t),
1357                ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1358                 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1359   else if (DECL_TEMPLATE_RESULT (t)
1360            && (VAR_P (DECL_TEMPLATE_RESULT (t))
1361                /* Alias template.  */
1362                || DECL_TYPE_TEMPLATE_P (t)))
1363     dump_decl (pp, DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1364   else
1365     {
1366       gcc_assert (TREE_TYPE (t));
1367       switch (NEXT_CODE (t))
1368         {
1369         case METHOD_TYPE:
1370         case FUNCTION_TYPE:
1371           dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME);
1372           break;
1373         default:
1374           /* This case can occur with some invalid code.  */
1375           dump_type (pp, TREE_TYPE (t),
1376                      (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1377                      | (flags & TFF_DECL_SPECIFIERS
1378                         ? TFF_CLASS_KEY_OR_ENUM : 0));
1379         }
1380     }
1381 }
1382
1383 /* find_typenames looks through the type of the function template T
1384    and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1385    it finds.  */
1386
1387 struct find_typenames_t
1388 {
1389   hash_set<tree> *p_set;
1390   vec<tree, va_gc> *typenames;
1391 };
1392
1393 static tree
1394 find_typenames_r (tree *tp, int *walk_subtrees, void *data)
1395 {
1396   struct find_typenames_t *d = (struct find_typenames_t *)data;
1397   tree mv = NULL_TREE;
1398
1399   if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1400     /* Add the type of the typedef without any additional cv-quals.  */
1401     mv = TREE_TYPE (TYPE_NAME (*tp));
1402   else if (TREE_CODE (*tp) == TYPENAME_TYPE
1403            || TREE_CODE (*tp) == DECLTYPE_TYPE)
1404     /* Add the typename without any cv-qualifiers.  */
1405     mv = TYPE_MAIN_VARIANT (*tp);
1406
1407   if (TREE_CODE (*tp) == TYPE_PACK_EXPANSION)
1408     {
1409       /* Don't mess with parameter packs since we don't remember
1410          the pack expansion context for a particular typename.  */
1411       *walk_subtrees = false;
1412       return NULL_TREE;
1413     }
1414
1415   if (mv && (mv == *tp || !d->p_set->add (mv)))
1416     vec_safe_push (d->typenames, mv);
1417
1418   /* Search into class template arguments, which cp_walk_subtrees
1419      doesn't do.  */
1420   if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1421     cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1422                   data, d->p_set);
1423
1424   return NULL_TREE;
1425 }
1426
1427 static vec<tree, va_gc> *
1428 find_typenames (tree t)
1429 {
1430   struct find_typenames_t ft;
1431   ft.p_set = new hash_set<tree>;
1432   ft.typenames = NULL;
1433   cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1434                 find_typenames_r, &ft, ft.p_set);
1435   delete ft.p_set;
1436   return ft.typenames;
1437 }
1438
1439 /* Output the "[with ...]" clause for a template instantiation T iff
1440    TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable.  T may be NULL if
1441    formatting a deduction/substitution diagnostic rather than an
1442    instantiation.  */
1443
1444 static void
1445 dump_substitution (cxx_pretty_printer *pp,
1446                    tree t, tree template_parms, tree template_args,
1447                    int flags)
1448 {
1449   if (template_parms != NULL_TREE && template_args != NULL_TREE
1450       && !(flags & TFF_NO_TEMPLATE_BINDINGS))
1451     {
1452       vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL;
1453       pp_cxx_whitespace (pp);
1454       pp_cxx_left_bracket (pp);
1455       pp->translate_string ("with");
1456       pp_cxx_whitespace (pp);
1457       dump_template_bindings (pp, template_parms, template_args, typenames);
1458       pp_cxx_right_bracket (pp);
1459     }
1460 }
1461
1462 /* Dump the lambda function FN including its 'mutable' qualifier and any
1463    template bindings.  */
1464
1465 static void
1466 dump_lambda_function (cxx_pretty_printer *pp,
1467                       tree fn, tree template_parms, tree template_args,
1468                       int flags)
1469 {
1470   /* A lambda's signature is essentially its "type".  */
1471   dump_type (pp, DECL_CONTEXT (fn), flags);
1472   if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST))
1473     {
1474       pp->padding = pp_before;
1475       pp_c_ws_string (pp, "mutable");
1476     }
1477   dump_substitution (pp, fn, template_parms, template_args, flags);
1478 }
1479
1480 /* Pretty print a function decl. There are several ways we want to print a
1481    function declaration. The TFF_ bits in FLAGS tells us how to behave.
1482    As error can only apply the '#' flag once to give 0 and 1 for V, there
1483    is %D which doesn't print the throw specs, and %F which does.  */
1484
1485 static void
1486 dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
1487 {
1488   tree fntype;
1489   tree parmtypes;
1490   tree cname = NULL_TREE;
1491   tree template_args = NULL_TREE;
1492   tree template_parms = NULL_TREE;
1493   int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1494   int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1495   tree exceptions;
1496   bool constexpr_p;
1497
1498   flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME);
1499   if (TREE_CODE (t) == TEMPLATE_DECL)
1500     t = DECL_TEMPLATE_RESULT (t);
1501
1502   /* Save the exceptions, in case t is a specialization and we are
1503      emitting an error about incompatible specifications.  */
1504   exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1505
1506   /* Likewise for the constexpr specifier, in case t is a specialization.  */
1507   constexpr_p = DECL_DECLARED_CONSTEXPR_P (t);
1508
1509   /* Pretty print template instantiations only.  */
1510   if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1511       && !(flags & TFF_NO_TEMPLATE_BINDINGS)
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_UNNAMED_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_TEMPLATE_BINDINGS
1993                          | TFF_NO_FUNCTION_ARGUMENTS));
1994       break;
1995
1996     case SSA_NAME:
1997       if (SSA_NAME_VAR (t)
1998           && !DECL_ARTIFICIAL (SSA_NAME_VAR (t)))
1999         dump_expr (pp, SSA_NAME_VAR (t), flags);
2000       else
2001         pp_cxx_ws_string (pp, M_("<unknown>"));
2002       break;
2003
2004     case VOID_CST:
2005     case INTEGER_CST:
2006     case REAL_CST:
2007     case STRING_CST:
2008     case COMPLEX_CST:
2009       pp->constant (t);
2010       break;
2011
2012     case USERDEF_LITERAL:
2013       pp_cxx_userdef_literal (pp, t);
2014       break;
2015
2016     case THROW_EXPR:
2017       /* While waiting for caret diagnostics, avoid printing
2018          __cxa_allocate_exception, __cxa_throw, and the like.  */
2019       pp_cxx_ws_string (pp, M_("<throw-expression>"));
2020       break;
2021
2022     case PTRMEM_CST:
2023       pp_ampersand (pp);
2024       dump_type (pp, PTRMEM_CST_CLASS (t), flags);
2025       pp_cxx_colon_colon (pp);
2026       pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
2027       break;
2028
2029     case COMPOUND_EXPR:
2030       pp_cxx_left_paren (pp);
2031       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2032       pp_separate_with_comma (pp);
2033       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2034       pp_cxx_right_paren (pp);
2035       break;
2036
2037     case COND_EXPR:
2038       pp_cxx_left_paren (pp);
2039       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2040       pp_string (pp, " ? ");
2041       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2042       pp_string (pp, " : ");
2043       dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
2044       pp_cxx_right_paren (pp);
2045       break;
2046
2047     case SAVE_EXPR:
2048       if (TREE_HAS_CONSTRUCTOR (t))
2049         {
2050           pp_cxx_ws_string (pp, "new");
2051           pp_cxx_whitespace (pp);
2052           dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
2053         }
2054       else
2055         dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2056       break;
2057
2058     case AGGR_INIT_EXPR:
2059       {
2060         tree fn = NULL_TREE;
2061
2062         if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
2063           fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
2064
2065         if (fn && TREE_CODE (fn) == FUNCTION_DECL)
2066           {
2067             if (DECL_CONSTRUCTOR_P (fn))
2068               dump_type (pp, DECL_CONTEXT (fn), flags);
2069             else
2070               dump_decl (pp, fn, 0);
2071           }
2072         else
2073           dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0);
2074       }
2075       dump_aggr_init_expr_args (pp, t, flags, true);
2076       break;
2077
2078     case CALL_EXPR:
2079       {
2080         tree fn = CALL_EXPR_FN (t);
2081         bool skipfirst = false;
2082
2083         /* Deal with internal functions.  */
2084         if (fn == NULL_TREE)
2085           {
2086             pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t)));
2087             dump_call_expr_args (pp, t, flags, skipfirst);
2088             break;
2089           }
2090
2091         if (TREE_CODE (fn) == ADDR_EXPR)
2092           fn = TREE_OPERAND (fn, 0);
2093
2094         /* Nobody is interested in seeing the guts of vcalls.  */
2095         if (TREE_CODE (fn) == OBJ_TYPE_REF)
2096           fn = resolve_virtual_fun_from_obj_type_ref (fn);
2097
2098         if (TREE_TYPE (fn) != NULL_TREE
2099             && NEXT_CODE (fn) == METHOD_TYPE
2100             && call_expr_nargs (t))
2101           {
2102             tree ob = CALL_EXPR_ARG (t, 0);
2103             if (TREE_CODE (ob) == ADDR_EXPR)
2104               {
2105                 dump_expr (pp, TREE_OPERAND (ob, 0),
2106                            flags | TFF_EXPR_IN_PARENS);
2107                 pp_cxx_dot (pp);
2108               }
2109             else if (TREE_CODE (ob) != PARM_DECL
2110                      || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
2111               {
2112                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2113                 pp_cxx_arrow (pp);
2114               }
2115             skipfirst = true;
2116           }
2117         if (flag_sanitize & SANITIZE_UNDEFINED
2118             && is_ubsan_builtin_p (fn))
2119           {
2120             pp_string (cxx_pp, M_("<ubsan routine call>"));
2121             break;
2122           }
2123         dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS);
2124         dump_call_expr_args (pp, t, flags, skipfirst);
2125       }
2126       break;
2127
2128     case TARGET_EXPR:
2129       /* Note that this only works for G++ target exprs.  If somebody
2130          builds a general TARGET_EXPR, there's no way to represent that
2131          it initializes anything other that the parameter slot for the
2132          default argument.  Note we may have cleared out the first
2133          operand in expand_expr, so don't go killing ourselves.  */
2134       if (TREE_OPERAND (t, 1))
2135         dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2136       break;
2137
2138     case POINTER_PLUS_EXPR:
2139       dump_binary_op (pp, "+", t, flags);
2140       break;
2141
2142     case INIT_EXPR:
2143     case MODIFY_EXPR:
2144       dump_binary_op (pp, assignment_operator_name_info[NOP_EXPR].name,
2145                       t, flags);
2146       break;
2147
2148     case PLUS_EXPR:
2149     case MINUS_EXPR:
2150     case MULT_EXPR:
2151     case TRUNC_DIV_EXPR:
2152     case TRUNC_MOD_EXPR:
2153     case MIN_EXPR:
2154     case MAX_EXPR:
2155     case LSHIFT_EXPR:
2156     case RSHIFT_EXPR:
2157     case BIT_IOR_EXPR:
2158     case BIT_XOR_EXPR:
2159     case BIT_AND_EXPR:
2160     case TRUTH_ANDIF_EXPR:
2161     case TRUTH_ORIF_EXPR:
2162     case LT_EXPR:
2163     case LE_EXPR:
2164     case GT_EXPR:
2165     case GE_EXPR:
2166     case EQ_EXPR:
2167     case NE_EXPR:
2168     case EXACT_DIV_EXPR:
2169       dump_binary_op (pp, operator_name_info[TREE_CODE (t)].name, t, flags);
2170       break;
2171
2172     case CEIL_DIV_EXPR:
2173     case FLOOR_DIV_EXPR:
2174     case ROUND_DIV_EXPR:
2175     case RDIV_EXPR:
2176       dump_binary_op (pp, "/", t, flags);
2177       break;
2178
2179     case CEIL_MOD_EXPR:
2180     case FLOOR_MOD_EXPR:
2181     case ROUND_MOD_EXPR:
2182       dump_binary_op (pp, "%", t, flags);
2183       break;
2184
2185     case COMPONENT_REF:
2186       {
2187         tree ob = TREE_OPERAND (t, 0);
2188         if (INDIRECT_REF_P (ob))
2189           {
2190             ob = TREE_OPERAND (ob, 0);
2191             if (TREE_CODE (ob) != PARM_DECL
2192                 || (DECL_NAME (ob)
2193                     && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
2194               {
2195                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2196                 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
2197                   pp_cxx_dot (pp);
2198                 else
2199                   pp_cxx_arrow (pp);
2200               }
2201           }
2202         else
2203           {
2204             dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2205             pp_cxx_dot (pp);
2206           }
2207         dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
2208       }
2209       break;
2210
2211     case ARRAY_REF:
2212       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2213       pp_cxx_left_bracket (pp);
2214       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2215       pp_cxx_right_bracket (pp);
2216       break;
2217
2218     case ARRAY_NOTATION_REF:
2219       dump_expr (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
2220       pp_cxx_left_bracket (pp);
2221       dump_expr (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
2222       pp_colon (pp);
2223       dump_expr (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
2224       pp_colon (pp);
2225       dump_expr (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
2226       pp_cxx_right_bracket (pp);
2227       break;
2228
2229     case UNARY_PLUS_EXPR:
2230       dump_unary_op (pp, "+", t, flags);
2231       break;
2232
2233     case ADDR_EXPR:
2234       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
2235           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
2236           /* An ADDR_EXPR can have reference type.  In that case, we
2237              shouldn't print the `&' doing so indicates to the user
2238              that the expression has pointer type.  */
2239           || (TREE_TYPE (t)
2240               && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
2241         dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2242       else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
2243         dump_unary_op (pp, "&&", t, flags);
2244       else
2245         dump_unary_op (pp, "&", t, flags);
2246       break;
2247
2248     case INDIRECT_REF:
2249       if (TREE_HAS_CONSTRUCTOR (t))
2250         {
2251           t = TREE_OPERAND (t, 0);
2252           gcc_assert (TREE_CODE (t) == CALL_EXPR);
2253           dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
2254           dump_call_expr_args (pp, t, flags, true);
2255         }
2256       else
2257         {
2258           if (TREE_OPERAND (t,0) != NULL_TREE
2259               && TREE_TYPE (TREE_OPERAND (t, 0))
2260               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
2261             dump_expr (pp, TREE_OPERAND (t, 0), flags);
2262           else
2263             dump_unary_op (pp, "*", t, flags);
2264         }
2265       break;
2266
2267     case MEM_REF:
2268       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
2269           && integer_zerop (TREE_OPERAND (t, 1)))
2270         dump_expr (pp, TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
2271       else
2272         {
2273           pp_cxx_star (pp);
2274           if (!integer_zerop (TREE_OPERAND (t, 1)))
2275             {
2276               pp_cxx_left_paren (pp);
2277               if (!integer_onep (TYPE_SIZE_UNIT
2278                                  (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
2279                 {
2280                   pp_cxx_left_paren (pp);
2281                   dump_type (pp, ptr_type_node, flags);
2282                   pp_cxx_right_paren (pp);
2283                 }
2284             }
2285           dump_expr (pp, TREE_OPERAND (t, 0), flags);
2286           if (!integer_zerop (TREE_OPERAND (t, 1)))
2287             {
2288               pp_cxx_ws_string (pp, "+");
2289               dump_expr (pp, fold_convert (ssizetype, TREE_OPERAND (t, 1)),
2290                          flags);
2291               pp_cxx_right_paren (pp);
2292             }
2293         }
2294       break;
2295
2296     case NEGATE_EXPR:
2297     case BIT_NOT_EXPR:
2298     case TRUTH_NOT_EXPR:
2299     case PREDECREMENT_EXPR:
2300     case PREINCREMENT_EXPR:
2301       dump_unary_op (pp, operator_name_info [TREE_CODE (t)].name, t, flags);
2302       break;
2303
2304     case POSTDECREMENT_EXPR:
2305     case POSTINCREMENT_EXPR:
2306       pp_cxx_left_paren (pp);
2307       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2308       pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2309       pp_cxx_right_paren (pp);
2310       break;
2311
2312     case NON_LVALUE_EXPR:
2313       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
2314          should be another level of INDIRECT_REF so that I don't have to do
2315          this.  */
2316       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2317         {
2318           tree next = TREE_TYPE (TREE_TYPE (t));
2319
2320           while (TYPE_PTR_P (next))
2321             next = TREE_TYPE (next);
2322
2323           if (TREE_CODE (next) == FUNCTION_TYPE)
2324             {
2325               if (flags & TFF_EXPR_IN_PARENS)
2326                 pp_cxx_left_paren (pp);
2327               pp_cxx_star (pp);
2328               dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2329               if (flags & TFF_EXPR_IN_PARENS)
2330                 pp_cxx_right_paren (pp);
2331               break;
2332             }
2333           /* Else fall through.  */
2334         }
2335       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2336       break;
2337
2338     CASE_CONVERT:
2339     case IMPLICIT_CONV_EXPR:
2340     case VIEW_CONVERT_EXPR:
2341       {
2342         tree op = TREE_OPERAND (t, 0);
2343         tree ttype = TREE_TYPE (t);
2344         tree optype = TREE_TYPE (op);
2345
2346         if (TREE_CODE (ttype) != TREE_CODE (optype)
2347             && POINTER_TYPE_P (ttype)
2348             && POINTER_TYPE_P (optype)
2349             && same_type_p (TREE_TYPE (optype),
2350                             TREE_TYPE (ttype)))
2351           {
2352             if (TREE_CODE (ttype) == REFERENCE_TYPE)
2353               {
2354                 STRIP_NOPS (op);
2355                 if (TREE_CODE (op) == ADDR_EXPR)
2356                   dump_expr (pp, TREE_OPERAND (op, 0), flags);
2357                 else
2358                   dump_unary_op (pp, "*", t, flags);
2359               }
2360             else
2361               dump_unary_op (pp, "&", t, flags);
2362           }
2363         else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2364           {
2365             /* It is a cast, but we cannot tell whether it is a
2366                reinterpret or static cast. Use the C style notation.  */
2367             if (flags & TFF_EXPR_IN_PARENS)
2368               pp_cxx_left_paren (pp);
2369             pp_cxx_left_paren (pp);
2370             dump_type (pp, TREE_TYPE (t), flags);
2371             pp_cxx_right_paren (pp);
2372             dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS);
2373             if (flags & TFF_EXPR_IN_PARENS)
2374               pp_cxx_right_paren (pp);
2375           }
2376         else
2377           dump_expr (pp, op, flags);
2378         break;
2379       }
2380
2381     case CONSTRUCTOR:
2382       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2383         {
2384           tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2385
2386           if (integer_zerop (idx))
2387             {
2388               /* A NULL pointer-to-member constant.  */
2389               pp_cxx_left_paren (pp);
2390               pp_cxx_left_paren (pp);
2391               dump_type (pp, TREE_TYPE (t), flags);
2392               pp_cxx_right_paren (pp);
2393               pp_character (pp, '0');
2394               pp_cxx_right_paren (pp);
2395               break;
2396             }
2397           else if (tree_fits_shwi_p (idx))
2398             {
2399               tree virtuals;
2400               unsigned HOST_WIDE_INT n;
2401
2402               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2403               t = TYPE_METHOD_BASETYPE (t);
2404               virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2405
2406               n = tree_to_shwi (idx);
2407
2408               /* Map vtable index back one, to allow for the null pointer to
2409                  member.  */
2410               --n;
2411
2412               while (n > 0 && virtuals)
2413                 {
2414                   --n;
2415                   virtuals = TREE_CHAIN (virtuals);
2416                 }
2417               if (virtuals)
2418                 {
2419                   dump_expr (pp, BV_FN (virtuals),
2420                              flags | TFF_EXPR_IN_PARENS);
2421                   break;
2422                 }
2423             }
2424         }
2425       if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t)))
2426         pp_string (pp, "<lambda closure object>");
2427       if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2428         {
2429           dump_type (pp, TREE_TYPE (t), 0);
2430           pp_cxx_left_paren (pp);
2431           pp_cxx_right_paren (pp);
2432         }
2433       else
2434         {
2435           if (!BRACE_ENCLOSED_INITIALIZER_P (t))
2436             dump_type (pp, TREE_TYPE (t), 0);
2437           pp_cxx_left_brace (pp);
2438           dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags);
2439           pp_cxx_right_brace (pp);
2440         }
2441
2442       break;
2443
2444     case OFFSET_REF:
2445       {
2446         tree ob = TREE_OPERAND (t, 0);
2447         if (is_dummy_object (ob))
2448           {
2449             t = TREE_OPERAND (t, 1);
2450             if (TREE_CODE (t) == FUNCTION_DECL)
2451               /* A::f */
2452               dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS);
2453             else if (BASELINK_P (t))
2454               dump_expr (pp, OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2455                          flags | TFF_EXPR_IN_PARENS);
2456             else
2457               dump_decl (pp, t, flags);
2458           }
2459         else
2460           {
2461             if (INDIRECT_REF_P (ob))
2462               {
2463                 dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2464                 pp_cxx_arrow (pp);
2465                 pp_cxx_star (pp);
2466               }
2467             else
2468               {
2469                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2470                 pp_cxx_dot (pp);
2471                 pp_cxx_star (pp);
2472               }
2473             dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2474           }
2475         break;
2476       }
2477
2478     case TEMPLATE_PARM_INDEX:
2479       dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2480       break;
2481
2482     case CAST_EXPR:
2483       if (TREE_OPERAND (t, 0) == NULL_TREE
2484           || TREE_CHAIN (TREE_OPERAND (t, 0)))
2485         {
2486           dump_type (pp, TREE_TYPE (t), flags);
2487           pp_cxx_left_paren (pp);
2488           dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2489           pp_cxx_right_paren (pp);
2490         }
2491       else
2492         {
2493           pp_cxx_left_paren (pp);
2494           dump_type (pp, TREE_TYPE (t), flags);
2495           pp_cxx_right_paren (pp);
2496           pp_cxx_left_paren (pp);
2497           dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2498           pp_cxx_right_paren (pp);
2499         }
2500       break;
2501
2502     case STATIC_CAST_EXPR:
2503       pp_cxx_ws_string (pp, "static_cast");
2504       goto cast;
2505     case REINTERPRET_CAST_EXPR:
2506       pp_cxx_ws_string (pp, "reinterpret_cast");
2507       goto cast;
2508     case CONST_CAST_EXPR:
2509       pp_cxx_ws_string (pp, "const_cast");
2510       goto cast;
2511     case DYNAMIC_CAST_EXPR:
2512       pp_cxx_ws_string (pp, "dynamic_cast");
2513     cast:
2514       pp_cxx_begin_template_argument_list (pp);
2515       dump_type (pp, TREE_TYPE (t), flags);
2516       pp_cxx_end_template_argument_list (pp);
2517       pp_cxx_left_paren (pp);
2518       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2519       pp_cxx_right_paren (pp);
2520       break;
2521
2522     case ARROW_EXPR:
2523       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2524       pp_cxx_arrow (pp);
2525       break;
2526
2527     case SIZEOF_EXPR:
2528     case ALIGNOF_EXPR:
2529       if (TREE_CODE (t) == SIZEOF_EXPR)
2530         pp_cxx_ws_string (pp, "sizeof");
2531       else
2532         {
2533           gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2534           pp_cxx_ws_string (pp, "__alignof__");
2535         }
2536       op = TREE_OPERAND (t, 0);
2537       if (PACK_EXPANSION_P (op))
2538         {
2539           pp_string (pp, "...");
2540           op = PACK_EXPANSION_PATTERN (op);
2541         }
2542       pp_cxx_whitespace (pp);
2543       pp_cxx_left_paren (pp);
2544       if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
2545         dump_type (pp, TREE_TYPE (op), flags);
2546       else if (TYPE_P (TREE_OPERAND (t, 0)))
2547         dump_type (pp, op, flags);
2548       else
2549         dump_expr (pp, op, flags);
2550       pp_cxx_right_paren (pp);
2551       break;
2552
2553     case AT_ENCODE_EXPR:
2554       pp_cxx_ws_string (pp, "@encode");
2555       pp_cxx_whitespace (pp);
2556       pp_cxx_left_paren (pp);
2557       dump_type (pp, TREE_OPERAND (t, 0), flags);
2558       pp_cxx_right_paren (pp);
2559       break;
2560
2561     case NOEXCEPT_EXPR:
2562       pp_cxx_ws_string (pp, "noexcept");
2563       pp_cxx_whitespace (pp);
2564       pp_cxx_left_paren (pp);
2565       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2566       pp_cxx_right_paren (pp);
2567       break;
2568
2569     case REALPART_EXPR:
2570     case IMAGPART_EXPR:
2571       pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2572       pp_cxx_whitespace (pp);
2573       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2574       break;
2575
2576     case DEFAULT_ARG:
2577       pp_string (pp, M_("<unparsed>"));
2578       break;
2579
2580     case TRY_CATCH_EXPR:
2581     case WITH_CLEANUP_EXPR:
2582     case CLEANUP_POINT_EXPR:
2583       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2584       break;
2585
2586     case PSEUDO_DTOR_EXPR:
2587       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2588       pp_cxx_dot (pp);
2589       if (TREE_OPERAND (t, 1))
2590         {
2591           dump_type (pp, TREE_OPERAND (t, 1), flags);
2592           pp_cxx_colon_colon (pp);
2593         }
2594       pp_cxx_complement (pp);
2595       dump_type (pp, TREE_OPERAND (t, 2), flags);
2596       break;
2597
2598     case TEMPLATE_ID_EXPR:
2599       dump_decl (pp, t, flags);
2600       break;
2601
2602     case BIND_EXPR:
2603     case STMT_EXPR:
2604     case EXPR_STMT:
2605     case STATEMENT_LIST:
2606       /* We don't yet have a way of dumping statements in a
2607          human-readable format.  */
2608       pp_string (pp, "({...})");
2609       break;
2610
2611     case LOOP_EXPR:
2612       pp_string (pp, "while (1) { ");
2613       dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2614       pp_cxx_right_brace (pp);
2615       break;
2616
2617     case EXIT_EXPR:
2618       pp_string (pp, "if (");
2619       dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2620       pp_string (pp, ") break; ");
2621       break;
2622
2623     case BASELINK:
2624       dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
2625       break;
2626
2627     case EMPTY_CLASS_EXPR:
2628       dump_type (pp, TREE_TYPE (t), flags);
2629       pp_cxx_left_paren (pp);
2630       pp_cxx_right_paren (pp);
2631       break;
2632
2633     case NON_DEPENDENT_EXPR:
2634       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2635       break;
2636
2637     case ARGUMENT_PACK_SELECT:
2638       dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2639       break;
2640
2641     case RECORD_TYPE:
2642     case UNION_TYPE:
2643     case ENUMERAL_TYPE:
2644     case REAL_TYPE:
2645     case VOID_TYPE:
2646     case BOOLEAN_TYPE:
2647     case INTEGER_TYPE:
2648     case COMPLEX_TYPE:
2649     case VECTOR_TYPE:
2650       pp_type_specifier_seq (pp, t);
2651       break;
2652
2653     case TYPENAME_TYPE:
2654       /* We get here when we want to print a dependent type as an
2655          id-expression, without any disambiguator decoration.  */
2656       pp->id_expression (t);
2657       break;
2658
2659     case TEMPLATE_TYPE_PARM:
2660     case TEMPLATE_TEMPLATE_PARM:
2661     case BOUND_TEMPLATE_TEMPLATE_PARM:
2662       dump_type (pp, t, flags);
2663       break;
2664
2665     case TRAIT_EXPR:
2666       pp_cxx_trait_expression (pp, t);
2667       break;
2668
2669     case VA_ARG_EXPR:
2670       pp_cxx_va_arg_expression (pp, t);
2671       break;
2672
2673     case OFFSETOF_EXPR:
2674       pp_cxx_offsetof_expression (pp, t);
2675       break;
2676
2677     case SCOPE_REF:
2678       dump_decl (pp, t, flags);
2679       break;
2680
2681     case EXPR_PACK_EXPANSION:
2682     case UNARY_LEFT_FOLD_EXPR:
2683     case UNARY_RIGHT_FOLD_EXPR:
2684     case BINARY_LEFT_FOLD_EXPR:
2685     case BINARY_RIGHT_FOLD_EXPR:
2686     case TYPEID_EXPR:
2687     case MEMBER_REF:
2688     case DOTSTAR_EXPR:
2689     case NEW_EXPR:
2690     case VEC_NEW_EXPR:
2691     case DELETE_EXPR:
2692     case VEC_DELETE_EXPR:
2693     case MODOP_EXPR:
2694     case ABS_EXPR:
2695     case CONJ_EXPR:
2696     case VECTOR_CST:
2697     case FIXED_CST:
2698     case UNORDERED_EXPR:
2699     case ORDERED_EXPR:
2700     case UNLT_EXPR:
2701     case UNLE_EXPR:
2702     case UNGT_EXPR:
2703     case UNGE_EXPR:
2704     case UNEQ_EXPR:
2705     case LTGT_EXPR:
2706     case COMPLEX_EXPR:
2707     case BIT_FIELD_REF:
2708     case FIX_TRUNC_EXPR:
2709     case FLOAT_EXPR:
2710       pp->expression (t);
2711       break;
2712
2713     case TRUTH_AND_EXPR:
2714     case TRUTH_OR_EXPR:
2715     case TRUTH_XOR_EXPR:
2716       if (flags & TFF_EXPR_IN_PARENS)
2717         pp_cxx_left_paren (pp);
2718       pp->expression (t);
2719       if (flags & TFF_EXPR_IN_PARENS)
2720         pp_cxx_right_paren (pp);
2721       break;
2722
2723     case OBJ_TYPE_REF:
2724       dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
2725       break;
2726
2727     case LAMBDA_EXPR:
2728       pp_string (pp, M_("<lambda>"));
2729       break;
2730
2731     case PAREN_EXPR:
2732       pp_cxx_left_paren (pp);
2733       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2734       pp_cxx_right_paren (pp);
2735       break;
2736
2737     case REQUIRES_EXPR:
2738       pp_cxx_requires_expr (cxx_pp, t);
2739       break;
2740
2741     case SIMPLE_REQ:
2742       pp_cxx_simple_requirement (cxx_pp, t);
2743       break;
2744
2745     case TYPE_REQ:
2746       pp_cxx_type_requirement (cxx_pp, t);
2747       break;
2748
2749     case COMPOUND_REQ:
2750       pp_cxx_compound_requirement (cxx_pp, t);
2751       break;
2752
2753     case NESTED_REQ:
2754       pp_cxx_nested_requirement (cxx_pp, t);
2755       break;
2756
2757     case PRED_CONSTR:
2758     case CHECK_CONSTR:
2759     case EXPR_CONSTR:
2760     case TYPE_CONSTR:
2761     case ICONV_CONSTR:
2762     case DEDUCT_CONSTR:
2763     case EXCEPT_CONSTR:
2764     case PARM_CONSTR:
2765     case CONJ_CONSTR:
2766     case DISJ_CONSTR:
2767       pp_cxx_constraint (cxx_pp, t);
2768       break;
2769
2770     case PLACEHOLDER_EXPR:
2771       pp_string (pp, M_("*this"));
2772       break;
2773
2774       /*  This list is incomplete, but should suffice for now.
2775           It is very important that `sorry' does not call
2776           `report_error_function'.  That could cause an infinite loop.  */
2777     default:
2778       pp_unsupported_tree (pp, t);
2779       /* Fall through.  */
2780     case ERROR_MARK:
2781       pp_string (pp, M_("<expression error>"));
2782       break;
2783     }
2784 }
2785
2786 static void
2787 dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
2788                 int flags)
2789 {
2790   pp_cxx_left_paren (pp);
2791   dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2792   pp_cxx_whitespace (pp);
2793   if (opstring)
2794     pp_cxx_ws_string (pp, opstring);
2795   else
2796     pp_string (pp, M_("<unknown operator>"));
2797   pp_cxx_whitespace (pp);
2798   dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2799   pp_cxx_right_paren (pp);
2800 }
2801
2802 static void
2803 dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
2804 {
2805   if (flags & TFF_EXPR_IN_PARENS)
2806     pp_cxx_left_paren (pp);
2807   pp_cxx_ws_string (pp, opstring);
2808   dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2809   if (flags & TFF_EXPR_IN_PARENS)
2810     pp_cxx_right_paren (pp);
2811 }
2812
2813 static void
2814 reinit_cxx_pp (void)
2815 {
2816   pp_clear_output_area (cxx_pp);
2817   cxx_pp->padding = pp_none;
2818   pp_indentation (cxx_pp) = 0;
2819   pp_needs_newline (cxx_pp) = false;
2820   cxx_pp->enclosing_scope = current_function_decl;
2821 }
2822
2823 /* Same as pp_formatted_text, except the return string is a separate
2824    copy and has a GGC storage duration, e.g. an indefinite lifetime.  */
2825
2826 inline const char *
2827 pp_ggc_formatted_text (pretty_printer *pp)
2828 {
2829   return ggc_strdup (pp_formatted_text (pp));
2830 }
2831
2832 /* Exported interface to stringifying types, exprs and decls under TFF_*
2833    control.  */
2834
2835 const char *
2836 type_as_string (tree typ, int flags)
2837 {
2838   reinit_cxx_pp ();
2839   pp_translate_identifiers (cxx_pp) = false;
2840   dump_type (cxx_pp, typ, flags);
2841   return pp_ggc_formatted_text (cxx_pp);
2842 }
2843
2844 const char *
2845 type_as_string_translate (tree typ, int flags)
2846 {
2847   reinit_cxx_pp ();
2848   dump_type (cxx_pp, typ, flags);
2849   return pp_ggc_formatted_text (cxx_pp);
2850 }
2851
2852 const char *
2853 expr_as_string (tree decl, int flags)
2854 {
2855   reinit_cxx_pp ();
2856   pp_translate_identifiers (cxx_pp) = false;
2857   dump_expr (cxx_pp, decl, flags);
2858   return pp_ggc_formatted_text (cxx_pp);
2859 }
2860
2861 /* Wrap decl_as_string with options appropriate for dwarf.  */
2862
2863 const char *
2864 decl_as_dwarf_string (tree decl, int flags)
2865 {
2866   const char *name;
2867   /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2868      here will be adequate to get the desired behavior.  */
2869   cxx_pp->flags |= pp_c_flag_gnu_v3;
2870   name = decl_as_string (decl, flags);
2871   /* Subsequent calls to the pretty printer shouldn't use this style.  */
2872   cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2873   return name;
2874 }
2875
2876 const char *
2877 decl_as_string (tree decl, int flags)
2878 {
2879   reinit_cxx_pp ();
2880   pp_translate_identifiers (cxx_pp) = false;
2881   dump_decl (cxx_pp, decl, flags);
2882   return pp_ggc_formatted_text (cxx_pp);
2883 }
2884
2885 const char *
2886 decl_as_string_translate (tree decl, int flags)
2887 {
2888   reinit_cxx_pp ();
2889   dump_decl (cxx_pp, decl, flags);
2890   return pp_ggc_formatted_text (cxx_pp);
2891 }
2892
2893 /* Wrap lang_decl_name with options appropriate for dwarf.  */
2894
2895 const char *
2896 lang_decl_dwarf_name (tree decl, int v, bool translate)
2897 {
2898   const char *name;
2899   /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2900      here will be adequate to get the desired behavior.  */
2901   cxx_pp->flags |= pp_c_flag_gnu_v3;
2902   name = lang_decl_name (decl, v, translate);
2903   /* Subsequent calls to the pretty printer shouldn't use this style.  */
2904   cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2905   return name;
2906 }
2907
2908 /* Generate the three forms of printable names for cxx_printable_name.  */
2909
2910 const char *
2911 lang_decl_name (tree decl, int v, bool translate)
2912 {
2913   if (v >= 2)
2914     return (translate
2915             ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2916             : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2917
2918   reinit_cxx_pp ();
2919   pp_translate_identifiers (cxx_pp) = translate;
2920   if (v == 1
2921       && (DECL_CLASS_SCOPE_P (decl)
2922           || (DECL_NAMESPACE_SCOPE_P (decl)
2923               && CP_DECL_CONTEXT (decl) != global_namespace)))
2924     {
2925       dump_type (cxx_pp, CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2926       pp_cxx_colon_colon (cxx_pp);
2927     }
2928
2929   if (TREE_CODE (decl) == FUNCTION_DECL)
2930     dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER);
2931   else if ((DECL_NAME (decl) == NULL_TREE)
2932            && TREE_CODE (decl) == NAMESPACE_DECL)
2933     dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER | TFF_UNQUALIFIED_NAME);
2934   else
2935     dump_decl (cxx_pp, DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2936
2937   return pp_ggc_formatted_text (cxx_pp);
2938 }
2939
2940 /* Return the location of a tree passed to %+ formats.  */
2941
2942 location_t
2943 location_of (tree t)
2944 {
2945   if (TYPE_P (t))
2946     {
2947       t = TYPE_MAIN_DECL (t);
2948       if (t == NULL_TREE)
2949         return input_location;
2950     }
2951   else if (TREE_CODE (t) == OVERLOAD)
2952     t = OVL_FUNCTION (t);
2953
2954   if (DECL_P (t))
2955     return DECL_SOURCE_LOCATION (t);
2956   return EXPR_LOC_OR_LOC (t, input_location);
2957 }
2958
2959 /* Now the interfaces from error et al to dump_type et al. Each takes an
2960    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2961    function.  */
2962
2963 static const char *
2964 decl_to_string (tree decl, int verbose)
2965 {
2966   int flags = 0;
2967
2968   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2969       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2970     flags = TFF_CLASS_KEY_OR_ENUM;
2971   if (verbose)
2972     flags |= TFF_DECL_SPECIFIERS;
2973   else if (TREE_CODE (decl) == FUNCTION_DECL)
2974     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2975   flags |= TFF_TEMPLATE_HEADER;
2976
2977   reinit_cxx_pp ();
2978   dump_decl (cxx_pp, decl, flags);
2979   return pp_ggc_formatted_text (cxx_pp);
2980 }
2981
2982 static const char *
2983 expr_to_string (tree decl)
2984 {
2985   reinit_cxx_pp ();
2986   dump_expr (cxx_pp, decl, 0);
2987   return pp_ggc_formatted_text (cxx_pp);
2988 }
2989
2990 static const char *
2991 fndecl_to_string (tree fndecl, int verbose)
2992 {
2993   int flags;
2994
2995   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2996     | TFF_TEMPLATE_HEADER;
2997   if (verbose)
2998     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2999   reinit_cxx_pp ();
3000   dump_decl (cxx_pp, fndecl, flags);
3001   return pp_ggc_formatted_text (cxx_pp);
3002 }
3003
3004
3005 static const char *
3006 code_to_string (enum tree_code c)
3007 {
3008   return get_tree_code_name (c);
3009 }
3010
3011 const char *
3012 language_to_string (enum languages c)
3013 {
3014   switch (c)
3015     {
3016     case lang_c:
3017       return "C";
3018
3019     case lang_cplusplus:
3020       return "C++";
3021
3022     case lang_java:
3023       return "Java";
3024
3025     default:
3026       gcc_unreachable ();
3027     }
3028   return NULL;
3029 }
3030
3031 /* Return the proper printed version of a parameter to a C++ function.  */
3032
3033 static const char *
3034 parm_to_string (int p)
3035 {
3036   reinit_cxx_pp ();
3037   if (p < 0)
3038     pp_string (cxx_pp, "'this'");
3039   else
3040     pp_decimal_int (cxx_pp, p + 1);
3041   return pp_ggc_formatted_text (cxx_pp);
3042 }
3043
3044 static const char *
3045 op_to_string (enum tree_code p)
3046 {
3047   tree id = operator_name_info[p].identifier;
3048   return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
3049 }
3050
3051 static const char *
3052 type_to_string (tree typ, int verbose)
3053 {
3054   int flags = 0;
3055   if (verbose)
3056     flags |= TFF_CLASS_KEY_OR_ENUM;
3057   flags |= TFF_TEMPLATE_HEADER;
3058
3059   reinit_cxx_pp ();
3060   dump_type (cxx_pp, typ, flags);
3061   /* If we're printing a type that involves typedefs, also print the
3062      stripped version.  But sometimes the stripped version looks
3063      exactly the same, so we don't want it after all.  To avoid printing
3064      it in that case, we play ugly obstack games.  */
3065   if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
3066       && !uses_template_parms (typ))
3067     {
3068       int aka_start, aka_len; char *p;
3069       struct obstack *ob = pp_buffer (cxx_pp)->obstack;
3070       /* Remember the end of the initial dump.  */
3071       int len = obstack_object_size (ob);
3072       tree aka = strip_typedefs (typ);
3073       pp_string (cxx_pp, " {aka");
3074       pp_cxx_whitespace (cxx_pp);
3075       /* And remember the start of the aka dump.  */
3076       aka_start = obstack_object_size (ob);
3077       dump_type (cxx_pp, aka, flags);
3078       aka_len = obstack_object_size (ob) - aka_start;
3079       pp_right_brace (cxx_pp);
3080       p = (char*)obstack_base (ob);
3081       /* If they are identical, cut off the aka with a NUL.  */
3082       if (len == aka_len && memcmp (p, p+aka_start, len) == 0)
3083         p[len] = '\0';
3084     }
3085   return pp_ggc_formatted_text (cxx_pp);
3086 }
3087
3088 static const char *
3089 assop_to_string (enum tree_code p)
3090 {
3091   tree id = assignment_operator_name_info[(int) p].identifier;
3092   return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
3093 }
3094
3095 static const char *
3096 args_to_string (tree p, int verbose)
3097 {
3098   int flags = 0;
3099   if (verbose)
3100     flags |= TFF_CLASS_KEY_OR_ENUM;
3101
3102   if (p == NULL_TREE)
3103     return "";
3104
3105   if (TYPE_P (TREE_VALUE (p)))
3106     return type_as_string_translate (p, flags);
3107
3108   reinit_cxx_pp ();
3109   for (; p; p = TREE_CHAIN (p))
3110     {
3111       if (TREE_VALUE (p) == null_node)
3112         pp_cxx_ws_string (cxx_pp, "NULL");
3113       else
3114         dump_type (cxx_pp, error_type (TREE_VALUE (p)), flags);
3115       if (TREE_CHAIN (p))
3116         pp_separate_with_comma (cxx_pp);
3117     }
3118   return pp_ggc_formatted_text (cxx_pp);
3119 }
3120
3121 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype).  P
3122    is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3123    arguments.  */
3124
3125 static const char *
3126 subst_to_string (tree p)
3127 {
3128   tree decl = TREE_PURPOSE (p);
3129   tree targs = TREE_VALUE (p);
3130   tree tparms = DECL_TEMPLATE_PARMS (decl);
3131   int flags = (TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER
3132                |TFF_NO_TEMPLATE_BINDINGS);
3133
3134   if (p == NULL_TREE)
3135     return "";
3136
3137   reinit_cxx_pp ();
3138   dump_template_decl (cxx_pp, TREE_PURPOSE (p), flags);
3139   dump_substitution (cxx_pp, NULL, tparms, targs, /*flags=*/0);
3140   return pp_ggc_formatted_text (cxx_pp);
3141 }
3142
3143 static const char *
3144 cv_to_string (tree p, int v)
3145 {
3146   reinit_cxx_pp ();
3147   cxx_pp->padding = v ? pp_before : pp_none;
3148   pp_cxx_cv_qualifier_seq (cxx_pp, p);
3149   return pp_ggc_formatted_text (cxx_pp);
3150 }
3151
3152 static const char *
3153 eh_spec_to_string (tree p, int /*v*/)
3154 {
3155   int flags = 0;
3156   reinit_cxx_pp ();
3157   dump_exception_spec (cxx_pp, p, flags);
3158   return pp_ggc_formatted_text (cxx_pp);
3159 }
3160
3161 /* Langhook for print_error_function.  */
3162 void
3163 cxx_print_error_function (diagnostic_context *context, const char *file,
3164                           diagnostic_info *diagnostic)
3165 {
3166   lhd_print_error_function (context, file, diagnostic);
3167   pp_set_prefix (context->printer, file);
3168   maybe_print_instantiation_context (context);
3169 }
3170
3171 static void
3172 cp_diagnostic_starter (diagnostic_context *context,
3173                        diagnostic_info *diagnostic)
3174 {
3175   diagnostic_report_current_module (context, diagnostic_location (diagnostic));
3176   cp_print_error_function (context, diagnostic);
3177   maybe_print_instantiation_context (context);
3178   maybe_print_constexpr_context (context);
3179   pp_set_prefix (context->printer, diagnostic_build_prefix (context,
3180                                                                  diagnostic));
3181 }
3182
3183 /* Print current function onto BUFFER, in the process of reporting
3184    a diagnostic message.  Called from cp_diagnostic_starter.  */
3185 static void
3186 cp_print_error_function (diagnostic_context *context,
3187                          diagnostic_info *diagnostic)
3188 {
3189   /* If we are in an instantiation context, current_function_decl is likely
3190      to be wrong, so just rely on print_instantiation_full_context.  */
3191   if (current_instantiation ())
3192     return;
3193   if (diagnostic_last_function_changed (context, diagnostic))
3194     {
3195       const char *old_prefix = context->printer->prefix;
3196       const char *file = LOCATION_FILE (diagnostic_location (diagnostic));
3197       tree abstract_origin = diagnostic_abstract_origin (diagnostic);
3198       char *new_prefix = (file && abstract_origin == NULL)
3199                          ? file_name_as_prefix (context, file) : NULL;
3200
3201       pp_set_prefix (context->printer, new_prefix);
3202
3203       if (current_function_decl == NULL)
3204         pp_string (context->printer, _("At global scope:"));
3205       else
3206         {
3207           tree fndecl, ao;
3208
3209           if (abstract_origin)
3210             {
3211               ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
3212               while (TREE_CODE (ao) == BLOCK
3213                      && BLOCK_ABSTRACT_ORIGIN (ao)
3214                      && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3215                 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3216               gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
3217               fndecl = ao;
3218             }
3219           else
3220             fndecl = current_function_decl;
3221
3222           pp_printf (context->printer, function_category (fndecl),
3223                      cxx_printable_name_translate (fndecl, 2));
3224
3225           while (abstract_origin)
3226             {
3227               location_t *locus;
3228               tree block = abstract_origin;
3229
3230               locus = &BLOCK_SOURCE_LOCATION (block);
3231               fndecl = NULL;
3232               block = BLOCK_SUPERCONTEXT (block);
3233               while (block && TREE_CODE (block) == BLOCK
3234                      && BLOCK_ABSTRACT_ORIGIN (block))
3235                 {
3236                   ao = BLOCK_ABSTRACT_ORIGIN (block);
3237
3238                   while (TREE_CODE (ao) == BLOCK
3239                          && BLOCK_ABSTRACT_ORIGIN (ao)
3240                          && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3241                     ao = BLOCK_ABSTRACT_ORIGIN (ao);
3242
3243                   if (TREE_CODE (ao) == FUNCTION_DECL)
3244                     {
3245                       fndecl = ao;
3246                       break;
3247                     }
3248                   else if (TREE_CODE (ao) != BLOCK)
3249                     break;
3250
3251                   block = BLOCK_SUPERCONTEXT (block);
3252                 }
3253               if (fndecl)
3254                 abstract_origin = block;
3255               else
3256                 {
3257                   while (block && TREE_CODE (block) == BLOCK)
3258                     block = BLOCK_SUPERCONTEXT (block);
3259
3260                   if (block && TREE_CODE (block) == FUNCTION_DECL)
3261                     fndecl = block;
3262                   abstract_origin = NULL;
3263                 }
3264               if (fndecl)
3265                 {
3266                   expanded_location s = expand_location (*locus);
3267                   pp_character (context->printer, ',');
3268                   pp_newline (context->printer);
3269                   if (s.file != NULL)
3270                     {
3271                       if (context->show_column && s.column != 0)
3272                         pp_printf (context->printer,
3273                                    _("    inlined from %qs at %r%s:%d:%d%R"),
3274                                    cxx_printable_name_translate (fndecl, 2),
3275                                    "locus", s.file, s.line, s.column);
3276                       else
3277                         pp_printf (context->printer,
3278                                    _("    inlined from %qs at %r%s:%d%R"),
3279                                    cxx_printable_name_translate (fndecl, 2),
3280                                    "locus", s.file, s.line);
3281
3282                     }
3283                   else
3284                     pp_printf (context->printer, _("    inlined from %qs"),
3285                                cxx_printable_name_translate (fndecl, 2));
3286                 }
3287             }
3288           pp_character (context->printer, ':');
3289         }
3290       pp_newline (context->printer);
3291
3292       diagnostic_set_last_function (context, diagnostic);
3293       pp_destroy_prefix (context->printer);
3294       context->printer->prefix = old_prefix;
3295     }
3296 }
3297
3298 /* Returns a description of FUNCTION using standard terminology.  The
3299    result is a format string of the form "In CATEGORY %qs".  */
3300 static const char *
3301 function_category (tree fn)
3302 {
3303   /* We can get called from the middle-end for diagnostics of function
3304      clones.  Make sure we have language specific information before
3305      dereferencing it.  */
3306   if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
3307       && DECL_FUNCTION_MEMBER_P (fn))
3308     {
3309       if (DECL_STATIC_FUNCTION_P (fn))
3310         return _("In static member function %qs");
3311       else if (DECL_COPY_CONSTRUCTOR_P (fn))
3312         return _("In copy constructor %qs");
3313       else if (DECL_CONSTRUCTOR_P (fn))
3314         return _("In constructor %qs");
3315       else if (DECL_DESTRUCTOR_P (fn))
3316         return _("In destructor %qs");
3317       else if (LAMBDA_FUNCTION_P (fn))
3318         return _("In lambda function");
3319       else
3320         return _("In member function %qs");
3321     }
3322   else
3323     return _("In function %qs");
3324 }
3325
3326 /* Report the full context of a current template instantiation,
3327    onto BUFFER.  */
3328 static void
3329 print_instantiation_full_context (diagnostic_context *context)
3330 {
3331   struct tinst_level *p = current_instantiation ();
3332   location_t location = input_location;
3333
3334   if (p)
3335     {
3336       pp_verbatim (context->printer,
3337                    TREE_CODE (p->decl) == TREE_LIST
3338                    ? _("%s: In substitution of %qS:\n")
3339                    : _("%s: In instantiation of %q#D:\n"),
3340                    LOCATION_FILE (location),
3341                    p->decl);
3342
3343       location = p->locus;
3344       p = p->next;
3345     }
3346
3347   print_instantiation_partial_context (context, p, location);
3348 }
3349
3350 /* Helper function of print_instantiation_partial_context() that
3351    prints a single line of instantiation context.  */
3352
3353 static void
3354 print_instantiation_partial_context_line (diagnostic_context *context,
3355                                           const struct tinst_level *t,
3356                                           location_t loc, bool recursive_p)
3357 {
3358   if (loc == UNKNOWN_LOCATION)
3359     return;
3360
3361   expanded_location xloc = expand_location (loc);
3362
3363   if (context->show_column)
3364     pp_verbatim (context->printer, _("%r%s:%d:%d:%R   "),
3365                  "locus", xloc.file, xloc.line, xloc.column);
3366   else
3367     pp_verbatim (context->printer, _("%r%s:%d:%R   "),
3368                  "locus", xloc.file, xloc.line);
3369
3370   if (t != NULL)
3371     {
3372       if (TREE_CODE (t->decl) == TREE_LIST)
3373         pp_verbatim (context->printer,
3374                      recursive_p
3375                      ? _("recursively required by substitution of %qS\n")
3376                      : _("required by substitution of %qS\n"),
3377                      t->decl);
3378       else
3379         pp_verbatim (context->printer,
3380                      recursive_p
3381                      ? _("recursively required from %q#D\n")
3382                      : _("required from %q#D\n"),
3383                      t->decl);
3384     }
3385   else
3386     {
3387       pp_verbatim (context->printer,
3388                    recursive_p
3389                    ? _("recursively required from here\n")
3390                    : _("required from here\n"));
3391     }
3392 }
3393
3394 /* Same as print_instantiation_full_context but less verbose.  */
3395
3396 static void
3397 print_instantiation_partial_context (diagnostic_context *context,
3398                                      struct tinst_level *t0, location_t loc)
3399 {
3400   struct tinst_level *t;
3401   int n_total = 0;
3402   int n;
3403   location_t prev_loc = loc;
3404
3405   for (t = t0; t != NULL; t = t->next)
3406     if (prev_loc != t->locus)
3407       {
3408         prev_loc = t->locus;
3409         n_total++;
3410       }
3411
3412   t = t0;
3413
3414   if (template_backtrace_limit
3415       && n_total > template_backtrace_limit)
3416     {
3417       int skip = n_total - template_backtrace_limit;
3418       int head = template_backtrace_limit / 2;
3419
3420       /* Avoid skipping just 1.  If so, skip 2.  */
3421       if (skip == 1)
3422        {
3423          skip = 2;
3424          head = (template_backtrace_limit - 1) / 2;
3425        }
3426
3427       for (n = 0; n < head; n++)
3428         {
3429           gcc_assert (t != NULL);
3430           if (loc != t->locus)
3431             print_instantiation_partial_context_line (context, t, loc,
3432                                                       /*recursive_p=*/false);
3433           loc = t->locus;
3434           t = t->next;
3435         }
3436       if (t != NULL && skip > 0)
3437         {
3438           expanded_location xloc;
3439           xloc = expand_location (loc);
3440           if (context->show_column)
3441             pp_verbatim (context->printer,
3442                          _("%r%s:%d:%d:%R   [ skipping %d instantiation "
3443                            "contexts, use -ftemplate-backtrace-limit=0 to "
3444                            "disable ]\n"),
3445                          "locus", xloc.file, xloc.line, xloc.column, skip);
3446           else
3447             pp_verbatim (context->printer,
3448                          _("%r%s:%d:%R   [ skipping %d instantiation "
3449                            "contexts, use -ftemplate-backtrace-limit=0 to "
3450                            "disable ]\n"),
3451                          "locus", xloc.file, xloc.line, skip);
3452
3453           do {
3454             loc = t->locus;
3455             t = t->next;
3456           } while (t != NULL && --skip > 0);
3457         }
3458     }
3459
3460   while (t != NULL)
3461     {
3462       while (t->next != NULL && t->locus == t->next->locus)
3463         {
3464           loc = t->locus;
3465           t = t->next;
3466         }
3467       print_instantiation_partial_context_line (context, t, loc,
3468                                                 t->locus == loc);
3469       loc = t->locus;
3470       t = t->next;
3471     }
3472   print_instantiation_partial_context_line (context, NULL, loc,
3473                                             /*recursive_p=*/false);
3474 }
3475
3476 /* Called from cp_thing to print the template context for an error.  */
3477 static void
3478 maybe_print_instantiation_context (diagnostic_context *context)
3479 {
3480   if (!problematic_instantiation_changed () || current_instantiation () == 0)
3481     return;
3482
3483   record_last_problematic_instantiation ();
3484   print_instantiation_full_context (context);
3485 }
3486 \f
3487 /* Report what constexpr call(s) we're trying to expand, if any.  */
3488
3489 void
3490 maybe_print_constexpr_context (diagnostic_context *context)
3491 {
3492   vec<tree> call_stack = cx_error_context ();
3493   unsigned ix;
3494   tree t;
3495
3496   FOR_EACH_VEC_ELT (call_stack, ix, t)
3497     {
3498       expanded_location xloc = expand_location (EXPR_LOCATION (t));
3499       const char *s = expr_as_string (t, 0);
3500       if (context->show_column)
3501         pp_verbatim (context->printer,
3502                      _("%r%s:%d:%d:%R   in constexpr expansion of %qs"),
3503                      "locus", xloc.file, xloc.line, xloc.column, s);
3504       else
3505         pp_verbatim (context->printer,
3506                      _("%r%s:%d:%R   in constexpr expansion of %qs"),
3507                      "locus", xloc.file, xloc.line, s);
3508       pp_newline (context->printer);
3509     }
3510 }
3511 \f
3512 /* Called from output_format -- during diagnostic message processing --
3513    to handle C++ specific format specifier with the following meanings:
3514    %A   function argument-list.
3515    %C   tree code.
3516    %D   declaration.
3517    %E   expression.
3518    %F   function declaration.
3519    %L   language as used in extern "lang".
3520    %O   binary operator.
3521    %P   function parameter whose position is indicated by an integer.
3522    %Q   assignment operator.
3523    %S   substitution (template + args)
3524    %T   type.
3525    %V   cv-qualifier.
3526    %X   exception-specification.  */
3527 static bool
3528 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
3529             int precision, bool wide, bool set_locus, bool verbose)
3530 {
3531   const char *result;
3532   tree t = NULL;
3533 #define next_tree    (t = va_arg (*text->args_ptr, tree))
3534 #define next_tcode   ((enum tree_code) va_arg (*text->args_ptr, int))
3535 #define next_lang    ((enum languages) va_arg (*text->args_ptr, int))
3536 #define next_int     va_arg (*text->args_ptr, int)
3537
3538   if (precision != 0 || wide)
3539     return false;
3540
3541   switch (*spec)
3542     {
3543     case 'A': result = args_to_string (next_tree, verbose);     break;
3544     case 'C': result = code_to_string (next_tcode);             break;
3545     case 'D':
3546       {
3547         tree temp = next_tree;
3548         if (VAR_P (temp)
3549             && DECL_HAS_DEBUG_EXPR_P (temp))
3550           {
3551             temp = DECL_DEBUG_EXPR (temp);
3552             if (!DECL_P (temp))
3553               {
3554                 result = expr_to_string (temp);
3555                 break;
3556               }
3557           }
3558         result = decl_to_string (temp, verbose);
3559       }
3560       break;
3561     case 'E': result = expr_to_string (next_tree);              break;
3562     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
3563     case 'L': result = language_to_string (next_lang);          break;
3564     case 'O': result = op_to_string (next_tcode);               break;
3565     case 'P': result = parm_to_string (next_int);               break;
3566     case 'Q': result = assop_to_string (next_tcode);            break;
3567     case 'S': result = subst_to_string (next_tree);             break;
3568     case 'T': result = type_to_string (next_tree, verbose);     break;
3569     case 'V': result = cv_to_string (next_tree, verbose);       break;
3570     case 'X': result = eh_spec_to_string (next_tree, verbose);  break;
3571
3572     case 'K':
3573       percent_K_format (text);
3574       return true;
3575
3576     default:
3577       return false;
3578     }
3579
3580   pp_string (pp, result);
3581   if (set_locus && t != NULL)
3582     text->set_location (0, location_of (t), true);
3583   return true;
3584 #undef next_tree
3585 #undef next_tcode
3586 #undef next_lang
3587 #undef next_int
3588 }
3589 \f
3590 /* Warn about the use of C++0x features when appropriate.  */
3591 void
3592 maybe_warn_cpp0x (cpp0x_warn_str str)
3593 {
3594   if ((cxx_dialect == cxx98) && !in_system_header_at (input_location))
3595     /* We really want to suppress this warning in system headers,
3596        because libstdc++ uses variadic templates even when we aren't
3597        in C++0x mode. */
3598     switch (str)
3599       {
3600       case CPP0X_INITIALIZER_LISTS:
3601         pedwarn (input_location, 0,
3602                  "extended initializer lists "
3603                  "only available with -std=c++11 or -std=gnu++11");
3604         break;
3605       case CPP0X_EXPLICIT_CONVERSION:
3606         pedwarn (input_location, 0,
3607                  "explicit conversion operators "
3608                  "only available with -std=c++11 or -std=gnu++11");
3609         break;
3610       case CPP0X_VARIADIC_TEMPLATES:
3611         pedwarn (input_location, 0,
3612                  "variadic templates "
3613                  "only available with -std=c++11 or -std=gnu++11");
3614         break;
3615       case CPP0X_LAMBDA_EXPR:
3616         pedwarn (input_location, 0,
3617                  "lambda expressions "
3618                   "only available with -std=c++11 or -std=gnu++11");
3619         break;
3620       case CPP0X_AUTO:
3621         pedwarn (input_location, 0,
3622                  "C++11 auto only available with -std=c++11 or -std=gnu++11");
3623         break;
3624       case CPP0X_SCOPED_ENUMS:
3625         pedwarn (input_location, 0,
3626                  "scoped enums only available with -std=c++11 or -std=gnu++11");
3627         break;
3628       case CPP0X_DEFAULTED_DELETED:
3629         pedwarn (input_location, 0,
3630                  "defaulted and deleted functions "
3631                  "only available with -std=c++11 or -std=gnu++11");
3632         break;
3633       case CPP0X_INLINE_NAMESPACES:
3634         pedwarn (input_location, OPT_Wpedantic,
3635                  "inline namespaces "
3636                  "only available with -std=c++11 or -std=gnu++11");
3637         break;
3638       case CPP0X_OVERRIDE_CONTROLS:
3639         pedwarn (input_location, 0,
3640                  "override controls (override/final) "
3641                  "only available with -std=c++11 or -std=gnu++11");
3642         break;
3643       case CPP0X_NSDMI:
3644         pedwarn (input_location, 0,
3645                  "non-static data member initializers "
3646                  "only available with -std=c++11 or -std=gnu++11");
3647         break;
3648       case CPP0X_USER_DEFINED_LITERALS:
3649         pedwarn (input_location, 0,
3650                  "user-defined literals "
3651                  "only available with -std=c++11 or -std=gnu++11");
3652         break;
3653       case CPP0X_DELEGATING_CTORS:
3654         pedwarn (input_location, 0,
3655                  "delegating constructors "
3656                  "only available with -std=c++11 or -std=gnu++11");
3657         break;
3658       case CPP0X_INHERITING_CTORS:
3659         pedwarn (input_location, 0,
3660                  "inheriting constructors "
3661                  "only available with -std=c++11 or -std=gnu++11");
3662         break;
3663       case CPP0X_ATTRIBUTES:
3664         pedwarn (input_location, 0,
3665                  "c++11 attributes "
3666                  "only available with -std=c++11 or -std=gnu++11");
3667         break;
3668       case CPP0X_REF_QUALIFIER:
3669         pedwarn (input_location, 0,
3670                  "ref-qualifiers "
3671                  "only available with -std=c++11 or -std=gnu++11");
3672         break;
3673       default:
3674         gcc_unreachable ();
3675       }
3676 }
3677
3678 /* Warn about the use of variadic templates when appropriate.  */
3679 void
3680 maybe_warn_variadic_templates (void)
3681 {
3682   maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3683 }
3684
3685
3686 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3687    option OPT with text GMSGID.  Use this function to report
3688    diagnostics for constructs that are invalid C++98, but valid
3689    C++0x.  */
3690 bool
3691 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3692 {
3693   diagnostic_info diagnostic;
3694   va_list ap;
3695   bool ret;
3696   rich_location richloc (line_table, location);
3697
3698   va_start (ap, gmsgid);
3699   diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc,
3700                        (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3701   diagnostic.option_index = opt;
3702   ret = report_diagnostic (&diagnostic);
3703   va_end (ap);
3704   return ret;
3705 }
3706
3707 /* Issue a diagnostic that NAME cannot be found in SCOPE.  DECL is what
3708    we found when we tried to do the lookup.  LOCATION is the location of
3709    the NAME identifier.  */
3710
3711 void
3712 qualified_name_lookup_error (tree scope, tree name,
3713                              tree decl, location_t location)
3714 {
3715   if (scope == error_mark_node)
3716     ; /* We already complained.  */
3717   else if (TYPE_P (scope))
3718     {
3719       if (!COMPLETE_TYPE_P (scope))
3720         error_at (location, "incomplete type %qT used in nested name specifier",
3721                   scope);
3722       else if (TREE_CODE (decl) == TREE_LIST)
3723         {
3724           error_at (location, "reference to %<%T::%D%> is ambiguous",
3725                     scope, name);
3726           print_candidates (decl);
3727         }
3728       else
3729         error_at (location, "%qD is not a member of %qT", name, scope);
3730     }
3731   else if (scope != global_namespace)
3732     {
3733       error_at (location, "%qD is not a member of %qD", name, scope);
3734       suggest_alternatives_for (location, name);
3735     }
3736   else
3737     {
3738       error_at (location, "%<::%D%> has not been declared", name);
3739       suggest_alternatives_for (location, name);
3740     }
3741 }