gcc/cp/error.c

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