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