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