gcc/cp/error.c

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