gcc/cp/error.c

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