gcc/cp/error.c

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