gcc/cp/error.c

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