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           pp_cxx_ws_string (pp, "template");
1299           pp_cxx_begin_template_argument_list (pp);
1300
1301           /* If we've shown the template prefix, we'd better show the
1302              parameters' and decl's type too.  */
1303             flags |= TFF_DECL_SPECIFIERS;
1304
1305           for (i = 0; i < len; i++)
1306             {
1307               if (i)
1308                 pp_separate_with_comma (pp);
1309               dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i),
1310                                        flags);
1311             }
1312           pp_cxx_end_template_argument_list (pp);
1313           pp_cxx_whitespace (pp);
1314         }
1315       nreverse(orig_parms);
1316
1317       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
1318         {
1319           /* Say `template<arg> class TT' not just `template<arg> TT'.  */
1320           pp_cxx_ws_string (pp, "class");
1321
1322           /* If this is a parameter pack, print the ellipsis.  */
1323           if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
1324             pp_cxx_ws_string (pp, "...");
1325         }
1326     }
1327
1328   if (DECL_CLASS_TEMPLATE_P (t))
1329     dump_type (pp, TREE_TYPE (t),
1330                ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1331                 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
1332   else if (DECL_TEMPLATE_RESULT (t)
1333            && (VAR_P (DECL_TEMPLATE_RESULT (t))
1334                /* Alias template.  */
1335                || DECL_TYPE_TEMPLATE_P (t)))
1336     dump_decl (pp, DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
1337   else
1338     {
1339       gcc_assert (TREE_TYPE (t));
1340       switch (NEXT_CODE (t))
1341         {
1342         case METHOD_TYPE:
1343         case FUNCTION_TYPE:
1344           dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME);
1345           break;
1346         default:
1347           /* This case can occur with some invalid code.  */
1348           dump_type (pp, TREE_TYPE (t),
1349                      (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
1350                      | (flags & TFF_DECL_SPECIFIERS
1351                         ? TFF_CLASS_KEY_OR_ENUM : 0));
1352         }
1353     }
1354 }
1355
1356 /* find_typenames looks through the type of the function template T
1357    and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1358    it finds.  */
1359
1360 struct find_typenames_t
1361 {
1362   hash_set<tree> *p_set;
1363   vec<tree, va_gc> *typenames;
1364 };
1365
1366 static tree
1367 find_typenames_r (tree *tp, int *walk_subtrees, void *data)
1368 {
1369   struct find_typenames_t *d = (struct find_typenames_t *)data;
1370   tree mv = NULL_TREE;
1371
1372   if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
1373     /* Add the type of the typedef without any additional cv-quals.  */
1374     mv = TREE_TYPE (TYPE_NAME (*tp));
1375   else if (TREE_CODE (*tp) == TYPENAME_TYPE
1376            || TREE_CODE (*tp) == DECLTYPE_TYPE)
1377     /* Add the typename without any cv-qualifiers.  */
1378     mv = TYPE_MAIN_VARIANT (*tp);
1379
1380   if (TREE_CODE (*tp) == TYPE_PACK_EXPANSION)
1381     {
1382       /* Don't mess with parameter packs since we don't remember
1383          the pack expansion context for a particular typename.  */
1384       *walk_subtrees = false;
1385       return NULL_TREE;
1386     }
1387
1388   if (mv && (mv == *tp || !d->p_set->add (mv)))
1389     vec_safe_push (d->typenames, mv);
1390
1391   /* Search into class template arguments, which cp_walk_subtrees
1392      doesn't do.  */
1393   if (CLASS_TYPE_P (*tp) && CLASSTYPE_TEMPLATE_INFO (*tp))
1394     cp_walk_tree (&CLASSTYPE_TI_ARGS (*tp), find_typenames_r,
1395                   data, d->p_set);
1396
1397   return NULL_TREE;
1398 }
1399
1400 static vec<tree, va_gc> *
1401 find_typenames (tree t)
1402 {
1403   struct find_typenames_t ft;
1404   ft.p_set = new hash_set<tree>;
1405   ft.typenames = NULL;
1406   cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
1407                 find_typenames_r, &ft, ft.p_set);
1408   delete ft.p_set;
1409   return ft.typenames;
1410 }
1411
1412 /* Output the "[with ...]" clause for a template instantiation T iff
1413    TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable.  T may be NULL if
1414    formatting a deduction/substitution diagnostic rather than an
1415    instantiation.  */
1416
1417 static void
1418 dump_substitution (cxx_pretty_printer *pp,
1419                    tree t, tree template_parms, tree template_args,
1420                    int flags)
1421 {
1422   if (template_parms != NULL_TREE && template_args != NULL_TREE
1423       && !(flags & TFF_NO_TEMPLATE_BINDINGS))
1424     {
1425       vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL;
1426       pp_cxx_whitespace (pp);
1427       pp_cxx_left_bracket (pp);
1428       pp->translate_string ("with");
1429       pp_cxx_whitespace (pp);
1430       dump_template_bindings (pp, template_parms, template_args, typenames);
1431       pp_cxx_right_bracket (pp);
1432     }
1433 }
1434
1435 /* Dump the lambda function FN including its 'mutable' qualifier and any
1436    template bindings.  */
1437
1438 static void
1439 dump_lambda_function (cxx_pretty_printer *pp,
1440                       tree fn, tree template_parms, tree template_args,
1441                       int flags)
1442 {
1443   /* A lambda's signature is essentially its "type".  */
1444   dump_type (pp, DECL_CONTEXT (fn), flags);
1445   if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST))
1446     {
1447       pp->padding = pp_before;
1448       pp_c_ws_string (pp, "mutable");
1449     }
1450   dump_substitution (pp, fn, template_parms, template_args, flags);
1451 }
1452
1453 /* Pretty print a function decl. There are several ways we want to print a
1454    function declaration. The TFF_ bits in FLAGS tells us how to behave.
1455    As error can only apply the '#' flag once to give 0 and 1 for V, there
1456    is %D which doesn't print the throw specs, and %F which does.  */
1457
1458 static void
1459 dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
1460 {
1461   tree fntype;
1462   tree parmtypes;
1463   tree cname = NULL_TREE;
1464   tree template_args = NULL_TREE;
1465   tree template_parms = NULL_TREE;
1466   int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
1467   int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
1468   tree exceptions;
1469
1470   flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME);
1471   if (TREE_CODE (t) == TEMPLATE_DECL)
1472     t = DECL_TEMPLATE_RESULT (t);
1473
1474   /* Save the exceptions, in case t is a specialization and we are
1475      emitting an error about incompatible specifications.  */
1476   exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
1477
1478   /* Pretty print template instantiations only.  */
1479   if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
1480       && flag_pretty_templates)
1481     {
1482       tree tmpl;
1483
1484       template_args = DECL_TI_ARGS (t);
1485       tmpl = most_general_template (t);
1486       if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
1487         {
1488           template_parms = DECL_TEMPLATE_PARMS (tmpl);
1489           t = tmpl;
1490         }
1491     }
1492
1493   if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
1494     return dump_lambda_function (pp, t, template_parms, template_args, flags);
1495
1496   fntype = TREE_TYPE (t);
1497   parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
1498
1499   if (DECL_CLASS_SCOPE_P (t))
1500     cname = DECL_CONTEXT (t);
1501   /* This is for partially instantiated template methods.  */
1502   else if (TREE_CODE (fntype) == METHOD_TYPE)
1503     cname = TREE_TYPE (TREE_VALUE (parmtypes));
1504
1505   if (flags & TFF_DECL_SPECIFIERS)
1506     {
1507       if (DECL_STATIC_FUNCTION_P (t))
1508         pp_cxx_ws_string (pp, "static");
1509       else if (DECL_VIRTUAL_P (t))
1510         pp_cxx_ws_string (pp, "virtual");
1511
1512       if (DECL_DECLARED_CONSTEXPR_P (t))
1513         pp_cxx_ws_string (pp, "constexpr");
1514     }
1515
1516   /* Print the return type?  */
1517   if (show_return)
1518     show_return = !DECL_CONV_FN_P (t)  && !DECL_CONSTRUCTOR_P (t)
1519                   && !DECL_DESTRUCTOR_P (t);
1520   if (show_return)
1521     {
1522       tree ret = fndecl_declared_return_type (t);
1523       dump_type_prefix (pp, ret, flags);
1524     }
1525
1526   /* Print the function name.  */
1527   if (!do_outer_scope)
1528     /* Nothing.  */;
1529   else if (cname)
1530     {
1531       dump_type (pp, cname, flags);
1532       pp_cxx_colon_colon (pp);
1533     }
1534   else
1535     dump_scope (pp, CP_DECL_CONTEXT (t), flags);
1536
1537   dump_function_name (pp, t, flags);
1538
1539   if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
1540     {
1541       dump_parameters (pp, parmtypes, flags);
1542
1543       if (TREE_CODE (fntype) == METHOD_TYPE)
1544         {
1545           pp->padding = pp_before;
1546           pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype));
1547           dump_ref_qualifier (pp, fntype, flags);
1548         }
1549
1550       if (flags & TFF_EXCEPTION_SPECIFICATION)
1551         {
1552           pp->padding = pp_before;
1553           dump_exception_spec (pp, exceptions, flags);
1554         }
1555
1556       if (show_return)
1557         dump_type_suffix (pp, TREE_TYPE (fntype), flags);
1558
1559       dump_substitution (pp, t, template_parms, template_args, flags);
1560     }
1561   else if (template_args)
1562     {
1563       bool need_comma = false;
1564       int i;
1565       pp_cxx_begin_template_argument_list (pp);
1566       template_args = INNERMOST_TEMPLATE_ARGS (template_args);
1567       for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
1568         {
1569           tree arg = TREE_VEC_ELT (template_args, i);
1570           if (need_comma)
1571             pp_separate_with_comma (pp);
1572           if (ARGUMENT_PACK_P (arg))
1573             pp_cxx_left_brace (pp);
1574           dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
1575           if (ARGUMENT_PACK_P (arg))
1576             pp_cxx_right_brace (pp);
1577           need_comma = true;
1578         }
1579       pp_cxx_end_template_argument_list (pp);
1580     }
1581 }
1582
1583 /* Print a parameter list. If this is for a member function, the
1584    member object ptr (and any other hidden args) should have
1585    already been removed.  */
1586
1587 static void
1588 dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags)
1589 {
1590   int first = 1;
1591   flags &= ~TFF_SCOPE;
1592   pp_cxx_left_paren (pp);
1593
1594   for (first = 1; parmtypes != void_list_node;
1595        parmtypes = TREE_CHAIN (parmtypes))
1596     {
1597       if (!first)
1598         pp_separate_with_comma (pp);
1599       first = 0;
1600       if (!parmtypes)
1601         {
1602           pp_cxx_ws_string (pp, "...");
1603           break;
1604         }
1605
1606       dump_type (pp, TREE_VALUE (parmtypes), flags);
1607
1608       if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
1609         {
1610           pp_cxx_whitespace (pp);
1611           pp_equal (pp);
1612           pp_cxx_whitespace (pp);
1613           dump_expr (pp, TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
1614         }
1615     }
1616
1617   pp_cxx_right_paren (pp);
1618 }
1619
1620 /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1621
1622 static void
1623 dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED)
1624 {
1625   if (FUNCTION_REF_QUALIFIED (t))
1626     {
1627       pp->padding = pp_before;
1628       if (FUNCTION_RVALUE_QUALIFIED (t))
1629         pp_cxx_ws_string (pp, "&&");
1630       else
1631         pp_cxx_ws_string (pp, "&");
1632     }
1633 }
1634
1635 /* Print an exception specification. T is the exception specification.  */
1636
1637 static void
1638 dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags)
1639 {
1640   if (t && TREE_PURPOSE (t))
1641     {
1642       pp_cxx_ws_string (pp, "noexcept");
1643       if (!integer_onep (TREE_PURPOSE (t)))
1644         {
1645           pp_cxx_whitespace (pp);
1646           pp_cxx_left_paren (pp);
1647           if (DEFERRED_NOEXCEPT_SPEC_P (t))
1648             pp_cxx_ws_string (pp, "<uninstantiated>");
1649           else
1650             dump_expr (pp, TREE_PURPOSE (t), flags);
1651           pp_cxx_right_paren (pp);
1652         }
1653     }
1654   else if (t)
1655     {
1656       pp_cxx_ws_string (pp, "throw");
1657       pp_cxx_whitespace (pp);
1658       pp_cxx_left_paren (pp);
1659       if (TREE_VALUE (t) != NULL_TREE)
1660         while (1)
1661           {
1662             dump_type (pp, TREE_VALUE (t), flags);
1663             t = TREE_CHAIN (t);
1664             if (!t)
1665               break;
1666             pp_separate_with_comma (pp);
1667           }
1668       pp_cxx_right_paren (pp);
1669     }
1670 }
1671
1672 /* Handle the function name for a FUNCTION_DECL node, grokking operators
1673    and destructors properly.  */
1674
1675 static void
1676 dump_function_name (cxx_pretty_printer *pp, tree t, int flags)
1677 {
1678   tree name = DECL_NAME (t);
1679
1680   /* We can get here with a decl that was synthesized by language-
1681      independent machinery (e.g. coverage.c) in which case it won't
1682      have a lang_specific structure attached and DECL_CONSTRUCTOR_P
1683      will crash.  In this case it is safe just to print out the
1684      literal name.  */
1685   if (!DECL_LANG_SPECIFIC (t))
1686     {
1687       pp_cxx_tree_identifier (pp, name);
1688       return;
1689     }
1690
1691   if (TREE_CODE (t) == TEMPLATE_DECL)
1692     t = DECL_TEMPLATE_RESULT (t);
1693
1694   /* Don't let the user see __comp_ctor et al.  */
1695   if (DECL_CONSTRUCTOR_P (t)
1696       || DECL_DESTRUCTOR_P (t))
1697     {
1698       if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
1699         name = get_identifier ("<lambda>");
1700       else if (TYPE_ANONYMOUS_P (DECL_CONTEXT (t)))
1701         name = get_identifier ("<constructor>");
1702       else
1703         name = constructor_name (DECL_CONTEXT (t));
1704     }
1705
1706   if (DECL_DESTRUCTOR_P (t))
1707     {
1708       pp_cxx_complement (pp);
1709       dump_decl (pp, name, TFF_PLAIN_IDENTIFIER);
1710     }
1711   else if (DECL_CONV_FN_P (t))
1712     {
1713       /* This cannot use the hack that the operator's return
1714          type is stashed off of its name because it may be
1715          used for error reporting.  In the case of conflicting
1716          declarations, both will have the same name, yet
1717          the types will be different, hence the TREE_TYPE field
1718          of the first name will be clobbered by the second.  */
1719       pp_cxx_ws_string (pp, "operator");
1720       dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
1721     }
1722   else if (name && IDENTIFIER_OPNAME_P (name))
1723     pp_cxx_tree_identifier (pp, name);
1724   else if (name && UDLIT_OPER_P (name))
1725     pp_cxx_tree_identifier (pp, name);
1726   else
1727     dump_decl (pp, name, flags);
1728
1729   if (DECL_TEMPLATE_INFO (t)
1730       && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
1731       && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
1732           || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
1733     dump_template_parms (pp, DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t),
1734                          flags);
1735 }
1736
1737 /* Dump the template parameters from the template info INFO under control of
1738    FLAGS. PRIMARY indicates whether this is a primary template decl, or
1739    specialization (partial or complete). For partial specializations we show
1740    the specialized parameter values. For a primary template we show no
1741    decoration.  */
1742
1743 static void
1744 dump_template_parms (cxx_pretty_printer *pp, tree info,
1745                      int primary, int flags)
1746 {
1747   tree args = info ? TI_ARGS (info) : NULL_TREE;
1748
1749   if (primary && flags & TFF_TEMPLATE_NAME)
1750     return;
1751   flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
1752   pp_cxx_begin_template_argument_list (pp);
1753
1754   /* Be careful only to print things when we have them, so as not
1755      to crash producing error messages.  */
1756   if (args && !primary)
1757     {
1758       int len, ix;
1759       len = get_non_default_template_args_count (args, flags);
1760
1761       args = INNERMOST_TEMPLATE_ARGS (args);
1762       for (ix = 0; ix != len; ix++)
1763         {
1764           tree arg = TREE_VEC_ELT (args, ix);
1765
1766           /* Only print a comma if we know there is an argument coming. In
1767              the case of an empty template argument pack, no actual
1768              argument will be printed.  */
1769           if (ix
1770               && (!ARGUMENT_PACK_P (arg)
1771                   || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
1772             pp_separate_with_comma (pp);
1773
1774           if (!arg)
1775             pp_string (pp, M_("<template parameter error>"));
1776           else
1777             dump_template_argument (pp, arg, flags);
1778         }
1779     }
1780   else if (primary)
1781     {
1782       tree tpl = TI_TEMPLATE (info);
1783       tree parms = DECL_TEMPLATE_PARMS (tpl);
1784       int len, ix;
1785
1786       parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
1787       len = parms ? TREE_VEC_LENGTH (parms) : 0;
1788
1789       for (ix = 0; ix != len; ix++)
1790         {
1791           tree parm;
1792
1793           if (TREE_VEC_ELT (parms, ix) == error_mark_node)
1794             {
1795               pp_string (pp, M_("<template parameter error>"));
1796               continue;
1797             }
1798
1799           parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
1800
1801           if (ix)
1802             pp_separate_with_comma (pp);
1803
1804           dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS);
1805         }
1806     }
1807   pp_cxx_end_template_argument_list (pp);
1808 }
1809
1810 /* Print out the arguments of CALL_EXPR T as a parenthesized list using
1811    flags FLAGS.  Skip over the first argument if SKIPFIRST is true.  */
1812
1813 static void
1814 dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst)
1815 {
1816   tree arg;
1817   call_expr_arg_iterator iter;
1818
1819   pp_cxx_left_paren (pp);
1820   FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
1821     {
1822       if (skipfirst)
1823         skipfirst = false;
1824       else
1825         {
1826           dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1827           if (more_call_expr_args_p (&iter))
1828             pp_separate_with_comma (pp);
1829         }
1830     }
1831   pp_cxx_right_paren (pp);
1832 }
1833
1834 /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
1835    using flags FLAGS.  Skip over the first argument if SKIPFIRST is
1836    true.  */
1837
1838 static void
1839 dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags,
1840                           bool skipfirst)
1841 {
1842   tree arg;
1843   aggr_init_expr_arg_iterator iter;
1844
1845   pp_cxx_left_paren (pp);
1846   FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
1847     {
1848       if (skipfirst)
1849         skipfirst = false;
1850       else
1851         {
1852           dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
1853           if (more_aggr_init_expr_args_p (&iter))
1854             pp_separate_with_comma (pp);
1855         }
1856     }
1857   pp_cxx_right_paren (pp);
1858 }
1859
1860 /* Print out a list of initializers (subr of dump_expr).  */
1861
1862 static void
1863 dump_expr_list (cxx_pretty_printer *pp, tree l, int flags)
1864 {
1865   while (l)
1866     {
1867       dump_expr (pp, TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
1868       l = TREE_CHAIN (l);
1869       if (l)
1870         pp_separate_with_comma (pp);
1871     }
1872 }
1873
1874 /* Print out a vector of initializers (subr of dump_expr).  */
1875
1876 static void
1877 dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v,
1878                     int flags)
1879 {
1880   unsigned HOST_WIDE_INT idx;
1881   tree value;
1882
1883   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1884     {
1885       dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS);
1886       if (idx != v->length () - 1)
1887         pp_separate_with_comma (pp);
1888     }
1889 }
1890
1891
1892 /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
1893    function.  Resolve it to a close relative -- in the sense of static
1894    type -- variant being overridden.  That is close to what was written in
1895    the source code.  Subroutine of dump_expr.  */
1896
1897 static tree
1898 resolve_virtual_fun_from_obj_type_ref (tree ref)
1899 {
1900   tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
1901   HOST_WIDE_INT index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref));
1902   tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
1903   while (index)
1904     {
1905       fun = TREE_CHAIN (fun);
1906       index -= (TARGET_VTABLE_USES_DESCRIPTORS
1907                 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
1908     }
1909
1910   return BV_FN (fun);
1911 }
1912
1913 /* Print out an expression E under control of FLAGS.  */
1914
1915 static void
1916 dump_expr (cxx_pretty_printer *pp, tree t, int flags)
1917 {
1918   tree op;
1919
1920   if (t == 0)
1921     return;
1922
1923   if (STATEMENT_CLASS_P (t))
1924     {
1925       pp_cxx_ws_string (pp, M_("<statement>"));
1926       return;
1927     }
1928
1929   switch (TREE_CODE (t))
1930     {
1931     case VAR_DECL:
1932     case PARM_DECL:
1933     case FIELD_DECL:
1934     case CONST_DECL:
1935     case FUNCTION_DECL:
1936     case TEMPLATE_DECL:
1937     case NAMESPACE_DECL:
1938     case LABEL_DECL:
1939     case OVERLOAD:
1940     case TYPE_DECL:
1941     case IDENTIFIER_NODE:
1942       dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
1943                                     |TFF_TEMPLATE_HEADER))
1944                          | TFF_NO_FUNCTION_ARGUMENTS));
1945       break;
1946
1947     case SSA_NAME:
1948       if (SSA_NAME_VAR (t)
1949           && !DECL_ARTIFICIAL (SSA_NAME_VAR (t)))
1950         dump_expr (pp, SSA_NAME_VAR (t), flags);
1951       else
1952         pp_cxx_ws_string (pp, M_("<unknown>"));
1953       break;
1954
1955     case VOID_CST:
1956     case INTEGER_CST:
1957     case REAL_CST:
1958     case STRING_CST:
1959     case COMPLEX_CST:
1960       pp->constant (t);
1961       break;
1962
1963     case USERDEF_LITERAL:
1964       pp_cxx_userdef_literal (pp, t);
1965       break;
1966
1967     case THROW_EXPR:
1968       /* While waiting for caret diagnostics, avoid printing
1969          __cxa_allocate_exception, __cxa_throw, and the like.  */
1970       pp_cxx_ws_string (pp, M_("<throw-expression>"));
1971       break;
1972
1973     case PTRMEM_CST:
1974       pp_ampersand (pp);
1975       dump_type (pp, PTRMEM_CST_CLASS (t), flags);
1976       pp_cxx_colon_colon (pp);
1977       pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
1978       break;
1979
1980     case COMPOUND_EXPR:
1981       pp_cxx_left_paren (pp);
1982       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1983       pp_separate_with_comma (pp);
1984       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1985       pp_cxx_right_paren (pp);
1986       break;
1987
1988     case COND_EXPR:
1989       pp_cxx_left_paren (pp);
1990       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
1991       pp_string (pp, " ? ");
1992       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
1993       pp_string (pp, " : ");
1994       dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
1995       pp_cxx_right_paren (pp);
1996       break;
1997
1998     case SAVE_EXPR:
1999       if (TREE_HAS_CONSTRUCTOR (t))
2000         {
2001           pp_cxx_ws_string (pp, "new");
2002           pp_cxx_whitespace (pp);
2003           dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
2004         }
2005       else
2006         dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2007       break;
2008
2009     case AGGR_INIT_EXPR:
2010       {
2011         tree fn = NULL_TREE;
2012
2013         if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
2014           fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
2015
2016         if (fn && TREE_CODE (fn) == FUNCTION_DECL)
2017           {
2018             if (DECL_CONSTRUCTOR_P (fn))
2019               dump_type (pp, DECL_CONTEXT (fn), flags);
2020             else
2021               dump_decl (pp, fn, 0);
2022           }
2023         else
2024           dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0);
2025       }
2026       dump_aggr_init_expr_args (pp, t, flags, true);
2027       break;
2028
2029     case CALL_EXPR:
2030       {
2031         tree fn = CALL_EXPR_FN (t);
2032         bool skipfirst = false;
2033
2034         /* Deal with internal functions.  */
2035         if (fn == NULL_TREE)
2036           {
2037             pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t)));
2038             dump_call_expr_args (pp, t, flags, skipfirst);
2039             break;
2040           }
2041
2042         if (TREE_CODE (fn) == ADDR_EXPR)
2043           fn = TREE_OPERAND (fn, 0);
2044
2045         /* Nobody is interested in seeing the guts of vcalls.  */
2046         if (TREE_CODE (fn) == OBJ_TYPE_REF)
2047           fn = resolve_virtual_fun_from_obj_type_ref (fn);
2048
2049         if (TREE_TYPE (fn) != NULL_TREE
2050             && NEXT_CODE (fn) == METHOD_TYPE
2051             && call_expr_nargs (t))
2052           {
2053             tree ob = CALL_EXPR_ARG (t, 0);
2054             if (TREE_CODE (ob) == ADDR_EXPR)
2055               {
2056                 dump_expr (pp, TREE_OPERAND (ob, 0),
2057                            flags | TFF_EXPR_IN_PARENS);
2058                 pp_cxx_dot (pp);
2059               }
2060             else if (TREE_CODE (ob) != PARM_DECL
2061                      || strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
2062               {
2063                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2064                 pp_cxx_arrow (pp);
2065               }
2066             skipfirst = true;
2067           }
2068         if (flag_sanitize & SANITIZE_UNDEFINED
2069             && is_ubsan_builtin_p (fn))
2070           {
2071             pp_string (cxx_pp, M_("<ubsan routine call>"));
2072             break;
2073           }
2074         dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS);
2075         dump_call_expr_args (pp, t, flags, skipfirst);
2076       }
2077       break;
2078
2079     case TARGET_EXPR:
2080       /* Note that this only works for G++ target exprs.  If somebody
2081          builds a general TARGET_EXPR, there's no way to represent that
2082          it initializes anything other that the parameter slot for the
2083          default argument.  Note we may have cleared out the first
2084          operand in expand_expr, so don't go killing ourselves.  */
2085       if (TREE_OPERAND (t, 1))
2086         dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2087       break;
2088
2089     case POINTER_PLUS_EXPR:
2090       dump_binary_op (pp, "+", t, flags);
2091       break;
2092
2093     case INIT_EXPR:
2094     case MODIFY_EXPR:
2095       dump_binary_op (pp, assignment_operator_name_info[NOP_EXPR].name,
2096                       t, flags);
2097       break;
2098
2099     case PLUS_EXPR:
2100     case MINUS_EXPR:
2101     case MULT_EXPR:
2102     case TRUNC_DIV_EXPR:
2103     case TRUNC_MOD_EXPR:
2104     case MIN_EXPR:
2105     case MAX_EXPR:
2106     case LSHIFT_EXPR:
2107     case RSHIFT_EXPR:
2108     case BIT_IOR_EXPR:
2109     case BIT_XOR_EXPR:
2110     case BIT_AND_EXPR:
2111     case TRUTH_ANDIF_EXPR:
2112     case TRUTH_ORIF_EXPR:
2113     case LT_EXPR:
2114     case LE_EXPR:
2115     case GT_EXPR:
2116     case GE_EXPR:
2117     case EQ_EXPR:
2118     case NE_EXPR:
2119     case EXACT_DIV_EXPR:
2120       dump_binary_op (pp, operator_name_info[TREE_CODE (t)].name, t, flags);
2121       break;
2122
2123     case CEIL_DIV_EXPR:
2124     case FLOOR_DIV_EXPR:
2125     case ROUND_DIV_EXPR:
2126     case RDIV_EXPR:
2127       dump_binary_op (pp, "/", t, flags);
2128       break;
2129
2130     case CEIL_MOD_EXPR:
2131     case FLOOR_MOD_EXPR:
2132     case ROUND_MOD_EXPR:
2133       dump_binary_op (pp, "%", t, flags);
2134       break;
2135
2136     case COMPONENT_REF:
2137       {
2138         tree ob = TREE_OPERAND (t, 0);
2139         if (INDIRECT_REF_P (ob))
2140           {
2141             ob = TREE_OPERAND (ob, 0);
2142             if (TREE_CODE (ob) != PARM_DECL
2143                 || (DECL_NAME (ob)
2144                     && strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this")))
2145               {
2146                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2147                 if (TREE_CODE (TREE_TYPE (ob)) == REFERENCE_TYPE)
2148                   pp_cxx_dot (pp);
2149                 else
2150                   pp_cxx_arrow (pp);
2151               }
2152           }
2153         else
2154           {
2155             dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2156             pp_cxx_dot (pp);
2157           }
2158         dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
2159       }
2160       break;
2161
2162     case ARRAY_REF:
2163       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2164       pp_cxx_left_bracket (pp);
2165       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2166       pp_cxx_right_bracket (pp);
2167       break;
2168
2169     case ARRAY_NOTATION_REF:
2170       dump_expr (pp, ARRAY_NOTATION_ARRAY (t), flags | TFF_EXPR_IN_PARENS);
2171       pp_cxx_left_bracket (pp);
2172       dump_expr (pp, ARRAY_NOTATION_START (t), flags | TFF_EXPR_IN_PARENS);
2173       pp_colon (pp);
2174       dump_expr (pp, ARRAY_NOTATION_LENGTH (t), flags | TFF_EXPR_IN_PARENS);
2175       pp_colon (pp);
2176       dump_expr (pp, ARRAY_NOTATION_STRIDE (t), flags | TFF_EXPR_IN_PARENS);
2177       pp_cxx_right_bracket (pp);
2178       break;
2179
2180     case UNARY_PLUS_EXPR:
2181       dump_unary_op (pp, "+", t, flags);
2182       break;
2183
2184     case ADDR_EXPR:
2185       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
2186           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
2187           /* An ADDR_EXPR can have reference type.  In that case, we
2188              shouldn't print the `&' doing so indicates to the user
2189              that the expression has pointer type.  */
2190           || (TREE_TYPE (t)
2191               && TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE))
2192         dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2193       else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
2194         dump_unary_op (pp, "&&", t, flags);
2195       else
2196         dump_unary_op (pp, "&", t, flags);
2197       break;
2198
2199     case INDIRECT_REF:
2200       if (TREE_HAS_CONSTRUCTOR (t))
2201         {
2202           t = TREE_OPERAND (t, 0);
2203           gcc_assert (TREE_CODE (t) == CALL_EXPR);
2204           dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
2205           dump_call_expr_args (pp, t, flags, true);
2206         }
2207       else
2208         {
2209           if (TREE_OPERAND (t,0) != NULL_TREE
2210               && TREE_TYPE (TREE_OPERAND (t, 0))
2211               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
2212             dump_expr (pp, TREE_OPERAND (t, 0), flags);
2213           else
2214             dump_unary_op (pp, "*", t, flags);
2215         }
2216       break;
2217
2218     case MEM_REF:
2219       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
2220           && integer_zerop (TREE_OPERAND (t, 1)))
2221         dump_expr (pp, TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
2222       else
2223         {
2224           pp_cxx_star (pp);
2225           if (!integer_zerop (TREE_OPERAND (t, 1)))
2226             {
2227               pp_cxx_left_paren (pp);
2228               if (!integer_onep (TYPE_SIZE_UNIT
2229                                  (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
2230                 {
2231                   pp_cxx_left_paren (pp);
2232                   dump_type (pp, ptr_type_node, flags);
2233                   pp_cxx_right_paren (pp);
2234                 }
2235             }
2236           dump_expr (pp, TREE_OPERAND (t, 0), flags);
2237           if (!integer_zerop (TREE_OPERAND (t, 1)))
2238             {
2239               pp_cxx_ws_string (pp, "+");
2240               dump_expr (pp, fold_convert (ssizetype, TREE_OPERAND (t, 1)),
2241                          flags);
2242               pp_cxx_right_paren (pp);
2243             }
2244         }
2245       break;
2246
2247     case NEGATE_EXPR:
2248     case BIT_NOT_EXPR:
2249     case TRUTH_NOT_EXPR:
2250     case PREDECREMENT_EXPR:
2251     case PREINCREMENT_EXPR:
2252       dump_unary_op (pp, operator_name_info [TREE_CODE (t)].name, t, flags);
2253       break;
2254
2255     case POSTDECREMENT_EXPR:
2256     case POSTINCREMENT_EXPR:
2257       pp_cxx_left_paren (pp);
2258       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2259       pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2260       pp_cxx_right_paren (pp);
2261       break;
2262
2263     case NON_LVALUE_EXPR:
2264       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
2265          should be another level of INDIRECT_REF so that I don't have to do
2266          this.  */
2267       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
2268         {
2269           tree next = TREE_TYPE (TREE_TYPE (t));
2270
2271           while (TYPE_PTR_P (next))
2272             next = TREE_TYPE (next);
2273
2274           if (TREE_CODE (next) == FUNCTION_TYPE)
2275             {
2276               if (flags & TFF_EXPR_IN_PARENS)
2277                 pp_cxx_left_paren (pp);
2278               pp_cxx_star (pp);
2279               dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2280               if (flags & TFF_EXPR_IN_PARENS)
2281                 pp_cxx_right_paren (pp);
2282               break;
2283             }
2284           /* Else fall through.  */
2285         }
2286       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2287       break;
2288
2289     CASE_CONVERT:
2290     case IMPLICIT_CONV_EXPR:
2291     case VIEW_CONVERT_EXPR:
2292       {
2293         tree op = TREE_OPERAND (t, 0);
2294         tree ttype = TREE_TYPE (t);
2295         tree optype = TREE_TYPE (op);
2296
2297         if (TREE_CODE (ttype) != TREE_CODE (optype)
2298             && POINTER_TYPE_P (ttype)
2299             && POINTER_TYPE_P (optype)
2300             && same_type_p (TREE_TYPE (optype),
2301                             TREE_TYPE (ttype)))
2302           {
2303             if (TREE_CODE (ttype) == REFERENCE_TYPE)
2304               {
2305                 STRIP_NOPS (op);
2306                 if (TREE_CODE (op) == ADDR_EXPR)
2307                   dump_expr (pp, TREE_OPERAND (op, 0), flags);
2308                 else
2309                   dump_unary_op (pp, "*", t, flags);
2310               }
2311             else
2312               dump_unary_op (pp, "&", t, flags);
2313           }
2314         else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
2315           {
2316             /* It is a cast, but we cannot tell whether it is a
2317                reinterpret or static cast. Use the C style notation.  */
2318             if (flags & TFF_EXPR_IN_PARENS)
2319               pp_cxx_left_paren (pp);
2320             pp_cxx_left_paren (pp);
2321             dump_type (pp, TREE_TYPE (t), flags);
2322             pp_cxx_right_paren (pp);
2323             dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS);
2324             if (flags & TFF_EXPR_IN_PARENS)
2325               pp_cxx_right_paren (pp);
2326           }
2327         else
2328           dump_expr (pp, op, flags);
2329         break;
2330       }
2331
2332     case CONSTRUCTOR:
2333       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2334         {
2335           tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
2336
2337           if (integer_zerop (idx))
2338             {
2339               /* A NULL pointer-to-member constant.  */
2340               pp_cxx_left_paren (pp);
2341               pp_cxx_left_paren (pp);
2342               dump_type (pp, TREE_TYPE (t), flags);
2343               pp_cxx_right_paren (pp);
2344               pp_character (pp, '0');
2345               pp_cxx_right_paren (pp);
2346               break;
2347             }
2348           else if (tree_fits_shwi_p (idx))
2349             {
2350               tree virtuals;
2351               unsigned HOST_WIDE_INT n;
2352
2353               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
2354               t = TYPE_METHOD_BASETYPE (t);
2355               virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
2356
2357               n = tree_to_shwi (idx);
2358
2359               /* Map vtable index back one, to allow for the null pointer to
2360                  member.  */
2361               --n;
2362
2363               while (n > 0 && virtuals)
2364                 {
2365                   --n;
2366                   virtuals = TREE_CHAIN (virtuals);
2367                 }
2368               if (virtuals)
2369                 {
2370                   dump_expr (pp, BV_FN (virtuals),
2371                              flags | TFF_EXPR_IN_PARENS);
2372                   break;
2373                 }
2374             }
2375         }
2376       if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t)))
2377         pp_string (pp, "<lambda closure object>");
2378       if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
2379         {
2380           dump_type (pp, TREE_TYPE (t), 0);
2381           pp_cxx_left_paren (pp);
2382           pp_cxx_right_paren (pp);
2383         }
2384       else
2385         {
2386           if (!BRACE_ENCLOSED_INITIALIZER_P (t))
2387             dump_type (pp, TREE_TYPE (t), 0);
2388           pp_cxx_left_brace (pp);
2389           dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags);
2390           pp_cxx_right_brace (pp);
2391         }
2392
2393       break;
2394
2395     case OFFSET_REF:
2396       {
2397         tree ob = TREE_OPERAND (t, 0);
2398         if (is_dummy_object (ob))
2399           {
2400             t = TREE_OPERAND (t, 1);
2401             if (TREE_CODE (t) == FUNCTION_DECL)
2402               /* A::f */
2403               dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS);
2404             else if (BASELINK_P (t))
2405               dump_expr (pp, OVL_CURRENT (BASELINK_FUNCTIONS (t)),
2406                          flags | TFF_EXPR_IN_PARENS);
2407             else
2408               dump_decl (pp, t, flags);
2409           }
2410         else
2411           {
2412             if (INDIRECT_REF_P (ob))
2413               {
2414                 dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
2415                 pp_cxx_arrow (pp);
2416                 pp_cxx_star (pp);
2417               }
2418             else
2419               {
2420                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
2421                 pp_cxx_dot (pp);
2422                 pp_cxx_star (pp);
2423               }
2424             dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2425           }
2426         break;
2427       }
2428
2429     case TEMPLATE_PARM_INDEX:
2430       dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
2431       break;
2432
2433     case CAST_EXPR:
2434       if (TREE_OPERAND (t, 0) == NULL_TREE
2435           || TREE_CHAIN (TREE_OPERAND (t, 0)))
2436         {
2437           dump_type (pp, TREE_TYPE (t), flags);
2438           pp_cxx_left_paren (pp);
2439           dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2440           pp_cxx_right_paren (pp);
2441         }
2442       else
2443         {
2444           pp_cxx_left_paren (pp);
2445           dump_type (pp, TREE_TYPE (t), flags);
2446           pp_cxx_right_paren (pp);
2447           pp_cxx_left_paren (pp);
2448           dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
2449           pp_cxx_right_paren (pp);
2450         }
2451       break;
2452
2453     case STATIC_CAST_EXPR:
2454       pp_cxx_ws_string (pp, "static_cast");
2455       goto cast;
2456     case REINTERPRET_CAST_EXPR:
2457       pp_cxx_ws_string (pp, "reinterpret_cast");
2458       goto cast;
2459     case CONST_CAST_EXPR:
2460       pp_cxx_ws_string (pp, "const_cast");
2461       goto cast;
2462     case DYNAMIC_CAST_EXPR:
2463       pp_cxx_ws_string (pp, "dynamic_cast");
2464     cast:
2465       pp_cxx_begin_template_argument_list (pp);
2466       dump_type (pp, TREE_TYPE (t), flags);
2467       pp_cxx_end_template_argument_list (pp);
2468       pp_cxx_left_paren (pp);
2469       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2470       pp_cxx_right_paren (pp);
2471       break;
2472
2473     case ARROW_EXPR:
2474       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2475       pp_cxx_arrow (pp);
2476       break;
2477
2478     case SIZEOF_EXPR:
2479     case ALIGNOF_EXPR:
2480       if (TREE_CODE (t) == SIZEOF_EXPR)
2481         pp_cxx_ws_string (pp, "sizeof");
2482       else
2483         {
2484           gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
2485           pp_cxx_ws_string (pp, "__alignof__");
2486         }
2487       op = TREE_OPERAND (t, 0);
2488       if (PACK_EXPANSION_P (op))
2489         {
2490           pp_string (pp, "...");
2491           op = PACK_EXPANSION_PATTERN (op);
2492         }
2493       pp_cxx_whitespace (pp);
2494       pp_cxx_left_paren (pp);
2495       if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
2496         dump_type (pp, TREE_TYPE (op), flags);
2497       else if (TYPE_P (TREE_OPERAND (t, 0)))
2498         dump_type (pp, op, flags);
2499       else
2500         dump_expr (pp, op, flags);
2501       pp_cxx_right_paren (pp);
2502       break;
2503
2504     case AT_ENCODE_EXPR:
2505       pp_cxx_ws_string (pp, "@encode");
2506       pp_cxx_whitespace (pp);
2507       pp_cxx_left_paren (pp);
2508       dump_type (pp, TREE_OPERAND (t, 0), flags);
2509       pp_cxx_right_paren (pp);
2510       break;
2511
2512     case NOEXCEPT_EXPR:
2513       pp_cxx_ws_string (pp, "noexcept");
2514       pp_cxx_whitespace (pp);
2515       pp_cxx_left_paren (pp);
2516       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2517       pp_cxx_right_paren (pp);
2518       break;
2519
2520     case REALPART_EXPR:
2521     case IMAGPART_EXPR:
2522       pp_cxx_ws_string (pp, operator_name_info[TREE_CODE (t)].name);
2523       pp_cxx_whitespace (pp);
2524       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2525       break;
2526
2527     case DEFAULT_ARG:
2528       pp_string (pp, M_("<unparsed>"));
2529       break;
2530
2531     case TRY_CATCH_EXPR:
2532     case WITH_CLEANUP_EXPR:
2533     case CLEANUP_POINT_EXPR:
2534       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2535       break;
2536
2537     case PSEUDO_DTOR_EXPR:
2538       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2539       pp_cxx_dot (pp);
2540       if (TREE_OPERAND (t, 1))
2541         {
2542           dump_type (pp, TREE_OPERAND (t, 1), flags);
2543           pp_cxx_colon_colon (pp);
2544         }
2545       pp_cxx_complement (pp);
2546       dump_type (pp, TREE_OPERAND (t, 2), flags);
2547       break;
2548
2549     case TEMPLATE_ID_EXPR:
2550       dump_decl (pp, t, flags);
2551       break;
2552
2553     case BIND_EXPR:
2554     case STMT_EXPR:
2555     case EXPR_STMT:
2556     case STATEMENT_LIST:
2557       /* We don't yet have a way of dumping statements in a
2558          human-readable format.  */
2559       pp_string (pp, "({...})");
2560       break;
2561
2562     case LOOP_EXPR:
2563       pp_string (pp, "while (1) { ");
2564       dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2565       pp_cxx_right_brace (pp);
2566       break;
2567
2568     case EXIT_EXPR:
2569       pp_string (pp, "if (");
2570       dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2571       pp_string (pp, ") break; ");
2572       break;
2573
2574     case BASELINK:
2575       dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
2576       break;
2577
2578     case EMPTY_CLASS_EXPR:
2579       dump_type (pp, TREE_TYPE (t), flags);
2580       pp_cxx_left_paren (pp);
2581       pp_cxx_right_paren (pp);
2582       break;
2583
2584     case NON_DEPENDENT_EXPR:
2585       dump_expr (pp, TREE_OPERAND (t, 0), flags);
2586       break;
2587
2588     case ARGUMENT_PACK_SELECT:
2589       dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
2590       break;
2591
2592     case RECORD_TYPE:
2593     case UNION_TYPE:
2594     case ENUMERAL_TYPE:
2595     case REAL_TYPE:
2596     case VOID_TYPE:
2597     case BOOLEAN_TYPE:
2598     case INTEGER_TYPE:
2599     case COMPLEX_TYPE:
2600     case VECTOR_TYPE:
2601       pp_type_specifier_seq (pp, t);
2602       break;
2603
2604     case TYPENAME_TYPE:
2605       /* We get here when we want to print a dependent type as an
2606          id-expression, without any disambiguator decoration.  */
2607       pp->id_expression (t);
2608       break;
2609
2610     case TEMPLATE_TYPE_PARM:
2611     case TEMPLATE_TEMPLATE_PARM:
2612     case BOUND_TEMPLATE_TEMPLATE_PARM:
2613       dump_type (pp, t, flags);
2614       break;
2615
2616     case TRAIT_EXPR:
2617       pp_cxx_trait_expression (pp, t);
2618       break;
2619
2620     case VA_ARG_EXPR:
2621       pp_cxx_va_arg_expression (pp, t);
2622       break;
2623
2624     case OFFSETOF_EXPR:
2625       pp_cxx_offsetof_expression (pp, t);
2626       break;
2627
2628     case SCOPE_REF:
2629       dump_decl (pp, t, flags);
2630       break;
2631
2632     case EXPR_PACK_EXPANSION:
2633     case TYPEID_EXPR:
2634     case MEMBER_REF:
2635     case DOTSTAR_EXPR:
2636     case NEW_EXPR:
2637     case VEC_NEW_EXPR:
2638     case DELETE_EXPR:
2639     case VEC_DELETE_EXPR:
2640     case MODOP_EXPR:
2641     case ABS_EXPR:
2642     case CONJ_EXPR:
2643     case VECTOR_CST:
2644     case FIXED_CST:
2645     case UNORDERED_EXPR:
2646     case ORDERED_EXPR:
2647     case UNLT_EXPR:
2648     case UNLE_EXPR:
2649     case UNGT_EXPR:
2650     case UNGE_EXPR:
2651     case UNEQ_EXPR:
2652     case LTGT_EXPR:
2653     case COMPLEX_EXPR:
2654     case BIT_FIELD_REF:
2655     case FIX_TRUNC_EXPR:
2656     case FLOAT_EXPR:
2657       pp->expression (t);
2658       break;
2659
2660     case TRUTH_AND_EXPR:
2661     case TRUTH_OR_EXPR:
2662     case TRUTH_XOR_EXPR:
2663       if (flags & TFF_EXPR_IN_PARENS)
2664         pp_cxx_left_paren (pp);
2665       pp->expression (t);
2666       if (flags & TFF_EXPR_IN_PARENS)
2667         pp_cxx_right_paren (pp);
2668       break;
2669
2670     case OBJ_TYPE_REF:
2671       dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
2672       break;
2673
2674     case LAMBDA_EXPR:
2675       pp_string (pp, M_("<lambda>"));
2676       break;
2677
2678     case PAREN_EXPR:
2679       pp_cxx_left_paren (pp);
2680       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2681       pp_cxx_right_paren (pp);
2682       break;
2683
2684     case PLACEHOLDER_EXPR:
2685       pp_string (pp, M_("*this"));
2686       break;
2687
2688       /*  This list is incomplete, but should suffice for now.
2689           It is very important that `sorry' does not call
2690           `report_error_function'.  That could cause an infinite loop.  */
2691     default:
2692       pp_unsupported_tree (pp, t);
2693       /* fall through to ERROR_MARK...  */
2694     case ERROR_MARK:
2695       pp_string (pp, M_("<expression error>"));
2696       break;
2697     }
2698 }
2699
2700 static void
2701 dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
2702                 int flags)
2703 {
2704   pp_cxx_left_paren (pp);
2705   dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
2706   pp_cxx_whitespace (pp);
2707   if (opstring)
2708     pp_cxx_ws_string (pp, opstring);
2709   else
2710     pp_string (pp, M_("<unknown operator>"));
2711   pp_cxx_whitespace (pp);
2712   dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
2713   pp_cxx_right_paren (pp);
2714 }
2715
2716 static void
2717 dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
2718 {
2719   if (flags & TFF_EXPR_IN_PARENS)
2720     pp_cxx_left_paren (pp);
2721   pp_cxx_ws_string (pp, opstring);
2722   dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
2723   if (flags & TFF_EXPR_IN_PARENS)
2724     pp_cxx_right_paren (pp);
2725 }
2726
2727 static void
2728 reinit_cxx_pp (void)
2729 {
2730   pp_clear_output_area (cxx_pp);
2731   cxx_pp->padding = pp_none;
2732   pp_indentation (cxx_pp) = 0;
2733   pp_needs_newline (cxx_pp) = false;
2734   cxx_pp->enclosing_scope = current_function_decl;
2735 }
2736
2737 /* Same as pp_formatted_text, except the return string is a separate
2738    copy and has a GGC storage duration, e.g. an indefinite lifetime.  */
2739
2740 inline const char *
2741 pp_ggc_formatted_text (pretty_printer *pp)
2742 {
2743   return ggc_strdup (pp_formatted_text (pp));
2744 }
2745
2746 /* Exported interface to stringifying types, exprs and decls under TFF_*
2747    control.  */
2748
2749 const char *
2750 type_as_string (tree typ, int flags)
2751 {
2752   reinit_cxx_pp ();
2753   pp_translate_identifiers (cxx_pp) = false;
2754   dump_type (cxx_pp, typ, flags);
2755   return pp_ggc_formatted_text (cxx_pp);
2756 }
2757
2758 const char *
2759 type_as_string_translate (tree typ, int flags)
2760 {
2761   reinit_cxx_pp ();
2762   dump_type (cxx_pp, typ, flags);
2763   return pp_ggc_formatted_text (cxx_pp);
2764 }
2765
2766 const char *
2767 expr_as_string (tree decl, int flags)
2768 {
2769   reinit_cxx_pp ();
2770   pp_translate_identifiers (cxx_pp) = false;
2771   dump_expr (cxx_pp, decl, flags);
2772   return pp_ggc_formatted_text (cxx_pp);
2773 }
2774
2775 /* Wrap decl_as_string with options appropriate for dwarf.  */
2776
2777 const char *
2778 decl_as_dwarf_string (tree decl, int flags)
2779 {
2780   const char *name;
2781   /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2782      here will be adequate to get the desired behaviour.  */
2783   cxx_pp->flags |= pp_c_flag_gnu_v3;
2784   name = decl_as_string (decl, flags);
2785   /* Subsequent calls to the pretty printer shouldn't use this style.  */
2786   cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2787   return name;
2788 }
2789
2790 const char *
2791 decl_as_string (tree decl, int flags)
2792 {
2793   reinit_cxx_pp ();
2794   pp_translate_identifiers (cxx_pp) = false;
2795   dump_decl (cxx_pp, decl, flags);
2796   return pp_ggc_formatted_text (cxx_pp);
2797 }
2798
2799 const char *
2800 decl_as_string_translate (tree decl, int flags)
2801 {
2802   reinit_cxx_pp ();
2803   dump_decl (cxx_pp, decl, flags);
2804   return pp_ggc_formatted_text (cxx_pp);
2805 }
2806
2807 /* Wrap lang_decl_name with options appropriate for dwarf.  */
2808
2809 const char *
2810 lang_decl_dwarf_name (tree decl, int v, bool translate)
2811 {
2812   const char *name;
2813   /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
2814      here will be adequate to get the desired behaviour.  */
2815   cxx_pp->flags |= pp_c_flag_gnu_v3;
2816   name = lang_decl_name (decl, v, translate);
2817   /* Subsequent calls to the pretty printer shouldn't use this style.  */
2818   cxx_pp->flags &= ~pp_c_flag_gnu_v3;
2819   return name;
2820 }
2821
2822 /* Generate the three forms of printable names for cxx_printable_name.  */
2823
2824 const char *
2825 lang_decl_name (tree decl, int v, bool translate)
2826 {
2827   if (v >= 2)
2828     return (translate
2829             ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
2830             : decl_as_string (decl, TFF_DECL_SPECIFIERS));
2831
2832   reinit_cxx_pp ();
2833   pp_translate_identifiers (cxx_pp) = translate;
2834   if (v == 1
2835       && (DECL_CLASS_SCOPE_P (decl)
2836           || (DECL_NAMESPACE_SCOPE_P (decl)
2837               && CP_DECL_CONTEXT (decl) != global_namespace)))
2838     {
2839       dump_type (cxx_pp, CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
2840       pp_cxx_colon_colon (cxx_pp);
2841     }
2842
2843   if (TREE_CODE (decl) == FUNCTION_DECL)
2844     dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER);
2845   else if ((DECL_NAME (decl) == NULL_TREE)
2846            && TREE_CODE (decl) == NAMESPACE_DECL)
2847     dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER | TFF_UNQUALIFIED_NAME);
2848   else
2849     dump_decl (cxx_pp, DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
2850
2851   return pp_ggc_formatted_text (cxx_pp);
2852 }
2853
2854 /* Return the location of a tree passed to %+ formats.  */
2855
2856 location_t
2857 location_of (tree t)
2858 {
2859   if (TYPE_P (t))
2860     {
2861       t = TYPE_MAIN_DECL (t);
2862       if (t == NULL_TREE)
2863         return input_location;
2864     }
2865   else if (TREE_CODE (t) == OVERLOAD)
2866     t = OVL_FUNCTION (t);
2867
2868   if (DECL_P (t))
2869     return DECL_SOURCE_LOCATION (t);
2870   return EXPR_LOC_OR_LOC (t, input_location);
2871 }
2872
2873 /* Now the interfaces from error et al to dump_type et al. Each takes an
2874    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
2875    function.  */
2876
2877 static const char *
2878 decl_to_string (tree decl, int verbose)
2879 {
2880   int flags = 0;
2881
2882   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
2883       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
2884     flags = TFF_CLASS_KEY_OR_ENUM;
2885   if (verbose)
2886     flags |= TFF_DECL_SPECIFIERS;
2887   else if (TREE_CODE (decl) == FUNCTION_DECL)
2888     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
2889   flags |= TFF_TEMPLATE_HEADER;
2890
2891   reinit_cxx_pp ();
2892   dump_decl (cxx_pp, decl, flags);
2893   return pp_ggc_formatted_text (cxx_pp);
2894 }
2895
2896 static const char *
2897 expr_to_string (tree decl)
2898 {
2899   reinit_cxx_pp ();
2900   dump_expr (cxx_pp, decl, 0);
2901   return pp_ggc_formatted_text (cxx_pp);
2902 }
2903
2904 static const char *
2905 fndecl_to_string (tree fndecl, int verbose)
2906 {
2907   int flags;
2908
2909   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
2910     | TFF_TEMPLATE_HEADER;
2911   if (verbose)
2912     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
2913   reinit_cxx_pp ();
2914   dump_decl (cxx_pp, fndecl, flags);
2915   return pp_ggc_formatted_text (cxx_pp);
2916 }
2917
2918
2919 static const char *
2920 code_to_string (enum tree_code c)
2921 {
2922   return get_tree_code_name (c);
2923 }
2924
2925 const char *
2926 language_to_string (enum languages c)
2927 {
2928   switch (c)
2929     {
2930     case lang_c:
2931       return "C";
2932
2933     case lang_cplusplus:
2934       return "C++";
2935
2936     case lang_java:
2937       return "Java";
2938
2939     default:
2940       gcc_unreachable ();
2941     }
2942   return NULL;
2943 }
2944
2945 /* Return the proper printed version of a parameter to a C++ function.  */
2946
2947 static const char *
2948 parm_to_string (int p)
2949 {
2950   reinit_cxx_pp ();
2951   if (p < 0)
2952     pp_string (cxx_pp, "'this'");
2953   else
2954     pp_decimal_int (cxx_pp, p + 1);
2955   return pp_ggc_formatted_text (cxx_pp);
2956 }
2957
2958 static const char *
2959 op_to_string (enum tree_code p)
2960 {
2961   tree id = operator_name_info[p].identifier;
2962   return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
2963 }
2964
2965 static const char *
2966 type_to_string (tree typ, int verbose)
2967 {
2968   int flags = 0;
2969   if (verbose)
2970     flags |= TFF_CLASS_KEY_OR_ENUM;
2971   flags |= TFF_TEMPLATE_HEADER;
2972
2973   reinit_cxx_pp ();
2974   dump_type (cxx_pp, typ, flags);
2975   /* If we're printing a type that involves typedefs, also print the
2976      stripped version.  But sometimes the stripped version looks
2977      exactly the same, so we don't want it after all.  To avoid printing
2978      it in that case, we play ugly obstack games.  */
2979   if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
2980       && !uses_template_parms (typ))
2981     {
2982       int aka_start, aka_len; char *p;
2983       struct obstack *ob = pp_buffer (cxx_pp)->obstack;
2984       /* Remember the end of the initial dump.  */
2985       int len = obstack_object_size (ob);
2986       tree aka = strip_typedefs (typ);
2987       pp_string (cxx_pp, " {aka");
2988       pp_cxx_whitespace (cxx_pp);
2989       /* And remember the start of the aka dump.  */
2990       aka_start = obstack_object_size (ob);
2991       dump_type (cxx_pp, aka, flags);
2992       aka_len = obstack_object_size (ob) - aka_start;
2993       pp_right_brace (cxx_pp);
2994       p = (char*)obstack_base (ob);
2995       /* If they are identical, cut off the aka with a NUL.  */
2996       if (len == aka_len && memcmp (p, p+aka_start, len) == 0)
2997         p[len] = '\0';
2998     }
2999   return pp_ggc_formatted_text (cxx_pp);
3000 }
3001
3002 static const char *
3003 assop_to_string (enum tree_code p)
3004 {
3005   tree id = assignment_operator_name_info[(int) p].identifier;
3006   return id ? IDENTIFIER_POINTER (id) : M_("{unknown}");
3007 }
3008
3009 static const char *
3010 args_to_string (tree p, int verbose)
3011 {
3012   int flags = 0;
3013   if (verbose)
3014     flags |= TFF_CLASS_KEY_OR_ENUM;
3015
3016   if (p == NULL_TREE)
3017     return "";
3018
3019   if (TYPE_P (TREE_VALUE (p)))
3020     return type_as_string_translate (p, flags);
3021
3022   reinit_cxx_pp ();
3023   for (; p; p = TREE_CHAIN (p))
3024     {
3025       if (TREE_VALUE (p) == null_node)
3026         pp_cxx_ws_string (cxx_pp, "NULL");
3027       else
3028         dump_type (cxx_pp, error_type (TREE_VALUE (p)), flags);
3029       if (TREE_CHAIN (p))
3030         pp_separate_with_comma (cxx_pp);
3031     }
3032   return pp_ggc_formatted_text (cxx_pp);
3033 }
3034
3035 /* Pretty-print a deduction substitution (from deduction_tsubst_fntype).  P
3036    is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3037    arguments.  */
3038
3039 static const char *
3040 subst_to_string (tree p)
3041 {
3042   tree decl = TREE_PURPOSE (p);
3043   tree targs = TREE_VALUE (p);
3044   tree tparms = DECL_TEMPLATE_PARMS (decl);
3045   int flags = (TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER
3046                |TFF_NO_TEMPLATE_BINDINGS);
3047
3048   if (p == NULL_TREE)
3049     return "";
3050
3051   reinit_cxx_pp ();
3052   dump_template_decl (cxx_pp, TREE_PURPOSE (p), flags);
3053   dump_substitution (cxx_pp, NULL, tparms, targs, /*flags=*/0);
3054   return pp_ggc_formatted_text (cxx_pp);
3055 }
3056
3057 static const char *
3058 cv_to_string (tree p, int v)
3059 {
3060   reinit_cxx_pp ();
3061   cxx_pp->padding = v ? pp_before : pp_none;
3062   pp_cxx_cv_qualifier_seq (cxx_pp, p);
3063   return pp_ggc_formatted_text (cxx_pp);
3064 }
3065
3066 static const char *
3067 eh_spec_to_string (tree p, int /*v*/)
3068 {
3069   int flags = 0;
3070   reinit_cxx_pp ();
3071   dump_exception_spec (cxx_pp, p, flags);
3072   return pp_ggc_formatted_text (cxx_pp);
3073 }
3074
3075 /* Langhook for print_error_function.  */
3076 void
3077 cxx_print_error_function (diagnostic_context *context, const char *file,
3078                           diagnostic_info *diagnostic)
3079 {
3080   lhd_print_error_function (context, file, diagnostic);
3081   pp_set_prefix (context->printer, file);
3082   maybe_print_instantiation_context (context);
3083 }
3084
3085 static void
3086 cp_diagnostic_starter (diagnostic_context *context,
3087                        diagnostic_info *diagnostic)
3088 {
3089   diagnostic_report_current_module (context, diagnostic_location (diagnostic));
3090   cp_print_error_function (context, diagnostic);
3091   maybe_print_instantiation_context (context);
3092   maybe_print_constexpr_context (context);
3093   pp_set_prefix (context->printer, diagnostic_build_prefix (context,
3094                                                                  diagnostic));
3095 }
3096
3097 /* Print current function onto BUFFER, in the process of reporting
3098    a diagnostic message.  Called from cp_diagnostic_starter.  */
3099 static void
3100 cp_print_error_function (diagnostic_context *context,
3101                          diagnostic_info *diagnostic)
3102 {
3103   /* If we are in an instantiation context, current_function_decl is likely
3104      to be wrong, so just rely on print_instantiation_full_context.  */
3105   if (current_instantiation ())
3106     return;
3107   if (diagnostic_last_function_changed (context, diagnostic))
3108     {
3109       const char *old_prefix = context->printer->prefix;
3110       const char *file = LOCATION_FILE (diagnostic_location (diagnostic));
3111       tree abstract_origin = diagnostic_abstract_origin (diagnostic);
3112       char *new_prefix = (file && abstract_origin == NULL)
3113                          ? file_name_as_prefix (context, file) : NULL;
3114
3115       pp_set_prefix (context->printer, new_prefix);
3116
3117       if (current_function_decl == NULL)
3118         pp_string (context->printer, _("At global scope:"));
3119       else
3120         {
3121           tree fndecl, ao;
3122
3123           if (abstract_origin)
3124             {
3125               ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
3126               while (TREE_CODE (ao) == BLOCK
3127                      && BLOCK_ABSTRACT_ORIGIN (ao)
3128                      && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3129                 ao = BLOCK_ABSTRACT_ORIGIN (ao);
3130               gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
3131               fndecl = ao;
3132             }
3133           else
3134             fndecl = current_function_decl;
3135
3136           pp_printf (context->printer, function_category (fndecl),
3137                      cxx_printable_name_translate (fndecl, 2));
3138
3139           while (abstract_origin)
3140             {
3141               location_t *locus;
3142               tree block = abstract_origin;
3143
3144               locus = &BLOCK_SOURCE_LOCATION (block);
3145               fndecl = NULL;
3146               block = BLOCK_SUPERCONTEXT (block);
3147               while (block && TREE_CODE (block) == BLOCK
3148                      && BLOCK_ABSTRACT_ORIGIN (block))
3149                 {
3150                   ao = BLOCK_ABSTRACT_ORIGIN (block);
3151
3152                   while (TREE_CODE (ao) == BLOCK
3153                          && BLOCK_ABSTRACT_ORIGIN (ao)
3154                          && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3155                     ao = BLOCK_ABSTRACT_ORIGIN (ao);
3156
3157                   if (TREE_CODE (ao) == FUNCTION_DECL)
3158                     {
3159                       fndecl = ao;
3160                       break;
3161                     }
3162                   else if (TREE_CODE (ao) != BLOCK)
3163                     break;
3164
3165                   block = BLOCK_SUPERCONTEXT (block);
3166                 }
3167               if (fndecl)
3168                 abstract_origin = block;
3169               else
3170                 {
3171                   while (block && TREE_CODE (block) == BLOCK)
3172                     block = BLOCK_SUPERCONTEXT (block);
3173
3174                   if (block && TREE_CODE (block) == FUNCTION_DECL)
3175                     fndecl = block;
3176                   abstract_origin = NULL;
3177                 }
3178               if (fndecl)
3179                 {
3180                   expanded_location s = expand_location (*locus);
3181                   pp_character (context->printer, ',');
3182                   pp_newline (context->printer);
3183                   if (s.file != NULL)
3184                     {
3185                       if (context->show_column && s.column != 0)
3186                         pp_printf (context->printer,
3187                                    _("    inlined from %qs at %r%s:%d:%d%R"),
3188                                    cxx_printable_name_translate (fndecl, 2),
3189                                    "locus", s.file, s.line, s.column);
3190                       else
3191                         pp_printf (context->printer,
3192                                    _("    inlined from %qs at %r%s:%d%R"),
3193                                    cxx_printable_name_translate (fndecl, 2),
3194                                    "locus", s.file, s.line);
3195
3196                     }
3197                   else
3198                     pp_printf (context->printer, _("    inlined from %qs"),
3199                                cxx_printable_name_translate (fndecl, 2));
3200                 }
3201             }
3202           pp_character (context->printer, ':');
3203         }
3204       pp_newline (context->printer);
3205
3206       diagnostic_set_last_function (context, diagnostic);
3207       pp_destroy_prefix (context->printer);
3208       context->printer->prefix = old_prefix;
3209     }
3210 }
3211
3212 /* Returns a description of FUNCTION using standard terminology.  The
3213    result is a format string of the form "In CATEGORY %qs".  */
3214 static const char *
3215 function_category (tree fn)
3216 {
3217   /* We can get called from the middle-end for diagnostics of function
3218      clones.  Make sure we have language specific information before
3219      dereferencing it.  */
3220   if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
3221       && DECL_FUNCTION_MEMBER_P (fn))
3222     {
3223       if (DECL_STATIC_FUNCTION_P (fn))
3224         return _("In static member function %qs");
3225       else if (DECL_COPY_CONSTRUCTOR_P (fn))
3226         return _("In copy constructor %qs");
3227       else if (DECL_CONSTRUCTOR_P (fn))
3228         return _("In constructor %qs");
3229       else if (DECL_DESTRUCTOR_P (fn))
3230         return _("In destructor %qs");
3231       else if (LAMBDA_FUNCTION_P (fn))
3232         return _("In lambda function");
3233       else
3234         return _("In member function %qs");
3235     }
3236   else
3237     return _("In function %qs");
3238 }
3239
3240 /* Report the full context of a current template instantiation,
3241    onto BUFFER.  */
3242 static void
3243 print_instantiation_full_context (diagnostic_context *context)
3244 {
3245   struct tinst_level *p = current_instantiation ();
3246   location_t location = input_location;
3247
3248   if (p)
3249     {
3250       pp_verbatim (context->printer,
3251                    TREE_CODE (p->decl) == TREE_LIST
3252                    ? _("%s: In substitution of %qS:\n")
3253                    : _("%s: In instantiation of %q#D:\n"),
3254                    LOCATION_FILE (location),
3255                    p->decl);
3256
3257       location = p->locus;
3258       p = p->next;
3259     }
3260
3261   print_instantiation_partial_context (context, p, location);
3262 }
3263
3264 /* Helper function of print_instantiation_partial_context() that
3265    prints a single line of instantiation context.  */
3266
3267 static void
3268 print_instantiation_partial_context_line (diagnostic_context *context,
3269                                           const struct tinst_level *t,
3270                                           location_t loc, bool recursive_p)
3271 {
3272   if (loc == UNKNOWN_LOCATION)
3273     return;
3274
3275   expanded_location xloc = expand_location (loc);
3276
3277   if (context->show_column)
3278     pp_verbatim (context->printer, _("%r%s:%d:%d:%R   "),
3279                  "locus", xloc.file, xloc.line, xloc.column);
3280   else
3281     pp_verbatim (context->printer, _("%r%s:%d:%R   "),
3282                  "locus", xloc.file, xloc.line);
3283
3284   if (t != NULL)
3285     {
3286       if (TREE_CODE (t->decl) == TREE_LIST)
3287         pp_verbatim (context->printer,
3288                      recursive_p
3289                      ? _("recursively required by substitution of %qS\n")
3290                      : _("required by substitution of %qS\n"),
3291                      t->decl);
3292       else
3293         pp_verbatim (context->printer,
3294                      recursive_p
3295                      ? _("recursively required from %q#D\n")
3296                      : _("required from %q#D\n"),
3297                      t->decl);
3298     }
3299   else
3300     {
3301       pp_verbatim (context->printer,
3302                    recursive_p
3303                    ? _("recursively required from here")
3304                    : _("required from here"));
3305     }
3306 }
3307
3308 /* Same as print_instantiation_full_context but less verbose.  */
3309
3310 static void
3311 print_instantiation_partial_context (diagnostic_context *context,
3312                                      struct tinst_level *t0, location_t loc)
3313 {
3314   struct tinst_level *t;
3315   int n_total = 0;
3316   int n;
3317   location_t prev_loc = loc;
3318
3319   for (t = t0; t != NULL; t = t->next)
3320     if (prev_loc != t->locus)
3321       {
3322         prev_loc = t->locus;
3323         n_total++;
3324       }
3325
3326   t = t0;
3327
3328   if (template_backtrace_limit
3329       && n_total > template_backtrace_limit)
3330     {
3331       int skip = n_total - template_backtrace_limit;
3332       int head = template_backtrace_limit / 2;
3333
3334       /* Avoid skipping just 1.  If so, skip 2.  */
3335       if (skip == 1)
3336        {
3337          skip = 2;
3338          head = (template_backtrace_limit - 1) / 2;
3339        }
3340
3341       for (n = 0; n < head; n++)
3342         {
3343           gcc_assert (t != NULL);
3344           if (loc != t->locus)
3345             print_instantiation_partial_context_line (context, t, loc,
3346                                                       /*recursive_p=*/false);
3347           loc = t->locus;
3348           t = t->next;
3349         }
3350       if (t != NULL && skip > 0)
3351         {
3352           expanded_location xloc;
3353           xloc = expand_location (loc);
3354           if (context->show_column)
3355             pp_verbatim (context->printer,
3356                          _("%r%s:%d:%d:%R   [ skipping %d instantiation "
3357                            "contexts, use -ftemplate-backtrace-limit=0 to "
3358                            "disable ]\n"),
3359                          "locus", xloc.file, xloc.line, xloc.column, skip);
3360           else
3361             pp_verbatim (context->printer,
3362                          _("%r%s:%d:%R   [ skipping %d instantiation "
3363                            "contexts, use -ftemplate-backtrace-limit=0 to "
3364                            "disable ]\n"),
3365                          "locus", xloc.file, xloc.line, skip);
3366
3367           do {
3368             loc = t->locus;
3369             t = t->next;
3370           } while (t != NULL && --skip > 0);
3371         }
3372     }
3373
3374   while (t != NULL)
3375     {
3376       while (t->next != NULL && t->locus == t->next->locus)
3377         {
3378           loc = t->locus;
3379           t = t->next;
3380         }
3381       print_instantiation_partial_context_line (context, t, loc,
3382                                                 t->locus == loc);
3383       loc = t->locus;
3384       t = t->next;
3385     }
3386   print_instantiation_partial_context_line (context, NULL, loc,
3387                                             /*recursive_p=*/false);
3388   pp_newline (context->printer);
3389 }
3390
3391 /* Called from cp_thing to print the template context for an error.  */
3392 static void
3393 maybe_print_instantiation_context (diagnostic_context *context)
3394 {
3395   if (!problematic_instantiation_changed () || current_instantiation () == 0)
3396     return;
3397
3398   record_last_problematic_instantiation ();
3399   print_instantiation_full_context (context);
3400 }
3401 \f
3402 /* Report what constexpr call(s) we're trying to expand, if any.  */
3403
3404 void
3405 maybe_print_constexpr_context (diagnostic_context *context)
3406 {
3407   vec<tree> call_stack = cx_error_context ();
3408   unsigned ix;
3409   tree t;
3410
3411   FOR_EACH_VEC_ELT (call_stack, ix, t)
3412     {
3413       expanded_location xloc = expand_location (EXPR_LOCATION (t));
3414       const char *s = expr_as_string (t, 0);
3415       if (context->show_column)
3416         pp_verbatim (context->printer,
3417                      _("%r%s:%d:%d:%R   in constexpr expansion of %qs"),
3418                      "locus", xloc.file, xloc.line, xloc.column, s);
3419       else
3420         pp_verbatim (context->printer,
3421                      _("%r%s:%d:%R   in constexpr expansion of %qs"),
3422                      "locus", xloc.file, xloc.line, s);
3423       pp_newline (context->printer);
3424     }
3425 }
3426 \f
3427 /* Called from output_format -- during diagnostic message processing --
3428    to handle C++ specific format specifier with the following meanings:
3429    %A   function argument-list.
3430    %C   tree code.
3431    %D   declaration.
3432    %E   expression.
3433    %F   function declaration.
3434    %L   language as used in extern "lang".
3435    %O   binary operator.
3436    %P   function parameter whose position is indicated by an integer.
3437    %Q   assignment operator.
3438    %S   substitution (template + args)
3439    %T   type.
3440    %V   cv-qualifier.
3441    %X   exception-specification.  */
3442 static bool
3443 cp_printer (pretty_printer *pp, text_info *text, const char *spec,
3444             int precision, bool wide, bool set_locus, bool verbose)
3445 {
3446   const char *result;
3447   tree t = NULL;
3448 #define next_tree    (t = va_arg (*text->args_ptr, tree))
3449 #define next_tcode   ((enum tree_code) va_arg (*text->args_ptr, int))
3450 #define next_lang    ((enum languages) va_arg (*text->args_ptr, int))
3451 #define next_int     va_arg (*text->args_ptr, int)
3452
3453   if (precision != 0 || wide)
3454     return false;
3455
3456   switch (*spec)
3457     {
3458     case 'A': result = args_to_string (next_tree, verbose);     break;
3459     case 'C': result = code_to_string (next_tcode);             break;
3460     case 'D':
3461       {
3462         tree temp = next_tree;
3463         if (VAR_P (temp)
3464             && DECL_HAS_DEBUG_EXPR_P (temp))
3465           {
3466             temp = DECL_DEBUG_EXPR (temp);
3467             if (!DECL_P (temp))
3468               {
3469                 result = expr_to_string (temp);
3470                 break;
3471               }
3472           }
3473         result = decl_to_string (temp, verbose);
3474       }
3475       break;
3476     case 'E': result = expr_to_string (next_tree);              break;
3477     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
3478     case 'L': result = language_to_string (next_lang);          break;
3479     case 'O': result = op_to_string (next_tcode);               break;
3480     case 'P': result = parm_to_string (next_int);               break;
3481     case 'Q': result = assop_to_string (next_tcode);            break;
3482     case 'S': result = subst_to_string (next_tree);             break;
3483     case 'T': result = type_to_string (next_tree, verbose);     break;
3484     case 'V': result = cv_to_string (next_tree, verbose);       break;
3485     case 'X': result = eh_spec_to_string (next_tree, verbose);  break;
3486
3487     case 'K':
3488       percent_K_format (text);
3489       return true;
3490
3491     default:
3492       return false;
3493     }
3494
3495   pp_string (pp, result);
3496   if (set_locus && t != NULL)
3497     text->set_location (0, location_of (t));
3498   return true;
3499 #undef next_tree
3500 #undef next_tcode
3501 #undef next_lang
3502 #undef next_int
3503 }
3504 \f
3505 /* Warn about the use of C++0x features when appropriate.  */
3506 void
3507 maybe_warn_cpp0x (cpp0x_warn_str str)
3508 {
3509   if ((cxx_dialect == cxx98) && !in_system_header_at (input_location))
3510     /* We really want to suppress this warning in system headers,
3511        because libstdc++ uses variadic templates even when we aren't
3512        in C++0x mode. */
3513     switch (str)
3514       {
3515       case CPP0X_INITIALIZER_LISTS:
3516         pedwarn (input_location, 0,
3517                  "extended initializer lists "
3518                  "only available with -std=c++11 or -std=gnu++11");
3519         break;
3520       case CPP0X_EXPLICIT_CONVERSION:
3521         pedwarn (input_location, 0,
3522                  "explicit conversion operators "
3523                  "only available with -std=c++11 or -std=gnu++11");
3524         break;
3525       case CPP0X_VARIADIC_TEMPLATES:
3526         pedwarn (input_location, 0,
3527                  "variadic templates "
3528                  "only available with -std=c++11 or -std=gnu++11");
3529         break;
3530       case CPP0X_LAMBDA_EXPR:
3531         pedwarn (input_location, 0,
3532                  "lambda expressions "
3533                   "only available with -std=c++11 or -std=gnu++11");
3534         break;
3535       case CPP0X_AUTO:
3536         pedwarn (input_location, 0,
3537                  "C++11 auto only available with -std=c++11 or -std=gnu++11");
3538         break;
3539       case CPP0X_SCOPED_ENUMS:
3540         pedwarn (input_location, 0,
3541                  "scoped enums only available with -std=c++11 or -std=gnu++11");
3542         break;
3543       case CPP0X_DEFAULTED_DELETED:
3544         pedwarn (input_location, 0,
3545                  "defaulted and deleted functions "
3546                  "only available with -std=c++11 or -std=gnu++11");
3547         break;
3548       case CPP0X_INLINE_NAMESPACES:
3549         pedwarn (input_location, OPT_Wpedantic,
3550                  "inline namespaces "
3551                  "only available with -std=c++11 or -std=gnu++11");
3552         break;
3553       case CPP0X_OVERRIDE_CONTROLS:
3554         pedwarn (input_location, 0,
3555                  "override controls (override/final) "
3556                  "only available with -std=c++11 or -std=gnu++11");
3557         break;
3558       case CPP0X_NSDMI:
3559         pedwarn (input_location, 0,
3560                  "non-static data member initializers "
3561                  "only available with -std=c++11 or -std=gnu++11");
3562         break;
3563       case CPP0X_USER_DEFINED_LITERALS:
3564         pedwarn (input_location, 0,
3565                  "user-defined literals "
3566                  "only available with -std=c++11 or -std=gnu++11");
3567         break;
3568       case CPP0X_DELEGATING_CTORS:
3569         pedwarn (input_location, 0,
3570                  "delegating constructors "
3571                  "only available with -std=c++11 or -std=gnu++11");
3572         break;
3573       case CPP0X_INHERITING_CTORS:
3574         pedwarn (input_location, 0,
3575                  "inheriting constructors "
3576                  "only available with -std=c++11 or -std=gnu++11");
3577         break;
3578       case CPP0X_ATTRIBUTES:
3579         pedwarn (input_location, 0,
3580                  "c++11 attributes "
3581                  "only available with -std=c++11 or -std=gnu++11");
3582         break;
3583       case CPP0X_REF_QUALIFIER:
3584         pedwarn (input_location, 0,
3585                  "ref-qualifiers "
3586                  "only available with -std=c++11 or -std=gnu++11");
3587         break;
3588       default:
3589         gcc_unreachable ();
3590       }
3591 }
3592
3593 /* Warn about the use of variadic templates when appropriate.  */
3594 void
3595 maybe_warn_variadic_templates (void)
3596 {
3597   maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
3598 }
3599
3600
3601 /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
3602    option OPT with text GMSGID.  Use this function to report
3603    diagnostics for constructs that are invalid C++98, but valid
3604    C++0x.  */
3605 bool
3606 pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
3607 {
3608   diagnostic_info diagnostic;
3609   va_list ap;
3610   bool ret;
3611
3612   va_start (ap, gmsgid);
3613   diagnostic_set_info (&diagnostic, gmsgid, &ap, location,
3614                        (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
3615   diagnostic.option_index = opt;
3616   ret = report_diagnostic (&diagnostic);
3617   va_end (ap);
3618   return ret;
3619 }
3620
3621 /* Issue a diagnostic that NAME cannot be found in SCOPE.  DECL is what
3622    we found when we tried to do the lookup.  LOCATION is the location of
3623    the NAME identifier.  */
3624
3625 void
3626 qualified_name_lookup_error (tree scope, tree name,
3627                              tree decl, location_t location)
3628 {
3629   if (scope == error_mark_node)
3630     ; /* We already complained.  */
3631   else if (TYPE_P (scope))
3632     {
3633       if (!COMPLETE_TYPE_P (scope))
3634         error_at (location, "incomplete type %qT used in nested name specifier",
3635                   scope);
3636       else if (TREE_CODE (decl) == TREE_LIST)
3637         {
3638           error_at (location, "reference to %<%T::%D%> is ambiguous",
3639                     scope, name);
3640           print_candidates (decl);
3641         }
3642       else
3643         error_at (location, "%qD is not a member of %qT", name, scope);
3644     }
3645   else if (scope != global_namespace)
3646     {
3647       error_at (location, "%qD is not a member of %qD", name, scope);
3648       suggest_alternatives_for (location, name);
3649     }
3650   else
3651     {
3652       error_at (location, "%<::%D%> has not been declared", name);
3653       suggest_alternatives_for (location, name);
3654     }
3655 }