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