gcc/cp/error.c

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