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