gcc/cp/error.c

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