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