gcc/cp/error.c

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