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