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