LCOV - code coverage report
Current view: top level - gcc/cp - error.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2116 2412 87.7 %
Date: 2020-03-28 11:57:23 Functions: 88 94 93.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Call-backs for C++ error reporting.
       2                 :            :    This code is non-reentrant.
       3                 :            :    Copyright (C) 1993-2020 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                 :            : /* For use with name_hint.  */
      22                 :            : #define INCLUDE_UNIQUE_PTR
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "cp-tree.h"
      26                 :            : #include "stringpool.h"
      27                 :            : #include "tree-diagnostic.h"
      28                 :            : #include "langhooks-def.h"
      29                 :            : #include "intl.h"
      30                 :            : #include "cxx-pretty-print.h"
      31                 :            : #include "tree-pretty-print.h"
      32                 :            : #include "gimple-pretty-print.h"
      33                 :            : #include "c-family/c-objc.h"
      34                 :            : #include "ubsan.h"
      35                 :            : #include "internal-fn.h"
      36                 :            : #include "gcc-rich-location.h"
      37                 :            : #include "cp-name-hint.h"
      38                 :            : 
      39                 :            : #define pp_separate_with_comma(PP) pp_cxx_separate_with (PP, ',')
      40                 :            : #define pp_separate_with_semicolon(PP) pp_cxx_separate_with (PP, ';')
      41                 :            : 
      42                 :            : /* cxx_pp is a C++ front-end-specific pretty printer: this is where we
      43                 :            :    dump C++ ASTs as strings. It is mostly used only by the various
      44                 :            :    tree -> string functions that are occasionally called from the
      45                 :            :    debugger or by the front-end for things like
      46                 :            :    __PRETTY_FUNCTION__.  */
      47                 :            : static cxx_pretty_printer actual_pretty_printer;
      48                 :            : static cxx_pretty_printer * const cxx_pp = &actual_pretty_printer;
      49                 :            : 
      50                 :            : /* Translate if being used for diagnostics, but not for dump files or
      51                 :            :    __PRETTY_FUNCTION.  */
      52                 :            : #define M_(msgid) (pp_translate_identifiers (cxx_pp) ? _(msgid) : (msgid))
      53                 :            : 
      54                 :            : # define NEXT_CODE(T) (TREE_CODE (TREE_TYPE (T)))
      55                 :            : 
      56                 :            : static const char *args_to_string (tree, int);
      57                 :            : static const char *code_to_string (enum tree_code);
      58                 :            : static const char *cv_to_string (tree, int);
      59                 :            : static const char *decl_to_string (tree, int);
      60                 :            : static const char *fndecl_to_string (tree, int);
      61                 :            : static const char *op_to_string (bool, enum tree_code);
      62                 :            : static const char *parm_to_string (int);
      63                 :            : static const char *type_to_string (tree, int, bool, bool *, bool);
      64                 :            : 
      65                 :            : static void dump_alias_template_specialization (cxx_pretty_printer *, tree, int);
      66                 :            : static void dump_type (cxx_pretty_printer *, tree, int);
      67                 :            : static void dump_typename (cxx_pretty_printer *, tree, int);
      68                 :            : static void dump_simple_decl (cxx_pretty_printer *, tree, tree, int);
      69                 :            : static void dump_decl (cxx_pretty_printer *, tree, int);
      70                 :            : static void dump_template_decl (cxx_pretty_printer *, tree, int);
      71                 :            : static void dump_function_decl (cxx_pretty_printer *, tree, int);
      72                 :            : static void dump_expr (cxx_pretty_printer *, tree, int);
      73                 :            : static void dump_unary_op (cxx_pretty_printer *, const char *, tree, int);
      74                 :            : static void dump_binary_op (cxx_pretty_printer *, const char *, tree, int);
      75                 :            : static void dump_aggr_type (cxx_pretty_printer *, tree, int);
      76                 :            : static void dump_type_prefix (cxx_pretty_printer *, tree, int);
      77                 :            : static void dump_type_suffix (cxx_pretty_printer *, tree, int);
      78                 :            : static void dump_function_name (cxx_pretty_printer *, tree, int);
      79                 :            : static void dump_call_expr_args (cxx_pretty_printer *, tree, int, bool);
      80                 :            : static void dump_aggr_init_expr_args (cxx_pretty_printer *, tree, int, bool);
      81                 :            : static void dump_expr_list (cxx_pretty_printer *, tree, int);
      82                 :            : static void dump_global_iord (cxx_pretty_printer *, tree);
      83                 :            : static void dump_parameters (cxx_pretty_printer *, tree, int);
      84                 :            : static void dump_ref_qualifier (cxx_pretty_printer *, tree, int);
      85                 :            : static void dump_exception_spec (cxx_pretty_printer *, tree, int);
      86                 :            : static void dump_template_argument (cxx_pretty_printer *, tree, int);
      87                 :            : static void dump_template_argument_list (cxx_pretty_printer *, tree, int);
      88                 :            : static void dump_template_parameter (cxx_pretty_printer *, tree, int);
      89                 :            : static void dump_template_bindings (cxx_pretty_printer *, tree, tree,
      90                 :            :                                     vec<tree, va_gc> *);
      91                 :            : static void dump_scope (cxx_pretty_printer *, tree, int);
      92                 :            : static void dump_template_parms (cxx_pretty_printer *, tree, int, int);
      93                 :            : static int get_non_default_template_args_count (tree, int);
      94                 :            : static const char *function_category (tree);
      95                 :            : static void maybe_print_constexpr_context (diagnostic_context *);
      96                 :            : static void maybe_print_instantiation_context (diagnostic_context *);
      97                 :            : static void print_instantiation_full_context (diagnostic_context *);
      98                 :            : static void print_instantiation_partial_context (diagnostic_context *,
      99                 :            :                                                  struct tinst_level *,
     100                 :            :                                                  location_t);
     101                 :            : static void maybe_print_constraint_context (diagnostic_context *);
     102                 :            : static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
     103                 :            : static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
     104                 :            : 
     105                 :            : static bool cp_printer (pretty_printer *, text_info *, const char *,
     106                 :            :                         int, bool, bool, bool, bool *, const char **);
     107                 :            : 
     108                 :            : /* Struct for handling %H or %I, which require delaying printing the
     109                 :            :    type until a postprocessing stage.  */
     110                 :            : 
     111                 :            : class deferred_printed_type
     112                 :            : {
     113                 :            : public:
     114                 :      88203 :   deferred_printed_type ()
     115                 :      78630 :   : m_tree (NULL_TREE), m_buffer_ptr (NULL), m_verbose (false), m_quote (false)
     116                 :            :   {}
     117                 :            : 
     118                 :      19146 :   deferred_printed_type (tree type, const char **buffer_ptr, bool verbose,
     119                 :            :                          bool quote)
     120                 :      19146 :   : m_tree (type), m_buffer_ptr (buffer_ptr), m_verbose (verbose),
     121                 :      19146 :     m_quote (quote)
     122                 :            :   {
     123                 :      19146 :     gcc_assert (type);
     124                 :      19146 :     gcc_assert (buffer_ptr);
     125                 :      19146 :   }
     126                 :            : 
     127                 :            :   /* The tree is not GTY-marked: they are only non-NULL within a
     128                 :            :      call to pp_format.  */
     129                 :            :   tree m_tree;
     130                 :            :   const char **m_buffer_ptr;
     131                 :            :   bool m_verbose;
     132                 :            :   bool m_quote;
     133                 :            : };
     134                 :            : 
     135                 :            : /* Subclass of format_postprocessor for the C++ frontend.
     136                 :            :    This handles the %H and %I formatting codes, printing them
     137                 :            :    in a postprocessing phase (since they affect each other).  */
     138                 :            : 
     139                 :            : class cxx_format_postprocessor : public format_postprocessor
     140                 :            : {
     141                 :            :  public:
     142                 :      78630 :   cxx_format_postprocessor ()
     143                 :      78630 :   : m_type_a (), m_type_b ()
     144                 :            :   {}
     145                 :            : 
     146                 :        338 :   format_postprocessor *clone() const FINAL OVERRIDE
     147                 :            :   {
     148                 :        338 :     return new cxx_format_postprocessor ();
     149                 :            :   }
     150                 :            : 
     151                 :            :   void handle (pretty_printer *pp) FINAL OVERRIDE;
     152                 :            : 
     153                 :            :   deferred_printed_type m_type_a;
     154                 :            :   deferred_printed_type m_type_b;
     155                 :            : };
     156                 :            : 
     157                 :            : /* CONTEXT->printer is a basic pretty printer that was constructed
     158                 :            :    presumably by diagnostic_initialize(), called early in the
     159                 :            :    compiler's initialization process (in general_init) Before the FE
     160                 :            :    is initialized.  This (C++) FE-specific diagnostic initializer is
     161                 :            :    thus replacing the basic pretty printer with one that has C++-aware
     162                 :            :    capacities.  */
     163                 :            : 
     164                 :            : void
     165                 :      78292 : cxx_initialize_diagnostics (diagnostic_context *context)
     166                 :            : {
     167                 :      78292 :   pretty_printer *base = context->printer;
     168                 :      78292 :   cxx_pretty_printer *pp = XNEW (cxx_pretty_printer);
     169                 :      78292 :   context->printer = new (pp) cxx_pretty_printer ();
     170                 :            : 
     171                 :            :   /* It is safe to free this object because it was previously XNEW()'d.  */
     172                 :      78292 :   base->~pretty_printer ();
     173                 :      78292 :   XDELETE (base);
     174                 :            : 
     175                 :      78292 :   c_common_diagnostics_set_defaults (context);
     176                 :      78292 :   diagnostic_starter (context) = cp_diagnostic_starter;
     177                 :            :   /* diagnostic_finalizer is already c_diagnostic_finalizer.  */
     178                 :      78292 :   diagnostic_format_decoder (context) = cp_printer;
     179                 :      78292 :   pp->m_format_postprocessor = new cxx_format_postprocessor ();
     180                 :      78292 : }
     181                 :            : 
     182                 :            : /* Dump a scope, if deemed necessary.  */
     183                 :            : 
     184                 :            : static void
     185                 :   79660400 : dump_scope (cxx_pretty_printer *pp, tree scope, int flags)
     186                 :            : {
     187                 :   79660400 :   int f = flags & (TFF_SCOPE | TFF_CHASE_TYPEDEF);
     188                 :            : 
     189                 :   79660400 :   if (scope == NULL_TREE)
     190                 :            :     return;
     191                 :            : 
     192                 :            :   /* Enum values within an unscoped enum will be CONST_DECL with an
     193                 :            :      ENUMERAL_TYPE as their "scope".  Use CP_TYPE_CONTEXT of the
     194                 :            :      ENUMERAL_TYPE, so as to print any enclosing namespace.  */
     195                 :   79660400 :   if (UNSCOPED_ENUM_P (scope))
     196                 :        129 :     scope = CP_TYPE_CONTEXT (scope);
     197                 :            : 
     198                 :   79660400 :   if (TREE_CODE (scope) == NAMESPACE_DECL)
     199                 :            :     {
     200                 :   68777400 :       if (scope != global_namespace)
     201                 :            :         {
     202                 :   35615700 :           dump_decl (pp, scope, f);
     203                 :   35615700 :           pp_cxx_colon_colon (pp);
     204                 :            :         }
     205                 :            :     }
     206                 :   10883000 :   else if (AGGREGATE_TYPE_P (scope)
     207                 :   10883000 :            || SCOPED_ENUM_P (scope))
     208                 :            :     {
     209                 :   10600700 :       dump_type (pp, scope, f);
     210                 :   10600700 :       pp_cxx_colon_colon (pp);
     211                 :            :     }
     212                 :     282305 :   else if ((flags & TFF_SCOPE) && TREE_CODE (scope) == FUNCTION_DECL)
     213                 :            :     {
     214                 :     277671 :       dump_function_decl (pp, scope, f);
     215                 :     277671 :       pp_cxx_colon_colon (pp);
     216                 :            :     }
     217                 :            : }
     218                 :            : 
     219                 :            : /* Dump the template ARGument under control of FLAGS.  */
     220                 :            : 
     221                 :            : static void
     222                 :   54387300 : dump_template_argument (cxx_pretty_printer *pp, tree arg, int flags)
     223                 :            : {
     224                 :   54387300 :   if (ARGUMENT_PACK_P (arg))
     225                 :    8269660 :     dump_template_argument_list (pp, ARGUMENT_PACK_ARGS (arg),
     226                 :            :                                  /* No default args in argument packs.  */
     227                 :            :                                  flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
     228                 :   50249900 :   else if (TYPE_P (arg) || TREE_CODE (arg) == TEMPLATE_DECL)
     229                 :   44737400 :     dump_type (pp, arg, flags & ~TFF_CLASS_KEY_OR_ENUM);
     230                 :            :   else
     231                 :            :     {
     232                 :    5512500 :       if (TREE_CODE (arg) == TREE_LIST)
     233                 :          0 :         arg = TREE_VALUE (arg);
     234                 :            : 
     235                 :            :       /* Strip implicit conversions.  */
     236                 :    5512550 :       while (CONVERT_EXPR_P (arg))
     237                 :         54 :         arg = TREE_OPERAND (arg, 0);
     238                 :            : 
     239                 :    5512500 :       dump_expr (pp, arg, (flags | TFF_EXPR_IN_PARENS) & ~TFF_CLASS_KEY_OR_ENUM);
     240                 :            :     }
     241                 :   54387300 : }
     242                 :            : 
     243                 :            : /* Count the number of template arguments ARGS whose value does not
     244                 :            :    match the (optional) default template parameter in PARAMS  */
     245                 :            : 
     246                 :            : static int
     247                 :   34311400 : get_non_default_template_args_count (tree args, int flags)
     248                 :            : {
     249                 :   34311400 :   int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args));
     250                 :            : 
     251                 :   34311400 :   if (/* We use this flag when generating debug information.  We don't
     252                 :            :          want to expand templates at this point, for this may generate
     253                 :            :          new decls, which gets decl counts out of sync, which may in
     254                 :            :          turn cause codegen differences between compilations with and
     255                 :            :          without -g.  */
     256                 :   34311400 :       (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS) != 0
     257                 :    1201230 :       || !flag_pretty_templates)
     258                 :            :     return n;
     259                 :            : 
     260                 :    1201190 :   return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args));
     261                 :            : }
     262                 :            : 
     263                 :            : /* Dump a template-argument-list ARGS (always a TREE_VEC) under control
     264                 :            :    of FLAGS.  */
     265                 :            : 
     266                 :            : static void
     267                 :    4138920 : dump_template_argument_list (cxx_pretty_printer *pp, tree args, int flags)
     268                 :            : {
     269                 :    4138920 :   int n = get_non_default_template_args_count (args, flags);
     270                 :    4138920 :   int need_comma = 0;
     271                 :    4138920 :   int i;
     272                 :            : 
     273                 :   12050900 :   for (i = 0; i < n; ++i)
     274                 :            :     {
     275                 :    7912020 :       tree arg = TREE_VEC_ELT (args, i);
     276                 :            : 
     277                 :            :       /* Only print a comma if we know there is an argument coming. In
     278                 :            :          the case of an empty template argument pack, no actual
     279                 :            :          argument will be printed.  */
     280                 :    7912020 :       if (need_comma
     281                 :    7912020 :           && (!ARGUMENT_PACK_P (arg)
     282                 :         22 :               || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
     283                 :    3940250 :         pp_separate_with_comma (pp);
     284                 :            : 
     285                 :    7912020 :       dump_template_argument (pp, arg, flags);
     286                 :    7912020 :       need_comma = 1;
     287                 :            :     }
     288                 :    4138920 : }
     289                 :            : 
     290                 :            : /* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS.  */
     291                 :            : 
     292                 :            : static void
     293                 :     145527 : dump_template_parameter (cxx_pretty_printer *pp, tree parm, int flags)
     294                 :            : {
     295                 :     145527 :   tree p;
     296                 :     145527 :   tree a;
     297                 :            : 
     298                 :     145527 :   if (parm == error_mark_node)
     299                 :            :    return;
     300                 :            : 
     301                 :     145527 :   p = TREE_VALUE (parm);
     302                 :     145527 :   a = TREE_PURPOSE (parm);
     303                 :            : 
     304                 :     145527 :   if (TREE_CODE (p) == TYPE_DECL)
     305                 :            :     {
     306                 :      99507 :       if (flags & TFF_DECL_SPECIFIERS)
     307                 :            :         {
     308                 :       5642 :           pp_cxx_ws_string (pp, "class");
     309                 :       5642 :           if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p)))
     310                 :        482 :             pp_cxx_ws_string (pp, "...");
     311                 :       5642 :           if (DECL_NAME (p))
     312                 :       5038 :             pp_cxx_tree_identifier (pp, DECL_NAME (p));
     313                 :            :         }
     314                 :      93865 :       else if (DECL_NAME (p))
     315                 :      93111 :         pp_cxx_tree_identifier (pp, DECL_NAME (p));
     316                 :            :       else
     317                 :        754 :         pp_cxx_canonical_template_parameter (pp, TREE_TYPE (p));
     318                 :            :     }
     319                 :            :   else
     320                 :      46020 :     dump_decl (pp, p, flags | TFF_DECL_SPECIFIERS);
     321                 :            : 
     322                 :     145527 :   if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && a != NULL_TREE)
     323                 :            :     {
     324                 :          0 :       pp_cxx_whitespace (pp);
     325                 :          0 :       pp_equal (pp);
     326                 :          0 :       pp_cxx_whitespace (pp);
     327                 :          0 :       if (TREE_CODE (p) == TYPE_DECL || TREE_CODE (p) == TEMPLATE_DECL)
     328                 :          0 :         dump_type (pp, a, flags & ~TFF_CHASE_TYPEDEF);
     329                 :            :       else
     330                 :          0 :         dump_expr (pp, a, flags | TFF_EXPR_IN_PARENS);
     331                 :            :     }
     332                 :            : }
     333                 :            : 
     334                 :            : /* Dump, under control of FLAGS, a template-parameter-list binding.
     335                 :            :    PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
     336                 :            :    TREE_VEC.  */
     337                 :            : 
     338                 :            : static void
     339                 :      70389 : dump_template_bindings (cxx_pretty_printer *pp, tree parms, tree args,
     340                 :            :                         vec<tree, va_gc> *typenames)
     341                 :            : {
     342                 :      70389 :   bool need_semicolon = false;
     343                 :     147485 :   int i;
     344                 :     147485 :   tree t;
     345                 :            : 
     346                 :     147485 :   while (parms)
     347                 :            :     {
     348                 :      77096 :       tree p = TREE_VALUE (parms);
     349                 :      77096 :       int lvl = TMPL_PARMS_DEPTH (parms);
     350                 :      77096 :       int arg_idx = 0;
     351                 :      77096 :       int i;
     352                 :      77096 :       tree lvl_args = NULL_TREE;
     353                 :            : 
     354                 :            :       /* Don't crash if we had an invalid argument list.  */
     355                 :     217874 :       if (TMPL_ARGS_DEPTH (args) >= lvl)
     356                 :     154192 :         lvl_args = TMPL_ARGS_LEVEL (args, lvl);
     357                 :            : 
     358                 :     215598 :       for (i = 0; i < TREE_VEC_LENGTH (p); ++i)
     359                 :            :         {
     360                 :     138502 :           tree arg = NULL_TREE;
     361                 :            : 
     362                 :            :           /* Don't crash if we had an invalid argument list.  */
     363                 :     277004 :           if (lvl_args && NUM_TMPL_ARGS (lvl_args) > arg_idx)
     364                 :     138502 :             arg = TREE_VEC_ELT (lvl_args, arg_idx);
     365                 :            : 
     366                 :     138502 :           if (need_semicolon)
     367                 :      68113 :             pp_separate_with_semicolon (pp);
     368                 :     138502 :           dump_template_parameter (pp, TREE_VEC_ELT (p, i),
     369                 :            :                                    TFF_PLAIN_IDENTIFIER);
     370                 :     138502 :           pp_cxx_whitespace (pp);
     371                 :     138502 :           pp_equal (pp);
     372                 :     138502 :           pp_cxx_whitespace (pp);
     373                 :     138502 :           if (arg)
     374                 :            :             {
     375                 :     138482 :               if (ARGUMENT_PACK_P (arg))
     376                 :      11388 :                 pp_cxx_left_brace (pp);
     377                 :     138482 :               dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
     378                 :     138482 :               if (ARGUMENT_PACK_P (arg))
     379                 :      11388 :                 pp_cxx_right_brace (pp);
     380                 :            :             }
     381                 :            :           else
     382                 :         20 :             pp_string (pp, M_("<missing>"));
     383                 :            : 
     384                 :     138502 :           ++arg_idx;
     385                 :     138502 :           need_semicolon = true;
     386                 :            :         }
     387                 :            : 
     388                 :      77096 :       parms = TREE_CHAIN (parms);
     389                 :            :     }
     390                 :            : 
     391                 :            :   /* Don't bother with typenames for a partial instantiation.  */
     392                 :      73965 :   if (vec_safe_is_empty (typenames) || uses_template_parms (args))
     393                 :      66986 :     return;
     394                 :            : 
     395                 :            :   /* Don't try to print typenames when we're processing a clone.  */
     396                 :       3403 :   if (current_function_decl
     397                 :       3403 :       && !DECL_LANG_SPECIFIC (current_function_decl))
     398                 :            :     return;
     399                 :            : 
     400                 :            :   /* Don't try to do this once cgraph starts throwing away front-end
     401                 :            :      information.  */
     402                 :       3403 :   if (at_eof >= 2)
     403                 :            :     return;
     404                 :            : 
     405                 :       6901 :   FOR_EACH_VEC_SAFE_ELT (typenames, i, t)
     406                 :            :     {
     407                 :       3759 :       if (need_semicolon)
     408                 :       3759 :         pp_separate_with_semicolon (pp);
     409                 :       3759 :       dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
     410                 :       3759 :       pp_cxx_whitespace (pp);
     411                 :       3759 :       pp_equal (pp);
     412                 :       3759 :       pp_cxx_whitespace (pp);
     413                 :       3759 :       push_deferring_access_checks (dk_no_check);
     414                 :       3759 :       t = tsubst (t, args, tf_none, NULL_TREE);
     415                 :       3759 :       pop_deferring_access_checks ();
     416                 :            :       /* Strip typedefs.  We can't just use TFF_CHASE_TYPEDEF because
     417                 :            :          pp_simple_type_specifier doesn't know about it.  */
     418                 :       3759 :       t = strip_typedefs (t, NULL, STF_USER_VISIBLE);
     419                 :       3759 :       dump_type (pp, t, TFF_PLAIN_IDENTIFIER);
     420                 :            :     }
     421                 :            : }
     422                 :            : 
     423                 :            : /* Dump a human-readable equivalent of the alias template
     424                 :            :    specialization of T.  */
     425                 :            : 
     426                 :            : static void
     427                 :       3264 : dump_alias_template_specialization (cxx_pretty_printer *pp, tree t, int flags)
     428                 :            : {
     429                 :       3264 :   gcc_assert (alias_template_specialization_p (t, nt_opaque));
     430                 :            : 
     431                 :       3264 :   tree decl = TYPE_NAME (t);
     432                 :       3264 :   if (!(flags & TFF_UNQUALIFIED_NAME))
     433                 :       3264 :     dump_scope (pp, CP_DECL_CONTEXT (decl), flags);
     434                 :       3264 :   pp_cxx_tree_identifier (pp, DECL_NAME (decl));
     435                 :       3264 :   dump_template_parms (pp, DECL_TEMPLATE_INFO (decl),
     436                 :            :                        /*primary=*/false,
     437                 :            :                        flags & ~TFF_TEMPLATE_HEADER);
     438                 :       3264 : }
     439                 :            : 
     440                 :            : /* Dump a human-readable equivalent of TYPE.  FLAGS controls the
     441                 :            :    format.  */
     442                 :            : 
     443                 :            : static void
     444                 :   78885600 : dump_type (cxx_pretty_printer *pp, tree t, int flags)
     445                 :            : {
     446                 :   78885600 :   if (t == NULL_TREE)
     447                 :            :     return;
     448                 :            : 
     449                 :            :   /* Don't print e.g. "struct mytypedef".  */
     450                 :   78885600 :   if (TYPE_P (t) && typedef_variant_p (t))
     451                 :            :     {
     452                 :      48977 :       tree decl = TYPE_NAME (t);
     453                 :      48977 :       if ((flags & TFF_CHASE_TYPEDEF)
     454                 :      97954 :                || DECL_SELF_REFERENCE_P (decl)
     455                 :      97522 :                || (!flag_pretty_templates
     456                 :          8 :                    && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)))
     457                 :            :         {
     458                 :        880 :           unsigned int stf_flags = (!(pp->flags & pp_c_flag_gnu_v3)
     459                 :        440 :                                     ? STF_USER_VISIBLE : 0);
     460                 :        440 :           t = strip_typedefs (t, NULL, stf_flags);
     461                 :            :         }
     462                 :      48537 :       else if (alias_template_specialization_p (t, nt_opaque))
     463                 :            :         {
     464                 :       3264 :           dump_alias_template_specialization (pp, t, flags);
     465                 :       3264 :           return;
     466                 :            :         }
     467                 :      45273 :       else if (same_type_p (t, TREE_TYPE (decl)))
     468                 :            :         t = decl;
     469                 :            :       else
     470                 :            :         {
     471                 :       1210 :           pp_cxx_cv_qualifier_seq (pp, t);
     472                 :       1210 :           pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
     473                 :       1210 :           return;
     474                 :            :         }
     475                 :            :     }
     476                 :            : 
     477                 :   78881100 :   if (TYPE_PTRMEMFUNC_P (t))
     478                 :     352074 :     goto offset_type;
     479                 :            : 
     480                 :   78529100 :   switch (TREE_CODE (t))
     481                 :            :     {
     482                 :        485 :     case LANG_TYPE:
     483                 :        485 :       if (t == init_list_type_node)
     484                 :        260 :         pp_string (pp, M_("<brace-enclosed initializer list>"));
     485                 :        225 :       else if (t == unknown_type_node)
     486                 :        225 :         pp_string (pp, M_("<unresolved overloaded function type>"));
     487                 :            :       else
     488                 :            :         {
     489                 :          0 :           pp_cxx_cv_qualifier_seq (pp, t);
     490                 :          0 :           pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
     491                 :            :         }
     492                 :            :       break;
     493                 :            : 
     494                 :          0 :     case TREE_LIST:
     495                 :            :       /* A list of function parms.  */
     496                 :          0 :       dump_parameters (pp, t, flags);
     497                 :          0 :       break;
     498                 :            : 
     499                 :        273 :     case IDENTIFIER_NODE:
     500                 :        273 :       pp_cxx_tree_identifier (pp, t);
     501                 :        273 :       break;
     502                 :            : 
     503                 :         30 :     case TREE_BINFO:
     504                 :         30 :       dump_type (pp, BINFO_TYPE (t), flags);
     505                 :         30 :       break;
     506                 :            : 
     507                 :   53272000 :     case RECORD_TYPE:
     508                 :   53272000 :     case UNION_TYPE:
     509                 :   53272000 :     case ENUMERAL_TYPE:
     510                 :   53272000 :       dump_aggr_type (pp, t, flags);
     511                 :   53272000 :       break;
     512                 :            : 
     513                 :      44707 :     case TYPE_DECL:
     514                 :      44707 :       if (flags & TFF_CHASE_TYPEDEF)
     515                 :            :         {
     516                 :          0 :           dump_type (pp, DECL_ORIGINAL_TYPE (t)
     517                 :          0 :                      ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t), flags);
     518                 :          0 :           break;
     519                 :            :         }
     520                 :            :       /* Fall through.  */
     521                 :            : 
     522                 :     286275 :     case TEMPLATE_DECL:
     523                 :     286275 :     case NAMESPACE_DECL:
     524                 :     286275 :       dump_decl (pp, t, flags & ~TFF_DECL_SPECIFIERS);
     525                 :     286275 :       break;
     526                 :            : 
     527                 :   13913700 :     case INTEGER_TYPE:
     528                 :   13913700 :     case REAL_TYPE:
     529                 :   13913700 :     case VOID_TYPE:
     530                 :   13913700 :     case BOOLEAN_TYPE:
     531                 :   13913700 :     case COMPLEX_TYPE:
     532                 :   13913700 :     case VECTOR_TYPE:
     533                 :   13913700 :     case FIXED_POINT_TYPE:
     534                 :   13913700 :       pp_type_specifier_seq (pp, t);
     535                 :   13913700 :       break;
     536                 :            : 
     537                 :      43308 :     case TEMPLATE_TEMPLATE_PARM:
     538                 :            :       /* For parameters inside template signature.  */
     539                 :      43308 :       if (TYPE_IDENTIFIER (t))
     540                 :      43226 :         pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
     541                 :            :       else
     542                 :         82 :         pp_cxx_canonical_template_parameter (pp, t);
     543                 :            :       break;
     544                 :            : 
     545                 :        404 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
     546                 :        404 :       {
     547                 :        808 :         tree args = TYPE_TI_ARGS (t);
     548                 :        404 :         pp_cxx_cv_qualifier_seq (pp, t);
     549                 :        404 :         pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
     550                 :        404 :         pp_cxx_begin_template_argument_list (pp);
     551                 :        404 :         dump_template_argument_list (pp, args, flags);
     552                 :        404 :         pp_cxx_end_template_argument_list (pp);
     553                 :            :       }
     554                 :        404 :       break;
     555                 :            : 
     556                 :     376907 :     case TEMPLATE_TYPE_PARM:
     557                 :     376907 :       pp_cxx_cv_qualifier_seq (pp, t);
     558                 :     376907 :       if (template_placeholder_p (t))
     559                 :            :         {
     560                 :         23 :           t = TREE_TYPE (CLASS_PLACEHOLDER_TEMPLATE (t));
     561                 :         23 :           pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
     562                 :         23 :           pp_string (pp, "<...auto...>");
     563                 :            :         }
     564                 :     376884 :       else if (TYPE_IDENTIFIER (t))
     565                 :     376064 :         pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t));
     566                 :            :       else
     567                 :        820 :         pp_cxx_canonical_template_parameter
     568                 :        820 :           (pp, TEMPLATE_TYPE_PARM_INDEX (t));
     569                 :            :       /* If this is a constrained placeholder, add the requirements.  */
     570                 :     376907 :       if (tree c = PLACEHOLDER_TYPE_CONSTRAINTS (t))
     571                 :         17 :         pp_cxx_constrained_type_spec (pp, c);
     572                 :            :       break;
     573                 :            : 
     574                 :            :       /* This is not always necessary for pointers and such, but doing this
     575                 :            :          reduces code size.  */
     576                 :   10953200 :     case ARRAY_TYPE:
     577                 :   10953200 :     case POINTER_TYPE:
     578                 :   10953200 :     case REFERENCE_TYPE:
     579                 :   10953200 :     case OFFSET_TYPE:
     580                 :   10953200 :     offset_type:
     581                 :   10953200 :     case FUNCTION_TYPE:
     582                 :   10953200 :     case METHOD_TYPE:
     583                 :   10953200 :     {
     584                 :   10953200 :       dump_type_prefix (pp, t, flags);
     585                 :   10953200 :       dump_type_suffix (pp, t, flags);
     586                 :   10953200 :       break;
     587                 :            :     }
     588                 :       1872 :     case TYPENAME_TYPE:
     589                 :       1872 :       if (! (flags & TFF_CHASE_TYPEDEF)
     590                 :       3744 :           && DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
     591                 :            :         {
     592                 :          0 :           dump_decl (pp, TYPE_NAME (t), TFF_PLAIN_IDENTIFIER);
     593                 :          0 :           break;
     594                 :            :         }
     595                 :       1872 :       pp_cxx_cv_qualifier_seq (pp, t);
     596                 :       3705 :       pp_cxx_ws_string (pp,
     597                 :            :                          TYPENAME_IS_ENUM_P (t) ? "enum"
     598                 :            :                          : TYPENAME_IS_CLASS_P (t) ? "class"
     599                 :            :                          : "typename");
     600                 :       1872 :       dump_typename (pp, t, flags);
     601                 :       1872 :       break;
     602                 :            : 
     603                 :          8 :     case UNBOUND_CLASS_TEMPLATE:
     604                 :          8 :       if (! (flags & TFF_UNQUALIFIED_NAME))
     605                 :            :         {
     606                 :          8 :           dump_type (pp, TYPE_CONTEXT (t), flags);
     607                 :          8 :           pp_cxx_colon_colon (pp);
     608                 :            :         }
     609                 :          8 :       pp_cxx_ws_string (pp, "template");
     610                 :          8 :       dump_type (pp, TYPE_IDENTIFIER (t), flags);
     611                 :          8 :       break;
     612                 :            : 
     613                 :          8 :     case TYPEOF_TYPE:
     614                 :          8 :       pp_cxx_ws_string (pp, "__typeof__");
     615                 :          8 :       pp_cxx_whitespace (pp);
     616                 :          8 :       pp_cxx_left_paren (pp);
     617                 :          8 :       dump_expr (pp, TYPEOF_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
     618                 :          8 :       pp_cxx_right_paren (pp);
     619                 :          8 :       break;
     620                 :            : 
     621                 :         24 :     case UNDERLYING_TYPE:
     622                 :         24 :       pp_cxx_ws_string (pp, "__underlying_type");
     623                 :         24 :       pp_cxx_whitespace (pp);
     624                 :         24 :       pp_cxx_left_paren (pp);
     625                 :         24 :       dump_expr (pp, UNDERLYING_TYPE_TYPE (t), flags & ~TFF_EXPR_IN_PARENS);
     626                 :         24 :       pp_cxx_right_paren (pp);
     627                 :         24 :       break;
     628                 :            : 
     629                 :      16144 :     case TYPE_PACK_EXPANSION:
     630                 :      32288 :       dump_type (pp, PACK_EXPANSION_PATTERN (t), flags);
     631                 :      16144 :       pp_cxx_ws_string (pp, "...");
     632                 :      16144 :       break;
     633                 :            : 
     634                 :         74 :     case TYPE_ARGUMENT_PACK:
     635                 :         74 :       dump_template_argument (pp, t, flags);
     636                 :         74 :       break;
     637                 :            : 
     638                 :        468 :     case DECLTYPE_TYPE:
     639                 :        468 :       pp_cxx_ws_string (pp, "decltype");
     640                 :        468 :       pp_cxx_whitespace (pp);
     641                 :        468 :       pp_cxx_left_paren (pp);
     642                 :        468 :       dump_expr (pp, DECLTYPE_TYPE_EXPR (t), flags & ~TFF_EXPR_IN_PARENS);
     643                 :        468 :       pp_cxx_right_paren (pp);
     644                 :        468 :       break;
     645                 :            : 
     646                 :      15934 :     case NULLPTR_TYPE:
     647                 :      15934 :       pp_string (pp, "std::nullptr_t");
     648                 :      15934 :       break;
     649                 :            : 
     650                 :          0 :     default:
     651                 :          0 :       pp_unsupported_tree (pp, t);
     652                 :            :       /* Fall through.  */
     653                 :            : 
     654                 :         28 :     case ERROR_MARK:
     655                 :         28 :       pp_string (pp, M_("<type error>"));
     656                 :         28 :       break;
     657                 :            :     }
     658                 :            : }
     659                 :            : 
     660                 :            : /* Dump a TYPENAME_TYPE. We need to notice when the context is itself
     661                 :            :    a TYPENAME_TYPE.  */
     662                 :            : 
     663                 :            : static void
     664                 :       2046 : dump_typename (cxx_pretty_printer *pp, tree t, int flags)
     665                 :            : {
     666                 :       2046 :   tree ctx = TYPE_CONTEXT (t);
     667                 :            : 
     668                 :       2046 :   if (TREE_CODE (ctx) == TYPENAME_TYPE)
     669                 :        174 :     dump_typename (pp, ctx, flags);
     670                 :            :   else
     671                 :       1872 :     dump_type (pp, ctx, flags & ~TFF_CLASS_KEY_OR_ENUM);
     672                 :       2046 :   pp_cxx_colon_colon (pp);
     673                 :       2046 :   dump_decl (pp, TYPENAME_TYPE_FULLNAME (t), flags);
     674                 :       2046 : }
     675                 :            : 
     676                 :            : /* Return the name of the supplied aggregate, or enumeral type.  */
     677                 :            : 
     678                 :            : const char *
     679                 :   53628700 : class_key_or_enum_as_string (tree t)
     680                 :            : {
     681                 :   53628700 :   if (TREE_CODE (t) == ENUMERAL_TYPE) 
     682                 :            :     {
     683                 :     303666 :       if (SCOPED_ENUM_P (t))
     684                 :            :         return "enum class";
     685                 :            :       else
     686                 :     263934 :         return "enum";
     687                 :            :     }
     688                 :   53325100 :   else if (TREE_CODE (t) == UNION_TYPE)
     689                 :            :     return "union";
     690                 :   52313300 :   else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
     691                 :   10296700 :     return "class";
     692                 :            :   else
     693                 :            :     return "struct";
     694                 :            : }
     695                 :            : 
     696                 :            : /* Print out a class declaration T under the control of FLAGS,
     697                 :            :    in the form `class foo'.  */
     698                 :            : 
     699                 :            : static void
     700                 :   53628700 : dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags)
     701                 :            : {
     702                 :   53628700 :   tree name;
     703                 :   53628700 :   const char *variety = class_key_or_enum_as_string (t);
     704                 :   53628700 :   int typdef = 0;
     705                 :   53628700 :   int tmplate = 0;
     706                 :            : 
     707                 :   53628700 :   pp_cxx_cv_qualifier_seq (pp, t);
     708                 :            : 
     709                 :   53628700 :   if (flags & TFF_CLASS_KEY_OR_ENUM)
     710                 :      10208 :     pp_cxx_ws_string (pp, variety);
     711                 :            : 
     712                 :   53628700 :   name = TYPE_NAME (t);
     713                 :            : 
     714                 :   53628700 :   if (name)
     715                 :            :     {
     716                 :   53628700 :       typdef = (!DECL_ARTIFICIAL (name)
     717                 :            :                 /* An alias specialization is not considered to be a
     718                 :            :                    typedef.  */
     719                 :   53628700 :                 && !alias_template_specialization_p (t, nt_opaque));
     720                 :            : 
     721                 :     102581 :       if ((typdef
     722                 :     102581 :            && ((flags & TFF_CHASE_TYPEDEF)
     723                 :     102581 :                || (!flag_pretty_templates && DECL_LANG_SPECIFIC (name)
     724                 :          0 :                    && DECL_TEMPLATE_INFO (name))))
     725                 :  107257000 :           || DECL_SELF_REFERENCE_P (name))
     726                 :            :         {
     727                 :          0 :           t = TYPE_MAIN_VARIANT (t);
     728                 :          0 :           name = TYPE_NAME (t);
     729                 :          0 :           typdef = 0;
     730                 :            :         }
     731                 :            : 
     732                 :   53526100 :       tmplate = !typdef && TREE_CODE (t) != ENUMERAL_TYPE
     733                 :  106445000 :                 && TYPE_LANG_SPECIFIC (t) && CLASSTYPE_TEMPLATE_INFO (t)
     734                 :   84033700 :                 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t)) != TEMPLATE_DECL
     735                 :   30420600 :                     || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)));
     736                 :            :       
     737                 :   53628700 :       if (! (flags & TFF_UNQUALIFIED_NAME))
     738                 :   43649500 :         dump_scope (pp, CP_DECL_CONTEXT (name), flags | TFF_SCOPE);
     739                 :   53628700 :       flags &= ~TFF_UNQUALIFIED_NAME;
     740                 :   53628700 :       if (tmplate)
     741                 :            :         {
     742                 :            :           /* Because the template names are mangled, we have to locate
     743                 :            :              the most general template, and use that name.  */
     744                 :   90434400 :           tree tpl = TYPE_TI_TEMPLATE (t);
     745                 :            : 
     746                 :   30315100 :           while (DECL_TEMPLATE_INFO (tpl))
     747                 :     170288 :             tpl = DECL_TI_TEMPLATE (tpl);
     748                 :            :           name = tpl;
     749                 :            :         }
     750                 :   53628700 :       name = DECL_NAME (name);
     751                 :            :     }
     752                 :            : 
     753                 :  105942000 :   if (LAMBDA_TYPE_P (t))
     754                 :            :     {
     755                 :            :       /* A lambda's "type" is essentially its signature.  */
     756                 :     336529 :       pp_string (pp, M_("<lambda"));
     757                 :     336529 :       if (lambda_function (t))
     758                 :     336529 :         dump_parameters (pp,
     759                 :     673058 :                          FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
     760                 :            :                          flags);
     761                 :     336529 :       pp_greater (pp);
     762                 :            :     }
     763                 :  106584000 :   else if (!name || IDENTIFIER_ANON_P (name))
     764                 :            :     {
     765                 :       2366 :       if (flags & TFF_CLASS_KEY_OR_ENUM)
     766                 :        166 :         pp_string (pp, M_("<unnamed>"));
     767                 :            :       else
     768                 :       2200 :         pp_printf (pp, M_("<unnamed %s>"), variety);
     769                 :            :     }
     770                 :            :   else
     771                 :   53289800 :     pp_cxx_tree_identifier (pp, name);
     772                 :            : 
     773                 :   53628700 :   if (tmplate)
     774                 :   60289600 :     dump_template_parms (pp, TYPE_TEMPLATE_INFO (t),
     775                 :   30144800 :                          !CLASSTYPE_USE_TEMPLATE (t),
     776                 :            :                          flags & ~TFF_TEMPLATE_HEADER);
     777                 :   53628700 : }
     778                 :            : 
     779                 :            : /* Dump into the obstack the initial part of the output for a given type.
     780                 :            :    This is necessary when dealing with things like functions returning
     781                 :            :    functions.  Examples:
     782                 :            : 
     783                 :            :    return type of `int (* fee ())()': pointer -> function -> int.  Both
     784                 :            :    pointer (and reference and offset) and function (and member) types must
     785                 :            :    deal with prefix and suffix.
     786                 :            : 
     787                 :            :    Arrays must also do this for DECL nodes, like int a[], and for things like
     788                 :            :    int *[]&.  */
     789                 :            : 
     790                 :            : static void
     791                 :   23012400 : dump_type_prefix (cxx_pretty_printer *pp, tree t, int flags)
     792                 :            : {
     793                 :   24287700 :   if (TYPE_PTRMEMFUNC_P (t))
     794                 :            :     {
     795                 :     356522 :       t = TYPE_PTRMEMFUNC_FN_TYPE (t);
     796                 :     356522 :       goto offset_type;
     797                 :            :     }
     798                 :            : 
     799                 :   23931200 :   switch (TREE_CODE (t))
     800                 :            :     {
     801                 :   11209700 :     case POINTER_TYPE:
     802                 :   11209700 :     case REFERENCE_TYPE:
     803                 :   11209700 :       {
     804                 :   11209700 :         tree sub = TREE_TYPE (t);
     805                 :            : 
     806                 :   11209700 :         dump_type_prefix (pp, sub, flags);
     807                 :   11209700 :         if (TREE_CODE (sub) == ARRAY_TYPE
     808                 :   11159600 :             || TREE_CODE (sub) == FUNCTION_TYPE)
     809                 :            :           {
     810                 :     748628 :             pp_cxx_whitespace (pp);
     811                 :     748628 :             pp_cxx_left_paren (pp);
     812                 :     748628 :             pp_c_attributes_display (pp, TYPE_ATTRIBUTES (sub));
     813                 :            :           }
     814                 :   11209700 :         if (TYPE_PTR_P (t))
     815                 :    6545470 :           pp_star (pp);
     816                 :    4664220 :         else if (TYPE_REF_P (t))
     817                 :            :           {
     818                 :    4664220 :             if (TYPE_REF_IS_RVALUE (t))
     819                 :    1356380 :               pp_ampersand_ampersand (pp);
     820                 :            :             else
     821                 :    3307840 :               pp_ampersand (pp);
     822                 :            :           }
     823                 :   11209700 :         pp->padding = pp_before;
     824                 :   11209700 :         pp_cxx_cv_qualifier_seq (pp, t);
     825                 :            :       }
     826                 :   11209700 :       break;
     827                 :            : 
     828                 :     421605 :     case OFFSET_TYPE:
     829                 :     421605 :     offset_type:
     830                 :     421605 :       dump_type_prefix (pp, TREE_TYPE (t), flags);
     831                 :     421605 :       if (TREE_CODE (t) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
     832                 :            :         {
     833                 :      65083 :           pp_maybe_space (pp);
     834                 :      65083 :           if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
     835                 :          4 :              pp_cxx_left_paren (pp);
     836                 :      65083 :           dump_type (pp, TYPE_OFFSET_BASETYPE (t), flags);
     837                 :      65083 :           pp_cxx_colon_colon (pp);
     838                 :            :         }
     839                 :     421605 :       pp_cxx_star (pp);
     840                 :     421605 :       pp_cxx_cv_qualifier_seq (pp, t);
     841                 :     421605 :       pp->padding = pp_before;
     842                 :     421605 :       break;
     843                 :            : 
     844                 :            :       /* This can be reached without a pointer when dealing with
     845                 :            :          templates, e.g. std::is_function.  */
     846                 :    1098630 :     case FUNCTION_TYPE:
     847                 :    1098630 :       dump_type_prefix (pp, TREE_TYPE (t), flags);
     848                 :    1098630 :       break;
     849                 :            : 
     850                 :     356728 :     case METHOD_TYPE:
     851                 :     356728 :       dump_type_prefix (pp, TREE_TYPE (t), flags);
     852                 :     356728 :       pp_maybe_space (pp);
     853                 :     356728 :       pp_cxx_left_paren (pp);
     854                 :     713456 :       dump_aggr_type (pp, TYPE_METHOD_BASETYPE (t), flags);
     855                 :     356728 :       pp_cxx_colon_colon (pp);
     856                 :     356728 :       break;
     857                 :            : 
     858                 :     176730 :     case ARRAY_TYPE:
     859                 :     176730 :       dump_type_prefix (pp, TREE_TYPE (t), flags);
     860                 :     176730 :       break;
     861                 :            : 
     862                 :   11024300 :     case ENUMERAL_TYPE:
     863                 :   11024300 :     case IDENTIFIER_NODE:
     864                 :   11024300 :     case INTEGER_TYPE:
     865                 :   11024300 :     case BOOLEAN_TYPE:
     866                 :   11024300 :     case REAL_TYPE:
     867                 :   11024300 :     case RECORD_TYPE:
     868                 :   11024300 :     case TEMPLATE_TYPE_PARM:
     869                 :   11024300 :     case TEMPLATE_TEMPLATE_PARM:
     870                 :   11024300 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
     871                 :   11024300 :     case TREE_LIST:
     872                 :   11024300 :     case TYPE_DECL:
     873                 :   11024300 :     case TREE_VEC:
     874                 :   11024300 :     case UNION_TYPE:
     875                 :   11024300 :     case LANG_TYPE:
     876                 :   11024300 :     case VOID_TYPE:
     877                 :   11024300 :     case TYPENAME_TYPE:
     878                 :   11024300 :     case COMPLEX_TYPE:
     879                 :   11024300 :     case VECTOR_TYPE:
     880                 :   11024300 :     case TYPEOF_TYPE:
     881                 :   11024300 :     case UNDERLYING_TYPE:
     882                 :   11024300 :     case DECLTYPE_TYPE:
     883                 :   11024300 :     case TYPE_PACK_EXPANSION:
     884                 :   11024300 :     case FIXED_POINT_TYPE:
     885                 :   11024300 :     case NULLPTR_TYPE:
     886                 :   11024300 :       dump_type (pp, t, flags);
     887                 :   11024300 :       pp->padding = pp_before;
     888                 :   11024300 :       break;
     889                 :            : 
     890                 :          0 :     default:
     891                 :          0 :       pp_unsupported_tree (pp, t);
     892                 :            :       /* fall through.  */
     893                 :         31 :     case ERROR_MARK:
     894                 :         31 :       pp_string (pp, M_("<typeprefixerror>"));
     895                 :         31 :       break;
     896                 :            :     }
     897                 :   23012400 : }
     898                 :            : 
     899                 :            : /* Dump the suffix of type T, under control of FLAGS.  This is the part
     900                 :            :    which appears after the identifier (or function parms).  */
     901                 :            : 
     902                 :            : static void
     903                 :   11024400 : dump_type_suffix (cxx_pretty_printer *pp, tree t, int flags)
     904                 :            : {
     905                 :   24287800 :   if (TYPE_PTRMEMFUNC_P (t))
     906                 :     356522 :     t = TYPE_PTRMEMFUNC_FN_TYPE (t);
     907                 :            : 
     908                 :   24287800 :   switch (TREE_CODE (t))
     909                 :            :     {
     910                 :   11631300 :     case POINTER_TYPE:
     911                 :   11631300 :     case REFERENCE_TYPE:
     912                 :   11631300 :     case OFFSET_TYPE:
     913                 :   11631300 :       if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
     914                 :   11631300 :           || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
     915                 :     748632 :         pp_cxx_right_paren (pp);
     916                 :   11631300 :       if (TREE_CODE (t) == POINTER_TYPE)
     917                 :    6901990 :         flags |= TFF_POINTER;
     918                 :   11631300 :       dump_type_suffix (pp, TREE_TYPE (t), flags);
     919                 :   11631300 :       break;
     920                 :            : 
     921                 :    1455360 :     case FUNCTION_TYPE:
     922                 :    1455360 :     case METHOD_TYPE:
     923                 :    1455360 :       {
     924                 :    1455360 :         tree arg;
     925                 :    1455360 :         if (TREE_CODE (t) == METHOD_TYPE)
     926                 :            :           /* Can only be reached through a pointer.  */
     927                 :     356728 :           pp_cxx_right_paren (pp);
     928                 :    1455360 :         arg = TYPE_ARG_TYPES (t);
     929                 :    1455360 :         if (TREE_CODE (t) == METHOD_TYPE)
     930                 :     356728 :           arg = TREE_CHAIN (arg);
     931                 :            : 
     932                 :            :         /* Function pointers don't have default args.  Not in standard C++,
     933                 :            :            anyway; they may in g++, but we'll just pretend otherwise.  */
     934                 :    1455360 :         dump_parameters (pp, arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS);
     935                 :            : 
     936                 :    1455360 :         pp->padding = pp_before;
     937                 :    2046290 :         pp_cxx_cv_qualifiers (pp, type_memfn_quals (t),
     938                 :            :                               TREE_CODE (t) == FUNCTION_TYPE
     939                 :            :                               && (flags & TFF_POINTER));
     940                 :    1455360 :         dump_ref_qualifier (pp, t, flags);
     941                 :    1455360 :         if (tx_safe_fn_type_p (t))
     942                 :         24 :           pp_cxx_ws_string (pp, "transaction_safe");
     943                 :    1812090 :         dump_exception_spec (pp, TYPE_RAISES_EXCEPTIONS (t), flags);
     944                 :    1455360 :         dump_type_suffix (pp, TREE_TYPE (t), flags);
     945                 :    1455360 :         break;
     946                 :            :       }
     947                 :            : 
     948                 :     176730 :     case ARRAY_TYPE:
     949                 :     176730 :       pp_maybe_space (pp);
     950                 :     176730 :       pp_cxx_left_bracket (pp);
     951                 :     176730 :       if (tree dtype = TYPE_DOMAIN (t))
     952                 :            :         {
     953                 :     131503 :           tree max = TYPE_MAX_VALUE (dtype);
     954                 :            :           /* Zero-length arrays have an upper bound of SIZE_MAX.  */
     955                 :     131503 :           if (integer_all_onesp (max))
     956                 :        280 :             pp_character (pp, '0');
     957                 :     131223 :           else if (tree_fits_shwi_p (max))
     958                 :     130768 :             pp_wide_integer (pp, tree_to_shwi (max) + 1);
     959                 :            :           else
     960                 :            :             {
     961                 :        455 :               STRIP_NOPS (max);
     962                 :        455 :               if (TREE_CODE (max) == SAVE_EXPR)
     963                 :        273 :                 max = TREE_OPERAND (max, 0);
     964                 :        455 :               if (TREE_CODE (max) == MINUS_EXPR
     965                 :        455 :                   || TREE_CODE (max) == PLUS_EXPR)
     966                 :            :                 {
     967                 :        423 :                   max = TREE_OPERAND (max, 0);
     968                 :        803 :                   while (CONVERT_EXPR_P (max))
     969                 :        380 :                     max = TREE_OPERAND (max, 0);
     970                 :            :                 }
     971                 :            :               else
     972                 :         32 :                 max = fold_build2_loc (input_location,
     973                 :            :                                        PLUS_EXPR, dtype, max,
     974                 :         32 :                                        build_int_cst (dtype, 1));
     975                 :        455 :               dump_expr (pp, max, flags & ~TFF_EXPR_IN_PARENS);
     976                 :            :             }
     977                 :            :         }
     978                 :     176730 :       pp_cxx_right_bracket (pp);
     979                 :     176730 :       dump_type_suffix (pp, TREE_TYPE (t), flags);
     980                 :     176730 :       break;
     981                 :            : 
     982                 :            :     case ENUMERAL_TYPE:
     983                 :            :     case IDENTIFIER_NODE:
     984                 :            :     case INTEGER_TYPE:
     985                 :            :     case BOOLEAN_TYPE:
     986                 :            :     case REAL_TYPE:
     987                 :            :     case RECORD_TYPE:
     988                 :            :     case TEMPLATE_TYPE_PARM:
     989                 :            :     case TEMPLATE_TEMPLATE_PARM:
     990                 :            :     case BOUND_TEMPLATE_TEMPLATE_PARM:
     991                 :            :     case TREE_LIST:
     992                 :            :     case TYPE_DECL:
     993                 :            :     case TREE_VEC:
     994                 :            :     case UNION_TYPE:
     995                 :            :     case LANG_TYPE:
     996                 :            :     case VOID_TYPE:
     997                 :            :     case TYPENAME_TYPE:
     998                 :            :     case COMPLEX_TYPE:
     999                 :            :     case VECTOR_TYPE:
    1000                 :            :     case TYPEOF_TYPE:
    1001                 :            :     case UNDERLYING_TYPE:
    1002                 :            :     case DECLTYPE_TYPE:
    1003                 :            :     case TYPE_PACK_EXPANSION:
    1004                 :            :     case FIXED_POINT_TYPE:
    1005                 :            :     case NULLPTR_TYPE:
    1006                 :            :       break;
    1007                 :            : 
    1008                 :          0 :     default:
    1009                 :          0 :       pp_unsupported_tree (pp, t);
    1010                 :            :     case ERROR_MARK:
    1011                 :            :       /* Don't mark it here, we should have already done in
    1012                 :            :          dump_type_prefix.  */
    1013                 :            :       break;
    1014                 :            :     }
    1015                 :   11024400 : }
    1016                 :            : 
    1017                 :            : static void
    1018                 :         69 : dump_global_iord (cxx_pretty_printer *pp, tree t)
    1019                 :            : {
    1020                 :         69 :   const char *p = NULL;
    1021                 :            : 
    1022                 :        138 :   if (DECL_GLOBAL_CTOR_P (t))
    1023                 :         69 :     p = M_("(static initializers for %s)");
    1024                 :          0 :   else if (DECL_GLOBAL_DTOR_P (t))
    1025                 :          0 :     p = M_("(static destructors for %s)");
    1026                 :            :   else
    1027                 :          0 :     gcc_unreachable ();
    1028                 :            : 
    1029                 :         69 :   pp_printf (pp, p, DECL_SOURCE_FILE (t));
    1030                 :         69 : }
    1031                 :            : 
    1032                 :            : static void
    1033                 :      84436 : dump_simple_decl (cxx_pretty_printer *pp, tree t, tree type, int flags)
    1034                 :            : {
    1035                 :      84436 :   if (template_parm_object_p (t))
    1036                 :          3 :     return dump_expr (pp, DECL_INITIAL (t), flags);
    1037                 :            : 
    1038                 :      84433 :   if (flags & TFF_DECL_SPECIFIERS)
    1039                 :            :     {
    1040                 :      10831 :       if (concept_definition_p (t))
    1041                 :         32 :         pp_cxx_ws_string (pp, "concept");
    1042                 :      14248 :       else if (VAR_P (t) && DECL_DECLARED_CONSTEXPR_P (t))
    1043                 :        498 :         pp_cxx_ws_string (pp, "constexpr");
    1044                 :            : 
    1045                 :      10831 :       if (!standard_concept_p (t))
    1046                 :      10808 :         dump_type_prefix (pp, type, flags & ~TFF_UNQUALIFIED_NAME);
    1047                 :      10831 :       pp_maybe_space (pp);
    1048                 :            :     }
    1049                 :      84433 :   if (! (flags & TFF_UNQUALIFIED_NAME)
    1050                 :      82359 :       && TREE_CODE (t) != PARM_DECL
    1051                 :     158458 :       && (!DECL_INITIAL (t)
    1052                 :       5188 :           || TREE_CODE (DECL_INITIAL (t)) != TEMPLATE_PARM_INDEX))
    1053                 :      72853 :     dump_scope (pp, CP_DECL_CONTEXT (t), flags);
    1054                 :      84433 :   flags &= ~TFF_UNQUALIFIED_NAME;
    1055                 :      84433 :   if ((flags & TFF_DECL_SPECIFIERS)
    1056                 :      10831 :       && DECL_TEMPLATE_PARM_P (t) 
    1057                 :      87725 :       && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t)))
    1058                 :         89 :     pp_string (pp, "...");
    1059                 :      84433 :   if (DECL_NAME (t))
    1060                 :            :     {
    1061                 :      81107 :       if (TREE_CODE (t) == FIELD_DECL && DECL_NORMAL_CAPTURE_P (t))
    1062                 :            :         {
    1063                 :          3 :           pp_less (pp);
    1064                 :          3 :           pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t)) + 2);
    1065                 :          3 :           pp_string (pp, " capture>");
    1066                 :            :         }
    1067                 :            :       else
    1068                 :      81104 :         dump_decl (pp, DECL_NAME (t), flags);
    1069                 :            :     }
    1070                 :       3403 :   else if (DECL_DECOMPOSITION_P (t))
    1071                 :          0 :     pp_string (pp, M_("<structured bindings>"));
    1072                 :            :   else
    1073                 :       3326 :     pp_string (pp, M_("<anonymous>"));
    1074                 :      84433 :   if (flags & TFF_DECL_SPECIFIERS)
    1075                 :      10831 :     dump_type_suffix (pp, type, flags);
    1076                 :            : }
    1077                 :            : 
    1078                 :            : /* Print an IDENTIFIER_NODE that is the name of a declaration.  */
    1079                 :            : 
    1080                 :            : static void
    1081                 :   21955400 : dump_decl_name (cxx_pretty_printer *pp, tree t, int flags)
    1082                 :            : {
    1083                 :            :   /* These special cases are duplicated here so that other functions
    1084                 :            :      can feed identifiers to error and get them demangled properly.  */
    1085                 :   21955400 :   if (IDENTIFIER_CONV_OP_P (t))
    1086                 :            :     {
    1087                 :         30 :       pp_cxx_ws_string (pp, "operator");
    1088                 :            :       /* Not exactly IDENTIFIER_TYPE_VALUE.  */
    1089                 :         30 :       dump_type (pp, TREE_TYPE (t), flags);
    1090                 :         30 :       return;
    1091                 :            :     }
    1092                 :   21955400 :   if (dguide_name_p (t))
    1093                 :            :     {
    1094                 :        237 :       dump_decl (pp, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t)),
    1095                 :            :                  TFF_UNQUALIFIED_NAME);
    1096                 :        237 :       return;
    1097                 :            :     }
    1098                 :            : 
    1099                 :   21955100 :   const char *str = IDENTIFIER_POINTER (t);
    1100                 :   21955100 :   if (!strncmp (str, "_ZGR", 4))
    1101                 :            :     {
    1102                 :          7 :       pp_cxx_ws_string (pp, "<temporary>");
    1103                 :          7 :       return;
    1104                 :            :     }
    1105                 :            : 
    1106                 :   21955100 :   pp_cxx_tree_identifier (pp, t);
    1107                 :            : }
    1108                 :            : 
    1109                 :            : /* Dump a human readable string for the decl T under control of FLAGS.  */
    1110                 :            : 
    1111                 :            : static void
    1112                 :   68078000 : dump_decl (cxx_pretty_printer *pp, tree t, int flags)
    1113                 :            : {
    1114                 :   68079200 :   if (t == NULL_TREE)
    1115                 :            :     return;
    1116                 :            : 
    1117                 :            :   /* If doing Objective-C++, give Objective-C a chance to demangle
    1118                 :            :      Objective-C method names.  */
    1119                 :   68079200 :   if (c_dialect_objc ())
    1120                 :            :     {
    1121                 :          0 :       const char *demangled = objc_maybe_printable_name (t, flags);
    1122                 :          0 :       if (demangled)
    1123                 :            :         {
    1124                 :          0 :           pp_string (pp, demangled);
    1125                 :          0 :           return;
    1126                 :            :         }
    1127                 :            :     }
    1128                 :            : 
    1129                 :   68079200 :   switch (TREE_CODE (t))
    1130                 :            :     {
    1131                 :   10118100 :     case TYPE_DECL:
    1132                 :            :       /* Don't say 'typedef class A' */
    1133                 :   10118100 :       if (DECL_ARTIFICIAL (t) && !DECL_SELF_REFERENCE_P (t))
    1134                 :            :         {
    1135                 :   10059400 :           if ((flags & TFF_DECL_SPECIFIERS)
    1136                 :   20081600 :               && TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
    1137                 :            :             {
    1138                 :            :               /* Say `class T' not just `T'.  */
    1139                 :         39 :               pp_cxx_ws_string (pp, "class");
    1140                 :            : 
    1141                 :            :               /* Emit the `...' for a parameter pack.  */
    1142                 :         39 :               if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
    1143                 :          3 :                 pp_cxx_ws_string (pp, "...");
    1144                 :            :             }
    1145                 :            : 
    1146                 :   10059400 :           dump_type (pp, TREE_TYPE (t), flags);
    1147                 :   10059400 :           break;
    1148                 :            :         }
    1149                 :      58704 :       if (TYPE_DECL_ALIAS_P (t)
    1150                 :      71509 :           && (flags & TFF_DECL_SPECIFIERS
    1151                 :      58704 :               || flags & TFF_CLASS_KEY_OR_ENUM))
    1152                 :            :         {
    1153                 :        202 :           pp_cxx_ws_string (pp, "using");
    1154                 :        202 :           dump_decl (pp, DECL_NAME (t), flags);
    1155                 :        202 :           pp_cxx_whitespace (pp);
    1156                 :        202 :           pp_cxx_ws_string (pp, "=");
    1157                 :        202 :           pp_cxx_whitespace (pp);
    1158                 :        202 :           dump_type (pp, (DECL_ORIGINAL_TYPE (t)
    1159                 :          6 :                           ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t)),
    1160                 :            :                      flags);
    1161                 :        202 :           break;
    1162                 :            :         }
    1163                 :      58502 :       if ((flags & TFF_DECL_SPECIFIERS)
    1164                 :      58502 :           && !DECL_SELF_REFERENCE_P (t))
    1165                 :       2318 :         pp_cxx_ws_string (pp, "typedef");
    1166                 :      58502 :       dump_simple_decl (pp, t, DECL_ORIGINAL_TYPE (t)
    1167                 :       2171 :                         ? DECL_ORIGINAL_TYPE (t) : TREE_TYPE (t),
    1168                 :            :                         flags);
    1169                 :      58502 :       break;
    1170                 :            : 
    1171                 :      11551 :     case VAR_DECL:
    1172                 :      11551 :       if (DECL_NAME (t) && VTABLE_NAME_P (DECL_NAME (t)))
    1173                 :            :         {
    1174                 :          0 :           pp_string (pp, M_("vtable for "));
    1175                 :          0 :           gcc_assert (TYPE_P (DECL_CONTEXT (t)));
    1176                 :          0 :           dump_type (pp, DECL_CONTEXT (t), flags);
    1177                 :          0 :           break;
    1178                 :            :         }
    1179                 :            :       /* Fall through.  */
    1180                 :      24557 :     case FIELD_DECL:
    1181                 :      24557 :     case PARM_DECL:
    1182                 :      24557 :       dump_simple_decl (pp, t, TREE_TYPE (t), flags);
    1183                 :            : 
    1184                 :            :       /* Handle variable template specializations.  */
    1185                 :      24557 :       if (VAR_P (t)
    1186                 :      11551 :           && DECL_LANG_SPECIFIC (t)
    1187                 :       3171 :           && DECL_TEMPLATE_INFO (t)
    1188                 :      24955 :           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t)))
    1189                 :            :         {
    1190                 :        123 :           pp_cxx_begin_template_argument_list (pp);
    1191                 :        123 :           tree args = INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t));
    1192                 :        123 :           dump_template_argument_list (pp, args, flags);
    1193                 :        123 :           pp_cxx_end_template_argument_list (pp);
    1194                 :            :         }
    1195                 :            :       break;
    1196                 :            : 
    1197                 :          0 :     case RESULT_DECL:
    1198                 :          0 :       pp_string (pp, M_("<return value> "));
    1199                 :          0 :       dump_simple_decl (pp, t, TREE_TYPE (t), flags);
    1200                 :          0 :       break;
    1201                 :            : 
    1202                 :   35625200 :     case NAMESPACE_DECL:
    1203                 :   35625200 :       if (flags & TFF_DECL_SPECIFIERS)
    1204                 :         78 :         pp->declaration (t);
    1205                 :            :       else
    1206                 :            :         {
    1207                 :   35625100 :           if (! (flags & TFF_UNQUALIFIED_NAME))
    1208                 :   35625100 :             dump_scope (pp, CP_DECL_CONTEXT (t), flags);
    1209                 :   35625100 :           flags &= ~TFF_UNQUALIFIED_NAME;
    1210                 :   35625100 :           if (DECL_NAME (t) == NULL_TREE)
    1211                 :            :             {
    1212                 :       4201 :               if (!(pp->flags & pp_c_flag_gnu_v3))
    1213                 :        773 :                 pp_cxx_ws_string (pp, M_("{anonymous}"));
    1214                 :            :               else
    1215                 :       3428 :                 pp_cxx_ws_string (pp, M_("(anonymous namespace)"));
    1216                 :            :             }
    1217                 :            :           else
    1218                 :   35620900 :             pp_cxx_tree_identifier (pp, DECL_NAME (t));
    1219                 :            :         }
    1220                 :            :       break;
    1221                 :            : 
    1222                 :        661 :     case SCOPE_REF:
    1223                 :        661 :       dump_type (pp, TREE_OPERAND (t, 0), flags);
    1224                 :        661 :       pp_cxx_colon_colon (pp);
    1225                 :        661 :       dump_decl (pp, TREE_OPERAND (t, 1), TFF_UNQUALIFIED_NAME);
    1226                 :        661 :       break;
    1227                 :            : 
    1228                 :          0 :     case ARRAY_REF:
    1229                 :          0 :       dump_decl (pp, TREE_OPERAND (t, 0), flags);
    1230                 :          0 :       pp_cxx_left_bracket (pp);
    1231                 :          0 :       dump_decl (pp, TREE_OPERAND (t, 1), flags);
    1232                 :          0 :       pp_cxx_right_bracket (pp);
    1233                 :          0 :       break;
    1234                 :            : 
    1235                 :            :       /* So that we can do dump_decl on an aggr type.  */
    1236                 :       1146 :     case RECORD_TYPE:
    1237                 :       1146 :     case UNION_TYPE:
    1238                 :       1146 :     case ENUMERAL_TYPE:
    1239                 :       1146 :       dump_type (pp, t, flags);
    1240                 :       1146 :       break;
    1241                 :            : 
    1242                 :         62 :     case BIT_NOT_EXPR:
    1243                 :            :       /* This is a pseudo destructor call which has not been folded into
    1244                 :            :          a PSEUDO_DTOR_EXPR yet.  */
    1245                 :         62 :       pp_cxx_complement (pp);
    1246                 :         62 :       dump_type (pp, TREE_OPERAND (t, 0), flags);
    1247                 :         62 :       break;
    1248                 :            : 
    1249                 :          0 :     case TYPE_EXPR:
    1250                 :          0 :       gcc_unreachable ();
    1251                 :   21955400 :       break;
    1252                 :            : 
    1253                 :   21955400 :     case IDENTIFIER_NODE:
    1254                 :   21955400 :       dump_decl_name (pp, t, flags);
    1255                 :   21955400 :       break;
    1256                 :            : 
    1257                 :        300 :     case OVERLOAD:
    1258                 :        300 :       if (!OVL_SINGLE_P (t))
    1259                 :            :         {
    1260                 :        141 :           tree ctx = ovl_scope (t);
    1261                 :        141 :           if (ctx != global_namespace)
    1262                 :            :             {
    1263                 :         75 :               if (TYPE_P (ctx))
    1264                 :         75 :                 dump_type (pp, ctx, flags);
    1265                 :            :               else
    1266                 :          0 :                 dump_decl (pp, ctx, flags);
    1267                 :         75 :               pp_cxx_colon_colon (pp);
    1268                 :            :             }
    1269                 :        282 :           dump_decl (pp, OVL_NAME (t), flags);
    1270                 :        141 :           break;
    1271                 :            :         }
    1272                 :            : 
    1273                 :            :       /* If there's only one function, just treat it like an ordinary
    1274                 :            :          FUNCTION_DECL.  */
    1275                 :      71128 :       t = OVL_FIRST (t);
    1276                 :            :       /* Fall through.  */
    1277                 :            : 
    1278                 :      71128 :     case FUNCTION_DECL:
    1279                 :      71128 :       if (! DECL_LANG_SPECIFIC (t))
    1280                 :            :         {
    1281                 :       1209 :           if (DECL_ABSTRACT_ORIGIN (t)
    1282                 :       1209 :               && DECL_ABSTRACT_ORIGIN (t) != t)
    1283                 :   68079200 :             dump_decl (pp, DECL_ABSTRACT_ORIGIN (t), flags);
    1284                 :            :           else
    1285                 :        945 :             dump_function_name (pp, t, flags);
    1286                 :            :         }
    1287                 :     139838 :       else if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
    1288                 :         69 :         dump_global_iord (pp, t);
    1289                 :            :       else
    1290                 :      69850 :         dump_function_decl (pp, t, flags);
    1291                 :            :       break;
    1292                 :            : 
    1293                 :     279847 :     case TEMPLATE_DECL:
    1294                 :     279847 :       dump_template_decl (pp, t, flags);
    1295                 :     279847 :       break;
    1296                 :            : 
    1297                 :         25 :     case CONCEPT_DECL:
    1298                 :         25 :       dump_simple_decl (pp, t, TREE_TYPE (t), flags);
    1299                 :         25 :       break;
    1300                 :            : 
    1301                 :          0 :     case WILDCARD_DECL:
    1302                 :          0 :       pp_string (pp, "<wildcard>");
    1303                 :          0 :       break;
    1304                 :            : 
    1305                 :       1038 :     case TEMPLATE_ID_EXPR:
    1306                 :       1038 :       {
    1307                 :       1038 :         tree name = TREE_OPERAND (t, 0);
    1308                 :       1038 :         tree args = TREE_OPERAND (t, 1);
    1309                 :            : 
    1310                 :       1472 :         if (!identifier_p (name))
    1311                 :        731 :           name = OVL_NAME (name);
    1312                 :       1038 :         dump_decl (pp, name, flags);
    1313                 :       1038 :         pp_cxx_begin_template_argument_list (pp);
    1314                 :       1038 :         if (args == error_mark_node)
    1315                 :         12 :           pp_string (pp, M_("<template arguments error>"));
    1316                 :       1026 :         else if (args)
    1317                 :        927 :           dump_template_argument_list
    1318                 :        927 :             (pp, args, flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS);
    1319                 :       1038 :         pp_cxx_end_template_argument_list (pp);
    1320                 :            :       }
    1321                 :       1038 :       break;
    1322                 :            : 
    1323                 :        257 :     case LABEL_DECL:
    1324                 :        257 :       pp_cxx_tree_identifier (pp, DECL_NAME (t));
    1325                 :        257 :       break;
    1326                 :            : 
    1327                 :       1370 :     case CONST_DECL:
    1328                 :       2740 :       if ((TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == ENUMERAL_TYPE)
    1329                 :       2500 :           || (DECL_INITIAL (t) &&
    1330                 :       1130 :               TREE_CODE (DECL_INITIAL (t)) == TEMPLATE_PARM_INDEX))
    1331                 :       1352 :         dump_simple_decl (pp, t, TREE_TYPE (t), flags);
    1332                 :         18 :       else if (DECL_NAME (t))
    1333                 :   68079200 :         dump_decl (pp, DECL_NAME (t), flags);
    1334                 :          0 :       else if (DECL_INITIAL (t))
    1335                 :          0 :         dump_expr (pp, DECL_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
    1336                 :            :       else
    1337                 :          0 :         pp_string (pp, M_("<enumerator>"));
    1338                 :            :       break;
    1339                 :            : 
    1340                 :        162 :     case USING_DECL:
    1341                 :        162 :       {
    1342                 :        162 :         pp_cxx_ws_string (pp, "using");
    1343                 :        162 :         tree scope = USING_DECL_SCOPE (t);
    1344                 :        162 :         bool variadic = false;
    1345                 :        162 :         if (PACK_EXPANSION_P (scope))
    1346                 :            :           {
    1347                 :          0 :             scope = PACK_EXPANSION_PATTERN (scope);
    1348                 :            :             variadic = true;
    1349                 :            :           }
    1350                 :        162 :         dump_type (pp, scope, flags);
    1351                 :        162 :         pp_cxx_colon_colon (pp);
    1352                 :        162 :         dump_decl (pp, DECL_NAME (t), flags);
    1353                 :        162 :         if (variadic)
    1354                 :          0 :           pp_cxx_ws_string (pp, "...");
    1355                 :            :       }
    1356                 :            :       break;
    1357                 :            : 
    1358                 :          0 :     case STATIC_ASSERT:
    1359                 :          0 :       pp->declaration (t);
    1360                 :          0 :       break;
    1361                 :            : 
    1362                 :         32 :     case BASELINK:
    1363                 :         32 :       dump_decl (pp, BASELINK_FUNCTIONS (t), flags);
    1364                 :         32 :       break;
    1365                 :            : 
    1366                 :          0 :     case NON_DEPENDENT_EXPR:
    1367                 :          0 :       dump_expr (pp, t, flags);
    1368                 :          0 :       break;
    1369                 :            : 
    1370                 :          0 :     case TEMPLATE_TYPE_PARM:
    1371                 :          0 :       if (flags & TFF_DECL_SPECIFIERS)
    1372                 :          0 :         pp->declaration (t);
    1373                 :            :       else
    1374                 :          0 :         pp->type_id (t);
    1375                 :            :       break;
    1376                 :            : 
    1377                 :         10 :     case UNBOUND_CLASS_TEMPLATE:
    1378                 :         10 :     case TYPE_PACK_EXPANSION:
    1379                 :         10 :     case TREE_BINFO:
    1380                 :         10 :       dump_type (pp, t, flags);
    1381                 :         10 :       break;
    1382                 :            : 
    1383                 :          0 :     default:
    1384                 :          0 :       pp_unsupported_tree (pp, t);
    1385                 :            :       /* Fall through.  */
    1386                 :            : 
    1387                 :         27 :     case ERROR_MARK:
    1388                 :         27 :       pp_string (pp, M_("<declaration error>"));
    1389                 :         27 :       break;
    1390                 :            :     }
    1391                 :            : }
    1392                 :            : 
    1393                 :            : /* Dump a template declaration T under control of FLAGS. This means the
    1394                 :            :    'template <...> leaders plus the 'class X' or 'void fn(...)' part.  */
    1395                 :            : 
    1396                 :            : static void
    1397                 :     280371 : dump_template_decl (cxx_pretty_printer *pp, tree t, int flags)
    1398                 :            : {
    1399                 :     280371 :   tree orig_parms = DECL_TEMPLATE_PARMS (t);
    1400                 :     280371 :   tree parms;
    1401                 :     280371 :   int i;
    1402                 :            : 
    1403                 :     280371 :   if (flags & TFF_TEMPLATE_HEADER)
    1404                 :            :     {
    1405                 :       9252 :       for (parms = orig_parms = nreverse (orig_parms);
    1406                 :       9252 :            parms;
    1407                 :       4859 :            parms = TREE_CHAIN (parms))
    1408                 :            :         {
    1409                 :       4859 :           tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms);
    1410                 :       4859 :           int len = TREE_VEC_LENGTH (inner_parms);
    1411                 :            : 
    1412                 :       4859 :           if (len == 0)
    1413                 :            :             {
    1414                 :            :               /* Skip over the dummy template levels of a template template
    1415                 :            :                  parm.  */
    1416                 :        307 :               gcc_assert (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TEMPLATE_PARM);
    1417                 :        307 :               continue;
    1418                 :            :             }
    1419                 :            : 
    1420                 :       4552 :           pp_cxx_ws_string (pp, "template");
    1421                 :       4552 :           pp_cxx_begin_template_argument_list (pp);
    1422                 :            : 
    1423                 :            :           /* If we've shown the template prefix, we'd better show the
    1424                 :            :              parameters' and decl's type too.  */
    1425                 :       4552 :             flags |= TFF_DECL_SPECIFIERS;
    1426                 :            : 
    1427                 :      11577 :           for (i = 0; i < len; i++)
    1428                 :            :             {
    1429                 :       7025 :               if (i)
    1430                 :       2473 :                 pp_separate_with_comma (pp);
    1431                 :       7025 :               dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i),
    1432                 :            :                                        flags);
    1433                 :            :             }
    1434                 :       4552 :           pp_cxx_end_template_argument_list (pp);
    1435                 :       4552 :           pp_cxx_whitespace (pp);
    1436                 :            :         }
    1437                 :       4393 :       nreverse(orig_parms);
    1438                 :            : 
    1439                 :       8786 :       if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
    1440                 :            :         {
    1441                 :            :           /* Say `template<arg> class TT' not just `template<arg> TT'.  */
    1442                 :        333 :           pp_cxx_ws_string (pp, "class");
    1443                 :            : 
    1444                 :            :           /* If this is a parameter pack, print the ellipsis.  */
    1445                 :        666 :           if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t)))
    1446                 :         65 :             pp_cxx_ws_string (pp, "...");
    1447                 :            :         }
    1448                 :            : 
    1449                 :            :       /* Only print the requirements if we're also printing
    1450                 :            :          the template header.  */
    1451                 :       4393 :       if (flag_concepts)
    1452                 :        983 :         if (tree ci = get_constraints (t))
    1453                 :        149 :           if (check_constraint_info (ci))
    1454                 :        149 :             if (tree reqs = CI_TEMPLATE_REQS (ci))
    1455                 :            :               {
    1456                 :        137 :                 pp_cxx_requires_clause (pp, reqs);
    1457                 :        137 :                 pp_cxx_whitespace (pp);
    1458                 :            :               }
    1459                 :            :     }
    1460                 :            : 
    1461                 :            : 
    1462                 :     280371 :   if (DECL_CLASS_TEMPLATE_P (t))
    1463                 :     221923 :     dump_type (pp, TREE_TYPE (t),
    1464                 :     221923 :                ((flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
    1465                 :     221923 :                 | (flags & TFF_DECL_SPECIFIERS ? TFF_CLASS_KEY_OR_ENUM : 0)));
    1466                 :      58448 :   else if (DECL_TEMPLATE_RESULT (t)
    1467                 :      58448 :            && (VAR_P (DECL_TEMPLATE_RESULT (t))
    1468                 :            :                /* Alias template.  */
    1469                 :      58391 :                || DECL_TYPE_TEMPLATE_P (t)
    1470                 :            :                /* Concept definition.  &*/
    1471                 :       3245 :                || TREE_CODE (DECL_TEMPLATE_RESULT (t)) == CONCEPT_DECL))
    1472                 :      55228 :     dump_decl (pp, DECL_TEMPLATE_RESULT (t), flags | TFF_TEMPLATE_NAME);
    1473                 :            :   else
    1474                 :            :     {
    1475                 :       3220 :       gcc_assert (TREE_TYPE (t));
    1476                 :       3220 :       switch (NEXT_CODE (t))
    1477                 :            :         {
    1478                 :       3220 :         case METHOD_TYPE:
    1479                 :       3220 :         case FUNCTION_TYPE:
    1480                 :       3220 :           dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME);
    1481                 :       3220 :           break;
    1482                 :          0 :         default:
    1483                 :            :           /* This case can occur with some invalid code.  */
    1484                 :          0 :           dump_type (pp, TREE_TYPE (t),
    1485                 :          0 :                      (flags & ~TFF_CLASS_KEY_OR_ENUM) | TFF_TEMPLATE_NAME
    1486                 :            :                      | (flags & TFF_DECL_SPECIFIERS
    1487                 :          0 :                         ? TFF_CLASS_KEY_OR_ENUM : 0));
    1488                 :            :         }
    1489                 :            :     }
    1490                 :     280371 : }
    1491                 :            : 
    1492                 :            : /* find_typenames looks through the type of the function template T
    1493                 :            :    and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
    1494                 :            :    it finds.  */
    1495                 :            : 
    1496                 :            : struct find_typenames_t
    1497                 :            : {
    1498                 :            :   hash_set<tree> *p_set;
    1499                 :            :   vec<tree, va_gc> *typenames;
    1500                 :            : };
    1501                 :            : 
    1502                 :            : static tree
    1503                 :     400569 : find_typenames_r (tree *tp, int *walk_subtrees, void *data)
    1504                 :            : {
    1505                 :     400569 :   struct find_typenames_t *d = (struct find_typenames_t *)data;
    1506                 :     400569 :   tree mv = NULL_TREE;
    1507                 :            : 
    1508                 :     400569 :   if (TYPE_P (*tp) && is_typedef_decl (TYPE_NAME (*tp)))
    1509                 :            :     /* Add the type of the typedef without any additional cv-quals.  */
    1510                 :       3902 :     mv = TREE_TYPE (TYPE_NAME (*tp));
    1511                 :     396667 :   else if (TREE_CODE (*tp) == TYPENAME_TYPE
    1512                 :     396409 :            || TREE_CODE (*tp) == DECLTYPE_TYPE)
    1513                 :            :     /* Add the typename without any cv-qualifiers.  */
    1514                 :        366 :     mv = TYPE_MAIN_VARIANT (*tp);
    1515                 :            : 
    1516                 :     400569 :   if (PACK_EXPANSION_P (*tp))
    1517                 :            :     {
    1518                 :            :       /* Don't mess with parameter packs since we don't remember
    1519                 :            :          the pack expansion context for a particular typename.  */
    1520                 :      12860 :       *walk_subtrees = false;
    1521                 :      12860 :       return NULL_TREE;
    1522                 :            :     }
    1523                 :            : 
    1524                 :     387709 :   if (mv && (mv == *tp || !d->p_set->add (mv)))
    1525                 :       4268 :     vec_safe_push (d->typenames, mv);
    1526                 :            : 
    1527                 :            :   return NULL_TREE;
    1528                 :            : }
    1529                 :            : 
    1530                 :            : static vec<tree, va_gc> *
    1531                 :      69865 : find_typenames (tree t)
    1532                 :            : {
    1533                 :      69865 :   struct find_typenames_t ft;
    1534                 :      69865 :   ft.p_set = new hash_set<tree>;
    1535                 :      69865 :   ft.typenames = NULL;
    1536                 :      69865 :   cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),
    1537                 :            :                 find_typenames_r, &ft, ft.p_set);
    1538                 :     139730 :   delete ft.p_set;
    1539                 :      69865 :   return ft.typenames;
    1540                 :            : }
    1541                 :            : 
    1542                 :            : /* Output the "[with ...]" clause for a template instantiation T iff
    1543                 :            :    TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable.  T may be NULL if
    1544                 :            :    formatting a deduction/substitution diagnostic rather than an
    1545                 :            :    instantiation.  */
    1546                 :            : 
    1547                 :            : static void
    1548                 :     348976 : dump_substitution (cxx_pretty_printer *pp,
    1549                 :            :                    tree t, tree template_parms, tree template_args,
    1550                 :            :                    int flags)
    1551                 :            : {
    1552                 :     348976 :   if (template_parms != NULL_TREE && template_args != NULL_TREE
    1553                 :      70389 :       && !(flags & TFF_NO_TEMPLATE_BINDINGS))
    1554                 :            :     {
    1555                 :      70389 :       vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL;
    1556                 :      70389 :       pp_cxx_whitespace (pp);
    1557                 :      70389 :       pp_cxx_left_bracket (pp);
    1558                 :      70389 :       pp->translate_string ("with");
    1559                 :      70389 :       pp_cxx_whitespace (pp);
    1560                 :      70389 :       dump_template_bindings (pp, template_parms, template_args, typenames);
    1561                 :      70389 :       pp_cxx_right_bracket (pp);
    1562                 :            :     }
    1563                 :     348976 : }
    1564                 :            : 
    1565                 :            : /* Dump the lambda function FN including its 'mutable' qualifier and any
    1566                 :            :    template bindings.  */
    1567                 :            : 
    1568                 :            : static void
    1569                 :       1193 : dump_lambda_function (cxx_pretty_printer *pp,
    1570                 :            :                       tree fn, tree template_parms, tree template_args,
    1571                 :            :                       int flags)
    1572                 :            : {
    1573                 :            :   /* A lambda's signature is essentially its "type".  */
    1574                 :       1193 :   dump_type (pp, DECL_CONTEXT (fn), flags);
    1575                 :       1193 :   if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn))) & TYPE_QUAL_CONST))
    1576                 :            :     {
    1577                 :         10 :       pp->padding = pp_before;
    1578                 :         10 :       pp_c_ws_string (pp, "mutable");
    1579                 :            :     }
    1580                 :       1193 :   dump_substitution (pp, fn, template_parms, template_args, flags);
    1581                 :       1193 : }
    1582                 :            : 
    1583                 :            : /* Pretty print a function decl. There are several ways we want to print a
    1584                 :            :    function declaration. The TFF_ bits in FLAGS tells us how to behave.
    1585                 :            :    As error can only apply the '#' flag once to give 0 and 1 for V, there
    1586                 :            :    is %D which doesn't print the throw specs, and %F which does.  */
    1587                 :            : 
    1588                 :            : static void
    1589                 :     350741 : dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
    1590                 :            : {
    1591                 :     350741 :   tree fntype;
    1592                 :     350741 :   tree parmtypes;
    1593                 :     350741 :   tree cname = NULL_TREE;
    1594                 :     350741 :   tree template_args = NULL_TREE;
    1595                 :     350741 :   tree template_parms = NULL_TREE;
    1596                 :     350741 :   int show_return = flags & TFF_RETURN_TYPE || flags & TFF_DECL_SPECIFIERS;
    1597                 :     350741 :   int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME);
    1598                 :     350741 :   tree exceptions;
    1599                 :     350741 :   bool constexpr_p;
    1600                 :     350741 :   tree ret = NULL_TREE;
    1601                 :            : 
    1602                 :     350741 :   flags &= ~(TFF_UNQUALIFIED_NAME | TFF_TEMPLATE_NAME);
    1603                 :     350741 :   if (TREE_CODE (t) == TEMPLATE_DECL)
    1604                 :       3371 :     t = DECL_TEMPLATE_RESULT (t);
    1605                 :            : 
    1606                 :            :   /* Save the exceptions, in case t is a specialization and we are
    1607                 :            :      emitting an error about incompatible specifications.  */
    1608                 :     390873 :   exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
    1609                 :            : 
    1610                 :            :   /* Likewise for the constexpr specifier, in case t is a specialization.  */
    1611                 :     701482 :   constexpr_p = DECL_DECLARED_CONSTEXPR_P (t);
    1612                 :            : 
    1613                 :            :   /* Pretty print template instantiations only.  */
    1614                 :     420945 :   if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
    1615                 :      70151 :       && !(flags & TFF_NO_TEMPLATE_BINDINGS)
    1616                 :     420632 :       && flag_pretty_templates)
    1617                 :            :     {
    1618                 :      69875 :       tree tmpl;
    1619                 :            : 
    1620                 :      69875 :       template_args = DECL_TI_ARGS (t);
    1621                 :      69875 :       tmpl = most_general_template (t);
    1622                 :      69875 :       if (tmpl && TREE_CODE (tmpl) == TEMPLATE_DECL)
    1623                 :            :         {
    1624                 :      69865 :           template_parms = DECL_TEMPLATE_PARMS (tmpl);
    1625                 :      69865 :           t = tmpl;
    1626                 :            :         }
    1627                 :            :     }
    1628                 :            : 
    1629                 :     380341 :   if (DECL_NAME (t) && LAMBDA_FUNCTION_P (t))
    1630                 :       1193 :     return dump_lambda_function (pp, t, template_parms, template_args, flags);
    1631                 :            : 
    1632                 :     349548 :   fntype = TREE_TYPE (t);
    1633                 :     388487 :   parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t);
    1634                 :            : 
    1635                 :     349548 :   if (DECL_CLASS_SCOPE_P (t))
    1636                 :     349548 :     cname = DECL_CONTEXT (t);
    1637                 :            :   /* This is for partially instantiated template methods.  */
    1638                 :     309772 :   else if (TREE_CODE (fntype) == METHOD_TYPE)
    1639                 :          0 :     cname = TREE_TYPE (TREE_VALUE (parmtypes));
    1640                 :            : 
    1641                 :     349548 :   if (flags & TFF_DECL_SPECIFIERS)
    1642                 :            :     {
    1643                 :     140620 :       if (DECL_STATIC_FUNCTION_P (t))
    1644                 :        740 :         pp_cxx_ws_string (pp, "static");
    1645                 :      69570 :       else if (DECL_VIRTUAL_P (t))
    1646                 :       2912 :         pp_cxx_ws_string (pp, "virtual");
    1647                 :            : 
    1648                 :      70310 :       if (constexpr_p)
    1649                 :            :         {
    1650                 :       4297 :           if (DECL_DECLARED_CONCEPT_P (t))
    1651                 :         16 :             pp_cxx_ws_string (pp, "concept");
    1652                 :       8562 :           else if (DECL_IMMEDIATE_FUNCTION_P (t))
    1653                 :         13 :             pp_cxx_ws_string (pp, "consteval");
    1654                 :            :           else
    1655                 :       4268 :             pp_cxx_ws_string (pp, "constexpr");
    1656                 :            :         }
    1657                 :            :     }
    1658                 :            : 
    1659                 :            :   /* Print the return type?  */
    1660                 :     349548 :   if (show_return)
    1661                 :     201705 :     show_return = (!DECL_CONV_FN_P (t)  && !DECL_CONSTRUCTOR_P (t)
    1662                 :     131729 :                    && !DECL_DESTRUCTOR_P (t) && !deduction_guide_p (t));
    1663                 :     349548 :   if (show_return)
    1664                 :            :     {
    1665                 :      60374 :       ret = fndecl_declared_return_type (t);
    1666                 :      60374 :       dump_type_prefix (pp, ret, flags);
    1667                 :            :     }
    1668                 :            : 
    1669                 :            :   /* Print the function name.  */
    1670                 :     349548 :   if (!do_outer_scope)
    1671                 :            :     /* Nothing.  */;
    1672                 :     349548 :   else if (cname)
    1673                 :            :     {
    1674                 :      39776 :       dump_type (pp, cname, flags);
    1675                 :      39776 :       pp_cxx_colon_colon (pp);
    1676                 :            :     }
    1677                 :            :   else
    1678                 :     309772 :     dump_scope (pp, CP_DECL_CONTEXT (t), flags);
    1679                 :            : 
    1680                 :     349548 :   dump_function_name (pp, t, flags);
    1681                 :            : 
    1682                 :     349548 :   if (!(flags & TFF_NO_FUNCTION_ARGUMENTS))
    1683                 :            :     {
    1684                 :     347259 :       dump_parameters (pp, parmtypes, flags);
    1685                 :            : 
    1686                 :     347259 :       if (TREE_CODE (fntype) == METHOD_TYPE)
    1687                 :            :         {
    1688                 :      38560 :           pp->padding = pp_before;
    1689                 :      38560 :           pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype));
    1690                 :      38560 :           dump_ref_qualifier (pp, fntype, flags);
    1691                 :            :         }
    1692                 :            : 
    1693                 :     347259 :       if (tx_safe_fn_type_p (fntype))
    1694                 :            :         {
    1695                 :         23 :           pp->padding = pp_before;
    1696                 :         23 :           pp_cxx_ws_string (pp, "transaction_safe");
    1697                 :            :         }
    1698                 :            : 
    1699                 :     347259 :       if (flags & TFF_EXCEPTION_SPECIFICATION)
    1700                 :            :         {
    1701                 :        409 :           pp->padding = pp_before;
    1702                 :        409 :           dump_exception_spec (pp, exceptions, flags);
    1703                 :            :         }
    1704                 :            : 
    1705                 :     347259 :       if (show_return)
    1706                 :      60374 :         dump_type_suffix (pp, ret, flags);
    1707                 :     286885 :       else if (deduction_guide_p (t))
    1708                 :            :         {
    1709                 :        180 :           pp_cxx_ws_string (pp, "->");
    1710                 :        180 :           dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
    1711                 :            :         }
    1712                 :            : 
    1713                 :     347259 :       if (flag_concepts)
    1714                 :     228519 :         if (tree ci = get_constraints (t))
    1715                 :      19740 :           if (tree reqs = CI_DECLARATOR_REQS (ci))
    1716                 :         80 :             pp_cxx_requires_clause (pp, reqs);
    1717                 :            : 
    1718                 :     347259 :       dump_substitution (pp, t, template_parms, template_args, flags);
    1719                 :            : 
    1720                 :     694588 :       if (tree base = DECL_INHERITED_CTOR_BASE (t))
    1721                 :            :         {
    1722                 :         70 :           pp_cxx_ws_string (pp, "[inherited from");
    1723                 :         70 :           dump_type (pp, base, TFF_PLAIN_IDENTIFIER);
    1724                 :         70 :           pp_character (pp, ']');
    1725                 :            :         }
    1726                 :            :     }
    1727                 :       2289 :   else if (template_args)
    1728                 :            :     {
    1729                 :          0 :       bool need_comma = false;
    1730                 :          0 :       int i;
    1731                 :          0 :       pp_cxx_begin_template_argument_list (pp);
    1732                 :          0 :       template_args = INNERMOST_TEMPLATE_ARGS (template_args);
    1733                 :          0 :       for (i = 0; i < TREE_VEC_LENGTH (template_args); ++i)
    1734                 :            :         {
    1735                 :          0 :           tree arg = TREE_VEC_ELT (template_args, i);
    1736                 :          0 :           if (need_comma)
    1737                 :          0 :             pp_separate_with_comma (pp);
    1738                 :          0 :           if (ARGUMENT_PACK_P (arg))
    1739                 :          0 :             pp_cxx_left_brace (pp);
    1740                 :          0 :           dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER);
    1741                 :          0 :           if (ARGUMENT_PACK_P (arg))
    1742                 :          0 :             pp_cxx_right_brace (pp);
    1743                 :          0 :           need_comma = true;
    1744                 :            :         }
    1745                 :          0 :       pp_cxx_end_template_argument_list (pp);
    1746                 :            :     }
    1747                 :            : }
    1748                 :            : 
    1749                 :            : /* Print a parameter list. If this is for a member function, the
    1750                 :            :    member object ptr (and any other hidden args) should have
    1751                 :            :    already been removed.  */
    1752                 :            : 
    1753                 :            : static void
    1754                 :    2139150 : dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags)
    1755                 :            : {
    1756                 :    2139150 :   int first = 1;
    1757                 :    2139150 :   flags &= ~TFF_SCOPE;
    1758                 :    2139150 :   pp_cxx_left_paren (pp);
    1759                 :            : 
    1760                 :    6087000 :   for (first = 1; parmtypes != void_list_node;
    1761                 :    1973930 :        parmtypes = TREE_CHAIN (parmtypes))
    1762                 :            :     {
    1763                 :    1976860 :       if (!first)
    1764                 :     695774 :         pp_separate_with_comma (pp);
    1765                 :    1976860 :       first = 0;
    1766                 :    1976860 :       if (!parmtypes)
    1767                 :            :         {
    1768                 :       2929 :           pp_cxx_ws_string (pp, "...");
    1769                 :       2929 :           break;
    1770                 :            :         }
    1771                 :            : 
    1772                 :    1973930 :       dump_type (pp, TREE_VALUE (parmtypes), flags);
    1773                 :            : 
    1774                 :    1973950 :       if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS) && TREE_PURPOSE (parmtypes))
    1775                 :            :         {
    1776                 :          8 :           pp_cxx_whitespace (pp);
    1777                 :          8 :           pp_equal (pp);
    1778                 :          8 :           pp_cxx_whitespace (pp);
    1779                 :          8 :           dump_expr (pp, TREE_PURPOSE (parmtypes), flags | TFF_EXPR_IN_PARENS);
    1780                 :            :         }
    1781                 :            :     }
    1782                 :            : 
    1783                 :    2139150 :   pp_cxx_right_paren (pp);
    1784                 :    2139150 : }
    1785                 :            : 
    1786                 :            : /* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
    1787                 :            : 
    1788                 :            : static void
    1789                 :    1493920 : dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED)
    1790                 :            : {
    1791                 :    3383130 :   if (FUNCTION_REF_QUALIFIED (t))
    1792                 :            :     {
    1793                 :       1184 :       pp->padding = pp_before;
    1794                 :       2963 :       if (FUNCTION_RVALUE_QUALIFIED (t))
    1795                 :        322 :         pp_cxx_ws_string (pp, "&&");
    1796                 :            :       else
    1797                 :        862 :         pp_cxx_ws_string (pp, "&");
    1798                 :            :     }
    1799                 :    1493920 : }
    1800                 :            : 
    1801                 :            : /* Print an exception specification. T is the exception specification.  */
    1802                 :            : 
    1803                 :            : static void
    1804                 :    1455770 : dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags)
    1805                 :            : {
    1806                 :    1457380 :   if (t && TREE_PURPOSE (t))
    1807                 :            :     {
    1808                 :       1454 :       pp_cxx_ws_string (pp, "noexcept");
    1809                 :       1454 :       if (!integer_onep (TREE_PURPOSE (t)))
    1810                 :            :         {
    1811                 :         91 :           pp_cxx_whitespace (pp);
    1812                 :         91 :           pp_cxx_left_paren (pp);
    1813                 :         91 :           if (DEFERRED_NOEXCEPT_SPEC_P (t))
    1814                 :          0 :             pp_cxx_ws_string (pp, "<uninstantiated>");
    1815                 :            :           else
    1816                 :         91 :             dump_expr (pp, TREE_PURPOSE (t), flags);
    1817                 :         91 :           pp_cxx_right_paren (pp);
    1818                 :            :         }
    1819                 :            :     }
    1820                 :    1454320 :   else if (t)
    1821                 :            :     {
    1822                 :        160 :       pp_cxx_ws_string (pp, "throw");
    1823                 :        160 :       pp_cxx_whitespace (pp);
    1824                 :        160 :       pp_cxx_left_paren (pp);
    1825                 :        160 :       if (TREE_VALUE (t) != NULL_TREE)
    1826                 :        131 :         while (1)
    1827                 :            :           {
    1828                 :        107 :             dump_type (pp, TREE_VALUE (t), flags);
    1829                 :        107 :             t = TREE_CHAIN (t);
    1830                 :        107 :             if (!t)
    1831                 :            :               break;
    1832                 :         24 :             pp_separate_with_comma (pp);
    1833                 :            :           }
    1834                 :        160 :       pp_cxx_right_paren (pp);
    1835                 :            :     }
    1836                 :    1455770 : }
    1837                 :            : 
    1838                 :            : /* Handle the function name for a FUNCTION_DECL node, grokking operators
    1839                 :            :    and destructors properly.  */
    1840                 :            : 
    1841                 :            : static void
    1842                 :    8235290 : dump_function_name (cxx_pretty_printer *pp, tree t, int flags)
    1843                 :            : {
    1844                 :    8235290 :   tree name = DECL_NAME (t);
    1845                 :            : 
    1846                 :            :   /* We can get here with a decl that was synthesized by language-
    1847                 :            :      independent machinery (e.g. coverage.c) in which case it won't
    1848                 :            :      have a lang_specific structure attached and DECL_CONSTRUCTOR_P
    1849                 :            :      will crash.  In this case it is safe just to print out the
    1850                 :            :      literal name.  */
    1851                 :    8235290 :   if (!DECL_LANG_SPECIFIC (t))
    1852                 :            :     {
    1853                 :       4799 :       pp_cxx_tree_identifier (pp, name);
    1854                 :       4799 :       return;
    1855                 :            :     }
    1856                 :            : 
    1857                 :    8230500 :   if (TREE_CODE (t) == TEMPLATE_DECL)
    1858                 :      69777 :     t = DECL_TEMPLATE_RESULT (t);
    1859                 :            : 
    1860                 :            :   /* Don't let the user see __comp_ctor et al.  */
    1861                 :    8230500 :   if (DECL_CONSTRUCTOR_P (t)
    1862                 :    8230500 :       || DECL_DESTRUCTOR_P (t))
    1863                 :            :     {
    1864                 :    1616330 :       if (LAMBDA_TYPE_P (DECL_CONTEXT (t)))
    1865                 :       7791 :         name = get_identifier ("<lambda>");
    1866                 :    1608540 :       else if (TYPE_UNNAMED_P (DECL_CONTEXT (t)))
    1867                 :         99 :         name = get_identifier ("<constructor>");
    1868                 :            :       else
    1869                 :    1608440 :         name = constructor_name (DECL_CONTEXT (t));
    1870                 :            :     }
    1871                 :            : 
    1872                 :   16461000 :   if (DECL_DESTRUCTOR_P (t))
    1873                 :            :     {
    1874                 :     303103 :       pp_cxx_complement (pp);
    1875                 :     303103 :       dump_decl (pp, name, TFF_PLAIN_IDENTIFIER);
    1876                 :            :     }
    1877                 :    7927390 :   else if (DECL_CONV_FN_P (t))
    1878                 :            :     {
    1879                 :            :       /* This cannot use the hack that the operator's return
    1880                 :            :          type is stashed off of its name because it may be
    1881                 :            :          used for error reporting.  In the case of conflicting
    1882                 :            :          declarations, both will have the same name, yet
    1883                 :            :          the types will be different, hence the TREE_TYPE field
    1884                 :            :          of the first name will be clobbered by the second.  */
    1885                 :      44680 :       pp_cxx_ws_string (pp, "operator");
    1886                 :      44680 :       dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
    1887                 :            :     }
    1888                 :            :   else
    1889                 :    7882710 :     dump_decl (pp, name, flags);
    1890                 :            : 
    1891                 :    8230500 :   if (DECL_TEMPLATE_INFO (t)
    1892                 :    6104220 :       && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)
    1893                 :   14257000 :       && (TREE_CODE (DECL_TI_TEMPLATE (t)) != TEMPLATE_DECL
    1894                 :    6026460 :           || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))))
    1895                 :     269386 :     dump_template_parms (pp, DECL_TEMPLATE_INFO (t), !DECL_USE_TEMPLATE (t),
    1896                 :            :                          flags);
    1897                 :            : }
    1898                 :            : 
    1899                 :            : /* Dump the template parameters from the template info INFO under control of
    1900                 :            :    FLAGS. PRIMARY indicates whether this is a primary template decl, or
    1901                 :            :    specialization (partial or complete). For partial specializations we show
    1902                 :            :    the specialized parameter values. For a primary template we show no
    1903                 :            :    decoration.  */
    1904                 :            : 
    1905                 :            : static void
    1906                 :   30417500 : dump_template_parms (cxx_pretty_printer *pp, tree info,
    1907                 :            :                      int primary, int flags)
    1908                 :            : {
    1909                 :   60834900 :   tree args = info ? TI_ARGS (info) : NULL_TREE;
    1910                 :            : 
    1911                 :   30417500 :   if (primary && flags & TFF_TEMPLATE_NAME)
    1912                 :            :     return;
    1913                 :   30195600 :   flags &= ~(TFF_CLASS_KEY_OR_ENUM | TFF_TEMPLATE_NAME);
    1914                 :   30195600 :   pp_cxx_begin_template_argument_list (pp);
    1915                 :            : 
    1916                 :            :   /* Be careful only to print things when we have them, so as not
    1917                 :            :      to crash producing error messages.  */
    1918                 :   30195600 :   if (args && !primary)
    1919                 :            :     {
    1920                 :   30171700 :       int len, ix;
    1921                 :   30171700 :       len = get_non_default_template_args_count (args, flags);
    1922                 :            : 
    1923                 :   30171700 :       args = INNERMOST_TEMPLATE_ARGS (args);
    1924                 :   76508500 :       for (ix = 0; ix != len; ix++)
    1925                 :            :         {
    1926                 :   46336800 :           tree arg = TREE_VEC_ELT (args, ix);
    1927                 :            : 
    1928                 :            :           /* Only print a comma if we know there is an argument coming. In
    1929                 :            :              the case of an empty template argument pack, no actual
    1930                 :            :              argument will be printed.  */
    1931                 :   46336800 :           if (ix
    1932                 :   46336800 :               && (!ARGUMENT_PACK_P (arg)
    1933                 :    4740070 :                   || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg)) > 0))
    1934                 :   16034300 :             pp_separate_with_comma (pp);
    1935                 :            :           
    1936                 :   46336800 :           if (!arg)
    1937                 :          0 :             pp_string (pp, M_("<template parameter error>"));
    1938                 :            :           else
    1939                 :   46336800 :             dump_template_argument (pp, arg, flags);
    1940                 :            :         }
    1941                 :            :     }
    1942                 :      23864 :   else if (primary)
    1943                 :            :     {
    1944                 :      23862 :       tree tpl = TI_TEMPLATE (info);
    1945                 :      23862 :       tree parms = DECL_TEMPLATE_PARMS (tpl);
    1946                 :      23862 :       int len, ix;
    1947                 :            : 
    1948                 :      23862 :       parms = TREE_CODE (parms) == TREE_LIST ? TREE_VALUE (parms) : NULL_TREE;
    1949                 :      47724 :       len = parms ? TREE_VEC_LENGTH (parms) : 0;
    1950                 :            : 
    1951                 :      62151 :       for (ix = 0; ix != len; ix++)
    1952                 :            :         {
    1953                 :      38289 :           tree parm;
    1954                 :            : 
    1955                 :      38289 :           if (TREE_VEC_ELT (parms, ix) == error_mark_node)
    1956                 :            :             {
    1957                 :          0 :               pp_string (pp, M_("<template parameter error>"));
    1958                 :          0 :               continue;
    1959                 :            :             }
    1960                 :            : 
    1961                 :      38289 :           parm = TREE_VALUE (TREE_VEC_ELT (parms, ix));
    1962                 :            : 
    1963                 :      38289 :           if (ix)
    1964                 :      14427 :             pp_separate_with_comma (pp);
    1965                 :            : 
    1966                 :      38289 :           dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS);
    1967                 :            :         }
    1968                 :            :     }
    1969                 :   30195600 :   pp_cxx_end_template_argument_list (pp);
    1970                 :            : }
    1971                 :            : 
    1972                 :            : /* Print out the arguments of CALL_EXPR T as a parenthesized list using
    1973                 :            :    flags FLAGS.  Skip over the first argument if SKIPFIRST is true.  */
    1974                 :            : 
    1975                 :            : static void
    1976                 :       1132 : dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst)
    1977                 :            : {
    1978                 :       1132 :   tree arg;
    1979                 :       1132 :   call_expr_arg_iterator iter;
    1980                 :            :   
    1981                 :       1132 :   pp_cxx_left_paren (pp);
    1982                 :       2289 :   FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
    1983                 :            :     {
    1984                 :       1157 :       if (skipfirst)
    1985                 :            :         skipfirst = false;
    1986                 :            :       else
    1987                 :            :         {
    1988                 :       1071 :           dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
    1989                 :       1071 :           if (more_call_expr_args_p (&iter))
    1990                 :        270 :             pp_separate_with_comma (pp);
    1991                 :            :         }
    1992                 :            :     }
    1993                 :       1132 :   pp_cxx_right_paren (pp);
    1994                 :       1132 : }
    1995                 :            : 
    1996                 :            : /* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
    1997                 :            :    using flags FLAGS.  Skip over the first argument if SKIPFIRST is
    1998                 :            :    true.  */
    1999                 :            : 
    2000                 :            : static void
    2001                 :        100 : dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags,
    2002                 :            :                           bool skipfirst)
    2003                 :            : {
    2004                 :        100 :   tree arg;
    2005                 :        100 :   aggr_init_expr_arg_iterator iter;
    2006                 :            :   
    2007                 :        100 :   pp_cxx_left_paren (pp);
    2008                 :        254 :   FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)
    2009                 :            :     {
    2010                 :        154 :       if (skipfirst)
    2011                 :            :         skipfirst = false;
    2012                 :            :       else
    2013                 :            :         {
    2014                 :         56 :           dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS);
    2015                 :         56 :           if (more_aggr_init_expr_args_p (&iter))
    2016                 :          6 :             pp_separate_with_comma (pp);
    2017                 :            :         }
    2018                 :            :     }
    2019                 :        100 :   pp_cxx_right_paren (pp);
    2020                 :        100 : }
    2021                 :            : 
    2022                 :            : /* Print out a list of initializers (subr of dump_expr).  */
    2023                 :            : 
    2024                 :            : static void
    2025                 :        124 : dump_expr_list (cxx_pretty_printer *pp, tree l, int flags)
    2026                 :            : {
    2027                 :        175 :   while (l)
    2028                 :            :     {
    2029                 :         51 :       dump_expr (pp, TREE_VALUE (l), flags | TFF_EXPR_IN_PARENS);
    2030                 :         51 :       l = TREE_CHAIN (l);
    2031                 :         51 :       if (l)
    2032                 :          0 :         pp_separate_with_comma (pp);
    2033                 :            :     }
    2034                 :        124 : }
    2035                 :            : 
    2036                 :            : /* Print out a vector of initializers (subr of dump_expr).  */
    2037                 :            : 
    2038                 :            : static void
    2039                 :        133 : dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v,
    2040                 :            :                     int flags)
    2041                 :            : {
    2042                 :        133 :   unsigned HOST_WIDE_INT idx;
    2043                 :        133 :   tree value;
    2044                 :            : 
    2045                 :        591 :   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
    2046                 :            :     {
    2047                 :        175 :       dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS);
    2048                 :        175 :       if (idx != v->length () - 1)
    2049                 :         67 :         pp_separate_with_comma (pp);
    2050                 :            :     }
    2051                 :        133 : }
    2052                 :            : 
    2053                 :            : 
    2054                 :            : /* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
    2055                 :            :    function.  Resolve it to a close relative -- in the sense of static
    2056                 :            :    type -- variant being overridden.  That is close to what was written in
    2057                 :            :    the source code.  Subroutine of dump_expr.  */
    2058                 :            : 
    2059                 :            : static tree
    2060                 :         13 : resolve_virtual_fun_from_obj_type_ref (tree ref)
    2061                 :            : {
    2062                 :         13 :   tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
    2063                 :         13 :   HOST_WIDE_INT index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref));
    2064                 :         13 :   tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
    2065                 :         21 :   while (index)
    2066                 :            :     {
    2067                 :          8 :       fun = TREE_CHAIN (fun);
    2068                 :          8 :       index -= (TARGET_VTABLE_USES_DESCRIPTORS
    2069                 :            :                 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
    2070                 :            :     }
    2071                 :            : 
    2072                 :         13 :   return BV_FN (fun);
    2073                 :            : }
    2074                 :            : 
    2075                 :            : /* Print out an expression E under control of FLAGS.  */
    2076                 :            : 
    2077                 :            : static void
    2078                 :    5543020 : dump_expr (cxx_pretty_printer *pp, tree t, int flags)
    2079                 :            : {
    2080                 :    5547430 :   tree op;
    2081                 :            : 
    2082                 :    5547430 :   if (t == 0)
    2083                 :            :     return;
    2084                 :            : 
    2085                 :    5547430 :   if (STATEMENT_CLASS_P (t))
    2086                 :            :     {
    2087                 :         41 :       pp_cxx_ws_string (pp, M_("<statement>"));
    2088                 :         41 :       return;
    2089                 :            :     }
    2090                 :            : 
    2091                 :    5547390 :   switch (TREE_CODE (t))
    2092                 :            :     {
    2093                 :      13714 :     case VAR_DECL:
    2094                 :      13714 :     case PARM_DECL:
    2095                 :      13714 :     case FIELD_DECL:
    2096                 :      13714 :     case CONST_DECL:
    2097                 :      13714 :     case FUNCTION_DECL:
    2098                 :      13714 :     case TEMPLATE_DECL:
    2099                 :      13714 :     case NAMESPACE_DECL:
    2100                 :      13714 :     case LABEL_DECL:
    2101                 :      13714 :     case WILDCARD_DECL:
    2102                 :      13714 :     case OVERLOAD:
    2103                 :      13714 :     case TYPE_DECL:
    2104                 :      13714 :     case IDENTIFIER_NODE:
    2105                 :      13714 :       dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
    2106                 :            :                                     |TFF_TEMPLATE_HEADER))
    2107                 :            :                          | TFF_NO_TEMPLATE_BINDINGS
    2108                 :      13714 :                          | TFF_NO_FUNCTION_ARGUMENTS));
    2109                 :      13714 :       break;
    2110                 :            : 
    2111                 :        118 :     case SSA_NAME:
    2112                 :        118 :       if (SSA_NAME_VAR (t)
    2113                 :        102 :           && !DECL_ARTIFICIAL (SSA_NAME_VAR (t)))
    2114                 :    5547430 :         dump_expr (pp, SSA_NAME_VAR (t), flags);
    2115                 :            :       else
    2116                 :         23 :         pp_cxx_ws_string (pp, M_("<unknown>"));
    2117                 :            :       break;
    2118                 :            : 
    2119                 :    5521640 :     case VOID_CST:
    2120                 :    5521640 :     case INTEGER_CST:
    2121                 :    5521640 :     case REAL_CST:
    2122                 :    5521640 :     case STRING_CST:
    2123                 :    5521640 :     case COMPLEX_CST:
    2124                 :    5521640 :       pp->constant (t);
    2125                 :    5521640 :       break;
    2126                 :            : 
    2127                 :          0 :     case USERDEF_LITERAL:
    2128                 :          0 :       pp_cxx_userdef_literal (pp, t);
    2129                 :          0 :       break;
    2130                 :            : 
    2131                 :         74 :     case THROW_EXPR:
    2132                 :            :       /* While waiting for caret diagnostics, avoid printing
    2133                 :            :          __cxa_allocate_exception, __cxa_throw, and the like.  */
    2134                 :         74 :       pp_cxx_ws_string (pp, M_("<throw-expression>"));
    2135                 :         74 :       break;
    2136                 :            : 
    2137                 :        140 :     case PTRMEM_CST:
    2138                 :        140 :       pp_ampersand (pp);
    2139                 :        189 :       dump_type (pp, PTRMEM_CST_CLASS (t), flags);
    2140                 :        140 :       pp_cxx_colon_colon (pp);
    2141                 :        140 :       pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)));
    2142                 :        140 :       break;
    2143                 :            : 
    2144                 :         33 :     case COMPOUND_EXPR:
    2145                 :         33 :       pp_cxx_left_paren (pp);
    2146                 :         33 :       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
    2147                 :         33 :       pp_separate_with_comma (pp);
    2148                 :         33 :       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
    2149                 :         33 :       pp_cxx_right_paren (pp);
    2150                 :         33 :       break;
    2151                 :            : 
    2152                 :         27 :     case COND_EXPR:
    2153                 :         27 :     case VEC_COND_EXPR:
    2154                 :         27 :       pp_cxx_left_paren (pp);
    2155                 :         27 :       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
    2156                 :         27 :       pp_string (pp, " ? ");
    2157                 :         27 :       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
    2158                 :         27 :       pp_string (pp, " : ");
    2159                 :         27 :       dump_expr (pp, TREE_OPERAND (t, 2), flags | TFF_EXPR_IN_PARENS);
    2160                 :         27 :       pp_cxx_right_paren (pp);
    2161                 :         27 :       break;
    2162                 :            : 
    2163                 :          0 :     case SAVE_EXPR:
    2164                 :          0 :       if (TREE_HAS_CONSTRUCTOR (t))
    2165                 :            :         {
    2166                 :          0 :           pp_cxx_ws_string (pp, "new");
    2167                 :          0 :           pp_cxx_whitespace (pp);
    2168                 :          0 :           dump_type (pp, TREE_TYPE (TREE_TYPE (t)), flags);
    2169                 :            :         }
    2170                 :            :       else
    2171                 :          0 :         dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
    2172                 :            :       break;
    2173                 :            : 
    2174                 :        100 :     case AGGR_INIT_EXPR:
    2175                 :        100 :       {
    2176                 :        100 :         tree fn = NULL_TREE;
    2177                 :            : 
    2178                 :        100 :         if (TREE_CODE (AGGR_INIT_EXPR_FN (t)) == ADDR_EXPR)
    2179                 :         96 :           fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0);
    2180                 :            : 
    2181                 :         96 :         if (fn && TREE_CODE (fn) == FUNCTION_DECL)
    2182                 :            :           {
    2183                 :         96 :             if (DECL_CONSTRUCTOR_P (fn))
    2184                 :         90 :               dump_type (pp, DECL_CONTEXT (fn), flags);
    2185                 :            :             else
    2186                 :          6 :               dump_decl (pp, fn, 0);
    2187                 :            :           }
    2188                 :            :         else
    2189                 :          4 :           dump_expr (pp, AGGR_INIT_EXPR_FN (t), 0);
    2190                 :            :       }
    2191                 :        100 :       dump_aggr_init_expr_args (pp, t, flags, true);
    2192                 :        100 :       break;
    2193                 :            : 
    2194                 :       1132 :     case CALL_EXPR:
    2195                 :       1132 :       {
    2196                 :       1132 :         tree fn = CALL_EXPR_FN (t);
    2197                 :       1132 :         bool skipfirst = false;
    2198                 :            : 
    2199                 :            :         /* Deal with internal functions.  */
    2200                 :       1132 :         if (fn == NULL_TREE)
    2201                 :            :           {
    2202                 :          0 :             pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t)));
    2203                 :          0 :             dump_call_expr_args (pp, t, flags, skipfirst);
    2204                 :          0 :             break;
    2205                 :            :           }
    2206                 :            : 
    2207                 :       1132 :         if (TREE_CODE (fn) == ADDR_EXPR)
    2208                 :        629 :           fn = TREE_OPERAND (fn, 0);
    2209                 :            : 
    2210                 :            :         /* Nobody is interested in seeing the guts of vcalls.  */
    2211                 :       1132 :         if (TREE_CODE (fn) == OBJ_TYPE_REF)
    2212                 :          4 :           fn = resolve_virtual_fun_from_obj_type_ref (fn);
    2213                 :            : 
    2214                 :       1132 :         if (TREE_TYPE (fn) != NULL_TREE
    2215                 :        885 :             && NEXT_CODE (fn) == METHOD_TYPE
    2216                 :       1218 :             && call_expr_nargs (t))
    2217                 :            :           {
    2218                 :         86 :             tree ob = CALL_EXPR_ARG (t, 0);
    2219                 :         86 :             if (TREE_CODE (ob) == ADDR_EXPR)
    2220                 :            :               {
    2221                 :         56 :                 dump_expr (pp, TREE_OPERAND (ob, 0),
    2222                 :            :                            flags | TFF_EXPR_IN_PARENS);
    2223                 :         56 :                 pp_cxx_dot (pp);
    2224                 :            :               }
    2225                 :         30 :             else if (!is_this_parameter (ob))
    2226                 :            :               {
    2227                 :         30 :                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
    2228                 :         30 :                 pp_cxx_arrow (pp);
    2229                 :            :               }
    2230                 :            :             skipfirst = true;
    2231                 :            :           }
    2232                 :       1132 :         if (flag_sanitize & SANITIZE_UNDEFINED
    2233                 :       1132 :             && is_ubsan_builtin_p (fn))
    2234                 :            :           {
    2235                 :          0 :             pp_string (cxx_pp, M_("<ubsan routine call>"));
    2236                 :          0 :             break;
    2237                 :            :           }
    2238                 :       1132 :         dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS);
    2239                 :       1132 :         dump_call_expr_args (pp, t, flags, skipfirst);
    2240                 :            :       }
    2241                 :       1132 :       break;
    2242                 :            : 
    2243                 :        266 :     case TARGET_EXPR:
    2244                 :            :       /* Note that this only works for G++ target exprs.  If somebody
    2245                 :            :          builds a general TARGET_EXPR, there's no way to represent that
    2246                 :            :          it initializes anything other that the parameter slot for the
    2247                 :            :          default argument.  Note we may have cleared out the first
    2248                 :            :          operand in expand_expr, so don't go killing ourselves.  */
    2249                 :        266 :       if (TREE_OPERAND (t, 1))
    2250                 :        266 :         dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
    2251                 :            :       break;
    2252                 :            : 
    2253                 :        180 :     case POINTER_PLUS_EXPR:
    2254                 :        180 :       dump_binary_op (pp, "+", t, flags);
    2255                 :        180 :       break;
    2256                 :            : 
    2257                 :          6 :     case POINTER_DIFF_EXPR:
    2258                 :          6 :       dump_binary_op (pp, "-", t, flags);
    2259                 :          6 :       break;
    2260                 :            : 
    2261                 :          8 :     case INIT_EXPR:
    2262                 :          8 :     case MODIFY_EXPR:
    2263                 :          8 :       dump_binary_op (pp, OVL_OP_INFO (true, NOP_EXPR)->name, t, flags);
    2264                 :          8 :       break;
    2265                 :            : 
    2266                 :        852 :     case PLUS_EXPR:
    2267                 :        852 :     case MINUS_EXPR:
    2268                 :        852 :     case MULT_EXPR:
    2269                 :        852 :     case TRUNC_DIV_EXPR:
    2270                 :        852 :     case TRUNC_MOD_EXPR:
    2271                 :        852 :     case MIN_EXPR:
    2272                 :        852 :     case MAX_EXPR:
    2273                 :        852 :     case LSHIFT_EXPR:
    2274                 :        852 :     case RSHIFT_EXPR:
    2275                 :        852 :     case BIT_IOR_EXPR:
    2276                 :        852 :     case BIT_XOR_EXPR:
    2277                 :        852 :     case BIT_AND_EXPR:
    2278                 :        852 :     case TRUTH_ANDIF_EXPR:
    2279                 :        852 :     case TRUTH_ORIF_EXPR:
    2280                 :        852 :     case LT_EXPR:
    2281                 :        852 :     case LE_EXPR:
    2282                 :        852 :     case GT_EXPR:
    2283                 :        852 :     case GE_EXPR:
    2284                 :        852 :     case EQ_EXPR:
    2285                 :        852 :     case NE_EXPR:
    2286                 :        852 :     case SPACESHIP_EXPR:
    2287                 :        852 :     case EXACT_DIV_EXPR:
    2288                 :        852 :       dump_binary_op (pp, OVL_OP_INFO (false, TREE_CODE (t))->name, t, flags);
    2289                 :        852 :       break;
    2290                 :            : 
    2291                 :         15 :     case CEIL_DIV_EXPR:
    2292                 :         15 :     case FLOOR_DIV_EXPR:
    2293                 :         15 :     case ROUND_DIV_EXPR:
    2294                 :         15 :     case RDIV_EXPR:
    2295                 :         15 :       dump_binary_op (pp, "/", t, flags);
    2296                 :         15 :       break;
    2297                 :            : 
    2298                 :          0 :     case CEIL_MOD_EXPR:
    2299                 :          0 :     case FLOOR_MOD_EXPR:
    2300                 :          0 :     case ROUND_MOD_EXPR:
    2301                 :          0 :       dump_binary_op (pp, "%", t, flags);
    2302                 :          0 :       break;
    2303                 :            : 
    2304                 :        469 :     case COMPONENT_REF:
    2305                 :        469 :       {
    2306                 :        469 :         tree ob = TREE_OPERAND (t, 0);
    2307                 :        469 :         if (INDIRECT_REF_P (ob))
    2308                 :            :           {
    2309                 :        289 :             ob = TREE_OPERAND (ob, 0);
    2310                 :        289 :             if (!is_this_parameter (ob))
    2311                 :            :               {
    2312                 :        289 :                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
    2313                 :        289 :                 if (TYPE_REF_P (TREE_TYPE (ob)))
    2314                 :         97 :                   pp_cxx_dot (pp);
    2315                 :            :                 else
    2316                 :        192 :                   pp_cxx_arrow (pp);
    2317                 :            :               }
    2318                 :            :           }
    2319                 :            :         else
    2320                 :            :           {
    2321                 :        180 :             dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
    2322                 :        180 :             if (TREE_CODE (ob) != ARROW_EXPR)
    2323                 :        176 :               pp_cxx_dot (pp);
    2324                 :            :           }
    2325                 :        469 :         dump_expr (pp, TREE_OPERAND (t, 1), flags & ~TFF_EXPR_IN_PARENS);
    2326                 :            :       }
    2327                 :        469 :       break;
    2328                 :            : 
    2329                 :         39 :     case ARRAY_REF:
    2330                 :         39 :       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
    2331                 :         39 :       pp_cxx_left_bracket (pp);
    2332                 :         39 :       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
    2333                 :         39 :       pp_cxx_right_bracket (pp);
    2334                 :         39 :       break;
    2335                 :            : 
    2336                 :          0 :     case UNARY_PLUS_EXPR:
    2337                 :          0 :       dump_unary_op (pp, "+", t, flags);
    2338                 :          0 :       break;
    2339                 :            : 
    2340                 :        899 :     case ADDR_EXPR:
    2341                 :        899 :       if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
    2342                 :        533 :           || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST
    2343                 :            :           /* An ADDR_EXPR can have reference type.  In that case, we
    2344                 :            :              shouldn't print the `&' doing so indicates to the user
    2345                 :            :              that the expression has pointer type.  */
    2346                 :       1412 :           || (TREE_TYPE (t)
    2347                 :        505 :               && TYPE_REF_P (TREE_TYPE (t))))
    2348                 :        386 :         dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
    2349                 :        513 :       else if (TREE_CODE (TREE_OPERAND (t, 0)) == LABEL_DECL)
    2350                 :         10 :         dump_unary_op (pp, "&&", t, flags);
    2351                 :            :       else
    2352                 :        503 :         dump_unary_op (pp, "&", t, flags);
    2353                 :            :       break;
    2354                 :            : 
    2355                 :        521 :     case INDIRECT_REF:
    2356                 :       1042 :       if (TREE_HAS_CONSTRUCTOR (t))
    2357                 :            :         {
    2358                 :          0 :           t = TREE_OPERAND (t, 0);
    2359                 :          0 :           gcc_assert (TREE_CODE (t) == CALL_EXPR);
    2360                 :          0 :           dump_expr (pp, CALL_EXPR_FN (t), flags | TFF_EXPR_IN_PARENS);
    2361                 :          0 :           dump_call_expr_args (pp, t, flags, true);
    2362                 :            :         }
    2363                 :            :       else
    2364                 :            :         {
    2365                 :        521 :           if (TREE_OPERAND (t,0) != NULL_TREE
    2366                 :        521 :               && TREE_TYPE (TREE_OPERAND (t, 0))
    2367                 :       1036 :               && NEXT_CODE (TREE_OPERAND (t, 0)) == REFERENCE_TYPE)
    2368                 :        390 :             dump_expr (pp, TREE_OPERAND (t, 0), flags);
    2369                 :            :           else
    2370                 :        131 :             dump_unary_op (pp, "*", t, flags);
    2371                 :            :         }
    2372                 :            :       break;
    2373                 :            : 
    2374                 :         15 :     case MEM_REF:
    2375                 :         15 :       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
    2376                 :         15 :           && integer_zerop (TREE_OPERAND (t, 1)))
    2377                 :          0 :         dump_expr (pp, TREE_OPERAND (TREE_OPERAND (t, 0), 0), flags);
    2378                 :            :       else
    2379                 :            :         {
    2380                 :         15 :           pp_cxx_star (pp);
    2381                 :         15 :           if (!integer_zerop (TREE_OPERAND (t, 1)))
    2382                 :            :             {
    2383                 :          0 :               pp_cxx_left_paren (pp);
    2384                 :          0 :               if (!integer_onep (TYPE_SIZE_UNIT
    2385                 :            :                                  (TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))))))
    2386                 :            :                 {
    2387                 :          0 :                   pp_cxx_left_paren (pp);
    2388                 :          0 :                   dump_type (pp, ptr_type_node, flags);
    2389                 :          0 :                   pp_cxx_right_paren (pp);
    2390                 :            :                 }
    2391                 :            :             }
    2392                 :         15 :           dump_expr (pp, TREE_OPERAND (t, 0), flags);
    2393                 :         15 :           if (!integer_zerop (TREE_OPERAND (t, 1)))
    2394                 :            :             {
    2395                 :          0 :               pp_cxx_ws_string (pp, "+");
    2396                 :          0 :               dump_expr (pp, fold_convert (ssizetype, TREE_OPERAND (t, 1)),
    2397                 :            :                          flags);
    2398                 :          0 :               pp_cxx_right_paren (pp);
    2399                 :            :             }
    2400                 :            :         }
    2401                 :            :       break;
    2402                 :            : 
    2403                 :         88 :     case NEGATE_EXPR:
    2404                 :         88 :     case BIT_NOT_EXPR:
    2405                 :         88 :     case TRUTH_NOT_EXPR:
    2406                 :         88 :     case PREDECREMENT_EXPR:
    2407                 :         88 :     case PREINCREMENT_EXPR:
    2408                 :         88 :       dump_unary_op (pp, OVL_OP_INFO (false, TREE_CODE (t))->name, t, flags);
    2409                 :         88 :       break;
    2410                 :            : 
    2411                 :          0 :     case POSTDECREMENT_EXPR:
    2412                 :          0 :     case POSTINCREMENT_EXPR:
    2413                 :          0 :       pp_cxx_left_paren (pp);
    2414                 :          0 :       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
    2415                 :          0 :       pp_cxx_ws_string (pp, OVL_OP_INFO (false, TREE_CODE (t))->name);
    2416                 :          0 :       pp_cxx_right_paren (pp);
    2417                 :          0 :       break;
    2418                 :            : 
    2419                 :        851 :     case NON_LVALUE_EXPR:
    2420                 :            :       /* FIXME: This is a KLUDGE workaround for a parsing problem.  There
    2421                 :            :          should be another level of INDIRECT_REF so that I don't have to do
    2422                 :            :          this.  */
    2423                 :        851 :       if (TREE_TYPE (t) != NULL_TREE && NEXT_CODE (t) == POINTER_TYPE)
    2424                 :            :         {
    2425                 :         12 :           tree next = TREE_TYPE (TREE_TYPE (t));
    2426                 :            : 
    2427                 :         12 :           while (TYPE_PTR_P (next))
    2428                 :          0 :             next = TREE_TYPE (next);
    2429                 :            : 
    2430                 :         12 :           if (TREE_CODE (next) == FUNCTION_TYPE)
    2431                 :            :             {
    2432                 :          0 :               if (flags & TFF_EXPR_IN_PARENS)
    2433                 :          0 :                 pp_cxx_left_paren (pp);
    2434                 :          0 :               pp_cxx_star (pp);
    2435                 :          0 :               dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
    2436                 :          0 :               if (flags & TFF_EXPR_IN_PARENS)
    2437                 :          0 :                 pp_cxx_right_paren (pp);
    2438                 :            :               break;
    2439                 :            :             }
    2440                 :            :           /* Else fall through.  */
    2441                 :            :         }
    2442                 :        851 :       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
    2443                 :        851 :       break;
    2444                 :            : 
    2445                 :       2506 :     CASE_CONVERT:
    2446                 :       2506 :     case IMPLICIT_CONV_EXPR:
    2447                 :       2506 :     case VIEW_CONVERT_EXPR:
    2448                 :       2506 :       {
    2449                 :       2506 :         tree op = TREE_OPERAND (t, 0);
    2450                 :       2506 :         tree ttype = TREE_TYPE (t);
    2451                 :       2506 :         tree optype = TREE_TYPE (op);
    2452                 :            : 
    2453                 :       2506 :         if (TREE_CODE (ttype) != TREE_CODE (optype)
    2454                 :        327 :             && INDIRECT_TYPE_P (ttype)
    2455                 :        272 :             && INDIRECT_TYPE_P (optype)
    2456                 :       2669 :             && same_type_p (TREE_TYPE (optype),
    2457                 :            :                             TREE_TYPE (ttype)))
    2458                 :            :           {
    2459                 :        112 :             if (TYPE_REF_P (ttype))
    2460                 :            :               {
    2461                 :         85 :                 STRIP_NOPS (op);
    2462                 :         85 :                 if (TREE_CODE (op) == ADDR_EXPR)
    2463                 :         81 :                   dump_expr (pp, TREE_OPERAND (op, 0), flags);
    2464                 :            :                 else
    2465                 :          4 :                   dump_unary_op (pp, "*", t, flags);
    2466                 :            :               }
    2467                 :            :             else
    2468                 :         27 :               dump_unary_op (pp, "&", t, flags);
    2469                 :            :           }
    2470                 :       2394 :         else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t)))
    2471                 :            :           {
    2472                 :            :             /* It is a cast, but we cannot tell whether it is a
    2473                 :            :                reinterpret or static cast. Use the C style notation.  */
    2474                 :        811 :             if (flags & TFF_EXPR_IN_PARENS)
    2475                 :        409 :               pp_cxx_left_paren (pp);
    2476                 :        811 :             pp_cxx_left_paren (pp);
    2477                 :        811 :             dump_type (pp, TREE_TYPE (t), flags);
    2478                 :        811 :             pp_cxx_right_paren (pp);
    2479                 :        811 :             dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS);
    2480                 :        811 :             if (flags & TFF_EXPR_IN_PARENS)
    2481                 :        409 :               pp_cxx_right_paren (pp);
    2482                 :            :           }
    2483                 :            :         else
    2484                 :            :           dump_expr (pp, op, flags);
    2485                 :            :         break;
    2486                 :            :       }
    2487                 :            : 
    2488                 :        322 :     case CONSTRUCTOR:
    2489                 :        322 :       if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
    2490                 :            :         {
    2491                 :          9 :           tree idx = build_ptrmemfunc_access_expr (t, pfn_identifier);
    2492                 :            : 
    2493                 :          9 :           if (integer_zerop (idx))
    2494                 :            :             {
    2495                 :            :               /* A NULL pointer-to-member constant.  */
    2496                 :          3 :               pp_cxx_left_paren (pp);
    2497                 :          3 :               pp_cxx_left_paren (pp);
    2498                 :          3 :               dump_type (pp, TREE_TYPE (t), flags);
    2499                 :          3 :               pp_cxx_right_paren (pp);
    2500                 :          3 :               pp_character (pp, '0');
    2501                 :          3 :               pp_cxx_right_paren (pp);
    2502                 :          3 :               break;
    2503                 :            :             }
    2504                 :          6 :           else if (tree_fits_shwi_p (idx))
    2505                 :            :             {
    2506                 :          6 :               tree virtuals;
    2507                 :          6 :               unsigned HOST_WIDE_INT n;
    2508                 :            : 
    2509                 :          6 :               t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
    2510                 :          6 :               t = TYPE_METHOD_BASETYPE (t);
    2511                 :          6 :               virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)));
    2512                 :            : 
    2513                 :          6 :               n = tree_to_shwi (idx);
    2514                 :            : 
    2515                 :            :               /* Map vtable index back one, to allow for the null pointer to
    2516                 :            :                  member.  */
    2517                 :          6 :               --n;
    2518                 :            : 
    2519                 :          6 :               while (n > 0 && virtuals)
    2520                 :            :                 {
    2521                 :          0 :                   --n;
    2522                 :          0 :                   virtuals = TREE_CHAIN (virtuals);
    2523                 :            :                 }
    2524                 :          6 :               if (virtuals)
    2525                 :            :                 {
    2526                 :          6 :                   dump_expr (pp, BV_FN (virtuals),
    2527                 :            :                              flags | TFF_EXPR_IN_PARENS);
    2528                 :          6 :                   break;
    2529                 :            :                 }
    2530                 :            :             }
    2531                 :            :         }
    2532                 :        313 :       if (TREE_TYPE (t) && LAMBDA_TYPE_P (TREE_TYPE (t)))
    2533                 :          7 :         pp_string (pp, "<lambda closure object>");
    2534                 :        313 :       if (TREE_TYPE (t) && EMPTY_CONSTRUCTOR_P (t))
    2535                 :            :         {
    2536                 :        180 :           dump_type (pp, TREE_TYPE (t), 0);
    2537                 :        180 :           pp_cxx_left_paren (pp);
    2538                 :        180 :           pp_cxx_right_paren (pp);
    2539                 :            :         }
    2540                 :            :       else
    2541                 :            :         {
    2542                 :        133 :           if (!BRACE_ENCLOSED_INITIALIZER_P (t))
    2543                 :         59 :             dump_type (pp, TREE_TYPE (t), 0);
    2544                 :        133 :           pp_cxx_left_brace (pp);
    2545                 :        133 :           dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t), flags);
    2546                 :        133 :           pp_cxx_right_brace (pp);
    2547                 :            :         }
    2548                 :            : 
    2549                 :            :       break;
    2550                 :            : 
    2551                 :         48 :     case OFFSET_REF:
    2552                 :         48 :       {
    2553                 :         48 :         tree ob = TREE_OPERAND (t, 0);
    2554                 :         48 :         if (is_dummy_object (ob))
    2555                 :            :           {
    2556                 :         41 :             t = TREE_OPERAND (t, 1);
    2557                 :         41 :             if (TREE_CODE (t) == FUNCTION_DECL)
    2558                 :            :               /* A::f */
    2559                 :          0 :               dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS);
    2560                 :         41 :             else if (BASELINK_P (t))
    2561                 :         74 :               dump_expr (pp, OVL_FIRST (BASELINK_FUNCTIONS (t)),
    2562                 :            :                          flags | TFF_EXPR_IN_PARENS);
    2563                 :            :             else
    2564                 :          4 :               dump_decl (pp, t, flags);
    2565                 :            :           }
    2566                 :            :         else
    2567                 :            :           {
    2568                 :          7 :             if (INDIRECT_REF_P (ob))
    2569                 :            :               {
    2570                 :          7 :                 dump_expr (pp, TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
    2571                 :          7 :                 pp_cxx_arrow (pp);
    2572                 :          7 :                 pp_cxx_star (pp);
    2573                 :            :               }
    2574                 :            :             else
    2575                 :            :               {
    2576                 :          0 :                 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS);
    2577                 :          0 :                 pp_cxx_dot (pp);
    2578                 :          0 :                 pp_cxx_star (pp);
    2579                 :            :               }
    2580                 :          7 :             dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
    2581                 :            :           }
    2582                 :            :         break;
    2583                 :            :       }
    2584                 :            : 
    2585                 :       1108 :     case TEMPLATE_PARM_INDEX:
    2586                 :       1108 :       dump_decl (pp, TEMPLATE_PARM_DECL (t), flags & ~TFF_DECL_SPECIFIERS);
    2587                 :       1108 :       break;
    2588                 :            : 
    2589                 :        115 :     case CAST_EXPR:
    2590                 :        115 :       if (TREE_OPERAND (t, 0) == NULL_TREE
    2591                 :        115 :           || TREE_CHAIN (TREE_OPERAND (t, 0)))
    2592                 :            :         {
    2593                 :         73 :           dump_type (pp, TREE_TYPE (t), flags);
    2594                 :         73 :           pp_cxx_left_paren (pp);
    2595                 :         73 :           dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
    2596                 :         73 :           pp_cxx_right_paren (pp);
    2597                 :            :         }
    2598                 :            :       else
    2599                 :            :         {
    2600                 :         42 :           pp_cxx_left_paren (pp);
    2601                 :         42 :           dump_type (pp, TREE_TYPE (t), flags);
    2602                 :         42 :           pp_cxx_right_paren (pp);
    2603                 :         42 :           pp_cxx_left_paren (pp);
    2604                 :         42 :           dump_expr_list (pp, TREE_OPERAND (t, 0), flags);
    2605                 :         42 :           pp_cxx_right_paren (pp);
    2606                 :            :         }
    2607                 :            :       break;
    2608                 :            : 
    2609                 :         36 :     case STATIC_CAST_EXPR:
    2610                 :         36 :       pp_cxx_ws_string (pp, "static_cast");
    2611                 :         36 :       goto cast;
    2612                 :          0 :     case REINTERPRET_CAST_EXPR:
    2613                 :          0 :       pp_cxx_ws_string (pp, "reinterpret_cast");
    2614                 :          0 :       goto cast;
    2615                 :          4 :     case CONST_CAST_EXPR:
    2616                 :          4 :       pp_cxx_ws_string (pp, "const_cast");
    2617                 :          4 :       goto cast;
    2618                 :          0 :     case DYNAMIC_CAST_EXPR:
    2619                 :          0 :       pp_cxx_ws_string (pp, "dynamic_cast");
    2620                 :         40 :     cast:
    2621                 :         40 :       pp_cxx_begin_template_argument_list (pp);
    2622                 :         40 :       dump_type (pp, TREE_TYPE (t), flags);
    2623                 :         40 :       pp_cxx_end_template_argument_list (pp);
    2624                 :         40 :       pp_cxx_left_paren (pp);
    2625                 :         40 :       dump_expr (pp, TREE_OPERAND (t, 0), flags);
    2626                 :         40 :       pp_cxx_right_paren (pp);
    2627                 :         40 :       break;
    2628                 :            : 
    2629                 :          4 :     case ARROW_EXPR:
    2630                 :          4 :       dump_expr (pp, TREE_OPERAND (t, 0), flags);
    2631                 :          4 :       pp_cxx_arrow (pp);
    2632                 :          4 :       break;
    2633                 :            : 
    2634                 :         80 :     case SIZEOF_EXPR:
    2635                 :         80 :     case ALIGNOF_EXPR:
    2636                 :         80 :       if (TREE_CODE (t) == SIZEOF_EXPR)
    2637                 :         71 :         pp_cxx_ws_string (pp, "sizeof");
    2638                 :            :       else
    2639                 :            :         {
    2640                 :          9 :           gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR);
    2641                 :          9 :           pp_cxx_ws_string (pp, "__alignof__");
    2642                 :            :         }
    2643                 :         80 :       op = TREE_OPERAND (t, 0);
    2644                 :         80 :       if (PACK_EXPANSION_P (op))
    2645                 :            :         {
    2646                 :         37 :           pp_string (pp, "...");
    2647                 :         52 :           op = PACK_EXPANSION_PATTERN (op);
    2648                 :            :         }
    2649                 :         80 :       pp_cxx_whitespace (pp);
    2650                 :         80 :       pp_cxx_left_paren (pp);
    2651                 :         80 :       if (TREE_CODE (t) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t))
    2652                 :         14 :         dump_type (pp, TREE_TYPE (op), flags);
    2653                 :         66 :       else if (TYPE_P (TREE_OPERAND (t, 0)))
    2654                 :         29 :         dump_type (pp, op, flags);
    2655                 :            :       else
    2656                 :         37 :         dump_expr (pp, op, flags);
    2657                 :         80 :       pp_cxx_right_paren (pp);
    2658                 :         80 :       break;
    2659                 :            : 
    2660                 :          0 :     case AT_ENCODE_EXPR:
    2661                 :          0 :       pp_cxx_ws_string (pp, "@encode");
    2662                 :          0 :       pp_cxx_whitespace (pp);
    2663                 :          0 :       pp_cxx_left_paren (pp);
    2664                 :          0 :       dump_type (pp, TREE_OPERAND (t, 0), flags);
    2665                 :          0 :       pp_cxx_right_paren (pp);
    2666                 :          0 :       break;
    2667                 :            : 
    2668                 :          6 :     case NOEXCEPT_EXPR:
    2669                 :          6 :       pp_cxx_ws_string (pp, "noexcept");
    2670                 :          6 :       pp_cxx_whitespace (pp);
    2671                 :          6 :       pp_cxx_left_paren (pp);
    2672                 :          6 :       dump_expr (pp, TREE_OPERAND (t, 0), flags);
    2673                 :          6 :       pp_cxx_right_paren (pp);
    2674                 :          6 :       break;
    2675                 :            : 
    2676                 :          0 :     case REALPART_EXPR:
    2677                 :          0 :     case IMAGPART_EXPR:
    2678                 :          0 :       pp_cxx_ws_string (pp, OVL_OP_INFO (false, TREE_CODE (t))->name);
    2679                 :          0 :       pp_cxx_whitespace (pp);
    2680                 :          0 :       dump_expr (pp, TREE_OPERAND (t, 0), flags);
    2681                 :          0 :       break;
    2682                 :            : 
    2683                 :          0 :     case DEFERRED_PARSE:
    2684                 :          0 :       pp_string (pp, M_("<unparsed>"));
    2685                 :          0 :       break;
    2686                 :            : 
    2687                 :          0 :     case TRY_CATCH_EXPR:
    2688                 :          0 :     case CLEANUP_POINT_EXPR:
    2689                 :          0 :       dump_expr (pp, TREE_OPERAND (t, 0), flags);
    2690                 :          0 :       break;
    2691                 :            : 
    2692                 :          0 :     case PSEUDO_DTOR_EXPR:
    2693                 :          0 :       dump_expr (pp, TREE_OPERAND (t, 0), flags);
    2694                 :          0 :       pp_cxx_dot (pp);
    2695                 :          0 :       if (TREE_OPERAND (t, 1))
    2696                 :            :         {
    2697                 :          0 :           dump_type (pp, TREE_OPERAND (t, 1), flags);
    2698                 :          0 :           pp_cxx_colon_colon (pp);
    2699                 :            :         }
    2700                 :          0 :       pp_cxx_complement (pp);
    2701                 :          0 :       dump_type (pp, TREE_OPERAND (t, 2), flags);
    2702                 :          0 :       break;
    2703                 :            : 
    2704                 :        499 :     case TEMPLATE_ID_EXPR:
    2705                 :        499 :       dump_decl (pp, t, flags);
    2706                 :        499 :       break;
    2707                 :            : 
    2708                 :         24 :     case BIND_EXPR:
    2709                 :         24 :     case STMT_EXPR:
    2710                 :         24 :     case EXPR_STMT:
    2711                 :         24 :     case STATEMENT_LIST:
    2712                 :            :       /* We don't yet have a way of dumping statements in a
    2713                 :            :          human-readable format.  */
    2714                 :         24 :       pp_string (pp, "({...})");
    2715                 :         24 :       break;
    2716                 :            : 
    2717                 :          0 :     case LOOP_EXPR:
    2718                 :          0 :       pp_string (pp, "while (1) { ");
    2719                 :          0 :       dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
    2720                 :          0 :       pp_cxx_right_brace (pp);
    2721                 :          0 :       break;
    2722                 :            : 
    2723                 :          0 :     case EXIT_EXPR:
    2724                 :          0 :       pp_string (pp, "if (");
    2725                 :          0 :       dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
    2726                 :          0 :       pp_string (pp, ") break; ");
    2727                 :          0 :       break;
    2728                 :            : 
    2729                 :        127 :     case BASELINK:
    2730                 :        127 :       dump_expr (pp, BASELINK_FUNCTIONS (t), flags & ~TFF_EXPR_IN_PARENS);
    2731                 :        127 :       break;
    2732                 :            : 
    2733                 :          1 :     case EMPTY_CLASS_EXPR:
    2734                 :          1 :       dump_type (pp, TREE_TYPE (t), flags);
    2735                 :          1 :       pp_cxx_left_paren (pp);
    2736                 :          1 :       pp_cxx_right_paren (pp);
    2737                 :          1 :       break;
    2738                 :            : 
    2739                 :        103 :     case NON_DEPENDENT_EXPR:
    2740                 :        103 :       dump_expr (pp, TREE_OPERAND (t, 0), flags);
    2741                 :        103 :       break;
    2742                 :            : 
    2743                 :          0 :     case ARGUMENT_PACK_SELECT:
    2744                 :          0 :       dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t), flags);
    2745                 :          0 :       break;
    2746                 :            : 
    2747                 :        104 :     case RECORD_TYPE:
    2748                 :        104 :     case UNION_TYPE:
    2749                 :        104 :     case ENUMERAL_TYPE:
    2750                 :        104 :     case REAL_TYPE:
    2751                 :        104 :     case VOID_TYPE:
    2752                 :        104 :     case BOOLEAN_TYPE:
    2753                 :        104 :     case INTEGER_TYPE:
    2754                 :        104 :     case COMPLEX_TYPE:
    2755                 :        104 :     case VECTOR_TYPE:
    2756                 :        104 :     case DECLTYPE_TYPE:
    2757                 :        104 :       pp_type_specifier_seq (pp, t);
    2758                 :        104 :       break;
    2759                 :            : 
    2760                 :          4 :     case TYPENAME_TYPE:
    2761                 :            :       /* We get here when we want to print a dependent type as an
    2762                 :            :          id-expression, without any disambiguator decoration.  */
    2763                 :          4 :       pp->id_expression (t);
    2764                 :          4 :       break;
    2765                 :            : 
    2766                 :         49 :     case TEMPLATE_TYPE_PARM:
    2767                 :         49 :     case TEMPLATE_TEMPLATE_PARM:
    2768                 :         49 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
    2769                 :         49 :       dump_type (pp, t, flags);
    2770                 :         49 :       break;
    2771                 :            : 
    2772                 :         75 :     case TRAIT_EXPR:
    2773                 :         75 :       pp_cxx_trait_expression (pp, t);
    2774                 :         75 :       break;
    2775                 :            : 
    2776                 :          4 :     case VA_ARG_EXPR:
    2777                 :          4 :       pp_cxx_va_arg_expression (pp, t);
    2778                 :          4 :       break;
    2779                 :            : 
    2780                 :         20 :     case OFFSETOF_EXPR:
    2781                 :         20 :       pp_cxx_offsetof_expression (pp, t);
    2782                 :         20 :       break;
    2783                 :            : 
    2784                 :          0 :     case ADDRESSOF_EXPR:
    2785                 :          0 :       pp_cxx_addressof_expression (pp, t);
    2786                 :          0 :       break;
    2787                 :            : 
    2788                 :        657 :     case SCOPE_REF:
    2789                 :        657 :       dump_decl (pp, t, flags);
    2790                 :        657 :       break;
    2791                 :            : 
    2792                 :        162 :     case EXPR_PACK_EXPANSION:
    2793                 :        162 :     case UNARY_LEFT_FOLD_EXPR:
    2794                 :        162 :     case UNARY_RIGHT_FOLD_EXPR:
    2795                 :        162 :     case BINARY_LEFT_FOLD_EXPR:
    2796                 :        162 :     case BINARY_RIGHT_FOLD_EXPR:
    2797                 :        162 :     case TYPEID_EXPR:
    2798                 :        162 :     case MEMBER_REF:
    2799                 :        162 :     case DOTSTAR_EXPR:
    2800                 :        162 :     case NEW_EXPR:
    2801                 :        162 :     case VEC_NEW_EXPR:
    2802                 :        162 :     case DELETE_EXPR:
    2803                 :        162 :     case VEC_DELETE_EXPR:
    2804                 :        162 :     case MODOP_EXPR:
    2805                 :        162 :     case ABS_EXPR:
    2806                 :        162 :     case ABSU_EXPR:
    2807                 :        162 :     case CONJ_EXPR:
    2808                 :        162 :     case VECTOR_CST:
    2809                 :        162 :     case FIXED_CST:
    2810                 :        162 :     case UNORDERED_EXPR:
    2811                 :        162 :     case ORDERED_EXPR:
    2812                 :        162 :     case UNLT_EXPR:
    2813                 :        162 :     case UNLE_EXPR:
    2814                 :        162 :     case UNGT_EXPR:
    2815                 :        162 :     case UNGE_EXPR:
    2816                 :        162 :     case UNEQ_EXPR:
    2817                 :        162 :     case LTGT_EXPR:
    2818                 :        162 :     case COMPLEX_EXPR:
    2819                 :        162 :     case BIT_FIELD_REF:
    2820                 :        162 :     case FIX_TRUNC_EXPR:
    2821                 :        162 :     case FLOAT_EXPR:
    2822                 :        162 :       pp->expression (t);
    2823                 :        162 :       break;
    2824                 :            : 
    2825                 :          0 :     case TRUTH_AND_EXPR:
    2826                 :          0 :     case TRUTH_OR_EXPR:
    2827                 :          0 :     case TRUTH_XOR_EXPR:
    2828                 :          0 :       if (flags & TFF_EXPR_IN_PARENS)
    2829                 :          0 :         pp_cxx_left_paren (pp);
    2830                 :          0 :       pp->expression (t);
    2831                 :          0 :       if (flags & TFF_EXPR_IN_PARENS)
    2832                 :          0 :         pp_cxx_right_paren (pp);
    2833                 :            :       break;
    2834                 :            : 
    2835                 :          9 :     case OBJ_TYPE_REF:
    2836                 :          9 :       dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
    2837                 :          9 :       break;
    2838                 :            : 
    2839                 :         14 :     case LAMBDA_EXPR:
    2840                 :         14 :       pp_string (pp, M_("<lambda>"));
    2841                 :         14 :       break;
    2842                 :            : 
    2843                 :          0 :     case PAREN_EXPR:
    2844                 :          0 :       pp_cxx_left_paren (pp);
    2845                 :          0 :       dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
    2846                 :          0 :       pp_cxx_right_paren (pp);
    2847                 :          0 :       break;
    2848                 :            : 
    2849                 :          0 :     case REQUIRES_EXPR:
    2850                 :          0 :       pp_cxx_requires_expr (cxx_pp, t);
    2851                 :          0 :       break;
    2852                 :            : 
    2853                 :          0 :     case SIMPLE_REQ:
    2854                 :          0 :       pp_cxx_simple_requirement (cxx_pp, t);
    2855                 :          0 :       break;
    2856                 :            : 
    2857                 :          0 :     case TYPE_REQ:
    2858                 :          0 :       pp_cxx_type_requirement (cxx_pp, t);
    2859                 :          0 :       break;
    2860                 :            : 
    2861                 :          0 :     case COMPOUND_REQ:
    2862                 :          0 :       pp_cxx_compound_requirement (cxx_pp, t);
    2863                 :          0 :       break;
    2864                 :            : 
    2865                 :          0 :     case NESTED_REQ:
    2866                 :          0 :       pp_cxx_nested_requirement (cxx_pp, t);
    2867                 :          0 :       break;
    2868                 :            : 
    2869                 :         56 :     case ATOMIC_CONSTR:
    2870                 :         56 :     case CHECK_CONSTR:
    2871                 :         56 :     case CONJ_CONSTR:
    2872                 :         56 :     case DISJ_CONSTR:
    2873                 :         56 :       {
    2874                 :         56 :         pp_cxx_constraint (cxx_pp, t);
    2875                 :         56 :         break;
    2876                 :            :       }
    2877                 :            : 
    2878                 :         13 :     case PLACEHOLDER_EXPR:
    2879                 :         13 :       pp_string (pp, M_("*this"));
    2880                 :         13 :       break;
    2881                 :            : 
    2882                 :          9 :     case TREE_LIST:
    2883                 :          9 :       dump_expr_list (pp, t, flags);
    2884                 :          9 :       break;
    2885                 :            : 
    2886                 :            :       /*  This list is incomplete, but should suffice for now.
    2887                 :            :           It is very important that `sorry' does not call
    2888                 :            :           `report_error_function'.  That could cause an infinite loop.  */
    2889                 :          3 :     default:
    2890                 :          3 :       pp_unsupported_tree (pp, t);
    2891                 :            :       /* Fall through.  */
    2892                 :         46 :     case ERROR_MARK:
    2893                 :         46 :       pp_string (pp, M_("<expression error>"));
    2894                 :         46 :       break;
    2895                 :            :     }
    2896                 :            : }
    2897                 :            : 
    2898                 :            : static void
    2899                 :       1061 : dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
    2900                 :            :                 int flags)
    2901                 :            : {
    2902                 :       1061 :   pp_cxx_left_paren (pp);
    2903                 :       1061 :   dump_expr (pp, TREE_OPERAND (t, 0), flags | TFF_EXPR_IN_PARENS);
    2904                 :       1061 :   pp_cxx_whitespace (pp);
    2905                 :       1061 :   if (opstring)
    2906                 :       1055 :     pp_cxx_ws_string (pp, opstring);
    2907                 :            :   else
    2908                 :          6 :     pp_string (pp, M_("<unknown operator>"));
    2909                 :       1061 :   pp_cxx_whitespace (pp);
    2910                 :       1061 :   dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
    2911                 :       1061 :   pp_cxx_right_paren (pp);
    2912                 :       1061 : }
    2913                 :            : 
    2914                 :            : static void
    2915                 :        763 : dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
    2916                 :            : {
    2917                 :        763 :   if (flags & TFF_EXPR_IN_PARENS)
    2918                 :        533 :     pp_cxx_left_paren (pp);
    2919                 :        763 :   pp_cxx_ws_string (pp, opstring);
    2920                 :        763 :   dump_expr (pp, TREE_OPERAND (t, 0), flags & ~TFF_EXPR_IN_PARENS);
    2921                 :        763 :   if (flags & TFF_EXPR_IN_PARENS)
    2922                 :        533 :     pp_cxx_right_paren (pp);
    2923                 :        763 : }
    2924                 :            : 
    2925                 :            : static void
    2926                 :   31714000 : reinit_cxx_pp (void)
    2927                 :            : {
    2928                 :          0 :   pp_clear_output_area (cxx_pp);
    2929                 :   31714000 :   cxx_pp->padding = pp_none;
    2930                 :   31714000 :   pp_indentation (cxx_pp) = 0;
    2931                 :   31714000 :   pp_needs_newline (cxx_pp) = false;
    2932                 :   31714000 :   cxx_pp->enclosing_scope = current_function_decl;
    2933                 :       2386 : }
    2934                 :            : 
    2935                 :            : /* Same as pp_formatted_text, except the return string is a separate
    2936                 :            :    copy and has a GGC storage duration, e.g. an indefinite lifetime.  */
    2937                 :            : 
    2938                 :            : inline const char *
    2939                 :   31714500 : pp_ggc_formatted_text (pretty_printer *pp)
    2940                 :            : {
    2941                 :   10154900 :   return ggc_strdup (pp_formatted_text (pp));
    2942                 :            : }
    2943                 :            : 
    2944                 :            : /* Exported interface to stringifying types, exprs and decls under TFF_*
    2945                 :            :    control.  */
    2946                 :            : 
    2947                 :            : const char *
    2948                 :        284 : type_as_string (tree typ, int flags)
    2949                 :            : {
    2950                 :        284 :   reinit_cxx_pp ();
    2951                 :        284 :   pp_translate_identifiers (cxx_pp) = false;
    2952                 :        284 :   dump_type (cxx_pp, typ, flags);
    2953                 :        284 :   return pp_ggc_formatted_text (cxx_pp);
    2954                 :            : }
    2955                 :            : 
    2956                 :            : const char *
    2957                 :          0 : type_as_string_translate (tree typ, int flags)
    2958                 :            : {
    2959                 :          0 :   reinit_cxx_pp ();
    2960                 :          0 :   dump_type (cxx_pp, typ, flags);
    2961                 :          0 :   return pp_ggc_formatted_text (cxx_pp);
    2962                 :            : }
    2963                 :            : 
    2964                 :            : const char *
    2965                 :       1255 : expr_as_string (tree decl, int flags)
    2966                 :            : {
    2967                 :       1255 :   reinit_cxx_pp ();
    2968                 :       1255 :   pp_translate_identifiers (cxx_pp) = false;
    2969                 :       1255 :   dump_expr (cxx_pp, decl, flags);
    2970                 :       1255 :   return pp_ggc_formatted_text (cxx_pp);
    2971                 :            : }
    2972                 :            : 
    2973                 :            : /* Wrap decl_as_string with options appropriate for dwarf.  */
    2974                 :            : 
    2975                 :            : const char *
    2976                 :    9981100 : decl_as_dwarf_string (tree decl, int flags)
    2977                 :            : {
    2978                 :    9981100 :   const char *name;
    2979                 :            :   /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
    2980                 :            :      here will be adequate to get the desired behavior.  */
    2981                 :    9981100 :   cxx_pp->flags |= pp_c_flag_gnu_v3;
    2982                 :    9981100 :   name = decl_as_string (decl, flags);
    2983                 :            :   /* Subsequent calls to the pretty printer shouldn't use this style.  */
    2984                 :    9981100 :   cxx_pp->flags &= ~pp_c_flag_gnu_v3;
    2985                 :    9981100 :   return name;
    2986                 :            : }
    2987                 :            : 
    2988                 :            : const char *
    2989                 :   10006800 : decl_as_string (tree decl, int flags)
    2990                 :            : {
    2991                 :   10006800 :   reinit_cxx_pp ();
    2992                 :   10006800 :   pp_translate_identifiers (cxx_pp) = false;
    2993                 :   10006800 :   dump_decl (cxx_pp, decl, flags);
    2994                 :   10006800 :   return pp_ggc_formatted_text (cxx_pp);
    2995                 :            : }
    2996                 :            : 
    2997                 :            : const char *
    2998                 :      16918 : decl_as_string_translate (tree decl, int flags)
    2999                 :            : {
    3000                 :      16918 :   reinit_cxx_pp ();
    3001                 :      16918 :   dump_decl (cxx_pp, decl, flags);
    3002                 :      16918 :   return pp_ggc_formatted_text (cxx_pp);
    3003                 :            : }
    3004                 :            : 
    3005                 :            : /* Wrap lang_decl_name with options appropriate for dwarf.  */
    3006                 :            : 
    3007                 :            : const char *
    3008                 :   21518300 : lang_decl_dwarf_name (tree decl, int v, bool translate)
    3009                 :            : {
    3010                 :   21518300 :   const char *name;
    3011                 :            :   /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
    3012                 :            :      here will be adequate to get the desired behavior.  */
    3013                 :   21518300 :   cxx_pp->flags |= pp_c_flag_gnu_v3;
    3014                 :   21518300 :   name = lang_decl_name (decl, v, translate);
    3015                 :            :   /* Subsequent calls to the pretty printer shouldn't use this style.  */
    3016                 :   21518300 :   cxx_pp->flags &= ~pp_c_flag_gnu_v3;
    3017                 :   21518300 :   return name;
    3018                 :            : }
    3019                 :            : 
    3020                 :            : /* Generate the three forms of printable names for cxx_printable_name.  */
    3021                 :            : 
    3022                 :            : const char *
    3023                 :   21599900 : lang_decl_name (tree decl, int v, bool translate)
    3024                 :            : {
    3025                 :   21599900 :   if (v >= 2)
    3026                 :      42583 :     return (translate
    3027                 :      42583 :             ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS)
    3028                 :      25665 :             : decl_as_string (decl, TFF_DECL_SPECIFIERS));
    3029                 :            : 
    3030                 :   21557300 :   reinit_cxx_pp ();
    3031                 :   21557300 :   pp_translate_identifiers (cxx_pp) = translate;
    3032                 :   21557300 :   if (v == 1
    3033                 :   21615300 :       && (DECL_CLASS_SCOPE_P (decl)
    3034                 :      37553 :           || (DECL_NAMESPACE_SCOPE_P (decl)
    3035                 :      36616 :               && CP_DECL_CONTEXT (decl) != global_namespace)))
    3036                 :            :     {
    3037                 :      29238 :       dump_type (cxx_pp, CP_DECL_CONTEXT (decl), TFF_PLAIN_IDENTIFIER);
    3038                 :      29238 :       pp_cxx_colon_colon (cxx_pp);
    3039                 :            :     }
    3040                 :            : 
    3041                 :   21557300 :   if (TREE_CODE (decl) == FUNCTION_DECL)
    3042                 :    7884800 :     dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER);
    3043                 :   13672500 :   else if ((DECL_NAME (decl) == NULL_TREE)
    3044                 :   13672500 :            && TREE_CODE (decl) == NAMESPACE_DECL)
    3045                 :         24 :     dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER | TFF_UNQUALIFIED_NAME);
    3046                 :            :   else
    3047                 :   13672500 :     dump_decl (cxx_pp, DECL_NAME (decl), TFF_PLAIN_IDENTIFIER);
    3048                 :            : 
    3049                 :   21557300 :   return pp_ggc_formatted_text (cxx_pp);
    3050                 :            : }
    3051                 :            : 
    3052                 :            : /* Return the location of a tree passed to %+ formats.  */
    3053                 :            : 
    3054                 :            : location_t
    3055                 :     598601 : location_of (tree t)
    3056                 :            : {
    3057                 :     598601 :   if (TYPE_P (t))
    3058                 :            :     {
    3059                 :       2544 :       t = TYPE_MAIN_DECL (t);
    3060                 :       2544 :       if (t == NULL_TREE)
    3061                 :         25 :         return input_location;
    3062                 :            :     }
    3063                 :     596057 :   else if (TREE_CODE (t) == OVERLOAD)
    3064                 :     598576 :     t = OVL_FIRST (t);
    3065                 :            : 
    3066                 :     598576 :   if (DECL_P (t))
    3067                 :     464997 :     return DECL_SOURCE_LOCATION (t);
    3068                 :     133579 :   if (TREE_CODE (t) == DEFERRED_PARSE)
    3069                 :         15 :     return defparse_location (t);
    3070                 :     133564 :   return cp_expr_loc_or_input_loc (t);
    3071                 :            : }
    3072                 :            : 
    3073                 :            : /* Now the interfaces from error et al to dump_type et al. Each takes an
    3074                 :            :    on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
    3075                 :            :    function.  */
    3076                 :            : 
    3077                 :            : static const char *
    3078                 :      53316 : decl_to_string (tree decl, int verbose)
    3079                 :            : {
    3080                 :      53316 :   int flags = 0;
    3081                 :            : 
    3082                 :      53316 :   if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == RECORD_TYPE
    3083                 :      50488 :       || TREE_CODE (decl) == UNION_TYPE || TREE_CODE (decl) == ENUMERAL_TYPE)
    3084                 :       2869 :     flags = TFF_CLASS_KEY_OR_ENUM;
    3085                 :      53316 :   if (verbose)
    3086                 :      23133 :     flags |= TFF_DECL_SPECIFIERS;
    3087                 :      30183 :   else if (TREE_CODE (decl) == FUNCTION_DECL)
    3088                 :      12405 :     flags |= TFF_DECL_SPECIFIERS | TFF_RETURN_TYPE;
    3089                 :      53316 :   flags |= TFF_TEMPLATE_HEADER;
    3090                 :            : 
    3091                 :      53316 :   reinit_cxx_pp ();
    3092                 :      53316 :   dump_decl (cxx_pp, decl, flags);
    3093                 :      53316 :   return pp_ggc_formatted_text (cxx_pp);
    3094                 :            : }
    3095                 :            : 
    3096                 :            : const char *
    3097                 :      21139 : expr_to_string (tree decl)
    3098                 :            : {
    3099                 :      21139 :   reinit_cxx_pp ();
    3100                 :      21139 :   dump_expr (cxx_pp, decl, 0);
    3101                 :      21139 :   return pp_ggc_formatted_text (cxx_pp);
    3102                 :            : }
    3103                 :            : 
    3104                 :            : static const char *
    3105                 :        409 : fndecl_to_string (tree fndecl, int verbose)
    3106                 :            : {
    3107                 :        409 :   int flags;
    3108                 :            : 
    3109                 :        409 :   flags = TFF_EXCEPTION_SPECIFICATION | TFF_DECL_SPECIFIERS
    3110                 :            :     | TFF_TEMPLATE_HEADER;
    3111                 :        409 :   if (verbose)
    3112                 :        102 :     flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS;
    3113                 :        409 :   reinit_cxx_pp ();
    3114                 :        409 :   dump_decl (cxx_pp, fndecl, flags);
    3115                 :        409 :   return pp_ggc_formatted_text (cxx_pp);
    3116                 :            : }
    3117                 :            : 
    3118                 :            : 
    3119                 :            : static const char *
    3120                 :          0 : code_to_string (enum tree_code c)
    3121                 :            : {
    3122                 :          0 :   return get_tree_code_name (c);
    3123                 :            : }
    3124                 :            : 
    3125                 :            : const char *
    3126                 :       7462 : language_to_string (enum languages c)
    3127                 :            : {
    3128                 :       7462 :   switch (c)
    3129                 :            :     {
    3130                 :            :     case lang_c:
    3131                 :            :       return "C";
    3132                 :            : 
    3133                 :          8 :     case lang_cplusplus:
    3134                 :          8 :       return "C++";
    3135                 :            : 
    3136                 :          0 :     default:
    3137                 :          0 :       gcc_unreachable ();
    3138                 :            :     }
    3139                 :            :   return NULL;
    3140                 :            : }
    3141                 :            : 
    3142                 :            : /* Return the proper printed version of a parameter to a C++ function.  */
    3143                 :            : 
    3144                 :            : static const char *
    3145                 :       1589 : parm_to_string (int p)
    3146                 :            : {
    3147                 :       1589 :   reinit_cxx_pp ();
    3148                 :       1589 :   if (p < 0)
    3149                 :          4 :     pp_string (cxx_pp, "'this'");
    3150                 :            :   else
    3151                 :       1585 :     pp_decimal_int (cxx_pp, p + 1);
    3152                 :       1589 :   return pp_ggc_formatted_text (cxx_pp);
    3153                 :            : }
    3154                 :            : 
    3155                 :            : static const char *
    3156                 :        240 : op_to_string (bool assop, enum tree_code p)
    3157                 :            : {
    3158                 :        240 :   tree id = ovl_op_identifier (assop, p);
    3159                 :        478 :   return id ? IDENTIFIER_POINTER (id) : M_("<unknown>");
    3160                 :            : }
    3161                 :            : 
    3162                 :            : /* Return a GC-allocated representation of type TYP, with verbosity VERBOSE.
    3163                 :            : 
    3164                 :            :    If QUOTE is non-NULL and if *QUOTE is true, then quotes are added to the
    3165                 :            :    string in appropriate places, and *QUOTE is written to with false
    3166                 :            :    to suppress pp_format's trailing close quote so that e.g.
    3167                 :            :      foo_typedef {aka underlying_foo} {enum}
    3168                 :            :    can be printed by "%qT" as:
    3169                 :            :      `foo_typedef' {aka `underlying_foo'} {enum}
    3170                 :            :    rather than:
    3171                 :            :      `foo_typedef {aka underlying_foo} {enum}'
    3172                 :            :    When adding such quotes, if POSTPROCESSED is true (for handling %H and %I)
    3173                 :            :    then a leading open quote will be added, whereas if POSTPROCESSED is false
    3174                 :            :    (for handling %T) then any leading quote has already been added by
    3175                 :            :    pp_format, or is not needed due to QUOTE being NULL (for template arguments
    3176                 :            :    within %H and %I).
    3177                 :            : 
    3178                 :            :    SHOW_COLOR is used to determine the colorization of any quotes that
    3179                 :            :    are added.  */
    3180                 :            : 
    3181                 :            : static const char *
    3182                 :      51663 : type_to_string (tree typ, int verbose, bool postprocessed, bool *quote,
    3183                 :            :                 bool show_color)
    3184                 :            : {
    3185                 :      51663 :   int flags = 0;
    3186                 :      51663 :   if (verbose)
    3187                 :       8649 :     flags |= TFF_CLASS_KEY_OR_ENUM;
    3188                 :      51663 :   flags |= TFF_TEMPLATE_HEADER;
    3189                 :            : 
    3190                 :      51663 :   reinit_cxx_pp ();
    3191                 :            : 
    3192                 :      51663 :   if (postprocessed && quote && *quote)
    3193                 :      18894 :     pp_begin_quote (cxx_pp, show_color);
    3194                 :            : 
    3195                 :      51663 :   struct obstack *ob = pp_buffer (cxx_pp)->obstack;
    3196                 :      51663 :   int type_start, type_len;
    3197                 :      51663 :   type_start = obstack_object_size (ob);
    3198                 :            : 
    3199                 :      51663 :   dump_type (cxx_pp, typ, flags);
    3200                 :            : 
    3201                 :            :   /* Remember the end of the initial dump.  */
    3202                 :      51663 :   type_len = obstack_object_size (ob) - type_start;
    3203                 :            : 
    3204                 :            :   /* If we're printing a type that involves typedefs, also print the
    3205                 :            :      stripped version.  But sometimes the stripped version looks
    3206                 :            :      exactly the same, so we don't want it after all.  To avoid printing
    3207                 :            :      it in that case, we play ugly obstack games.  */
    3208                 :      51654 :   if (typ && TYPE_P (typ) && typ != TYPE_CANONICAL (typ)
    3209                 :      56342 :       && !uses_template_parms (typ))
    3210                 :            :     {
    3211                 :       3415 :       int aka_start, aka_len; char *p;
    3212                 :       3415 :       tree aka = strip_typedefs (typ, NULL, STF_USER_VISIBLE);
    3213                 :       3415 :       if (quote && *quote)
    3214                 :       3267 :         pp_end_quote (cxx_pp, show_color);
    3215                 :       3415 :       pp_string (cxx_pp, " {aka");
    3216                 :       3415 :       pp_cxx_whitespace (cxx_pp);
    3217                 :       3415 :       if (quote && *quote)
    3218                 :       3267 :         pp_begin_quote (cxx_pp, show_color);
    3219                 :            :       /* And remember the start of the aka dump.  */
    3220                 :       3415 :       aka_start = obstack_object_size (ob);
    3221                 :       3415 :       dump_type (cxx_pp, aka, flags);
    3222                 :       3415 :       aka_len = obstack_object_size (ob) - aka_start;
    3223                 :       3415 :       if (quote && *quote)
    3224                 :       3267 :         pp_end_quote (cxx_pp, show_color);
    3225                 :       3415 :       pp_right_brace (cxx_pp);
    3226                 :       3415 :       p = (char*)obstack_base (ob);
    3227                 :            :       /* If they are identical, cut off the aka by unwinding the obstack.  */
    3228                 :       3415 :       if (type_len == aka_len
    3229                 :        801 :           && memcmp (p + type_start, p+aka_start, type_len) == 0)
    3230                 :            :         {
    3231                 :            :           /* We can't add a '\0' here, since we may be adding a closing quote
    3232                 :            :              below, and it would be hidden by the '\0'.
    3233                 :            :              Instead, manually unwind the current object within the obstack
    3234                 :            :              so that the insertion point is at the end of the type, before
    3235                 :            :              the "' {aka".  */
    3236                 :        649 :           int delta = type_start + type_len - obstack_object_size (ob);
    3237                 :        649 :           gcc_assert (delta <= 0);
    3238                 :        649 :           obstack_blank_fast (ob, delta);
    3239                 :            :         }
    3240                 :            :       else
    3241                 :       2766 :         if (quote)
    3242                 :            :           /* No further closing quotes are needed.  */
    3243                 :       2758 :           *quote = false;
    3244                 :            :     }
    3245                 :            : 
    3246                 :      51663 :   if (quote && *quote)
    3247                 :            :     {
    3248                 :      46154 :       pp_end_quote (cxx_pp, show_color);
    3249                 :      46154 :       *quote = false;
    3250                 :            :     }
    3251                 :      51663 :   return pp_ggc_formatted_text (cxx_pp);
    3252                 :            : }
    3253                 :            : 
    3254                 :            : static const char *
    3255                 :       2766 : args_to_string (tree p, int verbose)
    3256                 :            : {
    3257                 :       2766 :   int flags = 0;
    3258                 :       2766 :   if (verbose)
    3259                 :          0 :     flags |= TFF_CLASS_KEY_OR_ENUM;
    3260                 :            : 
    3261                 :       2766 :   if (p == NULL_TREE)
    3262                 :            :     return "";
    3263                 :            : 
    3264                 :       2386 :   if (TYPE_P (TREE_VALUE (p)))
    3265                 :          0 :     return type_as_string_translate (p, flags);
    3266                 :            : 
    3267                 :       2386 :   reinit_cxx_pp ();
    3268                 :       5151 :   for (; p; p = TREE_CHAIN (p))
    3269                 :            :     {
    3270                 :       2765 :       if (null_node_p (TREE_VALUE (p)))
    3271                 :          3 :         pp_cxx_ws_string (cxx_pp, "NULL");
    3272                 :            :       else
    3273                 :       2762 :         dump_type (cxx_pp, error_type (TREE_VALUE (p)), flags);
    3274                 :       2765 :       if (TREE_CHAIN (p))
    3275                 :        379 :         pp_separate_with_comma (cxx_pp);
    3276                 :            :     }
    3277                 :       2386 :   return pp_ggc_formatted_text (cxx_pp);
    3278                 :            : }
    3279                 :            : 
    3280                 :            : /* Pretty-print a deduction substitution (from deduction_tsubst_fntype).  P
    3281                 :            :    is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
    3282                 :            :    arguments.  */
    3283                 :            : 
    3284                 :            : static const char *
    3285                 :        524 : subst_to_string (tree p)
    3286                 :            : {
    3287                 :        524 :   tree decl = TREE_PURPOSE (p);
    3288                 :        524 :   tree targs = TREE_VALUE (p);
    3289                 :        524 :   tree tparms = DECL_TEMPLATE_PARMS (decl);
    3290                 :        524 :   int flags = (TFF_DECL_SPECIFIERS|TFF_TEMPLATE_HEADER
    3291                 :            :                |TFF_NO_TEMPLATE_BINDINGS);
    3292                 :            : 
    3293                 :        524 :   if (p == NULL_TREE)
    3294                 :            :     return "";
    3295                 :            : 
    3296                 :        524 :   reinit_cxx_pp ();
    3297                 :        524 :   dump_template_decl (cxx_pp, TREE_PURPOSE (p), flags);
    3298                 :        524 :   dump_substitution (cxx_pp, NULL, tparms, targs, /*flags=*/0);
    3299                 :        524 :   return pp_ggc_formatted_text (cxx_pp);
    3300                 :            : }
    3301                 :            : 
    3302                 :            : static const char *
    3303                 :        356 : cv_to_string (tree p, int v)
    3304                 :            : {
    3305                 :        356 :   reinit_cxx_pp ();
    3306                 :        356 :   cxx_pp->padding = v ? pp_before : pp_none;
    3307                 :        356 :   pp_cxx_cv_qualifier_seq (cxx_pp, p);
    3308                 :        356 :   return pp_ggc_formatted_text (cxx_pp);
    3309                 :            : }
    3310                 :            : 
    3311                 :            : static const char *
    3312                 :          0 : eh_spec_to_string (tree p, int /*v*/)
    3313                 :            : {
    3314                 :          0 :   int flags = 0;
    3315                 :          0 :   reinit_cxx_pp ();
    3316                 :          0 :   dump_exception_spec (cxx_pp, p, flags);
    3317                 :          0 :   return pp_ggc_formatted_text (cxx_pp);
    3318                 :            : }
    3319                 :            : 
    3320                 :            : /* Langhook for print_error_function.  */
    3321                 :            : void
    3322                 :          9 : cxx_print_error_function (diagnostic_context *context, const char *file,
    3323                 :            :                           diagnostic_info *diagnostic)
    3324                 :            : {
    3325                 :          9 :   char *prefix;
    3326                 :          9 :   if (file)
    3327                 :          9 :     prefix = xstrdup (file);
    3328                 :            :   else
    3329                 :            :     prefix = NULL;
    3330                 :          9 :   lhd_print_error_function (context, file, diagnostic);
    3331                 :          9 :   pp_set_prefix (context->printer, prefix);
    3332                 :          9 :   maybe_print_instantiation_context (context);
    3333                 :          9 : }
    3334                 :            : 
    3335                 :            : static void
    3336                 :     141138 : cp_diagnostic_starter (diagnostic_context *context,
    3337                 :            :                        diagnostic_info *diagnostic)
    3338                 :            : {
    3339                 :     141138 :   diagnostic_report_current_module (context, diagnostic_location (diagnostic));
    3340                 :     141138 :   cp_print_error_function (context, diagnostic);
    3341                 :     141138 :   maybe_print_instantiation_context (context);
    3342                 :     141138 :   maybe_print_constexpr_context (context);
    3343                 :     141138 :   maybe_print_constraint_context (context);
    3344                 :     141138 :   pp_set_prefix (context->printer, diagnostic_build_prefix (context,
    3345                 :            :                                                                  diagnostic));
    3346                 :     141138 : }
    3347                 :            : 
    3348                 :            : /* Print current function onto BUFFER, in the process of reporting
    3349                 :            :    a diagnostic message.  Called from cp_diagnostic_starter.  */
    3350                 :            : static void
    3351                 :     141138 : cp_print_error_function (diagnostic_context *context,
    3352                 :            :                          diagnostic_info *diagnostic)
    3353                 :            : {
    3354                 :            :   /* If we are in an instantiation context, current_function_decl is likely
    3355                 :            :      to be wrong, so just rely on print_instantiation_full_context.  */
    3356                 :     141138 :   if (current_instantiation ())
    3357                 :            :     return;
    3358                 :            :   /* The above is true for constraint satisfaction also.  */
    3359                 :     134196 :   if (current_failed_constraint)
    3360                 :            :     return;
    3361                 :     134132 :   if (diagnostic_last_function_changed (context, diagnostic))
    3362                 :            :     {
    3363                 :      17370 :       char *old_prefix = pp_take_prefix (context->printer);
    3364                 :      17370 :       const char *file = LOCATION_FILE (diagnostic_location (diagnostic));
    3365                 :      17370 :       tree abstract_origin = diagnostic_abstract_origin (diagnostic);
    3366                 :      17370 :       char *new_prefix = (file && abstract_origin == NULL)
    3367                 :      17370 :                          ? file_name_as_prefix (context, file) : NULL;
    3368                 :            : 
    3369                 :      17370 :       pp_set_prefix (context->printer, new_prefix);
    3370                 :            : 
    3371                 :      17370 :       if (current_function_decl == NULL)
    3372                 :        425 :         pp_string (context->printer, _("At global scope:"));
    3373                 :            :       else
    3374                 :            :         {
    3375                 :      16945 :           tree fndecl, ao;
    3376                 :            : 
    3377                 :      16945 :           if (abstract_origin)
    3378                 :            :             {
    3379                 :        132 :               ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
    3380                 :        132 :               gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
    3381                 :            :               fndecl = ao;
    3382                 :            :             }
    3383                 :            :           else
    3384                 :            :             fndecl = current_function_decl;
    3385                 :            : 
    3386                 :      16945 :           pp_printf (context->printer, function_category (fndecl),
    3387                 :            :                      cxx_printable_name_translate (fndecl, 2));
    3388                 :            : 
    3389                 :      17086 :           while (abstract_origin)
    3390                 :            :             {
    3391                 :        141 :               location_t *locus;
    3392                 :        141 :               tree block = abstract_origin;
    3393                 :            : 
    3394                 :        141 :               locus = &BLOCK_SOURCE_LOCATION (block);
    3395                 :        141 :               fndecl = NULL;
    3396                 :        141 :               block = BLOCK_SUPERCONTEXT (block);
    3397                 :        154 :               while (block && TREE_CODE (block) == BLOCK
    3398                 :        308 :                      && BLOCK_ABSTRACT_ORIGIN (block))
    3399                 :            :                 {
    3400                 :         22 :                   ao = BLOCK_ABSTRACT_ORIGIN (block);
    3401                 :         22 :                   if (TREE_CODE (ao) == FUNCTION_DECL)
    3402                 :            :                     {
    3403                 :            :                       fndecl = ao;
    3404                 :            :                       break;
    3405                 :            :                     }
    3406                 :         13 :                   else if (TREE_CODE (ao) != BLOCK)
    3407                 :            :                     break;
    3408                 :            : 
    3409                 :         13 :                   block = BLOCK_SUPERCONTEXT (block);
    3410                 :            :                 }
    3411                 :        141 :               if (fndecl)
    3412                 :            :                 abstract_origin = block;
    3413                 :            :               else
    3414                 :            :                 {
    3415                 :        264 :                   while (block && TREE_CODE (block) == BLOCK)
    3416                 :        132 :                     block = BLOCK_SUPERCONTEXT (block);
    3417                 :            : 
    3418                 :        132 :                   if (block && TREE_CODE (block) == FUNCTION_DECL)
    3419                 :        132 :                     fndecl = block;
    3420                 :            :                   abstract_origin = NULL;
    3421                 :            :                 }
    3422                 :        141 :               if (fndecl)
    3423                 :            :                 {
    3424                 :        141 :                   expanded_location s = expand_location (*locus);
    3425                 :        141 :                   pp_character (context->printer, ',');
    3426                 :        141 :                   pp_newline (context->printer);
    3427                 :        141 :                   if (s.file != NULL)
    3428                 :            :                     {
    3429                 :        141 :                       if (context->show_column && s.column != 0)
    3430                 :        141 :                         pp_printf (context->printer,
    3431                 :        141 :                                    _("    inlined from %qs at %r%s:%d:%d%R"),
    3432                 :            :                                    cxx_printable_name_translate (fndecl, 2),
    3433                 :            :                                    "locus", s.file, s.line, s.column);
    3434                 :            :                       else
    3435                 :          0 :                         pp_printf (context->printer,
    3436                 :          0 :                                    _("    inlined from %qs at %r%s:%d%R"),
    3437                 :            :                                    cxx_printable_name_translate (fndecl, 2),
    3438                 :            :                                    "locus", s.file, s.line);
    3439                 :            : 
    3440                 :            :                     }
    3441                 :            :                   else
    3442                 :          0 :                     pp_printf (context->printer, _("    inlined from %qs"),
    3443                 :            :                                cxx_printable_name_translate (fndecl, 2));
    3444                 :            :                 }
    3445                 :            :             }
    3446                 :      16945 :           pp_character (context->printer, ':');
    3447                 :            :         }
    3448                 :      17370 :       pp_newline (context->printer);
    3449                 :            : 
    3450                 :      17370 :       diagnostic_set_last_function (context, diagnostic);
    3451                 :      17370 :       pp_destroy_prefix (context->printer);
    3452                 :      17370 :       context->printer->prefix = old_prefix;
    3453                 :            :     }
    3454                 :            : }
    3455                 :            : 
    3456                 :            : /* Returns a description of FUNCTION using standard terminology.  The
    3457                 :            :    result is a format string of the form "In CATEGORY %qs".  */
    3458                 :            : static const char *
    3459                 :      16945 : function_category (tree fn)
    3460                 :            : {
    3461                 :            :   /* We can get called from the middle-end for diagnostics of function
    3462                 :            :      clones.  Make sure we have language specific information before
    3463                 :            :      dereferencing it.  */
    3464                 :      16945 :   if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))
    3465                 :      33782 :       && DECL_FUNCTION_MEMBER_P (fn))
    3466                 :            :     {
    3467                 :       2376 :       if (DECL_STATIC_FUNCTION_P (fn))
    3468                 :        110 :         return _("In static member function %qs");
    3469                 :       2266 :       else if (DECL_COPY_CONSTRUCTOR_P (fn))
    3470                 :         45 :         return _("In copy constructor %qs");
    3471                 :       4442 :       else if (DECL_CONSTRUCTOR_P (fn))
    3472                 :        697 :         return _("In constructor %qs");
    3473                 :       1524 :       else if (DECL_DESTRUCTOR_P (fn))
    3474                 :         71 :         return _("In destructor %qs");
    3475                 :       3196 :       else if (LAMBDA_FUNCTION_P (fn))
    3476                 :        286 :         return _("In lambda function");
    3477                 :            :       else
    3478                 :       1167 :         return _("In member function %qs");
    3479                 :            :     }
    3480                 :            :   else
    3481                 :      14569 :     return _("In function %qs");
    3482                 :            : }
    3483                 :            : 
    3484                 :            : /* Report the full context of a current template instantiation,
    3485                 :            :    onto BUFFER.  */
    3486                 :            : static void
    3487                 :       3282 : print_instantiation_full_context (diagnostic_context *context)
    3488                 :            : {
    3489                 :       3282 :   struct tinst_level *p = current_instantiation ();
    3490                 :       3282 :   location_t location = input_location;
    3491                 :            : 
    3492                 :       3282 :   if (p)
    3493                 :            :     {
    3494                 :       9846 :       pp_verbatim (context->printer,
    3495                 :       3282 :                    p->list_p ()
    3496                 :        284 :                    ? _("%s: In substitution of %qS:\n")
    3497                 :       2998 :                    : _("%s: In instantiation of %q#D:\n"),
    3498                 :       3282 :                    LOCATION_FILE (location),
    3499                 :            :                    p->get_node ());
    3500                 :            : 
    3501                 :       3282 :       location = p->locus;
    3502                 :       3282 :       p = p->next;
    3503                 :            :     }
    3504                 :            : 
    3505                 :       3282 :   print_instantiation_partial_context (context, p, location);
    3506                 :       3282 : }
    3507                 :            : 
    3508                 :            : /* Helper function of print_instantiation_partial_context() that
    3509                 :            :    prints a single line of instantiation context.  */
    3510                 :            : 
    3511                 :            : static void
    3512                 :       4540 : print_instantiation_partial_context_line (diagnostic_context *context,
    3513                 :            :                                           struct tinst_level *t,
    3514                 :            :                                           location_t loc, bool recursive_p)
    3515                 :            : {
    3516                 :       4540 :   if (loc == UNKNOWN_LOCATION)
    3517                 :         30 :     return;
    3518                 :            : 
    3519                 :       4510 :   expanded_location xloc = expand_location (loc);
    3520                 :            : 
    3521                 :       4510 :   if (context->show_column)
    3522                 :       3375 :     pp_verbatim (context->printer, _("%r%s:%d:%d:%R   "),
    3523                 :            :                  "locus", xloc.file, xloc.line, xloc.column);
    3524                 :            :   else
    3525                 :       1135 :     pp_verbatim (context->printer, _("%r%s:%d:%R   "),
    3526                 :            :                  "locus", xloc.file, xloc.line);
    3527                 :            : 
    3528                 :       4510 :   if (t != NULL)
    3529                 :            :     {
    3530                 :       1258 :       if (t->list_p ())
    3531                 :        639 :         pp_verbatim (context->printer,
    3532                 :            :                      recursive_p
    3533                 :         46 :                      ? _("recursively required by substitution of %qS\n")
    3534                 :        167 :                      : _("required by substitution of %qS\n"),
    3535                 :            :                      t->get_node ());
    3536                 :            :       else
    3537                 :       2090 :         pp_verbatim (context->printer,
    3538                 :            :                      recursive_p
    3539                 :         96 :                      ? _("recursively required from %q#D\n")
    3540                 :        949 :                      : _("required from %q#D\n"),
    3541                 :            :                      t->get_node ());
    3542                 :            :     }
    3543                 :            :   else
    3544                 :            :     {
    3545                 :       6504 :       pp_verbatim (context->printer,
    3546                 :            :                    recursive_p
    3547                 :          0 :                    ? _("recursively required from here\n")
    3548                 :       3252 :                    : _("required from here\n"));
    3549                 :            :     }
    3550                 :            : }
    3551                 :            : 
    3552                 :            : /* Same as print_instantiation_full_context but less verbose.  */
    3553                 :            : 
    3554                 :            : static void
    3555                 :       3282 : print_instantiation_partial_context (diagnostic_context *context,
    3556                 :            :                                      struct tinst_level *t0, location_t loc)
    3557                 :            : {
    3558                 :       3282 :   struct tinst_level *t;
    3559                 :       3282 :   int n_total = 0;
    3560                 :       3282 :   int n;
    3561                 :       3282 :   location_t prev_loc = loc;
    3562                 :            : 
    3563                 :      39352 :   for (t = t0; t != NULL; t = t->next)
    3564                 :      36070 :     if (prev_loc != t->locus)
    3565                 :            :       {
    3566                 :       1172 :         prev_loc = t->locus;
    3567                 :       1172 :         n_total++;
    3568                 :            :       }
    3569                 :            : 
    3570                 :       3282 :   t = t0;
    3571                 :            : 
    3572                 :       3282 :   if (template_backtrace_limit
    3573                 :       3282 :       && n_total > template_backtrace_limit) 
    3574                 :            :     {
    3575                 :          0 :       int skip = n_total - template_backtrace_limit;
    3576                 :          0 :       int head = template_backtrace_limit / 2;
    3577                 :            : 
    3578                 :            :       /* Avoid skipping just 1.  If so, skip 2.  */
    3579                 :          0 :       if (skip == 1)
    3580                 :            :        {
    3581                 :          0 :          skip = 2;
    3582                 :          0 :          head = (template_backtrace_limit - 1) / 2;
    3583                 :            :        }
    3584                 :            :      
    3585                 :          0 :       for (n = 0; n < head; n++)
    3586                 :            :         {
    3587                 :          0 :           gcc_assert (t != NULL);
    3588                 :          0 :           if (loc != t->locus)
    3589                 :          0 :             print_instantiation_partial_context_line (context, t, loc,
    3590                 :            :                                                       /*recursive_p=*/false);
    3591                 :          0 :           loc = t->locus;
    3592                 :          0 :           t = t->next;
    3593                 :            :         }
    3594                 :          0 :       if (t != NULL && skip > 0)
    3595                 :            :         {
    3596                 :          0 :           expanded_location xloc;
    3597                 :          0 :           xloc = expand_location (loc);
    3598                 :          0 :           if (context->show_column)
    3599                 :          0 :             pp_verbatim (context->printer,
    3600                 :          0 :                          _("%r%s:%d:%d:%R   [ skipping %d instantiation "
    3601                 :            :                            "contexts, use -ftemplate-backtrace-limit=0 to "
    3602                 :            :                            "disable ]\n"),
    3603                 :            :                          "locus", xloc.file, xloc.line, xloc.column, skip);
    3604                 :            :           else
    3605                 :          0 :             pp_verbatim (context->printer,
    3606                 :          0 :                          _("%r%s:%d:%R   [ skipping %d instantiation "
    3607                 :            :                            "contexts, use -ftemplate-backtrace-limit=0 to "
    3608                 :            :                            "disable ]\n"),
    3609                 :            :                          "locus", xloc.file, xloc.line, skip);
    3610                 :            :           
    3611                 :          0 :           do {
    3612                 :          0 :             loc = t->locus;
    3613                 :          0 :             t = t->next;
    3614                 :          0 :           } while (t != NULL && --skip > 0);
    3615                 :            :         }
    3616                 :            :     }
    3617                 :            :   
    3618                 :       4540 :   while (t != NULL)
    3619                 :            :     {
    3620                 :      36070 :       while (t->next != NULL && t->locus == t->next->locus)
    3621                 :            :         {
    3622                 :            :           loc = t->locus;
    3623                 :            :           t = t->next;
    3624                 :            :         }
    3625                 :       1258 :       print_instantiation_partial_context_line (context, t, loc,
    3626                 :       1258 :                                                 t->locus == loc);
    3627                 :       1258 :       loc = t->locus;
    3628                 :       1258 :       t = t->next;
    3629                 :            :     }
    3630                 :       3282 :   print_instantiation_partial_context_line (context, NULL, loc,
    3631                 :            :                                             /*recursive_p=*/false);
    3632                 :       3282 : }
    3633                 :            : 
    3634                 :            : /* Called from cp_thing to print the template context for an error.  */
    3635                 :            : static void
    3636                 :     141147 : maybe_print_instantiation_context (diagnostic_context *context)
    3637                 :            : {
    3638                 :     141147 :   if (!problematic_instantiation_changed () || current_instantiation () == 0)
    3639                 :     137865 :     return;
    3640                 :            : 
    3641                 :       3282 :   record_last_problematic_instantiation ();
    3642                 :       3282 :   print_instantiation_full_context (context);
    3643                 :            : }
    3644                 :            : 
    3645                 :            : /* Report what constexpr call(s) we're trying to expand, if any.  */
    3646                 :            : 
    3647                 :            : void
    3648                 :     141138 : maybe_print_constexpr_context (diagnostic_context *context)
    3649                 :            : {
    3650                 :     141138 :   vec<tree> call_stack = cx_error_context ();
    3651                 :     141138 :   unsigned ix;
    3652                 :     141138 :   tree t;
    3653                 :            : 
    3654                 :     141629 :   FOR_EACH_VEC_ELT (call_stack, ix, t)
    3655                 :            :     {
    3656                 :        491 :       expanded_location xloc = expand_location (EXPR_LOCATION (t));
    3657                 :        491 :       const char *s = expr_as_string (t, 0);
    3658                 :        491 :       if (context->show_column)
    3659                 :        489 :         pp_verbatim (context->printer,
    3660                 :        489 :                      _("%r%s:%d:%d:%R   in %<constexpr%> expansion of %qs"),
    3661                 :            :                      "locus", xloc.file, xloc.line, xloc.column, s);
    3662                 :            :       else
    3663                 :          2 :         pp_verbatim (context->printer,
    3664                 :          2 :                      _("%r%s:%d:%R   in %<constexpr%> expansion of %qs"),
    3665                 :            :                      "locus", xloc.file, xloc.line, s);
    3666                 :        491 :       pp_newline (context->printer);
    3667                 :            :     }
    3668                 :     141138 : }
    3669                 :            : 
    3670                 :            : 
    3671                 :            : static void
    3672                 :        369 : print_location (diagnostic_context *context, location_t loc)
    3673                 :            : {
    3674                 :        369 :   expanded_location xloc = expand_location (loc);
    3675                 :        369 :   if (context->show_column)
    3676                 :        333 :     pp_verbatim (context->printer, _("%r%s:%d:%d:%R   "),
    3677                 :            :                  "locus", xloc.file, xloc.line, xloc.column);
    3678                 :            :   else
    3679                 :         36 :     pp_verbatim (context->printer, _("%r%s:%d:%R   "),
    3680                 :            :                  "locus", xloc.file, xloc.line);
    3681                 :        369 : }
    3682                 :            : 
    3683                 :            : static void
    3684                 :         63 : print_constrained_decl_info (diagnostic_context *context, tree decl)
    3685                 :            : {
    3686                 :         63 :   print_location (context, DECL_SOURCE_LOCATION (decl));
    3687                 :         63 :   pp_verbatim (context->printer, "required by the constraints of %q#D\n", decl);
    3688                 :         63 : }
    3689                 :            : 
    3690                 :            : static void
    3691                 :        249 : print_concept_check_info (diagnostic_context *context, tree expr, tree map, tree args)
    3692                 :            : {
    3693                 :        249 :   gcc_assert (concept_check_p (expr));
    3694                 :            : 
    3695                 :        249 :   tree id = unpack_concept_check (expr);
    3696                 :        249 :   tree tmpl = TREE_OPERAND (id, 0);
    3697                 :        249 :   if (OVL_P (tmpl))
    3698                 :        249 :     tmpl = OVL_FIRST (tmpl);
    3699                 :            : 
    3700                 :        249 :   print_location (context, DECL_SOURCE_LOCATION (tmpl));
    3701                 :            : 
    3702                 :        249 :   cxx_pretty_printer *pp = (cxx_pretty_printer *)context->printer;
    3703                 :        249 :   pp_verbatim (pp, "required for the satisfaction of %qE", expr);
    3704                 :        249 :   if (map && map != error_mark_node)
    3705                 :            :     {
    3706                 :        217 :       tree subst_map = tsubst_parameter_mapping (map, args, tf_none, NULL_TREE);
    3707                 :        218 :       pp_cxx_parameter_mapping (pp, (subst_map != error_mark_node
    3708                 :            :                                      ? subst_map : map));
    3709                 :            :     }
    3710                 :        249 :   pp_newline (pp);
    3711                 :        249 : }
    3712                 :            : 
    3713                 :            : /* Diagnose the entry point into the satisfaction error. Returns the next
    3714                 :            :    context, if any.  */
    3715                 :            : 
    3716                 :            : static tree
    3717                 :        294 : print_constraint_context_head (diagnostic_context *context, tree cxt, tree args)
    3718                 :            : {
    3719                 :        294 :   tree src = TREE_VALUE (cxt);
    3720                 :        294 :   if (!src)
    3721                 :            :     {
    3722                 :          4 :       print_location (context, input_location);
    3723                 :          4 :       pp_verbatim (context->printer, "required for constraint satisfaction\n");
    3724                 :          4 :       return NULL_TREE;
    3725                 :            :     }
    3726                 :        290 :   if (DECL_P (src))
    3727                 :            :     {
    3728                 :         63 :       print_constrained_decl_info (context, src);
    3729                 :         63 :       return NULL_TREE;
    3730                 :            :     }
    3731                 :            :   else
    3732                 :            :     {
    3733                 :        227 :       print_concept_check_info (context, src, TREE_PURPOSE (cxt), args);
    3734                 :        227 :       return TREE_CHAIN (cxt);
    3735                 :            :     }
    3736                 :            : }
    3737                 :            : 
    3738                 :            : static void
    3739                 :         54 : print_requires_expression_info (diagnostic_context *context, tree constr, tree args)
    3740                 :            : {
    3741                 :            : 
    3742                 :         54 :   tree expr = ATOMIC_CONSTR_EXPR (constr);
    3743                 :         54 :   tree map = ATOMIC_CONSTR_MAP (constr);
    3744                 :         54 :   map = tsubst_parameter_mapping (map, args, tf_none, NULL_TREE);
    3745                 :         54 :   if (map == error_mark_node)
    3746                 :            :     return;
    3747                 :         53 :   args = get_mapped_args (map);
    3748                 :            : 
    3749                 :        106 :   print_location (context, cp_expr_loc_or_input_loc (expr));
    3750                 :         53 :   pp_verbatim (context->printer, "in requirements ");
    3751                 :            : 
    3752                 :         53 :   tree parms = TREE_OPERAND (expr, 0);
    3753                 :         53 :   if (parms)
    3754                 :         35 :     pp_verbatim (context->printer, "with ");
    3755                 :         96 :   while (parms)
    3756                 :            :     {
    3757                 :         43 :       tree next = TREE_CHAIN (parms);
    3758                 :            : 
    3759                 :         43 :       TREE_CHAIN (parms) = NULL_TREE;
    3760                 :         43 :       cp_unevaluated u;
    3761                 :         43 :       tree p = tsubst (parms, args, tf_none, NULL_TREE);
    3762                 :         43 :       pp_verbatim (context->printer, "%q#D", p);
    3763                 :         43 :       TREE_CHAIN (parms) = next;
    3764                 :            : 
    3765                 :         43 :       if (next)
    3766                 :          8 :         pp_separate_with_comma ((cxx_pretty_printer *)context->printer);
    3767                 :            : 
    3768                 :         43 :       parms = next;
    3769                 :            :     }
    3770                 :            : 
    3771                 :         53 :   pp_verbatim (context->printer, "\n");
    3772                 :            : }
    3773                 :            : 
    3774                 :            : void
    3775                 :        296 : maybe_print_single_constraint_context (diagnostic_context *context, tree failed)
    3776                 :            : {
    3777                 :        296 :   if (!failed)
    3778                 :            :     return;
    3779                 :            : 
    3780                 :        296 :   tree constr = TREE_VALUE (failed);
    3781                 :        296 :   if (!constr || constr == error_mark_node)
    3782                 :            :     return;
    3783                 :        303 :   tree cxt = CONSTR_CONTEXT (constr);
    3784                 :        296 :   if (!cxt)
    3785                 :            :     return;
    3786                 :        294 :   tree args = TREE_PURPOSE (failed);
    3787                 :            : 
    3788                 :            :   /* Print the stack of requirements.  */
    3789                 :        294 :   cxt = print_constraint_context_head (context, cxt, args);
    3790                 :        538 :   while (cxt && !DECL_P (TREE_VALUE (cxt)))
    3791                 :            :     {
    3792                 :         22 :       tree expr = TREE_VALUE (cxt);
    3793                 :         22 :       tree map = TREE_PURPOSE (cxt);
    3794                 :         22 :       print_concept_check_info (context, expr, map, args);
    3795                 :         22 :       cxt = TREE_CHAIN (cxt);
    3796                 :            :     }
    3797                 :            : 
    3798                 :            :   /* For certain constraints, we can provide additional context.  */
    3799                 :        294 :   if (TREE_CODE (constr) == ATOMIC_CONSTR
    3800                 :        294 :       && TREE_CODE (ATOMIC_CONSTR_EXPR (constr)) == REQUIRES_EXPR)
    3801                 :         54 :     print_requires_expression_info (context, constr, args);
    3802                 :            : }
    3803                 :            : 
    3804                 :            : void
    3805                 :     141138 : maybe_print_constraint_context (diagnostic_context *context)
    3806                 :            : {
    3807                 :     141138 :   if (!current_failed_constraint)
    3808                 :            :     return;
    3809                 :            : 
    3810                 :        296 :   tree cur = current_failed_constraint;
    3811                 :            : 
    3812                 :            :   /* Recursively print nested contexts.  */
    3813                 :        296 :   current_failed_constraint = TREE_CHAIN (current_failed_constraint);
    3814                 :        296 :   if (current_failed_constraint)
    3815                 :          0 :     maybe_print_constraint_context (context);
    3816                 :            : 
    3817                 :            :   /* Print this context.  */
    3818                 :        296 :   maybe_print_single_constraint_context (context, cur);
    3819                 :            : }
    3820                 :            : 
    3821                 :            : /* Return true iff TYPE_A and TYPE_B are template types that are
    3822                 :            :    meaningful to compare.  */
    3823                 :            : 
    3824                 :            : static bool
    3825                 :      10445 : comparable_template_types_p (tree type_a, tree type_b)
    3826                 :            : {
    3827                 :      11512 :   if (!CLASS_TYPE_P (type_a))
    3828                 :            :     return false;
    3829                 :       1288 :   if (!CLASS_TYPE_P (type_b))
    3830                 :            :     return false;
    3831                 :            : 
    3832                 :        327 :   tree tinfo_a = TYPE_TEMPLATE_INFO (type_a);
    3833                 :        327 :   tree tinfo_b = TYPE_TEMPLATE_INFO (type_b);
    3834                 :        327 :   if (!tinfo_a || !tinfo_b)
    3835                 :            :     return false;
    3836                 :            : 
    3837                 :        204 :   return TI_TEMPLATE (tinfo_a) == TI_TEMPLATE (tinfo_b);
    3838                 :            : }
    3839                 :            : 
    3840                 :            : /* Start a new line indented by SPC spaces on PP.  */
    3841                 :            : 
    3842                 :            : static void
    3843                 :        285 : newline_and_indent (pretty_printer *pp, int spc)
    3844                 :            : {
    3845                 :        285 :   pp_newline (pp);
    3846                 :       1277 :   for (int i = 0; i < spc; i++)
    3847                 :        992 :     pp_space (pp);
    3848                 :        285 : }
    3849                 :            : 
    3850                 :            : /* Generate a GC-allocated string for ARG, an expression or type.  */
    3851                 :            : 
    3852                 :            : static const char *
    3853                 :        623 : arg_to_string (tree arg, bool verbose)
    3854                 :            : {
    3855                 :        623 :   if (TYPE_P (arg))
    3856                 :        283 :     return type_to_string (arg, verbose, true, NULL, false);
    3857                 :            :   else
    3858                 :        340 :     return expr_to_string (arg);
    3859                 :            : }
    3860                 :            : 
    3861                 :            : /* Subroutine to type_to_string_with_compare and
    3862                 :            :    print_template_tree_comparison.
    3863                 :            : 
    3864                 :            :    Print a representation of ARG (an expression or type) to PP,
    3865                 :            :    colorizing it as "type-diff" if PP->show_color.  */
    3866                 :            : 
    3867                 :            : static void
    3868                 :        608 : print_nonequal_arg (pretty_printer *pp, tree arg, bool verbose)
    3869                 :            : {
    3870                 :       1216 :   pp_printf (pp, "%r%s%R",
    3871                 :            :              "type-diff",
    3872                 :            :              (arg
    3873                 :        608 :               ? arg_to_string (arg, verbose)
    3874                 :            :               : G_("(no argument)")));
    3875                 :        608 : }
    3876                 :            : 
    3877                 :            : /* Recursively print template TYPE_A to PP, as compared to template TYPE_B.
    3878                 :            : 
    3879                 :            :    The types must satisfy comparable_template_types_p.
    3880                 :            : 
    3881                 :            :    If INDENT is 0, then this is equivalent to type_to_string (TYPE_A), but
    3882                 :            :    potentially colorizing/eliding in comparison with TYPE_B.
    3883                 :            : 
    3884                 :            :    For example given types:
    3885                 :            :      vector<map<int,double>>
    3886                 :            :    and
    3887                 :            :      vector<map<int,float>>
    3888                 :            :    then the result on PP would be:
    3889                 :            :      vector<map<[...],double>>
    3890                 :            :    with type elision, and:
    3891                 :            :      vector<map<int,double>>
    3892                 :            :    without type elision.
    3893                 :            : 
    3894                 :            :    In both cases the parts of TYPE that differ from PEER will be colorized
    3895                 :            :    if pp_show_color (pp) is true.  In the above example, this would be
    3896                 :            :    "double".
    3897                 :            : 
    3898                 :            :    If INDENT is non-zero, then the types are printed in a tree-like form
    3899                 :            :    which shows both types.  In the above example, the result on PP would be:
    3900                 :            : 
    3901                 :            :      vector<
    3902                 :            :        map<
    3903                 :            :          [...],
    3904                 :            :          [double != float]>>
    3905                 :            : 
    3906                 :            :    and without type-elision would be:
    3907                 :            : 
    3908                 :            :      vector<
    3909                 :            :        map<
    3910                 :            :          int,
    3911                 :            :          [double != float]>>
    3912                 :            : 
    3913                 :            :    As before, the differing parts of the types are colorized if
    3914                 :            :    pp_show_color (pp) is true ("double" and "float" in this example).
    3915                 :            : 
    3916                 :            :    Template arguments in which both types are using the default arguments
    3917                 :            :    are not printed; if at least one of the two types is using a non-default
    3918                 :            :    argument, then that argument is printed (or both arguments for the
    3919                 :            :    tree-like print format).  */
    3920                 :            : 
    3921                 :            : static void
    3922                 :        384 : print_template_differences (pretty_printer *pp, tree type_a, tree type_b,
    3923                 :            :                             bool verbose, int indent)
    3924                 :            : {
    3925                 :        384 :   if (indent)
    3926                 :        104 :     newline_and_indent (pp, indent);
    3927                 :            : 
    3928                 :        768 :   tree tinfo_a = TYPE_TEMPLATE_INFO (type_a);
    3929                 :        768 :   tree tinfo_b = TYPE_TEMPLATE_INFO (type_b);
    3930                 :            : 
    3931                 :        384 :   pp_printf (pp, "%s<",
    3932                 :        384 :              IDENTIFIER_POINTER (DECL_NAME (TI_TEMPLATE (tinfo_a))));
    3933                 :            : 
    3934                 :        384 :   tree args_a = TI_ARGS (tinfo_a);
    3935                 :        384 :   tree args_b = TI_ARGS (tinfo_b);
    3936                 :        384 :   gcc_assert (TREE_CODE (args_a) == TREE_VEC);
    3937                 :        384 :   gcc_assert (TREE_CODE (args_b) == TREE_VEC);
    3938                 :        384 :   int flags = 0;
    3939                 :        384 :   int len_a = get_non_default_template_args_count (args_a, flags);
    3940                 :        384 :   args_a = INNERMOST_TEMPLATE_ARGS (args_a);
    3941                 :        384 :   int len_b = get_non_default_template_args_count (args_b, flags);
    3942                 :        384 :   args_b = INNERMOST_TEMPLATE_ARGS (args_b);
    3943                 :            :   /* Determine the maximum range of args for which non-default template args
    3944                 :            :      were used; beyond this, only default args (if any) were used, and so
    3945                 :            :      they will be equal from this point onwards.
    3946                 :            :      One of the two peers might have used default arguments within this
    3947                 :            :      range, but the other will be using non-default arguments, and so
    3948                 :            :      it's more readable to print both within this range, to highlight
    3949                 :            :      the differences.  */
    3950                 :        384 :   int len_max = MAX (len_a, len_b);
    3951                 :        384 :   gcc_assert (TREE_CODE (args_a) == TREE_VEC);
    3952                 :        384 :   gcc_assert (TREE_CODE (args_b) == TREE_VEC);
    3953                 :       1063 :   for (int idx = 0; idx < len_max; idx++)
    3954                 :            :     {
    3955                 :        679 :       if (idx)
    3956                 :        295 :         pp_character (pp, ',');
    3957                 :            : 
    3958                 :        679 :       tree arg_a = TREE_VEC_ELT (args_a, idx);
    3959                 :        679 :       tree arg_b = TREE_VEC_ELT (args_b, idx);
    3960                 :        679 :       if (arg_a == arg_b)
    3961                 :            :         {
    3962                 :        163 :           if (indent)
    3963                 :         50 :             newline_and_indent (pp, indent + 2);
    3964                 :            :           /* Can do elision here, printing "[...]".  */
    3965                 :        163 :           if (flag_elide_type)
    3966                 :        148 :             pp_string (pp, G_("[...]"));
    3967                 :            :           else
    3968                 :         15 :             pp_string (pp, arg_to_string (arg_a, verbose));
    3969                 :            :         }
    3970                 :            :       else
    3971                 :            :         {
    3972                 :        516 :           int new_indent = indent ? indent + 2 : 0;
    3973                 :        516 :           if (comparable_template_types_p (arg_a, arg_b))
    3974                 :         39 :             print_template_differences (pp, arg_a, arg_b, verbose, new_indent);
    3975                 :            :           else
    3976                 :        477 :             if (indent)
    3977                 :            :               {
    3978                 :        131 :                 newline_and_indent (pp, indent + 2);
    3979                 :        131 :                 pp_character (pp, '[');
    3980                 :        131 :                 print_nonequal_arg (pp, arg_a, verbose);
    3981                 :        131 :                 pp_string (pp, " != ");
    3982                 :        131 :                 print_nonequal_arg (pp, arg_b, verbose);
    3983                 :        131 :                 pp_character (pp, ']');
    3984                 :            :               }
    3985                 :            :             else
    3986                 :        346 :               print_nonequal_arg (pp, arg_a, verbose);
    3987                 :            :         }
    3988                 :            :     }
    3989                 :        384 :   pp_printf (pp, ">");
    3990                 :        384 : }
    3991                 :            : 
    3992                 :            : /* As type_to_string, but for a template, potentially colorizing/eliding
    3993                 :            :    in comparison with PEER.
    3994                 :            :    For example, if TYPE is map<int,double> and PEER is map<int,int>,
    3995                 :            :    then the resulting string would be:
    3996                 :            :      map<[...],double>
    3997                 :            :    with type elision, and:
    3998                 :            :      map<int,double>
    3999                 :            :    without type elision.
    4000                 :            : 
    4001                 :            :    In both cases the parts of TYPE that differ from PEER will be colorized
    4002                 :            :    if SHOW_COLOR is true.  In the above example, this would be "double".
    4003                 :            : 
    4004                 :            :    Template arguments in which both types are using the default arguments
    4005                 :            :    are not printed; if at least one of the two types is using a non-default
    4006                 :            :    argument, then both arguments are printed.
    4007                 :            : 
    4008                 :            :    The resulting string is in a GC-allocated buffer.  */
    4009                 :            : 
    4010                 :            : static const char *
    4011                 :        254 : type_to_string_with_compare (tree type, tree peer, bool verbose,
    4012                 :            :                              bool show_color)
    4013                 :            : {
    4014                 :        254 :   pretty_printer inner_pp;
    4015                 :        254 :   pretty_printer *pp = &inner_pp;
    4016                 :        254 :   pp_show_color (pp) = show_color;
    4017                 :            : 
    4018                 :        254 :   print_template_differences (pp, type, peer, verbose, 0);
    4019                 :        508 :   return pp_ggc_formatted_text (pp);
    4020                 :            : }
    4021                 :            : 
    4022                 :            : /* Recursively print a tree-like comparison of TYPE_A and TYPE_B to PP,
    4023                 :            :    indented by INDENT spaces.
    4024                 :            : 
    4025                 :            :    For example given types:
    4026                 :            : 
    4027                 :            :      vector<map<int,double>>
    4028                 :            : 
    4029                 :            :    and
    4030                 :            : 
    4031                 :            :      vector<map<double,float>>
    4032                 :            : 
    4033                 :            :    the output with type elision would be:
    4034                 :            : 
    4035                 :            :      vector<
    4036                 :            :        map<
    4037                 :            :          [...],
    4038                 :            :          [double != float]>>
    4039                 :            : 
    4040                 :            :    and without type-elision would be:
    4041                 :            : 
    4042                 :            :      vector<
    4043                 :            :        map<
    4044                 :            :          int,
    4045                 :            :          [double != float]>>
    4046                 :            : 
    4047                 :            :    TYPE_A and TYPE_B must both be comparable template types
    4048                 :            :    (as per comparable_template_types_p).
    4049                 :            : 
    4050                 :            :    Template arguments in which both types are using the default arguments
    4051                 :            :    are not printed; if at least one of the two types is using a non-default
    4052                 :            :    argument, then both arguments are printed.  */
    4053                 :            : 
    4054                 :            : static void
    4055                 :         91 : print_template_tree_comparison (pretty_printer *pp, tree type_a, tree type_b,
    4056                 :            :                                 bool verbose, int indent)
    4057                 :            : {
    4058                 :          0 :   print_template_differences (pp, type_a, type_b, verbose, indent);
    4059                 :          0 : }
    4060                 :            : 
    4061                 :            : /* Subroutine for use in a format_postprocessor::handle
    4062                 :            :    implementation.  Adds a chunk to the end of
    4063                 :            :    formatted output, so that it will be printed
    4064                 :            :    by pp_output_formatted_text.  */
    4065                 :            : 
    4066                 :            : static void
    4067                 :         91 : append_formatted_chunk (pretty_printer *pp, const char *content)
    4068                 :            : {
    4069                 :         91 :   output_buffer *buffer = pp_buffer (pp);
    4070                 :         91 :   struct chunk_info *chunk_array = buffer->cur_chunk_array;
    4071                 :         91 :   const char **args = chunk_array->args;
    4072                 :            : 
    4073                 :         91 :   unsigned int chunk_idx;
    4074                 :        637 :   for (chunk_idx = 0; args[chunk_idx]; chunk_idx++)
    4075                 :            :     ;
    4076                 :         91 :   args[chunk_idx++] = content;
    4077                 :         91 :   args[chunk_idx] = NULL;
    4078                 :          0 : }
    4079                 :            : 
    4080                 :            : /* Create a copy of CONTENT, with quotes added, and,
    4081                 :            :    potentially, with colorization.
    4082                 :            :    No escaped is performed on CONTENT.
    4083                 :            :    The result is in a GC-allocated buffer. */
    4084                 :            : 
    4085                 :            : static const char *
    4086                 :        252 : add_quotes (const char *content, bool show_color)
    4087                 :            : {
    4088                 :        252 :   pretty_printer tmp_pp;
    4089                 :        252 :   pp_show_color (&tmp_pp) = show_color;
    4090                 :            : 
    4091                 :            :   /* We have to use "%<%s%>" rather than "%qs" here in order to avoid
    4092                 :            :      quoting colorization bytes within the results.  */
    4093                 :        252 :   pp_printf (&tmp_pp, "%<%s%>", content);
    4094                 :            : 
    4095                 :        504 :   return pp_ggc_formatted_text (&tmp_pp);
    4096                 :            : }
    4097                 :            : 
    4098                 :            : /* If we had %H and %I, and hence deferred printing them,
    4099                 :            :    print them now, storing the result into the chunk_info
    4100                 :            :    for pp_format.  Quote them if 'q' was provided.
    4101                 :            :    Also print the difference in tree form, adding it as
    4102                 :            :    an additional chunk.  */
    4103                 :            : 
    4104                 :            : void
    4105                 :     180965 : cxx_format_postprocessor::handle (pretty_printer *pp)
    4106                 :            : {
    4107                 :            :   /* If we have one of %H and %I, the other should have
    4108                 :            :      been present.  */
    4109                 :     180965 :   if (m_type_a.m_tree || m_type_b.m_tree)
    4110                 :            :     {
    4111                 :            :       /* Avoid reentrancy issues by working with a copy of
    4112                 :            :          m_type_a and m_type_b, resetting them now.  */
    4113                 :       9573 :       deferred_printed_type type_a = m_type_a;
    4114                 :       9573 :       deferred_printed_type type_b = m_type_b;
    4115                 :       9573 :       m_type_a = deferred_printed_type ();
    4116                 :       9573 :       m_type_b = deferred_printed_type ();
    4117                 :            : 
    4118                 :       9573 :       gcc_assert (type_a.m_buffer_ptr);
    4119                 :       9573 :       gcc_assert (type_b.m_buffer_ptr);
    4120                 :            : 
    4121                 :       9573 :       bool show_color = pp_show_color (pp);
    4122                 :            : 
    4123                 :       9573 :       const char *type_a_text;
    4124                 :       9573 :       const char *type_b_text;
    4125                 :            : 
    4126                 :       9573 :       if (comparable_template_types_p (type_a.m_tree, type_b.m_tree))
    4127                 :            :         {
    4128                 :        126 :           type_a_text
    4129                 :        252 :             = type_to_string_with_compare (type_a.m_tree, type_b.m_tree,
    4130                 :        126 :                                            type_a.m_verbose, show_color);
    4131                 :        126 :           type_b_text
    4132                 :        252 :             = type_to_string_with_compare (type_b.m_tree, type_a.m_tree,
    4133                 :        126 :                                            type_b.m_verbose, show_color);
    4134                 :            : 
    4135                 :        126 :           if (flag_diagnostics_show_template_tree)
    4136                 :            :             {
    4137                 :         91 :               pretty_printer inner_pp;
    4138                 :         91 :               pp_show_color (&inner_pp) = pp_show_color (pp);
    4139                 :         91 :               print_template_tree_comparison
    4140                 :         91 :                 (&inner_pp, type_a.m_tree, type_b.m_tree, type_a.m_verbose, 2);
    4141                 :        273 :               append_formatted_chunk (pp, pp_ggc_formatted_text (&inner_pp));
    4142                 :            :             }
    4143                 :            :         }
    4144                 :            :       else
    4145                 :            :         {
    4146                 :            :           /* If the types were not comparable (or if only one of %H/%I was
    4147                 :            :              provided), they are printed normally, and no difference tree
    4148                 :            :              is printed.  */
    4149                 :       9447 :           type_a_text = type_to_string (type_a.m_tree, type_a.m_verbose,
    4150                 :            :                                         true, &type_a.m_quote, show_color);
    4151                 :       9447 :           type_b_text = type_to_string (type_b.m_tree, type_b.m_verbose,
    4152                 :            :                                         true, &type_b.m_quote, show_color);
    4153                 :            :         }
    4154                 :            : 
    4155                 :       9573 :       if (type_a.m_quote)
    4156                 :        126 :         type_a_text = add_quotes (type_a_text, show_color);
    4157                 :       9573 :       *type_a.m_buffer_ptr = type_a_text;
    4158                 :            : 
    4159                 :       9573 :        if (type_b.m_quote)
    4160                 :        126 :         type_b_text = add_quotes (type_b_text, show_color);
    4161                 :       9573 :       *type_b.m_buffer_ptr = type_b_text;
    4162                 :            :    }
    4163                 :     180965 : }
    4164                 :            : 
    4165                 :            : /* Subroutine for handling %H and %I, to support i18n of messages like:
    4166                 :            : 
    4167                 :            :     error_at (loc, "could not convert %qE from %qH to %qI",
    4168                 :            :                expr, type_a, type_b);
    4169                 :            : 
    4170                 :            :    so that we can print things like:
    4171                 :            : 
    4172                 :            :      could not convert 'foo' from 'map<int,double>' to 'map<int,int>'
    4173                 :            : 
    4174                 :            :    and, with type-elision:
    4175                 :            : 
    4176                 :            :      could not convert 'foo' from 'map<[...],double>' to 'map<[...],int>'
    4177                 :            : 
    4178                 :            :    (with color-coding of the differences between the types).
    4179                 :            : 
    4180                 :            :    The %H and %I format codes are peers: both must be present,
    4181                 :            :    and they affect each other.  Hence to handle them, we must
    4182                 :            :    delay printing until we have both, deferring the printing to
    4183                 :            :    pretty_printer's m_format_postprocessor hook.
    4184                 :            : 
    4185                 :            :    This is called in phase 2 of pp_format, when it is accumulating
    4186                 :            :    a series of formatted chunks.  We stash the location of the chunk
    4187                 :            :    we're meant to have written to, so that we can write to it in the
    4188                 :            :    m_format_postprocessor hook.
    4189                 :            : 
    4190                 :            :    We also need to stash whether a 'q' prefix was provided (the QUOTE
    4191                 :            :    param)  so that we can add the quotes when writing out the delayed
    4192                 :            :    chunk.  */
    4193                 :            : 
    4194                 :            : static void
    4195                 :      19146 : defer_phase_2_of_type_diff (deferred_printed_type *deferred,
    4196                 :            :                             tree type, const char **buffer_ptr,
    4197                 :            :                             bool verbose, bool quote)
    4198                 :            : {
    4199                 :      19146 :   gcc_assert (deferred->m_tree == NULL_TREE);
    4200                 :      19146 :   gcc_assert (deferred->m_buffer_ptr == NULL);
    4201                 :      19146 :   *deferred = deferred_printed_type (type, buffer_ptr, verbose, quote);
    4202                 :      19146 : }
    4203                 :            : 
    4204                 :            : 
    4205                 :            : /* Called from output_format -- during diagnostic message processing --
    4206                 :            :    to handle C++ specific format specifier with the following meanings:
    4207                 :            :    %A   function argument-list.
    4208                 :            :    %C   tree code.
    4209                 :            :    %D   declaration.
    4210                 :            :    %E   expression.
    4211                 :            :    %F   function declaration.
    4212                 :            :    %G   gcall *
    4213                 :            :    %H   type difference (from).
    4214                 :            :    %I   type difference (to).
    4215                 :            :    %K   tree
    4216                 :            :    %L   language as used in extern "lang".
    4217                 :            :    %O   binary operator.
    4218                 :            :    %P   function parameter whose position is indicated by an integer.
    4219                 :            :    %Q   assignment operator.
    4220                 :            :    %S   substitution (template + args)
    4221                 :            :    %T   type.
    4222                 :            :    %V   cv-qualifier.
    4223                 :            :    %X   exception-specification.  */
    4224                 :            : static bool
    4225                 :     133228 : cp_printer (pretty_printer *pp, text_info *text, const char *spec,
    4226                 :            :             int precision, bool wide, bool set_locus, bool verbose,
    4227                 :            :             bool *quoted, const char **buffer_ptr)
    4228                 :            : {
    4229                 :     133228 :   gcc_assert (pp->m_format_postprocessor);
    4230                 :     133228 :   cxx_format_postprocessor *postprocessor
    4231                 :            :     = static_cast <cxx_format_postprocessor *> (pp->m_format_postprocessor);
    4232                 :            : 
    4233                 :     133228 :   const char *result;
    4234                 :     133228 :   tree t = NULL;
    4235                 :            : #define next_tree    (t = va_arg (*text->args_ptr, tree))
    4236                 :            : #define next_tcode   ((enum tree_code) va_arg (*text->args_ptr, int))
    4237                 :            : #define next_lang    ((enum languages) va_arg (*text->args_ptr, int))
    4238                 :            : #define next_int     va_arg (*text->args_ptr, int)
    4239                 :            : 
    4240                 :     133228 :   if (precision != 0 || wide)
    4241                 :            :     return false;
    4242                 :            : 
    4243                 :     133228 :   switch (*spec)
    4244                 :            :     {
    4245                 :       2766 :     case 'A': result = args_to_string (next_tree, verbose);     break;
    4246                 :          0 :     case 'C': result = code_to_string (next_tcode);             break;
    4247                 :      53340 :     case 'D':
    4248                 :      53340 :       {
    4249                 :      53340 :         tree temp = next_tree;
    4250                 :      53340 :         if (VAR_P (temp)
    4251                 :      53340 :             && DECL_HAS_DEBUG_EXPR_P (temp))
    4252                 :            :           {
    4253                 :         24 :             temp = DECL_DEBUG_EXPR (temp);
    4254                 :         24 :             if (!DECL_P (temp))
    4255                 :            :               {
    4256                 :         24 :                 result = expr_to_string (temp);
    4257                 :         24 :                 break;
    4258                 :            :               }
    4259                 :            :           }
    4260                 :      53316 :         result = decl_to_string (temp, verbose);
    4261                 :            :       }
    4262                 :      53316 :       break;
    4263                 :      20646 :     case 'E': result = expr_to_string (next_tree);              break;
    4264                 :        409 :     case 'F': result = fndecl_to_string (next_tree, verbose);   break;
    4265                 :       1789 :     case 'G':
    4266                 :       1789 :       percent_G_format (text);
    4267                 :       1789 :       return true;
    4268                 :       9573 :     case 'H':
    4269                 :      19146 :       defer_phase_2_of_type_diff (&postprocessor->m_type_a, next_tree,
    4270                 :       9573 :                                   buffer_ptr, verbose, *quoted);
    4271                 :       9573 :       return true;
    4272                 :       9573 :     case 'I':
    4273                 :      19146 :       defer_phase_2_of_type_diff (&postprocessor->m_type_b, next_tree,
    4274                 :       9573 :                                   buffer_ptr, verbose, *quoted);
    4275                 :       9573 :       return true;
    4276                 :        279 :     case 'K':
    4277                 :        279 :       t = va_arg (*text->args_ptr, tree);
    4278                 :        279 :       percent_K_format (text, EXPR_LOCATION (t), TREE_BLOCK (t));
    4279                 :        279 :       return true;
    4280                 :         16 :     case 'L': result = language_to_string (next_lang);          break;
    4281                 :        212 :     case 'O': result = op_to_string (false, next_tcode);        break;
    4282                 :       1589 :     case 'P': result = parm_to_string (next_int);               break;
    4283                 :         28 :     case 'Q': result = op_to_string (true, next_tcode);         break;
    4284                 :        524 :     case 'S': result = subst_to_string (next_tree);             break;
    4285                 :      32128 :     case 'T':
    4286                 :      32128 :       {
    4287                 :      64256 :         result = type_to_string (next_tree, verbose, false, quoted,
    4288                 :      32128 :                                  pp_show_color (pp));
    4289                 :            :       }
    4290                 :      32128 :       break;
    4291                 :        356 :     case 'V': result = cv_to_string (next_tree, verbose);       break;
    4292                 :          0 :     case 'X': result = eh_spec_to_string (next_tree, verbose);  break;
    4293                 :            : 
    4294                 :            :     default:
    4295                 :            :       return false;
    4296                 :            :     }
    4297                 :            : 
    4298                 :     112014 :   pp_string (pp, result);
    4299                 :     112014 :   if (set_locus && t != NULL)
    4300                 :       1580 :     text->set_location (0, location_of (t), SHOW_RANGE_WITH_CARET);
    4301                 :            :   return true;
    4302                 :            : #undef next_tree
    4303                 :            : #undef next_tcode
    4304                 :            : #undef next_lang
    4305                 :            : #undef next_int
    4306                 :            : }
    4307                 :            : 
    4308                 :            : /* Warn about the use of C++0x features when appropriate.  */
    4309                 :            : void
    4310                 :    2871270 : maybe_warn_cpp0x (cpp0x_warn_str str)
    4311                 :            : {
    4312                 :    2871270 :   if (cxx_dialect == cxx98)
    4313                 :       3436 :     switch (str)
    4314                 :            :       {
    4315                 :        192 :       case CPP0X_INITIALIZER_LISTS:
    4316                 :        192 :         pedwarn (input_location, 0, 
    4317                 :            :                  "extended initializer lists "
    4318                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4319                 :        192 :         break;
    4320                 :          0 :       case CPP0X_EXPLICIT_CONVERSION:
    4321                 :          0 :         pedwarn (input_location, 0,
    4322                 :            :                  "explicit conversion operators "
    4323                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4324                 :          0 :         break;
    4325                 :       1725 :       case CPP0X_VARIADIC_TEMPLATES:
    4326                 :       1725 :         pedwarn (input_location, 0,
    4327                 :            :                  "variadic templates "
    4328                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4329                 :       1725 :         break;
    4330                 :          6 :       case CPP0X_LAMBDA_EXPR:
    4331                 :          6 :         pedwarn (input_location, 0,
    4332                 :            :                  "lambda expressions "
    4333                 :            :                   "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4334                 :          6 :         break;
    4335                 :          0 :       case CPP0X_AUTO:
    4336                 :          0 :         pedwarn (input_location, 0,
    4337                 :            :                  "C++11 auto only available with %<-std=c++11%> or "
    4338                 :            :                  "%<-std=gnu++11%>");
    4339                 :          0 :         break;
    4340                 :          4 :       case CPP0X_SCOPED_ENUMS:
    4341                 :          4 :         pedwarn (input_location, 0,
    4342                 :            :                  "scoped enums only available with %<-std=c++11%> or "
    4343                 :            :                  "%<-std=gnu++11%>");
    4344                 :          4 :         break;
    4345                 :         14 :       case CPP0X_DEFAULTED_DELETED:
    4346                 :         14 :         pedwarn (input_location, 0,
    4347                 :            :                  "defaulted and deleted functions "
    4348                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4349                 :         14 :         break;
    4350                 :       1339 :       case CPP0X_INLINE_NAMESPACES:
    4351                 :       1339 :         pedwarn (input_location, OPT_Wpedantic,
    4352                 :            :                  "inline namespaces "
    4353                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4354                 :       1339 :         break;
    4355                 :          2 :       case CPP0X_OVERRIDE_CONTROLS:
    4356                 :          2 :         pedwarn (input_location, 0,
    4357                 :            :                  "override controls (override/final) "
    4358                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4359                 :          2 :         break;
    4360                 :        145 :       case CPP0X_NSDMI:
    4361                 :        145 :         pedwarn (input_location, 0,
    4362                 :            :                  "non-static data member initializers "
    4363                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4364                 :        145 :         break;
    4365                 :          4 :       case CPP0X_USER_DEFINED_LITERALS:
    4366                 :          4 :         pedwarn (input_location, 0,
    4367                 :            :                  "user-defined literals "
    4368                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4369                 :          4 :         break;
    4370                 :          3 :       case CPP0X_DELEGATING_CTORS:
    4371                 :          3 :         pedwarn (input_location, 0,
    4372                 :            :                  "delegating constructors "
    4373                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4374                 :          3 :         break;
    4375                 :          2 :       case CPP0X_INHERITING_CTORS:
    4376                 :          2 :         pedwarn (input_location, 0,
    4377                 :            :                  "inheriting constructors "
    4378                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4379                 :          2 :         break;
    4380                 :          0 :       case CPP0X_ATTRIBUTES:
    4381                 :          0 :         pedwarn (input_location, 0,
    4382                 :            :                  "c++11 attributes "
    4383                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4384                 :          0 :         break;
    4385                 :          0 :       case CPP0X_REF_QUALIFIER:
    4386                 :          0 :         pedwarn (input_location, 0,
    4387                 :            :                  "ref-qualifiers "
    4388                 :            :                  "only available with %<-std=c++11%> or %<-std=gnu++11%>");
    4389                 :          0 :         break;
    4390                 :          0 :       default:
    4391                 :          0 :         gcc_unreachable ();
    4392                 :            :       }
    4393                 :    2871270 : }
    4394                 :            : 
    4395                 :            : /* Warn about the use of variadic templates when appropriate.  */
    4396                 :            : void
    4397                 :    1090140 : maybe_warn_variadic_templates (void)
    4398                 :            : {
    4399                 :    1090140 :   maybe_warn_cpp0x (CPP0X_VARIADIC_TEMPLATES);
    4400                 :    1090140 : }
    4401                 :            : 
    4402                 :            : 
    4403                 :            : /* Issue an ISO C++98 pedantic warning at LOCATION, conditional on
    4404                 :            :    option OPT with text GMSGID.  Use this function to report
    4405                 :            :    diagnostics for constructs that are invalid C++98, but valid
    4406                 :            :    C++0x.  */
    4407                 :            : bool
    4408                 :     474003 : pedwarn_cxx98 (location_t location, int opt, const char *gmsgid, ...)
    4409                 :            : {
    4410                 :     474003 :   diagnostic_info diagnostic;
    4411                 :     474003 :   va_list ap;
    4412                 :     474003 :   bool ret;
    4413                 :     474003 :   rich_location richloc (line_table, location);
    4414                 :            : 
    4415                 :     474003 :   va_start (ap, gmsgid);
    4416                 :     474003 :   diagnostic_set_info (&diagnostic, gmsgid, &ap, &richloc,
    4417                 :     474003 :                        (cxx_dialect == cxx98) ? DK_PEDWARN : DK_WARNING);
    4418                 :     474003 :   diagnostic.option_index = opt;
    4419                 :     474003 :   ret = diagnostic_report_diagnostic (global_dc, &diagnostic);
    4420                 :     474003 :   va_end (ap);
    4421                 :     474003 :   return ret;
    4422                 :            : }
    4423                 :            : 
    4424                 :            : /* Issue a diagnostic that NAME cannot be found in SCOPE.  DECL is what
    4425                 :            :    we found when we tried to do the lookup.  LOCATION is the location of
    4426                 :            :    the NAME identifier.  */
    4427                 :            : 
    4428                 :            : void
    4429                 :        473 : qualified_name_lookup_error (tree scope, tree name,
    4430                 :            :                              tree decl, location_t location)
    4431                 :            : {
    4432                 :        473 :   if (scope == error_mark_node)
    4433                 :            :     ; /* We already complained.  */
    4434                 :        390 :   else if (TYPE_P (scope))
    4435                 :            :     {
    4436                 :        188 :       if (!COMPLETE_TYPE_P (scope))
    4437                 :         65 :         error_at (location, "incomplete type %qT used in nested name specifier",
    4438                 :            :                   scope);
    4439                 :        123 :       else if (TREE_CODE (decl) == TREE_LIST)
    4440                 :            :         {
    4441                 :          0 :           error_at (location, "reference to %<%T::%D%> is ambiguous",
    4442                 :            :                     scope, name);
    4443                 :          0 :           print_candidates (decl);
    4444                 :            :         }
    4445                 :            :       else
    4446                 :            :         {
    4447                 :        246 :           name_hint hint;
    4448                 :        123 :           if (SCOPED_ENUM_P (scope) && TREE_CODE (name) == IDENTIFIER_NODE)
    4449                 :         15 :             hint = suggest_alternative_in_scoped_enum (name, scope);
    4450                 :        123 :           if (const char *suggestion = hint.suggestion ())
    4451                 :            :             {
    4452                 :         18 :               gcc_rich_location richloc (location);
    4453                 :          9 :               richloc.add_fixit_replace (suggestion);
    4454                 :          9 :               error_at (&richloc,
    4455                 :            :                         "%qD is not a member of %qT; did you mean %qs?",
    4456                 :            :                         name, scope, suggestion);
    4457                 :            :             }
    4458                 :            :           else
    4459                 :        114 :             error_at (location, "%qD is not a member of %qT", name, scope);
    4460                 :            :         }
    4461                 :            :     }
    4462                 :        202 :   else if (scope != global_namespace)
    4463                 :            :     {
    4464                 :        179 :       auto_diagnostic_group d;
    4465                 :        179 :       bool emit_fixit = true;
    4466                 :        179 :       name_hint hint
    4467                 :        358 :         = suggest_alternative_in_explicit_scope (location, name, scope);
    4468                 :        179 :       if (!hint)
    4469                 :            :         {
    4470                 :         47 :           hint = suggest_alternatives_in_other_namespaces (location, name);
    4471                 :            :           /* "location" is just the location of the name, not of the explicit
    4472                 :            :              scope, and it's not easy to get at the latter, so we can't issue
    4473                 :            :              fix-it hints for the suggestion.  */
    4474                 :         47 :           emit_fixit = false;
    4475                 :            :         }
    4476                 :        179 :       if (const char *suggestion = hint.suggestion ())
    4477                 :            :         {
    4478                 :        142 :           gcc_rich_location richloc (location);
    4479                 :         71 :           if (emit_fixit)
    4480                 :         44 :             richloc.add_fixit_replace (suggestion);
    4481                 :         71 :           error_at (&richloc, "%qD is not a member of %qD; did you mean %qs?",
    4482                 :            :                     name, scope, suggestion);
    4483                 :            :         }
    4484                 :            :       else
    4485                 :        108 :         error_at (location, "%qD is not a member of %qD", name, scope);
    4486                 :            :     }
    4487                 :            :   else
    4488                 :            :     {
    4489                 :         23 :       auto_diagnostic_group d;
    4490                 :         46 :       name_hint hint = suggest_alternatives_for (location, name, true);
    4491                 :         23 :       if (const char *suggestion = hint.suggestion ())
    4492                 :            :         {
    4493                 :         24 :           gcc_rich_location richloc (location);
    4494                 :         12 :           richloc.add_fixit_replace (suggestion);
    4495                 :         12 :           error_at (&richloc,
    4496                 :            :                     "%<::%D%> has not been declared; did you mean %qs?",
    4497                 :            :                     name, suggestion);
    4498                 :            :         }
    4499                 :            :       else
    4500                 :         11 :         error_at (location, "%<::%D%> has not been declared", name);
    4501                 :            :     }
    4502                 :        473 : }
    4503                 :            : 
    4504                 :            : /* C++-specific implementation of range_label::get_text () vfunc for
    4505                 :            :    range_label_for_type_mismatch.
    4506                 :            : 
    4507                 :            :    Compare with print_template_differences above.  */
    4508                 :            : 
    4509                 :            : label_text
    4510                 :        360 : range_label_for_type_mismatch::get_text (unsigned /*range_idx*/) const
    4511                 :            : {
    4512                 :        360 :   if (m_labelled_type == NULL_TREE)
    4513                 :          0 :     return label_text::borrow (NULL);
    4514                 :            : 
    4515                 :        360 :   const bool verbose = false;
    4516                 :        360 :   const bool show_color = false;
    4517                 :            : 
    4518                 :        360 :   const char *result;
    4519                 :        360 :   if (m_other_type
    4520                 :        360 :       && comparable_template_types_p (m_labelled_type, m_other_type))
    4521                 :          2 :     result = type_to_string_with_compare (m_labelled_type, m_other_type,
    4522                 :            :                                           verbose, show_color);
    4523                 :            :   else
    4524                 :        358 :     result = type_to_string (m_labelled_type, verbose, true, NULL, show_color);
    4525                 :            : 
    4526                 :            :   /* Both of the above return GC-allocated buffers, so the caller mustn't
    4527                 :            :      free them.  */
    4528                 :        360 :   return label_text::borrow (result);
    4529                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.