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