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