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