gcc/cp/error.c

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