LCOV - code coverage report
Current view: top level - gcc/cp - mangle.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1671 1860 89.8 %
Date: 2020-03-28 11:57:23 Functions: 86 92 93.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Name mangling for the 3.0 -*- C++ -*- ABI.
       2                 :            :    Copyright (C) 2000-2020 Free Software Foundation, Inc.
       3                 :            :    Written by Alex Samuel <samuel@codesourcery.com>
       4                 :            : 
       5                 :            :    This file is part of GCC.
       6                 :            : 
       7                 :            :    GCC is free software; you can redistribute it and/or modify it
       8                 :            :    under the terms of the GNU General Public License as published by
       9                 :            :    the Free Software Foundation; either version 3, or (at your option)
      10                 :            :    any later version.
      11                 :            : 
      12                 :            :    GCC is distributed in the hope that it will be useful, but
      13                 :            :    WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15                 :            :    General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : /* This file implements mangling of C++ names according to the IA64
      22                 :            :    C++ ABI specification.  A mangled name encodes a function or
      23                 :            :    variable's name, scope, type, and/or template arguments into a text
      24                 :            :    identifier.  This identifier is used as the function's or
      25                 :            :    variable's linkage name, to preserve compatibility between C++'s
      26                 :            :    language features (templates, scoping, and overloading) and C
      27                 :            :    linkers.
      28                 :            : 
      29                 :            :    Additionally, g++ uses mangled names internally.  To support this,
      30                 :            :    mangling of types is allowed, even though the mangled name of a
      31                 :            :    type should not appear by itself as an exported name.  Ditto for
      32                 :            :    uninstantiated templates.
      33                 :            : 
      34                 :            :    The primary entry point for this module is mangle_decl, which
      35                 :            :    returns an identifier containing the mangled name for a decl.
      36                 :            :    Additional entry points are provided to build mangled names of
      37                 :            :    particular constructs when the appropriate decl for that construct
      38                 :            :    is not available.  These are:
      39                 :            : 
      40                 :            :      mangle_typeinfo_for_type:          typeinfo data
      41                 :            :      mangle_typeinfo_string_for_type:   typeinfo type name
      42                 :            :      mangle_vtbl_for_type:              virtual table data
      43                 :            :      mangle_vtt_for_type:               VTT data
      44                 :            :      mangle_ctor_vtbl_for_type:         `C-in-B' constructor virtual table data
      45                 :            :      mangle_thunk:                      thunk function or entry  */
      46                 :            : 
      47                 :            : #include "config.h"
      48                 :            : #include "system.h"
      49                 :            : #include "coretypes.h"
      50                 :            : #include "target.h"
      51                 :            : #include "vtable-verify.h"
      52                 :            : #include "cp-tree.h"
      53                 :            : #include "stringpool.h"
      54                 :            : #include "cgraph.h"
      55                 :            : #include "stor-layout.h"
      56                 :            : #include "flags.h"
      57                 :            : #include "attribs.h"
      58                 :            : 
      59                 :            : /* Debugging support.  */
      60                 :            : 
      61                 :            : /* Define DEBUG_MANGLE to enable very verbose trace messages.  */
      62                 :            : #ifndef DEBUG_MANGLE
      63                 :            : #define DEBUG_MANGLE 0
      64                 :            : #endif
      65                 :            : 
      66                 :            : /* Macros for tracing the write_* functions.  */
      67                 :            : #if DEBUG_MANGLE
      68                 :            : # define MANGLE_TRACE(FN, INPUT) \
      69                 :            :   fprintf (stderr, "  %-24s: %-24s\n", (FN), (INPUT))
      70                 :            : # define MANGLE_TRACE_TREE(FN, NODE) \
      71                 :            :   fprintf (stderr, "  %-24s: %-24s (%p)\n", \
      72                 :            :            (FN), get_tree_code_name (TREE_CODE (NODE)), (void *) (NODE))
      73                 :            : #else
      74                 :            : # define MANGLE_TRACE(FN, INPUT)
      75                 :            : # define MANGLE_TRACE_TREE(FN, NODE)
      76                 :            : #endif
      77                 :            : 
      78                 :            : /* Nonzero if NODE is a class template-id.  We can't rely on
      79                 :            :    CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
      80                 :            :    that hard to distinguish A<T> from A, where A<T> is the type as
      81                 :            :    instantiated outside of the template, and A is the type used
      82                 :            :    without parameters inside the template.  */
      83                 :            : #define CLASSTYPE_TEMPLATE_ID_P(NODE)                                   \
      84                 :            :   (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM                     \
      85                 :            :    || (CLASS_TYPE_P (NODE)                                              \
      86                 :            :        && CLASSTYPE_TEMPLATE_INFO (NODE) != NULL                        \
      87                 :            :        && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))
      88                 :            : 
      89                 :            : /* For deciding whether to set G.need_abi_warning, we need to consider both
      90                 :            :    warn_abi_version and flag_abi_compat_version.  */
      91                 :            : #define abi_warn_or_compat_version_crosses(N) \
      92                 :            :   (abi_version_crosses (N) || abi_compat_version_crosses (N))
      93                 :            : 
      94                 :            : /* And sometimes we can simplify the code path if we don't need to worry about
      95                 :            :    previous ABIs.  */
      96                 :            : #define abi_flag_at_least(flag,N) (flag == 0 || flag >= N)
      97                 :            : #define any_abi_below(N) \
      98                 :            :   (!abi_version_at_least (N) \
      99                 :            :    || !abi_flag_at_least (warn_abi_version, (N)) \
     100                 :            :    || !abi_flag_at_least (flag_abi_compat_version, (N)))
     101                 :            : 
     102                 :            : /* Things we only need one of.  This module is not reentrant.  */
     103                 :            : struct GTY(()) globals {
     104                 :            :   /* An array of the current substitution candidates, in the order
     105                 :            :      we've seen them.  */
     106                 :            :   vec<tree, va_gc> *substitutions;
     107                 :            : 
     108                 :            :   /* The entity that is being mangled.  */
     109                 :            :   tree GTY ((skip)) entity;
     110                 :            : 
     111                 :            :   /* How many parameter scopes we are inside.  */
     112                 :            :   int parm_depth;
     113                 :            : 
     114                 :            :   /* True if the mangling will be different in a future version of the
     115                 :            :      ABI.  */
     116                 :            :   bool need_abi_warning;
     117                 :            : 
     118                 :            :   /* True if the mangling will be different in C++17 mode.  */
     119                 :            :   bool need_cxx17_warning;
     120                 :            : };
     121                 :            : 
     122                 :            : static GTY (()) globals G;
     123                 :            : 
     124                 :            : /* The obstack on which we build mangled names.  */
     125                 :            : static struct obstack *mangle_obstack;
     126                 :            : 
     127                 :            : /* The obstack on which we build mangled names that are not going to
     128                 :            :    be IDENTIFIER_NODEs.  */
     129                 :            : static struct obstack name_obstack;
     130                 :            : 
     131                 :            : /* The first object on the name_obstack; we use this to free memory
     132                 :            :    allocated on the name_obstack.  */
     133                 :            : static void *name_base;
     134                 :            : 
     135                 :            : /* Indices into subst_identifiers.  These are identifiers used in
     136                 :            :    special substitution rules.  */
     137                 :            : typedef enum
     138                 :            : {
     139                 :            :   SUBID_ALLOCATOR,
     140                 :            :   SUBID_BASIC_STRING,
     141                 :            :   SUBID_CHAR_TRAITS,
     142                 :            :   SUBID_BASIC_ISTREAM,
     143                 :            :   SUBID_BASIC_OSTREAM,
     144                 :            :   SUBID_BASIC_IOSTREAM,
     145                 :            :   SUBID_MAX
     146                 :            : }
     147                 :            : substitution_identifier_index_t;
     148                 :            : 
     149                 :            : /* For quick substitution checks, look up these common identifiers
     150                 :            :    once only.  */
     151                 :            : static GTY(()) tree subst_identifiers[SUBID_MAX];
     152                 :            : 
     153                 :            : /* Single-letter codes for builtin integer types, defined in
     154                 :            :    <builtin-type>.  These are indexed by integer_type_kind values.  */
     155                 :            : static const char
     156                 :            : integer_type_codes[itk_none] =
     157                 :            : {
     158                 :            :   'c',  /* itk_char */
     159                 :            :   'a',  /* itk_signed_char */
     160                 :            :   'h',  /* itk_unsigned_char */
     161                 :            :   's',  /* itk_short */
     162                 :            :   't',  /* itk_unsigned_short */
     163                 :            :   'i',  /* itk_int */
     164                 :            :   'j',  /* itk_unsigned_int */
     165                 :            :   'l',  /* itk_long */
     166                 :            :   'm',  /* itk_unsigned_long */
     167                 :            :   'x',  /* itk_long_long */
     168                 :            :   'y',  /* itk_unsigned_long_long */
     169                 :            :   /* __intN types are handled separately */
     170                 :            :   '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
     171                 :            : };
     172                 :            : 
     173                 :            : static int decl_is_template_id (const tree, tree* const);
     174                 :            : 
     175                 :            : /* Functions for handling substitutions.  */
     176                 :            : 
     177                 :            : static inline tree canonicalize_for_substitution (tree);
     178                 :            : static void add_substitution (tree);
     179                 :            : static inline int is_std_substitution (const tree,
     180                 :            :                                        const substitution_identifier_index_t);
     181                 :            : static inline int is_std_substitution_char (const tree,
     182                 :            :                                             const substitution_identifier_index_t);
     183                 :            : static int find_substitution (tree);
     184                 :            : static void mangle_call_offset (const tree, const tree);
     185                 :            : 
     186                 :            : /* Functions for emitting mangled representations of things.  */
     187                 :            : 
     188                 :            : static void write_mangled_name (const tree, bool);
     189                 :            : static void write_encoding (const tree);
     190                 :            : static void write_name (tree, const int);
     191                 :            : static void write_abi_tags (tree);
     192                 :            : static void write_unscoped_name (const tree);
     193                 :            : static void write_unscoped_template_name (const tree);
     194                 :            : static void write_nested_name (const tree);
     195                 :            : static void write_prefix (const tree);
     196                 :            : static void write_template_prefix (const tree);
     197                 :            : static void write_unqualified_name (tree);
     198                 :            : static void write_conversion_operator_name (const tree);
     199                 :            : static void write_source_name (tree);
     200                 :            : static void write_literal_operator_name (tree);
     201                 :            : static void write_unnamed_type_name (const tree);
     202                 :            : static void write_closure_type_name (const tree);
     203                 :            : static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
     204                 :            :                            const unsigned int);
     205                 :            : static void write_number (unsigned HOST_WIDE_INT, const int,
     206                 :            :                           const unsigned int);
     207                 :            : static void write_compact_number (int num);
     208                 :            : static void write_integer_cst (const tree);
     209                 :            : static void write_real_cst (const tree);
     210                 :            : static void write_identifier (const char *);
     211                 :            : static void write_special_name_constructor (const tree);
     212                 :            : static void write_special_name_destructor (const tree);
     213                 :            : static void write_type (tree);
     214                 :            : static int write_CV_qualifiers_for_type (const tree);
     215                 :            : static void write_builtin_type (tree);
     216                 :            : static void write_function_type (const tree);
     217                 :            : static void write_bare_function_type (const tree, const int, const tree);
     218                 :            : static void write_method_parms (tree, const int, const tree);
     219                 :            : static void write_class_enum_type (const tree);
     220                 :            : static void write_template_args (tree);
     221                 :            : static void write_expression (tree);
     222                 :            : static void write_template_arg_literal (const tree);
     223                 :            : static void write_template_arg (tree);
     224                 :            : static void write_template_template_arg (const tree);
     225                 :            : static void write_array_type (const tree);
     226                 :            : static void write_pointer_to_member_type (const tree);
     227                 :            : static void write_template_param (const tree);
     228                 :            : static void write_template_template_param (const tree);
     229                 :            : static void write_substitution (const int);
     230                 :            : static int discriminator_for_local_entity (tree);
     231                 :            : static int discriminator_for_string_literal (tree, tree);
     232                 :            : static void write_discriminator (const int);
     233                 :            : static void write_local_name (tree, const tree, const tree);
     234                 :            : static void dump_substitution_candidates (void);
     235                 :            : static tree mangle_decl_string (const tree);
     236                 :            : static void maybe_check_abi_tags (tree, tree = NULL_TREE, int = 10);
     237                 :            : static bool equal_abi_tags (tree, tree);
     238                 :            : 
     239                 :            : /* Control functions.  */
     240                 :            : 
     241                 :            : static inline void start_mangling (const tree);
     242                 :            : static tree mangle_special_for_type (const tree, const char *);
     243                 :            : 
     244                 :            : /* Append a single character to the end of the mangled
     245                 :            :    representation.  */
     246                 :            : #define write_char(CHAR)                                                \
     247                 :            :   obstack_1grow (mangle_obstack, (CHAR))
     248                 :            : 
     249                 :            : /* Append a sized buffer to the end of the mangled representation.  */
     250                 :            : #define write_chars(CHAR, LEN)                                          \
     251                 :            :   obstack_grow (mangle_obstack, (CHAR), (LEN))
     252                 :            : 
     253                 :            : /* Append a NUL-terminated string to the end of the mangled
     254                 :            :    representation.  */
     255                 :            : #define write_string(STRING)                                            \
     256                 :            :   obstack_grow (mangle_obstack, (STRING), strlen (STRING))
     257                 :            : 
     258                 :            : /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
     259                 :            :    same purpose (context, which may be a type) and value (template
     260                 :            :    decl).  See write_template_prefix for more information on what this
     261                 :            :    is used for.  */
     262                 :            : #define NESTED_TEMPLATE_MATCH(NODE1, NODE2)                             \
     263                 :            :   (TREE_CODE (NODE1) == TREE_LIST                                       \
     264                 :            :    && TREE_CODE (NODE2) == TREE_LIST                                    \
     265                 :            :    && ((TYPE_P (TREE_PURPOSE (NODE1))                                   \
     266                 :            :         && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2)))    \
     267                 :            :        || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2))                 \
     268                 :            :    && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
     269                 :            : 
     270                 :            : /* Write out an unsigned quantity in base 10.  */
     271                 :            : #define write_unsigned_number(NUMBER)                                   \
     272                 :            :   write_number ((NUMBER), /*unsigned_p=*/1, 10)
     273                 :            : 
     274                 :            : /* If DECL is a template instance (including the uninstantiated template
     275                 :            :    itself), return nonzero and, if TEMPLATE_INFO is non-NULL, set
     276                 :            :    *TEMPLATE_INFO to its template info.  Otherwise return zero.  */
     277                 :            : 
     278                 :            : static int
     279                 :  269599000 : decl_is_template_id (const tree decl, tree* const template_info)
     280                 :            : {
     281                 :  269599000 :   if (TREE_CODE (decl) == TYPE_DECL)
     282                 :            :     {
     283                 :            :       /* TYPE_DECLs are handled specially.  Look at its type to decide
     284                 :            :          if this is a template instantiation.  */
     285                 :  100597000 :       const tree type = TREE_TYPE (decl);
     286                 :            : 
     287                 :  196186000 :       if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
     288                 :            :         {
     289                 :   84352100 :           if (template_info != NULL)
     290                 :            :             /* For a templated TYPE_DECL, the template info is hanging
     291                 :            :                off the type.  */
     292                 :   84352100 :             *template_info = TYPE_TEMPLATE_INFO (type);
     293                 :   84352100 :           return 1;
     294                 :            :         }
     295                 :            :     }
     296                 :            :   else
     297                 :            :     {
     298                 :            :       /* Check if this is a primary template.  */
     299                 :  169002000 :       if (DECL_LANG_SPECIFIC (decl) != NULL
     300                 :  167830000 :           && VAR_OR_FUNCTION_DECL_P (decl)
     301                 :  146442000 :           && DECL_TEMPLATE_INFO (decl)
     302                 :  124603000 :           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
     303                 :  185914000 :           && TREE_CODE (decl) != TEMPLATE_DECL)
     304                 :            :         {
     305                 :   16911900 :           if (template_info != NULL)
     306                 :            :             /* For most templated decls, the template info is hanging
     307                 :            :                off the decl.  */
     308                 :    7271120 :             *template_info = DECL_TEMPLATE_INFO (decl);
     309                 :   16911900 :           return 1;
     310                 :            :         }
     311                 :            :     }
     312                 :            : 
     313                 :            :   /* It's not a template id.  */
     314                 :            :   return 0;
     315                 :            : }
     316                 :            : 
     317                 :            : /* Produce debugging output of current substitution candidates.  */
     318                 :            : 
     319                 :            : static void
     320                 :          0 : dump_substitution_candidates (void)
     321                 :            : {
     322                 :          0 :   unsigned i;
     323                 :          0 :   tree el;
     324                 :            : 
     325                 :          0 :   fprintf (stderr, "  ++ substitutions  ");
     326                 :          0 :   FOR_EACH_VEC_ELT (*G.substitutions, i, el)
     327                 :            :     {
     328                 :          0 :       const char *name = "???";
     329                 :            : 
     330                 :          0 :       if (i > 0)
     331                 :          0 :         fprintf (stderr, "                    ");
     332                 :          0 :       if (DECL_P (el))
     333                 :          0 :         name = IDENTIFIER_POINTER (DECL_NAME (el));
     334                 :          0 :       else if (TREE_CODE (el) == TREE_LIST)
     335                 :          0 :         name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
     336                 :          0 :       else if (TYPE_NAME (el))
     337                 :          0 :         name = TYPE_NAME_STRING (el);
     338                 :          0 :       fprintf (stderr, " S%d_ = ", i - 1);
     339                 :          0 :       if (TYPE_P (el) &&
     340                 :          0 :           (CP_TYPE_RESTRICT_P (el)
     341                 :          0 :            || CP_TYPE_VOLATILE_P (el)
     342                 :          0 :            || CP_TYPE_CONST_P (el)))
     343                 :          0 :         fprintf (stderr, "CV-");
     344                 :          0 :       fprintf (stderr, "%s (%s at %p)\n",
     345                 :          0 :                name, get_tree_code_name (TREE_CODE (el)), (void *) el);
     346                 :            :     }
     347                 :          0 : }
     348                 :            : 
     349                 :            : /* <exception-spec> ::=
     350                 :            :       Do  -- non-throwing exception specification
     351                 :            :       DO <expression> E  -- computed (instantiation-dependent) noexcept
     352                 :            :       Dw <type>* E  -- throw (types)  */
     353                 :            : 
     354                 :            : static void
     355                 :    1809350 : write_exception_spec (tree spec)
     356                 :            : {
     357                 :            : 
     358                 :    1809350 :   if (!spec || spec == noexcept_false_spec)
     359                 :            :     /* Nothing.  */
     360                 :            :     return;
     361                 :            : 
     362                 :        374 :   if (!flag_noexcept_type)
     363                 :            :     {
     364                 :          8 :       G.need_cxx17_warning = true;
     365                 :          8 :       return;
     366                 :            :     }
     367                 :            : 
     368                 :        366 :   if (spec == noexcept_true_spec || spec == empty_except_spec)
     369                 :        362 :     write_string ("Do");
     370                 :          4 :   else if (tree expr = TREE_PURPOSE (spec))
     371                 :            :     {
     372                 :            :       /* noexcept (expr)  */
     373                 :          4 :       gcc_assert (uses_template_parms (expr));
     374                 :          4 :       write_string ("DO");
     375                 :          4 :       write_expression (expr);
     376                 :          4 :       write_char ('E');
     377                 :            :     }
     378                 :            :   else
     379                 :            :     {
     380                 :            :       /* throw (type-list) */
     381                 :          0 :       write_string ("Dw");
     382                 :          0 :       for (tree t = spec; t; t = TREE_CHAIN (t))
     383                 :          0 :         write_type (TREE_VALUE (t));
     384                 :          0 :       write_char ('E');
     385                 :            :     }
     386                 :            : }
     387                 :            : 
     388                 :            : /* Both decls and types can be substitution candidates, but sometimes
     389                 :            :    they refer to the same thing.  For instance, a TYPE_DECL and
     390                 :            :    RECORD_TYPE for the same class refer to the same thing, and should
     391                 :            :    be treated accordingly in substitutions.  This function returns a
     392                 :            :    canonicalized tree node representing NODE that is used when adding
     393                 :            :    and substitution candidates and finding matches.  */
     394                 :            : 
     395                 :            : static inline tree
     396                 :  987369000 : canonicalize_for_substitution (tree node)
     397                 :            : {
     398                 :            :   /* For a TYPE_DECL, use the type instead.  */
     399                 :  987369000 :   if (TREE_CODE (node) == TYPE_DECL)
     400                 :          0 :     node = TREE_TYPE (node);
     401                 :  987369000 :   if (TYPE_P (node)
     402                 :  748350000 :       && TYPE_CANONICAL (node) != node
     403                 : 1104120000 :       && TYPE_MAIN_VARIANT (node) != node)
     404                 :            :     {
     405                 :   28055800 :       tree orig = node;
     406                 :            :       /* Here we want to strip the topmost typedef only.
     407                 :            :          We need to do that so is_std_substitution can do proper
     408                 :            :          name matching.  */
     409                 :   28055800 :       if (TREE_CODE (node) == FUNCTION_TYPE)
     410                 :            :         /* Use build_qualified_type and TYPE_QUALS here to preserve
     411                 :            :            the old buggy mangling of attribute noreturn with abi<5.  */
     412                 :        210 :         node = build_qualified_type (TYPE_MAIN_VARIANT (node),
     413                 :        210 :                                      TYPE_QUALS (node));
     414                 :            :       else
     415                 :   28055500 :         node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node),
     416                 :            :                                         cp_type_quals (node));
     417                 :   28055800 :       if (FUNC_OR_METHOD_TYPE_P (node))
     418                 :            :         {
     419                 :        210 :           node = build_ref_qualified_type (node, type_memfn_rqual (orig));
     420                 :        210 :           tree r = canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (orig));
     421                 :        210 :           if (flag_noexcept_type)
     422                 :        166 :             node = build_exception_variant (node, r);
     423                 :            :           else
     424                 :            :             /* Set the warning flag if appropriate.  */
     425                 :         44 :             write_exception_spec (r);
     426                 :            :         }
     427                 :            :     }
     428                 :  987369000 :   return node;
     429                 :            : }
     430                 :            : 
     431                 :            : /* Add NODE as a substitution candidate.  NODE must not already be on
     432                 :            :    the list of candidates.  */
     433                 :            : 
     434                 :            : static void
     435                 :  257936000 : add_substitution (tree node)
     436                 :            : {
     437                 :  257936000 :   tree c;
     438                 :            : 
     439                 :  257936000 :   if (DEBUG_MANGLE)
     440                 :            :     fprintf (stderr, "  ++ add_substitution (%s at %10p)\n",
     441                 :            :              get_tree_code_name (TREE_CODE (node)), (void *) node);
     442                 :            : 
     443                 :            :   /* Get the canonicalized substitution candidate for NODE.  */
     444                 :  257936000 :   c = canonicalize_for_substitution (node);
     445                 :  257936000 :   if (DEBUG_MANGLE && c != node)
     446                 :            :     fprintf (stderr, "  ++ using candidate (%s at %10p)\n",
     447                 :            :              get_tree_code_name (TREE_CODE (node)), (void *) node);
     448                 :  257936000 :   node = c;
     449                 :            : 
     450                 :            :   /* Make sure NODE isn't already a candidate.  */
     451                 :  257936000 :   if (flag_checking)
     452                 :            :     {
     453                 :            :       int i;
     454                 :            :       tree candidate;
     455                 :            : 
     456                 : 1291860000 :       FOR_EACH_VEC_SAFE_ELT (G.substitutions, i, candidate)
     457                 :            :         {
     458                 : 1033920000 :           gcc_assert (!(DECL_P (node) && node == candidate));
     459                 : 1033920000 :           gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
     460                 :            :                       && same_type_p (node, candidate)));
     461                 :            :         }
     462                 :            :     }
     463                 :            : 
     464                 :            :   /* Put the decl onto the varray of substitution candidates.  */
     465                 :  257936000 :   vec_safe_push (G.substitutions, node);
     466                 :            : 
     467                 :  257936000 :   if (DEBUG_MANGLE)
     468                 :            :     dump_substitution_candidates ();
     469                 :  257936000 : }
     470                 :            : 
     471                 :            : /* Helper function for find_substitution.  Returns nonzero if NODE,
     472                 :            :    which may be a decl or a CLASS_TYPE, is a template-id with template
     473                 :            :    name of substitution_index[INDEX] in the ::std namespace.  */
     474                 :            : 
     475                 :            : static inline int
     476                 :  834011000 : is_std_substitution (const tree node,
     477                 :            :                      const substitution_identifier_index_t index)
     478                 :            : {
     479                 :  834011000 :   tree type = NULL;
     480                 :  834011000 :   tree decl = NULL;
     481                 :            : 
     482                 :  834011000 :   if (DECL_P (node))
     483                 :            :     {
     484                 :  827439000 :       type = TREE_TYPE (node);
     485                 :  827439000 :       decl = node;
     486                 :            :     }
     487                 :    7159790 :   else if (CLASS_TYPE_P (node))
     488                 :            :     {
     489                 :     588504 :       type = node;
     490                 :     588504 :       decl = TYPE_NAME (node);
     491                 :            :     }
     492                 :            :   else
     493                 :            :     /* These are not the droids you're looking for.  */
     494                 :            :     return 0;
     495                 :            : 
     496                 :  828028000 :   return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
     497                 :  315693000 :           && TYPE_LANG_SPECIFIC (type)
     498                 :  282596000 :           && TYPE_TEMPLATE_INFO (type)
     499                 : 1345500000 :           && (DECL_NAME (TYPE_TI_TEMPLATE (type))
     500                 : 1049750000 :               == subst_identifiers[index]));
     501                 :            : }
     502                 :            : 
     503                 :            : /* Return the ABI tags (the TREE_VALUE of the "abi_tag" attribute entry) for T,
     504                 :            :    which can be a decl or type.  */
     505                 :            : 
     506                 :            : static tree
     507                 :  373171000 : get_abi_tags (tree t)
     508                 :            : {
     509                 :  373171000 :   if (!t || TREE_CODE (t) == NAMESPACE_DECL)
     510                 :            :     return NULL_TREE;
     511                 :            : 
     512                 :  351990000 :   if (DECL_P (t) && DECL_DECLARES_TYPE_P (t))
     513                 :   90873400 :     t = TREE_TYPE (t);
     514                 :            : 
     515                 :  351990000 :   tree attrs;
     516                 :  351990000 :   if (TYPE_P (t))
     517                 :  303418000 :     attrs = TYPE_ATTRIBUTES (t);
     518                 :            :   else
     519                 :   48571600 :     attrs = DECL_ATTRIBUTES (t);
     520                 :            : 
     521                 :  351990000 :   tree tags = lookup_attribute ("abi_tag", attrs);
     522                 :  351990000 :   if (tags)
     523                 :    3177450 :     tags = TREE_VALUE (tags);
     524                 :            :   return tags;
     525                 :            : }
     526                 :            : 
     527                 :            : /* Helper function for find_substitution.  Returns nonzero if NODE,
     528                 :            :    which may be a decl or a CLASS_TYPE, is the template-id
     529                 :            :    ::std::identifier<char>, where identifier is
     530                 :            :    substitution_index[INDEX].  */
     531                 :            : 
     532                 :            : static inline int
     533                 :     878561 : is_std_substitution_char (const tree node,
     534                 :            :                           const substitution_identifier_index_t index)
     535                 :            : {
     536                 :     878561 :   tree args;
     537                 :            :   /* Check NODE's name is ::std::identifier.  */
     538                 :     878561 :   if (!is_std_substitution (node, index))
     539                 :            :     return 0;
     540                 :            :   /* Figure out its template args.  */
     541                 :     446378 :   if (DECL_P (node))
     542                 :          0 :     args = DECL_TI_ARGS (node);
     543                 :     892756 :   else if (CLASS_TYPE_P (node))
     544                 :     446378 :     args = CLASSTYPE_TI_ARGS (node);
     545                 :            :   else
     546                 :            :     /* Oops, not a template.  */
     547                 :            :     return 0;
     548                 :            :   /* NODE's template arg list should be <char>.  */
     549                 :     446378 :   return
     550                 :     446378 :     TREE_VEC_LENGTH (args) == 1
     551                 :     446382 :     && TREE_VEC_ELT (args, 0) == char_type_node;
     552                 :            : }
     553                 :            : 
     554                 :            : /* Check whether a substitution should be used to represent NODE in
     555                 :            :    the mangling.
     556                 :            : 
     557                 :            :    First, check standard special-case substitutions.
     558                 :            : 
     559                 :            :      <substitution> ::= St
     560                 :            :          # ::std
     561                 :            : 
     562                 :            :                     ::= Sa
     563                 :            :          # ::std::allocator
     564                 :            : 
     565                 :            :                     ::= Sb
     566                 :            :          # ::std::basic_string
     567                 :            : 
     568                 :            :                     ::= Ss
     569                 :            :          # ::std::basic_string<char,
     570                 :            :                                ::std::char_traits<char>,
     571                 :            :                                ::std::allocator<char> >
     572                 :            : 
     573                 :            :                     ::= Si
     574                 :            :          # ::std::basic_istream<char, ::std::char_traits<char> >
     575                 :            : 
     576                 :            :                     ::= So
     577                 :            :          # ::std::basic_ostream<char, ::std::char_traits<char> >
     578                 :            : 
     579                 :            :                     ::= Sd
     580                 :            :          # ::std::basic_iostream<char, ::std::char_traits<char> >
     581                 :            : 
     582                 :            :    Then examine the stack of currently available substitution
     583                 :            :    candidates for entities appearing earlier in the same mangling
     584                 :            : 
     585                 :            :    If a substitution is found, write its mangled representation and
     586                 :            :    return nonzero.  If none is found, just return zero.  */
     587                 :            : 
     588                 :            : static int
     589                 :  466662000 : find_substitution (tree node)
     590                 :            : {
     591                 :  466662000 :   int i;
     592                 :  466662000 :   const int size = vec_safe_length (G.substitutions);
     593                 :  466662000 :   tree decl;
     594                 :  466662000 :   tree type;
     595                 :  466662000 :   const char *abbr = NULL;
     596                 :            : 
     597                 :  466662000 :   if (DEBUG_MANGLE)
     598                 :            :     fprintf (stderr, "  ++ find_substitution (%s at %p)\n",
     599                 :            :              get_tree_code_name (TREE_CODE (node)), (void *) node);
     600                 :            : 
     601                 :            :   /* Obtain the canonicalized substitution representation for NODE.
     602                 :            :      This is what we'll compare against.  */
     603                 :  466662000 :   node = canonicalize_for_substitution (node);
     604                 :            : 
     605                 :            :   /* Check for builtin substitutions.  */
     606                 :            : 
     607                 :  466662000 :   decl = TYPE_P (node) ? TYPE_NAME (node) : node;
     608                 :  617859000 :   type = TYPE_P (node) ? node : TREE_TYPE (node);
     609                 :            : 
     610                 :            :   /* Check for std::allocator.  */
     611                 :  466662000 :   if (decl
     612                 :  424082000 :       && is_std_substitution (decl, SUBID_ALLOCATOR)
     613                 :  502913000 :       && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
     614                 :            :     abbr = "Sa";
     615                 :            : 
     616                 :            :   /* Check for std::basic_string.  */
     617                 :  450730000 :   else if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
     618                 :            :     {
     619                 :     215202 :       if (TYPE_P (node))
     620                 :            :         {
     621                 :            :           /* If this is a type (i.e. a fully-qualified template-id),
     622                 :            :              check for
     623                 :            :                  std::basic_string <char,
     624                 :            :                                     std::char_traits<char>,
     625                 :            :                                     std::allocator<char> > .  */
     626                 :     149384 :           if (cp_type_quals (type) == TYPE_UNQUALIFIED
     627                 :     282632 :               && CLASSTYPE_USE_TEMPLATE (type))
     628                 :            :             {
     629                 :     133248 :               tree args = CLASSTYPE_TI_ARGS (type);
     630                 :     133248 :               if (TREE_VEC_LENGTH (args) == 3
     631                 :     133248 :                   && (TREE_CODE (TREE_VEC_ELT (args, 0))
     632                 :     133248 :                       == TREE_CODE (char_type_node))
     633                 :     131932 :                   && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
     634                 :      51777 :                   && is_std_substitution_char (TREE_VEC_ELT (args, 1),
     635                 :            :                                                SUBID_CHAR_TRAITS)
     636                 :     185017 :                   && is_std_substitution_char (TREE_VEC_ELT (args, 2),
     637                 :            :                                                SUBID_ALLOCATOR))
     638                 :            :                 abbr = "Ss";
     639                 :            :             }
     640                 :            :         }
     641                 :            :       else
     642                 :            :         /* Substitute for the template name only if this isn't a type.  */
     643                 :            :         abbr = "Sb";
     644                 :            :     }
     645                 :            : 
     646                 :            :   /* Check for basic_{i,o,io}stream.  */
     647                 :  450515000 :   else if (TYPE_P (node)
     648                 :  315315000 :            && cp_type_quals (type) == TYPE_UNQUALIFIED
     649                 :  420403000 :            && CLASS_TYPE_P (type)
     650                 :  121853000 :            && CLASSTYPE_USE_TEMPLATE (type)
     651                 :  544739000 :            && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
     652                 :            :     {
     653                 :            :       /* First, check for the template
     654                 :            :          args <char, std::char_traits<char> > .  */
     655                 :   94224200 :       tree args = CLASSTYPE_TI_ARGS (type);
     656                 :   94224200 :       if (TREE_VEC_LENGTH (args) == 2
     657                 :   25161200 :           && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_CODE (char_type_node)
     658                 :   10066000 :           && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
     659                 :   94999200 :           && is_std_substitution_char (TREE_VEC_ELT (args, 1),
     660                 :            :                                        SUBID_CHAR_TRAITS))
     661                 :            :         {
     662                 :            :           /* Got them.  Is this basic_istream?  */
     663                 :     342836 :           if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
     664                 :            :             abbr = "Si";
     665                 :            :           /* Or basic_ostream?  */
     666                 :     302460 :           else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
     667                 :            :             abbr = "So";
     668                 :            :           /* Or basic_iostream?  */
     669                 :     254131 :           else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
     670                 :      12043 :             abbr = "Sd";
     671                 :            :         }
     672                 :            :     }
     673                 :            : 
     674                 :            :   /* Check for namespace std.  */
     675                 :  356291000 :   else if (decl && DECL_NAMESPACE_STD_P (decl))
     676                 :            :     {
     677                 :   42704900 :       write_string ("St");
     678                 :   42704900 :       return 1;
     679                 :            :     }
     680                 :            : 
     681                 :  423957000 :   tree tags = NULL_TREE;
     682                 :  553548000 :   if (OVERLOAD_TYPE_P (node) || DECL_CLASS_TEMPLATE_P (node))
     683                 :  212545000 :     tags = get_abi_tags (type);
     684                 :            :   /* Now check the list of available substitutions for this mangling
     685                 :            :      operation.  */
     686                 : 1767430000 :   if (!abbr || tags) for (i = 0; i < size; ++i)
     687                 :            :     {
     688                 : 1374360000 :       tree candidate = (*G.substitutions)[i];
     689                 :            :       /* NODE is a matched to a candidate if it's the same decl node or
     690                 :            :          if it's the same type.  */
     691                 : 1374360000 :       if (decl == candidate
     692                 : 1370830000 :           || (TYPE_P (candidate) && type && TYPE_P (node)
     693                 :  663584000 :               && same_type_p (type, candidate))
     694                 : 2718170000 :           || NESTED_TEMPLATE_MATCH (node, candidate))
     695                 :            :         {
     696                 :   30889200 :           write_substitution (i);
     697                 :   30889200 :           return 1;
     698                 :            :         }
     699                 :            :     }
     700                 :            : 
     701                 :  393068000 :   if (!abbr)
     702                 :            :     /* No substitution found.  */
     703                 :            :     return 0;
     704                 :            : 
     705                 :   16150100 :   write_string (abbr);
     706                 :   16150100 :   if (tags)
     707                 :            :     {
     708                 :            :       /* If there are ABI tags on the abbreviation, it becomes
     709                 :            :          a substitution candidate.  */
     710                 :          8 :       write_abi_tags (tags);
     711                 :          8 :       add_substitution (node);
     712                 :            :     }
     713                 :            :   return 1;
     714                 :            : }
     715                 :            : 
     716                 :            : /* Returns whether DECL's symbol name should be the plain unqualified-id
     717                 :            :    rather than a more complicated mangled name.  */
     718                 :            : 
     719                 :            : static bool
     720                 :   47636400 : unmangled_name_p (const tree decl)
     721                 :            : {
     722                 :   47636400 :   if (TREE_CODE (decl) == FUNCTION_DECL)
     723                 :            :     {
     724                 :            :       /* The names of `extern "C"' functions are not mangled.  */
     725                 :   81370300 :       return (DECL_EXTERN_C_FUNCTION_P (decl)
     726                 :            :               /* But overloaded operator names *are* mangled.  */
     727                 :    1744020 :               && !DECL_OVERLOADED_OPERATOR_P (decl));
     728                 :            :     }
     729                 :    6951310 :   else if (VAR_P (decl))
     730                 :            :     {
     731                 :            :       /* static variables are mangled.  */
     732                 :    6951240 :       if (!DECL_EXTERNAL_LINKAGE_P (decl))
     733                 :            :         return false;
     734                 :            : 
     735                 :            :       /* extern "C" declarations aren't mangled.  */
     736                 :    6836140 :       if (DECL_EXTERN_C_P (decl))
     737                 :            :         return true;
     738                 :            : 
     739                 :            :       /* Other variables at non-global scope are mangled.  */
     740                 :    6660360 :       if (CP_DECL_CONTEXT (decl) != global_namespace)
     741                 :            :         return false;
     742                 :            : 
     743                 :            :       /* Variable template instantiations are mangled.  */
     744                 :      97867 :       if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
     745                 :      98073 :           && variable_template_p (DECL_TI_TEMPLATE (decl)))
     746                 :            :         return false;
     747                 :            : 
     748                 :            :       /* Declarations with ABI tags are mangled.  */
     749                 :      97681 :       if (get_abi_tags (decl))
     750                 :            :         return false;
     751                 :            : 
     752                 :            :       /* The names of non-static global variables aren't mangled.  */
     753                 :      97438 :       return true;
     754                 :            :     }
     755                 :            : 
     756                 :            :   return false;
     757                 :            : }
     758                 :            : 
     759                 :            : /* TOP_LEVEL is true, if this is being called at outermost level of
     760                 :            :   mangling. It should be false when mangling a decl appearing in an
     761                 :            :   expression within some other mangling.
     762                 :            : 
     763                 :            :   <mangled-name>      ::= _Z <encoding>  */
     764                 :            : 
     765                 :            : static void
     766                 :   47636400 : write_mangled_name (const tree decl, bool top_level)
     767                 :            : {
     768                 :   47636400 :   MANGLE_TRACE_TREE ("mangled-name", decl);
     769                 :            : 
     770                 :   47636400 :   check_abi_tags (decl);
     771                 :            : 
     772                 :   47636400 :   if (unmangled_name_p (decl))
     773                 :            :     {
     774                 :    2017230 :       if (top_level)
     775                 :    2017080 :         write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
     776                 :            :       else
     777                 :            :         {
     778                 :            :           /* The standard notes: "The <encoding> of an extern "C"
     779                 :            :              function is treated like global-scope data, i.e. as its
     780                 :            :              <source-name> without a type."  We cannot write
     781                 :            :              overloaded operators that way though, because it contains
     782                 :            :              characters invalid in assembler.  */
     783                 :        153 :           write_string ("_Z");
     784                 :        153 :           write_source_name (DECL_NAME (decl));
     785                 :            :         }
     786                 :            :     }
     787                 :            :   else
     788                 :            :     {
     789                 :   45619200 :       write_string ("_Z");
     790                 :   45619200 :       write_encoding (decl);
     791                 :            :     }
     792                 :   47636400 : }
     793                 :            : 
     794                 :            : /* Returns true if the return type of DECL is part of its signature, and
     795                 :            :    therefore its mangling.  */
     796                 :            : 
     797                 :            : bool
     798                 :   81087700 : mangle_return_type_p (tree decl)
     799                 :            : {
     800                 :   81087700 :   return (!DECL_CONSTRUCTOR_P (decl)
     801                 :   62898400 :           && !DECL_DESTRUCTOR_P (decl)
     802                 :   57618000 :           && !DECL_CONV_FN_P (decl)
     803                 :  138290000 :           && decl_is_template_id (decl, NULL));
     804                 :            : }
     805                 :            : 
     806                 :            : /*   <encoding>           ::= <function name> <bare-function-type>
     807                 :            :                         ::= <data name>  */
     808                 :            : 
     809                 :            : static void
     810                 :   46893200 : write_encoding (const tree decl)
     811                 :            : {
     812                 :   46893200 :   MANGLE_TRACE_TREE ("encoding", decl);
     813                 :            : 
     814                 :   46893200 :   if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
     815                 :            :     {
     816                 :            :       /* For overloaded operators write just the mangled name
     817                 :            :          without arguments.  */
     818                 :       6262 :       if (DECL_OVERLOADED_OPERATOR_P (decl))
     819                 :          4 :         write_name (decl, /*ignore_local_scope=*/0);
     820                 :            :       else
     821                 :       6258 :         write_source_name (DECL_NAME (decl));
     822                 :       6262 :       return;
     823                 :            :     }
     824                 :            : 
     825                 :   46886900 :   write_name (decl, /*ignore_local_scope=*/0);
     826                 :   46886900 :   if (TREE_CODE (decl) == FUNCTION_DECL)
     827                 :            :     {
     828                 :   40208600 :       tree fn_type;
     829                 :   40208600 :       tree d;
     830                 :   40208600 :       bool tmpl = decl_is_template_id (decl, NULL);
     831                 :            : 
     832                 :   40208600 :       if (tmpl)
     833                 :            :         {
     834                 :    4159400 :           fn_type = get_mostly_instantiated_function_type (decl);
     835                 :            :           /* FN_TYPE will not have parameter types for in-charge or
     836                 :            :              VTT parameters.  Therefore, we pass NULL_TREE to
     837                 :            :              write_bare_function_type -- otherwise, it will get
     838                 :            :              confused about which artificial parameters to skip.  */
     839                 :    4159400 :           d = NULL_TREE;
     840                 :            :         }
     841                 :            :       else
     842                 :            :         {
     843                 :   36049200 :           fn_type = TREE_TYPE (decl);
     844                 :   36049200 :           d = decl;
     845                 :            :         }
     846                 :            : 
     847                 :   40208600 :       write_bare_function_type (fn_type,
     848                 :   40208600 :                                 mangle_return_type_p (decl),
     849                 :            :                                 d);
     850                 :            :     }
     851                 :            : }
     852                 :            : 
     853                 :            : /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
     854                 :            :    or PARM_DECL context, which doesn't belong in DECL_CONTEXT.  */
     855                 :            : 
     856                 :            : static tree
     857                 :  388685000 : decl_mangling_context (tree decl)
     858                 :            : {
     859                 :  388686000 :   tree tcontext = targetm.cxx.decl_mangling_context (decl);
     860                 :            : 
     861                 :  388686000 :   if (tcontext != NULL_TREE)
     862                 :            :     return tcontext;
     863                 :            : 
     864                 :  388686000 :   if (TREE_CODE (decl) == TEMPLATE_DECL
     865                 :  388686000 :       && DECL_TEMPLATE_RESULT (decl))
     866                 :  388686000 :     decl = DECL_TEMPLATE_RESULT (decl);
     867                 :            : 
     868                 :  388686000 :   if (TREE_CODE (decl) == TYPE_DECL
     869                 :  590900000 :       && LAMBDA_TYPE_P (TREE_TYPE (decl)))
     870                 :            :     {
     871                 :     329044 :       tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl));
     872                 :     329044 :       if (extra)
     873                 :            :         return extra;
     874                 :            :     }
     875                 :  388357000 :   else if (template_type_parameter_p (decl))
     876                 :            :      /* template type parms have no mangling context.  */
     877                 :            :       return NULL_TREE;
     878                 :            : 
     879                 :  388357000 :   tcontext = CP_DECL_CONTEXT (decl);
     880                 :            : 
     881                 :            :   /* Ignore the artificial declare reduction functions.  */
     882                 :  388357000 :   if (tcontext
     883                 :  388357000 :       && TREE_CODE (tcontext) == FUNCTION_DECL
     884                 :  390699000 :       && DECL_OMP_DECLARE_REDUCTION_P (tcontext))
     885                 :            :     return decl_mangling_context (tcontext);
     886                 :            : 
     887                 :            :   return tcontext;
     888                 :            : }
     889                 :            : 
     890                 :            : /* <name> ::= <unscoped-name>
     891                 :            :           ::= <unscoped-template-name> <template-args>
     892                 :            :           ::= <nested-name>
     893                 :            :           ::= <local-name>
     894                 :            : 
     895                 :            :    If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
     896                 :            :    called from <local-name>, which mangles the enclosing scope
     897                 :            :    elsewhere and then uses this function to mangle just the part
     898                 :            :    underneath the function scope.  So don't use the <local-name>
     899                 :            :    production, to avoid an infinite recursion.  */
     900                 :            : 
     901                 :            : static void
     902                 :  104930000 : write_name (tree decl, const int ignore_local_scope)
     903                 :            : {
     904                 :  104930000 :   tree context;
     905                 :            : 
     906                 :  104930000 :   MANGLE_TRACE_TREE ("name", decl);
     907                 :            : 
     908                 :  104930000 :   if (TREE_CODE (decl) == TYPE_DECL)
     909                 :            :     {
     910                 :            :       /* In case this is a typedef, fish out the corresponding
     911                 :            :          TYPE_DECL for the main variant.  */
     912                 :   56656600 :       decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
     913                 :            :     }
     914                 :            : 
     915                 :  104930000 :   context = decl_mangling_context (decl);
     916                 :            : 
     917                 :  104930000 :   gcc_assert (context != NULL_TREE);
     918                 :            : 
     919                 :  108618000 :   if (abi_warn_or_compat_version_crosses (7)
     920                 :    1244200 :       && ignore_local_scope
     921                 :      20260 :       && TREE_CODE (context) == PARM_DECL)
     922                 :          0 :     G.need_abi_warning = 1;
     923                 :            : 
     924                 :            :   /* A decl in :: or ::std scope is treated specially.  The former is
     925                 :            :      mangled using <unscoped-name> or <unscoped-template-name>, the
     926                 :            :      latter with a special substitution.  Also, a name that is
     927                 :            :      directly in a local function scope is also mangled with
     928                 :            :      <unscoped-name> rather than a full <nested-name>.  */
     929                 :  104930000 :   if (context == global_namespace
     930                 :  102135000 :       || DECL_NAMESPACE_STD_P (context)
     931                 :   59567800 :       || (ignore_local_scope
     932                 :    1241630 :           && (TREE_CODE (context) == FUNCTION_DECL
     933                 :    1115850 :               || (abi_version_at_least (7)
     934                 :    1102360 :                   && TREE_CODE (context) == PARM_DECL))))
     935                 :            :     {
     936                 :   45488000 :       tree template_info;
     937                 :            :       /* Is this a template instance?  */
     938                 :   45488000 :       if (decl_is_template_id (decl, &template_info))
     939                 :            :         {
     940                 :            :           /* Yes: use <unscoped-template-name>.  */
     941                 :   37568600 :           write_unscoped_template_name (TI_TEMPLATE (template_info));
     942                 :   37568600 :           write_template_args (TI_ARGS (template_info));
     943                 :            :         }
     944                 :            :       else
     945                 :            :         /* Everything else gets an <unqualified-name>.  */
     946                 :   45488000 :         write_unscoped_name (decl);
     947                 :            :     }
     948                 :            :   else
     949                 :            :     {
     950                 :            :       /* Handle local names, unless we asked not to (that is, invoked
     951                 :            :          under <local-name>, to handle only the part of the name under
     952                 :            :          the local scope).  */
     953                 :   59442000 :       if (!ignore_local_scope)
     954                 :            :         {
     955                 :            :           /* Scan up the list of scope context, looking for a
     956                 :            :              function.  If we find one, this entity is in local
     957                 :            :              function scope.  local_entity tracks context one scope
     958                 :            :              level down, so it will contain the element that's
     959                 :            :              directly in that function's scope, either decl or one of
     960                 :            :              its enclosing scopes.  */
     961                 :            :           tree local_entity = decl;
     962                 :  181687000 :           while (context != global_namespace)
     963                 :            :             {
     964                 :            :               /* Make sure we're always dealing with decls.  */
     965                 :  124602000 :               if (TYPE_P (context))
     966                 :   53059800 :                 context = TYPE_NAME (context);
     967                 :            :               /* Is this a function?  */
     968                 :  124602000 :               if (TREE_CODE (context) == FUNCTION_DECL
     969                 :  123361000 :                   || TREE_CODE (context) == PARM_DECL)
     970                 :            :                 {
     971                 :            :                   /* Yes, we have local scope.  Use the <local-name>
     972                 :            :                      production for the innermost function scope.  */
     973                 :    1241630 :                   write_local_name (context, local_entity, decl);
     974                 :    1241630 :                   return;
     975                 :            :                 }
     976                 :            :               /* Up one scope level.  */
     977                 :  123361000 :               local_entity = context;
     978                 :  123361000 :               context = decl_mangling_context (context);
     979                 :            :             }
     980                 :            : 
     981                 :            :           /* No local scope found?  Fall through to <nested-name>.  */
     982                 :            :         }
     983                 :            : 
     984                 :            :       /* Other decls get a <nested-name> to encode their scope.  */
     985                 :   58200400 :       write_nested_name (decl);
     986                 :            :     }
     987                 :            : }
     988                 :            : 
     989                 :            : /* <unscoped-name> ::= <unqualified-name>
     990                 :            :                    ::= St <unqualified-name>   # ::std::  */
     991                 :            : 
     992                 :            : static void
     993                 :   29536600 : write_unscoped_name (const tree decl)
     994                 :            : {
     995                 :   29536600 :   tree context = decl_mangling_context (decl);
     996                 :            : 
     997                 :   29536600 :   MANGLE_TRACE_TREE ("unscoped-name", decl);
     998                 :            : 
     999                 :            :   /* Is DECL in ::std?  */
    1000                 :   29536600 :   if (DECL_NAMESPACE_STD_P (context))
    1001                 :            :     {
    1002                 :   27124900 :       write_string ("St");
    1003                 :   27124900 :       write_unqualified_name (decl);
    1004                 :            :     }
    1005                 :            :   else
    1006                 :            :     {
    1007                 :            :       /* If not, it should be either in the global namespace, or directly
    1008                 :            :          in a local function scope.  A lambda can also be mangled in the
    1009                 :            :          scope of a default argument.  */
    1010                 :    2411700 :       gcc_assert (context == global_namespace
    1011                 :            :                   || TREE_CODE (context) == PARM_DECL
    1012                 :            :                   || TREE_CODE (context) == FUNCTION_DECL);
    1013                 :            : 
    1014                 :    2411700 :       write_unqualified_name (decl);
    1015                 :            :     }
    1016                 :   29536600 : }
    1017                 :            : 
    1018                 :            : /* <unscoped-template-name> ::= <unscoped-name>
    1019                 :            :                             ::= <substitution>  */
    1020                 :            : 
    1021                 :            : static void
    1022                 :   37568600 : write_unscoped_template_name (const tree decl)
    1023                 :            : {
    1024                 :   37568600 :   MANGLE_TRACE_TREE ("unscoped-template-name", decl);
    1025                 :            : 
    1026                 :   37568600 :   if (find_substitution (decl))
    1027                 :            :     return;
    1028                 :   21617300 :   write_unscoped_name (decl);
    1029                 :   21617300 :   add_substitution (decl);
    1030                 :            : }
    1031                 :            : 
    1032                 :            : /* Write the nested name, including CV-qualifiers, of DECL.
    1033                 :            : 
    1034                 :            :    <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
    1035                 :            :                  ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
    1036                 :            : 
    1037                 :            :    <ref-qualifier> ::= R # & ref-qualifier
    1038                 :            :                    ::= O # && ref-qualifier
    1039                 :            :    <CV-qualifiers> ::= [r] [V] [K]  */
    1040                 :            : 
    1041                 :            : static void
    1042                 :   58858700 : write_nested_name (const tree decl)
    1043                 :            : {
    1044                 :   58858700 :   tree template_info;
    1045                 :            : 
    1046                 :   58858700 :   MANGLE_TRACE_TREE ("nested-name", decl);
    1047                 :            : 
    1048                 :   58858700 :   write_char ('N');
    1049                 :            : 
    1050                 :            :   /* Write CV-qualifiers, if this is a member function.  */
    1051                 :   58858700 :   if (TREE_CODE (decl) == FUNCTION_DECL
    1052                 :   96991100 :       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
    1053                 :            :     {
    1054                 :   32818900 :       if (DECL_VOLATILE_MEMFUNC_P (decl))
    1055                 :    2431950 :         write_char ('V');
    1056                 :   32818900 :       if (DECL_CONST_MEMFUNC_P (decl))
    1057                 :    7195090 :         write_char ('K');
    1058                 :   98456600 :       if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl)))
    1059                 :            :         {
    1060                 :      11300 :           if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
    1061                 :       2557 :             write_char ('O');
    1062                 :            :           else
    1063                 :       3093 :             write_char ('R');
    1064                 :            :         }
    1065                 :            :     }
    1066                 :            : 
    1067                 :            :   /* Is this a template instance?  */
    1068                 :   58858700 :   if (decl_is_template_id (decl, &template_info))
    1069                 :            :     {
    1070                 :            :       /* Yes, use <template-prefix>.  */
    1071                 :    7822540 :       write_template_prefix (decl);
    1072                 :    7822540 :       write_template_args (TI_ARGS (template_info));
    1073                 :            :     }
    1074                 :   51036200 :   else if ((!abi_version_at_least (10) || TREE_CODE (decl) == TYPE_DECL)
    1075                 :   60679600 :            && TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
    1076                 :            :     {
    1077                 :     658299 :       tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
    1078                 :     658299 :       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
    1079                 :            :         {
    1080                 :         12 :           write_template_prefix (decl);
    1081                 :         12 :           write_template_args (TREE_OPERAND (name, 1));
    1082                 :            :         }
    1083                 :            :       else
    1084                 :            :         {
    1085                 :     658287 :           write_prefix (decl_mangling_context (decl));
    1086                 :     658287 :           write_unqualified_name (decl);
    1087                 :            :         }
    1088                 :            :     }
    1089                 :            :   else
    1090                 :            :     {
    1091                 :            :       /* No, just use <prefix>  */
    1092                 :   50377900 :       write_prefix (decl_mangling_context (decl));
    1093                 :   50377900 :       write_unqualified_name (decl);
    1094                 :            :     }
    1095                 :   58858700 :   write_char ('E');
    1096                 :   58858700 : }
    1097                 :            : 
    1098                 :            : /* <prefix> ::= <prefix> <unqualified-name>
    1099                 :            :             ::= <template-param>
    1100                 :            :             ::= <template-prefix> <template-args>
    1101                 :            :             ::= <decltype>
    1102                 :            :             ::= # empty
    1103                 :            :             ::= <substitution>  */
    1104                 :            : 
    1105                 :            : static void
    1106                 :  129441000 : write_prefix (const tree node)
    1107                 :            : {
    1108                 :  129441000 :   tree decl;
    1109                 :            :   /* Non-NULL if NODE represents a template-id.  */
    1110                 :  129441000 :   tree template_info = NULL;
    1111                 :            : 
    1112                 :  129441000 :   if (node == NULL
    1113                 :  129441000 :       || node == global_namespace)
    1114                 :   57464600 :     return;
    1115                 :            : 
    1116                 :  119883000 :   MANGLE_TRACE_TREE ("prefix", node);
    1117                 :            : 
    1118                 :  119883000 :   if (TREE_CODE (node) == DECLTYPE_TYPE)
    1119                 :            :     {
    1120                 :          9 :       write_type (node);
    1121                 :          9 :       return;
    1122                 :            :     }
    1123                 :            : 
    1124                 :  119883000 :   if (find_substitution (node))
    1125                 :            :     return;
    1126                 :            : 
    1127                 :   73117200 :   if (DECL_P (node))
    1128                 :            :     {
    1129                 :            :       /* If this is a function or parm decl, that means we've hit function
    1130                 :            :          scope, so this prefix must be for a local name.  In this
    1131                 :            :          case, we're under the <local-name> production, which encodes
    1132                 :            :          the enclosing function scope elsewhere.  So don't continue
    1133                 :            :          here.  */
    1134                 :   22327400 :       if (TREE_CODE (node) == FUNCTION_DECL
    1135                 :   21212100 :           || TREE_CODE (node) == PARM_DECL)
    1136                 :            :         return;
    1137                 :            : 
    1138                 :   21211800 :       decl = node;
    1139                 :   21211800 :       decl_is_template_id (decl, &template_info);
    1140                 :            :     }
    1141                 :            :   else
    1142                 :            :     {
    1143                 :            :       /* Node is a type.  */
    1144                 :   50789800 :       decl = TYPE_NAME (node);
    1145                 :  141988000 :       if (CLASSTYPE_TEMPLATE_ID_P (node))
    1146                 :   38399800 :         template_info = TYPE_TEMPLATE_INFO (node);
    1147                 :            :     }
    1148                 :            : 
    1149                 :   72001600 :   if (TREE_CODE (node) == TEMPLATE_TYPE_PARM)
    1150                 :       2467 :     write_template_param (node);
    1151                 :   71999100 :   else if (template_info != NULL)
    1152                 :            :     /* Templated.  */
    1153                 :            :     {
    1154                 :   38405100 :       write_template_prefix (decl);
    1155                 :   38405100 :       write_template_args (TI_ARGS (template_info));
    1156                 :            :     }
    1157                 :   33594000 :   else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
    1158                 :            :     {
    1159                 :       1031 :       tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
    1160                 :       1031 :       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
    1161                 :            :         {
    1162                 :         48 :           write_template_prefix (decl);
    1163                 :         48 :           write_template_args (TREE_OPERAND (name, 1));
    1164                 :            :         }
    1165                 :            :       else
    1166                 :            :         {
    1167                 :        983 :           write_prefix (decl_mangling_context (decl));
    1168                 :        983 :           write_unqualified_name (decl);
    1169                 :            :         }
    1170                 :            :     }
    1171                 :            :   else
    1172                 :            :     /* Not templated.  */
    1173                 :            :     {
    1174                 :   33593000 :       write_prefix (decl_mangling_context (decl));
    1175                 :   33593000 :       write_unqualified_name (decl);
    1176                 :   33593000 :       if (VAR_P (decl)
    1177                 :   33593000 :           || TREE_CODE (decl) == FIELD_DECL)
    1178                 :            :         {
    1179                 :            :           /* <data-member-prefix> := <member source-name> M */
    1180                 :      25547 :           write_char ('M');
    1181                 :      25547 :           return;
    1182                 :            :         }
    1183                 :            :     }
    1184                 :            : 
    1185                 :   71976000 :   add_substitution (node);
    1186                 :            : }
    1187                 :            : 
    1188                 :            : /* <template-prefix> ::= <prefix> <template component>
    1189                 :            :                      ::= <template-param>
    1190                 :            :                      ::= <substitution>  */
    1191                 :            : 
    1192                 :            : static void
    1193                 :   46227700 : write_template_prefix (const tree node)
    1194                 :            : {
    1195                 :   46227700 :   tree decl = DECL_P (node) ? node : TYPE_NAME (node);
    1196                 :   92455500 :   tree type = DECL_P (node) ? TREE_TYPE (node) : node;
    1197                 :   46227700 :   tree context = decl_mangling_context (decl);
    1198                 :   46227700 :   tree template_info;
    1199                 :   46227700 :   tree templ;
    1200                 :   46227700 :   tree substitution;
    1201                 :            : 
    1202                 :   46227700 :   MANGLE_TRACE_TREE ("template-prefix", node);
    1203                 :            : 
    1204                 :            :   /* Find the template decl.  */
    1205                 :   46227700 :   if (decl_is_template_id (decl, &template_info))
    1206                 :   46226800 :     templ = TI_TEMPLATE (template_info);
    1207                 :        948 :   else if (TREE_CODE (type) == TYPENAME_TYPE)
    1208                 :            :     /* For a typename type, all we have is the name.  */
    1209                 :         60 :     templ = DECL_NAME (decl);
    1210                 :            :   else
    1211                 :            :     {
    1212                 :        888 :       gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
    1213                 :            : 
    1214                 :       2664 :       templ = TYPE_TI_TEMPLATE (type);
    1215                 :            :     }
    1216                 :            : 
    1217                 :            :   /* For a member template, though, the template name for the
    1218                 :            :      innermost name must have all the outer template levels
    1219                 :            :      instantiated.  For instance, consider
    1220                 :            : 
    1221                 :            :        template<typename T> struct Outer {
    1222                 :            :          template<typename U> struct Inner {};
    1223                 :            :        };
    1224                 :            : 
    1225                 :            :      The template name for `Inner' in `Outer<int>::Inner<float>' is
    1226                 :            :      `Outer<int>::Inner<U>'.  In g++, we don't instantiate the template
    1227                 :            :      levels separately, so there's no TEMPLATE_DECL available for this
    1228                 :            :      (there's only `Outer<T>::Inner<U>').
    1229                 :            : 
    1230                 :            :      In order to get the substitutions right, we create a special
    1231                 :            :      TREE_LIST to represent the substitution candidate for a nested
    1232                 :            :      template.  The TREE_PURPOSE is the template's context, fully
    1233                 :            :      instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
    1234                 :            :      template.
    1235                 :            : 
    1236                 :            :      So, for the example above, `Outer<int>::Inner' is represented as a
    1237                 :            :      substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
    1238                 :            :      and whose value is `Outer<T>::Inner<U>'.  */
    1239                 :   46227700 :   if (context && TYPE_P (context))
    1240                 :    2847310 :     substitution = build_tree_list (context, templ);
    1241                 :            :   else
    1242                 :            :     substitution = templ;
    1243                 :            : 
    1244                 :   46227700 :   if (find_substitution (substitution))
    1245                 :    1416390 :     return;
    1246                 :            : 
    1247                 :   44811300 :   if (TREE_TYPE (templ)
    1248                 :   44811300 :       && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM)
    1249                 :        888 :     write_template_param (TREE_TYPE (templ));
    1250                 :            :   else
    1251                 :            :     {
    1252                 :   44810400 :       write_prefix (context);
    1253                 :   44810400 :       write_unqualified_name (decl);
    1254                 :            :     }
    1255                 :            : 
    1256                 :   44811300 :   add_substitution (substitution);
    1257                 :            : }
    1258                 :            : 
    1259                 :            : /* As the list of identifiers for the structured binding declaration
    1260                 :            :    DECL is likely gone, try to recover the DC <source-name>+ E portion
    1261                 :            :    from its mangled name.  Return pointer to the DC and set len to
    1262                 :            :    the length up to and including the terminating E.  On failure
    1263                 :            :    return NULL.  */
    1264                 :            : 
    1265                 :            : static const char *
    1266                 :         12 : find_decomp_unqualified_name (tree decl, size_t *len)
    1267                 :            : {
    1268                 :         12 :   const char *p = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
    1269                 :         12 :   const char *end = p + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl));
    1270                 :         12 :   bool nested = false;
    1271                 :         12 :   if (strncmp (p, "_Z", 2))
    1272                 :            :     return NULL;
    1273                 :         12 :   p += 2;
    1274                 :         12 :   if (!strncmp (p, "St", 2))
    1275                 :          0 :     p += 2;
    1276                 :         12 :   else if (*p == 'N')
    1277                 :            :     {
    1278                 :          3 :       nested = true;
    1279                 :          3 :       ++p;
    1280                 :          9 :       while (ISDIGIT (p[0]))
    1281                 :            :         {
    1282                 :          6 :           char *e;
    1283                 :          6 :           long num = strtol (p, &e, 10);
    1284                 :          6 :           if (num >= 1 && num < end - e)
    1285                 :          6 :             p = e + num;
    1286                 :            :           else
    1287                 :            :             break;
    1288                 :            :         }
    1289                 :            :     }
    1290                 :         12 :   if (strncmp (p, "DC", 2))
    1291                 :            :     return NULL;
    1292                 :         12 :   if (nested)
    1293                 :            :     {
    1294                 :          3 :       if (end[-1] != 'E')
    1295                 :            :         return NULL;
    1296                 :          3 :       --end;
    1297                 :            :     }
    1298                 :         12 :   if (end[-1] != 'E')
    1299                 :            :     return NULL;
    1300                 :         12 :   *len = end - p;
    1301                 :         12 :   return p;
    1302                 :            : }
    1303                 :            : 
    1304                 :            : /* We don't need to handle thunks, vtables, or VTTs here.  Those are
    1305                 :            :    mangled through special entry points.
    1306                 :            : 
    1307                 :            :     <unqualified-name>  ::= <operator-name>
    1308                 :            :                         ::= <special-name>
    1309                 :            :                         ::= <source-name>
    1310                 :            :                         ::= <unnamed-type-name>
    1311                 :            :                         ::= <local-source-name> 
    1312                 :            : 
    1313                 :            :     <local-source-name>   ::= L <source-name> <discriminator> */
    1314                 :            : 
    1315                 :            : static void
    1316                 :     116120 : write_unqualified_id (tree identifier)
    1317                 :            : {
    1318                 :     116120 :   if (IDENTIFIER_CONV_OP_P (identifier))
    1319                 :         15 :     write_conversion_operator_name (TREE_TYPE (identifier));
    1320                 :     116105 :   else if (IDENTIFIER_OVL_OP_P (identifier))
    1321                 :            :     {
    1322                 :        164 :       const ovl_op_info_t *ovl_op = IDENTIFIER_OVL_OP_INFO (identifier);
    1323                 :        164 :       write_string (ovl_op->mangled_name);
    1324                 :            :     }
    1325                 :     115941 :   else if (UDLIT_OPER_P (identifier))
    1326                 :          0 :     write_literal_operator_name (identifier);
    1327                 :            :   else
    1328                 :     115941 :     write_source_name (identifier);
    1329                 :     116120 : }
    1330                 :            : 
    1331                 :            : static void
    1332                 :  158978000 : write_unqualified_name (tree decl)
    1333                 :            : {
    1334                 :  158978000 :   MANGLE_TRACE_TREE ("unqualified-name", decl);
    1335                 :            : 
    1336                 :  158978000 :   if (identifier_p (decl))
    1337                 :            :     {
    1338                 :          0 :       write_unqualified_id (decl);
    1339                 :          0 :       return;
    1340                 :            :     }
    1341                 :            : 
    1342                 :  158978000 :   bool found = false;
    1343                 :            : 
    1344                 :  158978000 :   if (DECL_NAME (decl) == NULL_TREE)
    1345                 :            :     {
    1346                 :      19265 :       found = true;
    1347                 :      19265 :       gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
    1348                 :      19265 :       const char *decomp_str = NULL;
    1349                 :      19265 :       size_t decomp_len = 0;
    1350                 :      19265 :       if (VAR_P (decl)
    1351                 :         35 :           && DECL_DECOMPOSITION_P (decl)
    1352                 :         32 :           && DECL_NAME (decl) == NULL_TREE
    1353                 :      19297 :           && DECL_NAMESPACE_SCOPE_P (decl))
    1354                 :         12 :         decomp_str = find_decomp_unqualified_name (decl, &decomp_len);
    1355                 :         12 :       if (decomp_str)
    1356                 :         12 :         write_chars (decomp_str, decomp_len);
    1357                 :            :       else
    1358                 :      19253 :         write_source_name (DECL_ASSEMBLER_NAME (decl));
    1359                 :            :     }
    1360                 :  158958000 :   else if (DECL_DECLARES_FUNCTION_P (decl))
    1361                 :            :     {
    1362                 :   40208600 :       found = true;
    1363                 :   80417200 :       if (DECL_CONSTRUCTOR_P (decl))
    1364                 :    9061590 :         write_special_name_constructor (decl);
    1365                 :   31147000 :       else if (DECL_DESTRUCTOR_P (decl))
    1366                 :    2639800 :         write_special_name_destructor (decl);
    1367                 :   28507200 :       else if (DECL_CONV_FN_P (decl))
    1368                 :            :         {
    1369                 :            :           /* Conversion operator. Handle it right here.
    1370                 :            :              <operator> ::= cv <type>  */
    1371                 :     401540 :           tree type;
    1372                 :     401540 :           if (decl_is_template_id (decl, NULL))
    1373                 :            :             {
    1374                 :        256 :               tree fn_type;
    1375                 :        256 :               fn_type = get_mostly_instantiated_function_type (decl);
    1376                 :        256 :               type = TREE_TYPE (fn_type);
    1377                 :            :             }
    1378                 :     401284 :           else if (FNDECL_USED_AUTO (decl))
    1379                 :         36 :             type = DECL_SAVED_AUTO_RETURN_TYPE (decl);
    1380                 :            :           else
    1381                 :     401248 :             type = DECL_CONV_FN_TYPE (decl);
    1382                 :     401540 :           write_conversion_operator_name (type);
    1383                 :            :         }
    1384                 :   28105700 :       else if (DECL_OVERLOADED_OPERATOR_P (decl))
    1385                 :            :         {
    1386                 :    7154750 :           const char *mangled_name
    1387                 :    7154750 :             = (ovl_op_info[DECL_ASSIGNMENT_OPERATOR_P (decl)]
    1388                 :    7154750 :                [DECL_OVERLOADED_OPERATOR_CODE_RAW (decl)].mangled_name);
    1389                 :    7154750 :           write_string (mangled_name);
    1390                 :            :         }
    1391                 :   20950900 :       else if (UDLIT_OPER_P (DECL_NAME (decl)))
    1392                 :      17403 :         write_literal_operator_name (DECL_NAME (decl));
    1393                 :            :       else
    1394                 :            :         found = false;
    1395                 :            :     }
    1396                 :            : 
    1397                 :   19294300 :   if (found)
    1398                 :            :     /* OK */;
    1399                 :  139683000 :   else if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
    1400                 :     257609 :            && DECL_NAMESPACE_SCOPE_P (decl)
    1401                 :  139906000 :            && decl_linkage (decl) == lk_internal)
    1402                 :            :     {
    1403                 :     199416 :       MANGLE_TRACE_TREE ("local-source-name", decl);
    1404                 :     199416 :       write_char ('L');
    1405                 :     199416 :       write_source_name (DECL_NAME (decl));
    1406                 :            :       /* The default discriminator is 1, and that's all we ever use,
    1407                 :            :          so there's no code to output one here.  */
    1408                 :            :     }
    1409                 :            :   else
    1410                 :            :     {
    1411                 :  139484000 :       tree type = TREE_TYPE (decl);
    1412                 :            : 
    1413                 :  139484000 :       if (TREE_CODE (decl) == TYPE_DECL
    1414                 :  210047000 :           && TYPE_UNNAMED_P (type))
    1415                 :       1235 :         write_unnamed_type_name (type);
    1416                 :  139483000 :       else if (TREE_CODE (decl) == TYPE_DECL
    1417                 :  204590000 :                && LAMBDA_TYPE_P (type))
    1418                 :     141407 :         write_closure_type_name (type);
    1419                 :            :       else
    1420                 :  139341000 :         write_source_name (DECL_NAME (decl));
    1421                 :            :     }
    1422                 :            : 
    1423                 :            :   /* We use the ABI tags from the primary class template, ignoring tags on any
    1424                 :            :      specializations.  This is necessary because C++ doesn't require a
    1425                 :            :      specialization to be declared before it is used unless the use requires a
    1426                 :            :      complete type, but we need to get the tags right on incomplete types as
    1427                 :            :      well.  */
    1428                 :  158978000 :   if (tree tmpl = most_general_template (decl))
    1429                 :            :     {
    1430                 :  101078000 :       tree res = DECL_TEMPLATE_RESULT (tmpl);
    1431                 :  101078000 :       if (res == NULL_TREE)
    1432                 :            :         /* UNBOUND_CLASS_TEMPLATE.  */;
    1433                 :  101078000 :       else if (DECL_DECLARES_TYPE_P (decl))
    1434                 :            :         decl = res;
    1435                 :   36725200 :       else if (any_abi_below (11))
    1436                 :            :         {
    1437                 :            :           /* ABI v10 implicit tags on the template.  */
    1438                 :     614843 :           tree mtags = missing_abi_tags (res);
    1439                 :            :           /* Explicit tags on the template.  */
    1440                 :     614843 :           tree ttags = get_abi_tags (res);
    1441                 :            :           /* Tags on the instantiation.  */
    1442                 :     614843 :           tree dtags = get_abi_tags (decl);
    1443                 :            : 
    1444                 :     614849 :           if (mtags && abi_warn_or_compat_version_crosses (10))
    1445                 :          6 :             G.need_abi_warning = 1;
    1446                 :            : 
    1447                 :            :           /* Add the v10 tags to the explicit tags now.  */
    1448                 :     614843 :           mtags = chainon (mtags, ttags);
    1449                 :            : 
    1450                 :     614843 :           if (!G.need_abi_warning
    1451                 :    1855770 :               && abi_warn_or_compat_version_crosses (11)
    1452                 :     986644 :               && !equal_abi_tags (dtags, mtags))
    1453                 :          6 :             G.need_abi_warning = 1;
    1454                 :            : 
    1455                 :     614843 :           if (!abi_version_at_least (10))
    1456                 :            :             /* In abi <10, we only got the explicit tags.  */
    1457                 :            :             decl = res;
    1458                 :     313312 :           else if (flag_abi_version == 10)
    1459                 :            :             {
    1460                 :            :               /* In ABI 10, we want explict and implicit tags.  */
    1461                 :         79 :               write_abi_tags (mtags);
    1462                 :         79 :               return;
    1463                 :            :             }
    1464                 :            :         }
    1465                 :            :     }
    1466                 :            : 
    1467                 :  158978000 :   tree tags = get_abi_tags (decl);
    1468                 :   38918100 :   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CONV_FN_P (decl)
    1469                 :  159379000 :       && any_abi_below (11))
    1470                 :       7374 :     if (tree mtags = missing_abi_tags (decl))
    1471                 :            :       {
    1472                 :         16 :         if (abi_warn_or_compat_version_crosses (11))
    1473                 :          8 :           G.need_abi_warning = true;
    1474                 :         12 :         if (!abi_version_at_least (11))
    1475                 :          8 :           tags = chainon (mtags, tags);
    1476                 :            :       }
    1477                 :  158978000 :   write_abi_tags (tags);
    1478                 :            : }
    1479                 :            : 
    1480                 :            : /* Write the unqualified-name for a conversion operator to TYPE.  */
    1481                 :            : 
    1482                 :            : static void
    1483                 :     401555 : write_conversion_operator_name (const tree type)
    1484                 :            : {
    1485                 :     401555 :   write_string ("cv");
    1486                 :     401555 :   write_type (type);
    1487                 :     401555 : }
    1488                 :            : 
    1489                 :            : /* Non-terminal <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
    1490                 :            : 
    1491                 :            :      <source-name> ::= </length/ number> <identifier>  */
    1492                 :            : 
    1493                 :            : static void
    1494                 :  139683000 : write_source_name (tree identifier)
    1495                 :            : {
    1496                 :  139683000 :   MANGLE_TRACE_TREE ("source-name", identifier);
    1497                 :            : 
    1498                 :  139683000 :   write_unsigned_number (IDENTIFIER_LENGTH (identifier));
    1499                 :  139683000 :   write_identifier (IDENTIFIER_POINTER (identifier));
    1500                 :  139683000 : }
    1501                 :            : 
    1502                 :            : /* Compare two TREE_STRINGs like strcmp.  */
    1503                 :            : 
    1504                 :            : int
    1505                 :        170 : tree_string_cmp (const void *p1, const void *p2)
    1506                 :            : {
    1507                 :        170 :   if (p1 == p2)
    1508                 :            :     return 0;
    1509                 :        112 :   tree s1 = *(const tree*)p1;
    1510                 :        112 :   tree s2 = *(const tree*)p2;
    1511                 :        112 :   return strcmp (TREE_STRING_POINTER (s1),
    1512                 :        112 :                  TREE_STRING_POINTER (s2));
    1513                 :            : }
    1514                 :            : 
    1515                 :            : /* Return the TREE_LIST of TAGS as a sorted VEC.  */
    1516                 :            : 
    1517                 :            : static vec<tree, va_gc> *
    1518                 :     794119 : sorted_abi_tags (tree tags)
    1519                 :            : {
    1520                 :     794119 :   vec<tree, va_gc> * vec = make_tree_vector();
    1521                 :            : 
    1522                 :     844786 :   for (tree t = tags; t; t = TREE_CHAIN (t))
    1523                 :            :     {
    1524                 :      50667 :       if (ABI_TAG_IMPLICIT (t))
    1525                 :          0 :         continue;
    1526                 :      50667 :       tree str = TREE_VALUE (t);
    1527                 :      50667 :       vec_safe_push (vec, str);
    1528                 :            :     }
    1529                 :            : 
    1530                 :     794119 :   vec->qsort (tree_string_cmp);
    1531                 :            : 
    1532                 :     794119 :   return vec;
    1533                 :            : }
    1534                 :            : 
    1535                 :            : /* ID is the name of a function or type with abi_tags attribute TAGS.
    1536                 :            :    Write out the name, suitably decorated.  */
    1537                 :            : 
    1538                 :            : static void
    1539                 :  158978000 : write_abi_tags (tree tags)
    1540                 :            : {
    1541                 :  158978000 :   if (tags == NULL_TREE)
    1542                 :  158978000 :     return;
    1543                 :            : 
    1544                 :      50517 :   vec<tree, va_gc> * vec = sorted_abi_tags (tags);
    1545                 :            : 
    1546                 :      50517 :   unsigned i; tree str;
    1547                 :     101062 :   FOR_EACH_VEC_ELT (*vec, i, str)
    1548                 :            :     {
    1549                 :      50545 :       write_string ("B");
    1550                 :      50545 :       write_unsigned_number (TREE_STRING_LENGTH (str) - 1);
    1551                 :      50545 :       write_identifier (TREE_STRING_POINTER (str));
    1552                 :            :     }
    1553                 :            : 
    1554                 :      50517 :   release_tree_vector (vec);
    1555                 :            : }
    1556                 :            : 
    1557                 :            : /* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent.  */
    1558                 :            : 
    1559                 :            : static bool
    1560                 :     371801 : equal_abi_tags (tree t1, tree t2)
    1561                 :            : {
    1562                 :     371801 :   releasing_vec v1 = sorted_abi_tags (t1);
    1563                 :     743602 :   releasing_vec v2 = sorted_abi_tags (t2);
    1564                 :            : 
    1565                 :     371801 :   unsigned len1 = v1->length();
    1566                 :     371801 :   if (len1 != v2->length())
    1567                 :            :     return false;
    1568                 :     371853 :   for (unsigned i = 0; i < len1; ++i)
    1569                 :         58 :     if (tree_string_cmp (v1[i], v2[i]) != 0)
    1570                 :            :       return false;
    1571                 :            :   return true;
    1572                 :            : }
    1573                 :            : 
    1574                 :            : /* Write a user-defined literal operator.
    1575                 :            :           ::= li <source-name>    # "" <source-name>
    1576                 :            :    IDENTIFIER is an LITERAL_IDENTIFIER_NODE.  */
    1577                 :            : 
    1578                 :            : static void
    1579                 :      17403 : write_literal_operator_name (tree identifier)
    1580                 :            : {
    1581                 :      17403 :   const char* suffix = UDLIT_OP_SUFFIX (identifier);
    1582                 :      17403 :   write_identifier (UDLIT_OP_MANGLED_PREFIX);
    1583                 :      17403 :   write_unsigned_number (strlen (suffix));
    1584                 :      17403 :   write_identifier (suffix);
    1585                 :      17403 : }
    1586                 :            : 
    1587                 :            : /* Encode 0 as _, and 1+ as n-1_.  */
    1588                 :            : 
    1589                 :            : static void
    1590                 :    8502490 : write_compact_number (int num)
    1591                 :            : {
    1592                 :    8502490 :   if (num > 0)
    1593                 :    4562260 :     write_unsigned_number (num - 1);
    1594                 :    8502490 :   write_char ('_');
    1595                 :    8502490 : }
    1596                 :            : 
    1597                 :            : /* Return how many unnamed types precede TYPE in its enclosing class.  */
    1598                 :            : 
    1599                 :            : static int
    1600                 :        494 : nested_anon_class_index (tree type)
    1601                 :            : {
    1602                 :        494 :   int index = 0;
    1603                 :        561 :   tree member = TYPE_FIELDS (TYPE_CONTEXT (type));
    1604                 :      15157 :   for (; member; member = DECL_CHAIN (member))
    1605                 :      17240 :     if (DECL_IMPLICIT_TYPEDEF_P (member))
    1606                 :            :       {
    1607                 :        761 :         tree memtype = TREE_TYPE (member);
    1608                 :        761 :         if (memtype == type)
    1609                 :        494 :           return index;
    1610                 :        267 :         else if (TYPE_UNNAMED_P (memtype))
    1611                 :        143 :           ++index;
    1612                 :            :       }
    1613                 :            : 
    1614                 :          0 :   if (seen_error ())
    1615                 :            :     return -1;
    1616                 :            : 
    1617                 :          0 :   gcc_unreachable ();
    1618                 :            : }
    1619                 :            : 
    1620                 :            : /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
    1621                 :            : 
    1622                 :            : static void
    1623                 :       1235 : write_unnamed_type_name (const tree type)
    1624                 :            : {
    1625                 :       1235 :   int discriminator;
    1626                 :       1235 :   MANGLE_TRACE_TREE ("unnamed-type-name", type);
    1627                 :            : 
    1628                 :       1235 :   if (TYPE_FUNCTION_SCOPE_P (type))
    1629                 :        434 :     discriminator = discriminator_for_local_entity (TYPE_NAME (type));
    1630                 :        801 :   else if (TYPE_CLASS_SCOPE_P (type))
    1631                 :        494 :     discriminator = nested_anon_class_index (type);
    1632                 :            :   else
    1633                 :            :     {
    1634                 :        307 :       gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
    1635                 :            :       /* Just use the old mangling at namespace scope.  */
    1636                 :        307 :       write_source_name (TYPE_IDENTIFIER (type));
    1637                 :        307 :       return;
    1638                 :            :     }
    1639                 :            : 
    1640                 :        928 :   write_string ("Ut");
    1641                 :        928 :   write_compact_number (discriminator);
    1642                 :            : }
    1643                 :            : 
    1644                 :            : /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
    1645                 :            :    <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters */
    1646                 :            : 
    1647                 :            : static void
    1648                 :     141407 : write_closure_type_name (const tree type)
    1649                 :            : {
    1650                 :     141407 :   tree fn = lambda_function (type);
    1651                 :     141407 :   tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
    1652                 :     141407 :   tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
    1653                 :            : 
    1654                 :     141407 :   MANGLE_TRACE_TREE ("closure-type-name", type);
    1655                 :            : 
    1656                 :     141407 :   write_string ("Ul");
    1657                 :     141407 :   write_method_parms (parms, /*method_p=*/1, fn);
    1658                 :     141407 :   write_char ('E');
    1659                 :     141407 :   write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda));
    1660                 :     141407 : }
    1661                 :            : 
    1662                 :            : /* Convert NUMBER to ascii using base BASE and generating at least
    1663                 :            :    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
    1664                 :            :    into which to store the characters. Returns the number of
    1665                 :            :    characters generated (these will be laid out in advance of where
    1666                 :            :    BUFFER points).  */
    1667                 :            : 
    1668                 :            : static int
    1669                 :          0 : hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
    1670                 :            :                 char *buffer, const unsigned int min_digits)
    1671                 :            : {
    1672                 :          0 :   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    1673                 :          0 :   unsigned digits = 0;
    1674                 :            : 
    1675                 :          0 :   while (number)
    1676                 :            :     {
    1677                 :  277598000 :       unsigned HOST_WIDE_INT d = number / base;
    1678                 :            : 
    1679                 :  277598000 :       *--buffer = base_digits[number - d * base];
    1680                 :  277598000 :       digits++;
    1681                 :  277598000 :       number = d;
    1682                 :            :     }
    1683                 :  197425000 :   while (digits < min_digits)
    1684                 :            :     {
    1685                 :    9289560 :       *--buffer = base_digits[0];
    1686                 :    9289560 :       digits++;
    1687                 :            :     }
    1688                 :  188135000 :   return digits;
    1689                 :            : }
    1690                 :            : 
    1691                 :            : /* Non-terminal <number>.
    1692                 :            : 
    1693                 :            :      <number> ::= [n] </decimal integer/>  */
    1694                 :            : 
    1695                 :            : static void
    1696                 :  188135000 : write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
    1697                 :            :               const unsigned int base)
    1698                 :            : {
    1699                 :  188135000 :   char buffer[sizeof (HOST_WIDE_INT) * 8];
    1700                 :  188135000 :   unsigned count = 0;
    1701                 :            : 
    1702                 :  188135000 :   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
    1703                 :            :     {
    1704                 :          0 :       write_char ('n');
    1705                 :          0 :       number = -((HOST_WIDE_INT) number);
    1706                 :            :     }
    1707                 :  465733000 :   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
    1708                 :  188135000 :   write_chars (buffer + sizeof (buffer) - count, count);
    1709                 :  188135000 : }
    1710                 :            : 
    1711                 :            : /* Write out an integral CST in decimal. Most numbers are small, and
    1712                 :            :    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
    1713                 :            :    bigger than that, which we must deal with.  */
    1714                 :            : 
    1715                 :            : static inline void
    1716                 :   14871200 : write_integer_cst (const tree cst)
    1717                 :            : {
    1718                 :   14871200 :   int sign = tree_int_cst_sgn (cst);
    1719                 :   14871200 :   widest_int abs_value = wi::abs (wi::to_widest (cst));
    1720                 :   14871200 :   if (!wi::fits_uhwi_p (abs_value))
    1721                 :            :     {
    1722                 :            :       /* A bignum. We do this in chunks, each of which fits in a
    1723                 :            :          HOST_WIDE_INT.  */
    1724                 :          0 :       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
    1725                 :          0 :       unsigned HOST_WIDE_INT chunk;
    1726                 :          0 :       unsigned chunk_digits;
    1727                 :          0 :       char *ptr = buffer + sizeof (buffer);
    1728                 :          0 :       unsigned count = 0;
    1729                 :          0 :       tree n, base, type;
    1730                 :          0 :       int done;
    1731                 :            : 
    1732                 :            :       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
    1733                 :            :          representable.  */
    1734                 :          0 :       chunk = 1000000000;
    1735                 :          0 :       chunk_digits = 9;
    1736                 :            : 
    1737                 :          0 :       if (sizeof (HOST_WIDE_INT) >= 8)
    1738                 :            :         {
    1739                 :            :           /* It is at least 64 bits, so 10^18 is representable.  */
    1740                 :          0 :           chunk_digits = 18;
    1741                 :          0 :           chunk *= chunk;
    1742                 :            :         }
    1743                 :            : 
    1744                 :          0 :       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
    1745                 :          0 :       base = build_int_cstu (type, chunk);
    1746                 :          0 :       n = wide_int_to_tree (type, wi::to_wide (cst));
    1747                 :            : 
    1748                 :          0 :       if (sign < 0)
    1749                 :            :         {
    1750                 :          0 :           write_char ('n');
    1751                 :          0 :           n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
    1752                 :            :         }
    1753                 :          0 :       do
    1754                 :            :         {
    1755                 :          0 :           tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
    1756                 :          0 :           tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
    1757                 :          0 :           unsigned c;
    1758                 :            : 
    1759                 :          0 :           done = integer_zerop (d);
    1760                 :          0 :           tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
    1761                 :          0 :           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
    1762                 :            :                               done ? 1 : chunk_digits);
    1763                 :          0 :           ptr -= c;
    1764                 :          0 :           count += c;
    1765                 :          0 :           n = d;
    1766                 :            :         }
    1767                 :          0 :       while (!done);
    1768                 :          0 :       write_chars (ptr, count);
    1769                 :            :     }
    1770                 :            :   else
    1771                 :            :     {
    1772                 :            :       /* A small num.  */
    1773                 :   14871200 :       if (sign < 0)
    1774                 :      34054 :         write_char ('n');
    1775                 :   14871200 :       write_unsigned_number (abs_value.to_uhwi ());
    1776                 :            :     }
    1777                 :   14871200 : }
    1778                 :            : 
    1779                 :            : /* Write out a floating-point literal.
    1780                 :            : 
    1781                 :            :     "Floating-point literals are encoded using the bit pattern of the
    1782                 :            :     target processor's internal representation of that number, as a
    1783                 :            :     fixed-length lowercase hexadecimal string, high-order bytes first
    1784                 :            :     (even if the target processor would store low-order bytes first).
    1785                 :            :     The "n" prefix is not used for floating-point literals; the sign
    1786                 :            :     bit is encoded with the rest of the number.
    1787                 :            : 
    1788                 :            :     Here are some examples, assuming the IEEE standard representation
    1789                 :            :     for floating point numbers.  (Spaces are for readability, not
    1790                 :            :     part of the encoding.)
    1791                 :            : 
    1792                 :            :         1.0f                    Lf 3f80 0000 E
    1793                 :            :        -1.0f                    Lf bf80 0000 E
    1794                 :            :         1.17549435e-38f         Lf 0080 0000 E
    1795                 :            :         1.40129846e-45f         Lf 0000 0001 E
    1796                 :            :         0.0f                    Lf 0000 0000 E"
    1797                 :            : 
    1798                 :            :    Caller is responsible for the Lx and the E.  */
    1799                 :            : static void
    1800                 :          8 : write_real_cst (const tree value)
    1801                 :            : {
    1802                 :          8 :   long target_real[4];  /* largest supported float */
    1803                 :            :   /* Buffer for eight hex digits in a 32-bit number but big enough
    1804                 :            :      even for 64-bit long to avoid warnings.  */
    1805                 :          8 :   char buffer[17];
    1806                 :          8 :   int i, limit, dir;
    1807                 :            : 
    1808                 :          8 :   tree type = TREE_TYPE (value);
    1809                 :          8 :   int words = GET_MODE_BITSIZE (SCALAR_FLOAT_TYPE_MODE (type)) / 32;
    1810                 :            : 
    1811                 :         16 :   real_to_target (target_real, &TREE_REAL_CST (value),
    1812                 :          8 :                   TYPE_MODE (type));
    1813                 :            : 
    1814                 :            :   /* The value in target_real is in the target word order,
    1815                 :            :      so we must write it out backward if that happens to be
    1816                 :            :      little-endian.  write_number cannot be used, it will
    1817                 :            :      produce uppercase.  */
    1818                 :          8 :   if (FLOAT_WORDS_BIG_ENDIAN)
    1819                 :            :     i = 0, limit = words, dir = 1;
    1820                 :            :   else
    1821                 :          8 :     i = words - 1, limit = -1, dir = -1;
    1822                 :            : 
    1823                 :         16 :   for (; i != limit; i += dir)
    1824                 :            :     {
    1825                 :          8 :       sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
    1826                 :          8 :       write_chars (buffer, 8);
    1827                 :            :     }
    1828                 :          8 : }
    1829                 :            : 
    1830                 :            : /* Non-terminal <identifier>.
    1831                 :            : 
    1832                 :            :      <identifier> ::= </unqualified source code identifier>  */
    1833                 :            : 
    1834                 :            : static void
    1835                 :  139790000 : write_identifier (const char *identifier)
    1836                 :            : {
    1837                 :  139790000 :   MANGLE_TRACE ("identifier", identifier);
    1838                 :  139790000 :   write_string (identifier);
    1839                 :  139790000 : }
    1840                 :            : 
    1841                 :            : /* Handle constructor productions of non-terminal <special-name>.
    1842                 :            :    CTOR is a constructor FUNCTION_DECL.
    1843                 :            : 
    1844                 :            :      <special-name> ::= C1   # complete object constructor
    1845                 :            :                     ::= C2   # base object constructor
    1846                 :            :                     ::= C3   # complete object allocating constructor
    1847                 :            : 
    1848                 :            :    Currently, allocating constructors are never used.  */
    1849                 :            : 
    1850                 :            : static void
    1851                 :    9061590 : write_special_name_constructor (const tree ctor)
    1852                 :            : {
    1853                 :    9061590 :   write_char ('C');
    1854                 :    9061590 :   bool new_inh = (flag_new_inheriting_ctors
    1855                 :   18107400 :                   && DECL_INHERITED_CTOR (ctor));
    1856                 :      88043 :   if (new_inh)
    1857                 :      88043 :     write_char ('I');
    1858                 :    9061590 :   if (DECL_BASE_CONSTRUCTOR_P (ctor))
    1859                 :    1544160 :     write_char ('2');
    1860                 :            :   /* This is the old-style "[unified]" constructor.
    1861                 :            :      In some cases, we may emit this function and call
    1862                 :            :      it from the clones in order to share code and save space.  */
    1863                 :    7517430 :   else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
    1864                 :    5948570 :     write_char ('4');
    1865                 :            :   else
    1866                 :            :     {
    1867                 :    1568860 :       gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor));
    1868                 :    1568860 :       write_char ('1');
    1869                 :            :     }
    1870                 :    9061590 :   if (new_inh)
    1871                 :     264129 :     write_type (DECL_INHERITED_CTOR_BASE (ctor));
    1872                 :    9061590 : }
    1873                 :            : 
    1874                 :            : /* Handle destructor productions of non-terminal <special-name>.
    1875                 :            :    DTOR is a destructor FUNCTION_DECL.
    1876                 :            : 
    1877                 :            :      <special-name> ::= D0 # deleting (in-charge) destructor
    1878                 :            :                     ::= D1 # complete object (in-charge) destructor
    1879                 :            :                     ::= D2 # base object (not-in-charge) destructor  */
    1880                 :            : 
    1881                 :            : static void
    1882                 :    2639800 : write_special_name_destructor (const tree dtor)
    1883                 :            : {
    1884                 :    2639800 :   if (DECL_DELETING_DESTRUCTOR_P (dtor))
    1885                 :     125891 :     write_string ("D0");
    1886                 :    2513910 :   else if (DECL_BASE_DESTRUCTOR_P (dtor))
    1887                 :     618662 :     write_string ("D2");
    1888                 :    1895250 :   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
    1889                 :            :     /* This is the old-style "[unified]" destructor.
    1890                 :            :        In some cases, we may emit this function and call
    1891                 :            :        it from the clones in order to share code and save space.  */
    1892                 :    1224260 :     write_string ("D4");
    1893                 :            :   else
    1894                 :            :     {
    1895                 :     670986 :       gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor));
    1896                 :     670986 :       write_string ("D1");
    1897                 :            :     }
    1898                 :    2639800 : }
    1899                 :            : 
    1900                 :            : /* Return the discriminator for ENTITY appearing inside
    1901                 :            :    FUNCTION.  The discriminator is the lexical ordinal of VAR or TYPE among
    1902                 :            :    entities with the same name and kind in the same FUNCTION.  */
    1903                 :            : 
    1904                 :            : static int
    1905                 :    1130980 : discriminator_for_local_entity (tree entity)
    1906                 :            : {
    1907                 :    1130980 :   if (!DECL_LANG_SPECIFIC (entity))
    1908                 :            :     {
    1909                 :            :       /* Some decls, like __FUNCTION__, don't need a discriminator.  */
    1910                 :      20803 :       gcc_checking_assert (DECL_ARTIFICIAL (entity));
    1911                 :            :       return 0;
    1912                 :            :     }
    1913                 :    1110170 :   else if (tree disc = DECL_DISCRIMINATOR (entity))
    1914                 :       2255 :     return TREE_INT_CST_LOW (disc);
    1915                 :            :   else
    1916                 :            :     /* The first entity with a particular name doesn't get
    1917                 :            :        DECL_DISCRIMINATOR set up.  */
    1918                 :            :     return 0;
    1919                 :            : }
    1920                 :            : 
    1921                 :            : /* Return the discriminator for STRING, a string literal used inside
    1922                 :            :    FUNCTION.  The discriminator is the lexical ordinal of STRING among
    1923                 :            :    string literals used in FUNCTION.  */
    1924                 :            : 
    1925                 :            : static int
    1926                 :          0 : discriminator_for_string_literal (tree /*function*/,
    1927                 :            :                                   tree /*string*/)
    1928                 :            : {
    1929                 :            :   /* For now, we don't discriminate amongst string literals.  */
    1930                 :          0 :   return 0;
    1931                 :            : }
    1932                 :            : 
    1933                 :            : /*   <discriminator> := _ <number>    # when number < 10
    1934                 :            :                      := __ <number> _ # when number >= 10
    1935                 :            : 
    1936                 :            :    The discriminator is used only for the second and later occurrences
    1937                 :            :    of the same name within a single function. In this case <number> is
    1938                 :            :    n - 2, if this is the nth occurrence, in lexical order.  */
    1939                 :            : 
    1940                 :            : static void
    1941                 :    1130540 : write_discriminator (const int discriminator)
    1942                 :            : {
    1943                 :            :   /* If discriminator is zero, don't write anything.  Otherwise...  */
    1944                 :    1130540 :   if (discriminator > 0)
    1945                 :            :     {
    1946                 :       2252 :       write_char ('_');
    1947                 :       2252 :       if (discriminator - 1 >= 10)
    1948                 :            :         {
    1949                 :       1477 :           if (abi_warn_or_compat_version_crosses (11))
    1950                 :          0 :             G.need_abi_warning = 1;
    1951                 :       1477 :           if (abi_version_at_least (11))
    1952                 :       1477 :             write_char ('_');
    1953                 :            :         }
    1954                 :       2252 :       write_unsigned_number (discriminator - 1);
    1955                 :       2252 :       if (abi_version_at_least (11) && discriminator - 1 >= 10)
    1956                 :       1477 :         write_char ('_');
    1957                 :            :     }
    1958                 :    1130540 : }
    1959                 :            : 
    1960                 :            : /* Mangle the name of a function-scope entity.  FUNCTION is the
    1961                 :            :    FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
    1962                 :            :    default argument scope.  ENTITY is the decl for the entity itself.
    1963                 :            :    LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
    1964                 :            :    either ENTITY itself or an enclosing scope of ENTITY.
    1965                 :            : 
    1966                 :            :      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
    1967                 :            :                   := Z <function encoding> E s [<discriminator>]
    1968                 :            :                   := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
    1969                 :            : 
    1970                 :            : static void
    1971                 :    1241630 : write_local_name (tree function, const tree local_entity,
    1972                 :            :                   const tree entity)
    1973                 :            : {
    1974                 :    1241630 :   tree parm = NULL_TREE;
    1975                 :            : 
    1976                 :    1241630 :   MANGLE_TRACE_TREE ("local-name", entity);
    1977                 :            : 
    1978                 :    1241630 :   if (TREE_CODE (function) == PARM_DECL)
    1979                 :            :     {
    1980                 :        258 :       parm = function;
    1981                 :        258 :       function = DECL_CONTEXT (parm);
    1982                 :            :     }
    1983                 :            : 
    1984                 :    1241630 :   write_char ('Z');
    1985                 :    1241630 :   write_encoding (function);
    1986                 :    1241630 :   write_char ('E');
    1987                 :            : 
    1988                 :            :   /* For this purpose, parameters are numbered from right-to-left.  */
    1989                 :    1241630 :   if (parm)
    1990                 :            :     {
    1991                 :        258 :       tree t;
    1992                 :        258 :       int i = 0;
    1993                 :        837 :       for (t = DECL_ARGUMENTS (function); t; t = DECL_CHAIN (t))
    1994                 :            :         {
    1995                 :        579 :           if (t == parm)
    1996                 :            :             i = 1;
    1997                 :        321 :           else if (i)
    1998                 :         36 :             ++i;
    1999                 :            :         }
    2000                 :        258 :       write_char ('d');
    2001                 :        258 :       write_compact_number (i - 1);
    2002                 :            :     }
    2003                 :            : 
    2004                 :    1241630 :   if (TREE_CODE (entity) == STRING_CST)
    2005                 :            :     {
    2006                 :          0 :       write_char ('s');
    2007                 :          0 :       write_discriminator (discriminator_for_string_literal (function,
    2008                 :            :                                                              entity));
    2009                 :            :     }
    2010                 :            :   else
    2011                 :            :     {
    2012                 :            :       /* Now the <entity name>.  Let write_name know its being called
    2013                 :            :          from <local-name>, so it doesn't try to process the enclosing
    2014                 :            :          function scope again.  */
    2015                 :    1241630 :       write_name (entity, /*ignore_local_scope=*/1);
    2016                 :    3607920 :       if (DECL_DISCRIMINATOR_P (local_entity)
    2017                 :    2482990 :           && !(TREE_CODE (local_entity) == TYPE_DECL
    2018                 :    1182890 :                && TYPE_ANON_P (TREE_TYPE (local_entity))))
    2019                 :    1130540 :         write_discriminator (discriminator_for_local_entity (local_entity));
    2020                 :            :     }
    2021                 :    1241630 : }
    2022                 :            : 
    2023                 :            : /* Non-terminals <type> and <CV-qualifier>.
    2024                 :            : 
    2025                 :            :      <type> ::= <builtin-type>
    2026                 :            :             ::= <function-type>
    2027                 :            :             ::= <class-enum-type>
    2028                 :            :             ::= <array-type>
    2029                 :            :             ::= <pointer-to-member-type>
    2030                 :            :             ::= <template-param>
    2031                 :            :             ::= <substitution>
    2032                 :            :             ::= <CV-qualifier>
    2033                 :            :             ::= P <type>    # pointer-to
    2034                 :            :             ::= R <type>    # reference-to
    2035                 :            :             ::= C <type>    # complex pair (C 2000)
    2036                 :            :             ::= G <type>    # imaginary (C 2000)     [not supported]
    2037                 :            :             ::= U <source-name> <type>   # vendor extended type qualifier
    2038                 :            : 
    2039                 :            :    C++0x extensions
    2040                 :            : 
    2041                 :            :      <type> ::= RR <type>   # rvalue reference-to
    2042                 :            :      <type> ::= Dt <expression> # decltype of an id-expression or 
    2043                 :            :                                 # class member access
    2044                 :            :      <type> ::= DT <expression> # decltype of an expression
    2045                 :            :      <type> ::= Dn              # decltype of nullptr
    2046                 :            : 
    2047                 :            :    TYPE is a type node.  */
    2048                 :            : 
    2049                 :            : static void
    2050                 :  262771000 : write_type (tree type)
    2051                 :            : {
    2052                 :            :   /* This gets set to nonzero if TYPE turns out to be a (possibly
    2053                 :            :      CV-qualified) builtin type.  */
    2054                 :  262771000 :   int is_builtin_type = 0;
    2055                 :            : 
    2056                 :  262771000 :   MANGLE_TRACE_TREE ("type", type);
    2057                 :            : 
    2058                 :  262771000 :   if (type == error_mark_node)
    2059                 :            :     return;
    2060                 :            : 
    2061                 :  262771000 :   type = canonicalize_for_substitution (type);
    2062                 :  262771000 :   if (find_substitution (type))
    2063                 :            :     return;
    2064                 :            : 
    2065                 :            : 
    2066                 :  237165000 :   if (write_CV_qualifiers_for_type (type) > 0)
    2067                 :            :     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
    2068                 :            :        mangle the unqualified type.  The recursive call is needed here
    2069                 :            :        since both the qualified and unqualified types are substitution
    2070                 :            :        candidates.  */
    2071                 :            :     {
    2072                 :   16523900 :       tree t = TYPE_MAIN_VARIANT (type);
    2073                 :   16523900 :       if (TYPE_ATTRIBUTES (t) && !OVERLOAD_TYPE_P (t))
    2074                 :            :         {
    2075                 :        751 :           tree attrs = NULL_TREE;
    2076                 :        751 :           if (tx_safe_fn_type_p (type))
    2077                 :          4 :             attrs = tree_cons (get_identifier ("transaction_safe"),
    2078                 :            :                                NULL_TREE, attrs);
    2079                 :        751 :           t = cp_build_type_attribute_variant (t, attrs);
    2080                 :            :         }
    2081                 :   16523900 :       gcc_assert (t != type);
    2082                 :   16523900 :       if (FUNC_OR_METHOD_TYPE_P (t))
    2083                 :            :         {
    2084                 :        267 :           t = build_ref_qualified_type (t, type_memfn_rqual (type));
    2085                 :        267 :           if (flag_noexcept_type)
    2086                 :            :             {
    2087                 :         69 :               tree r = TYPE_RAISES_EXCEPTIONS (type);
    2088                 :         69 :               t = build_exception_variant (t, r);
    2089                 :            :             }
    2090                 :        267 :           if (abi_version_at_least (8)
    2091                 :        291 :               || type == TYPE_MAIN_VARIANT (type))
    2092                 :            :             /* Avoid adding the unqualified function type as a substitution.  */
    2093                 :        243 :             write_function_type (t);
    2094                 :            :           else
    2095                 :         24 :             write_type (t);
    2096                 :        323 :           if (abi_warn_or_compat_version_crosses (8))
    2097                 :         24 :             G.need_abi_warning = 1;
    2098                 :            :         }
    2099                 :            :       else
    2100                 :   16523600 :         write_type (t);
    2101                 :            :     }
    2102                 :  220641000 :   else if (TREE_CODE (type) == ARRAY_TYPE)
    2103                 :            :     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
    2104                 :            :        so that the cv-qualification of the element type is available
    2105                 :            :        in write_array_type.  */
    2106                 :     381280 :     write_array_type (type);
    2107                 :            :   else
    2108                 :            :     {
    2109                 :  220260000 :       tree type_orig = type;
    2110                 :            : 
    2111                 :            :       /* See through any typedefs.  */
    2112                 :  220260000 :       type = TYPE_MAIN_VARIANT (type);
    2113                 :  220260000 :       if (FUNC_OR_METHOD_TYPE_P (type))
    2114                 :    1809060 :         type = cxx_copy_lang_qualifiers (type, type_orig);
    2115                 :            : 
    2116                 :            :       /* According to the C++ ABI, some library classes are passed the
    2117                 :            :          same as the scalar type of their single member and use the same
    2118                 :            :          mangling.  */
    2119                 :  220260000 :       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
    2120                 :      14364 :         type = TREE_TYPE (first_field (type));
    2121                 :            : 
    2122                 :  220260000 :       if (TYPE_PTRDATAMEM_P (type))
    2123                 :       7327 :         write_pointer_to_member_type (type);
    2124                 :            :       else
    2125                 :            :         {
    2126                 :            :           /* Handle any target-specific fundamental types.  */
    2127                 :  220252000 :           const char *target_mangling
    2128                 :  220252000 :             = targetm.mangle_type (type_orig);
    2129                 :            : 
    2130                 :  220252000 :           if (target_mangling)
    2131                 :            :             {
    2132                 :    1702260 :               write_string (target_mangling);
    2133                 :            :               /* Add substitutions for types other than fundamental
    2134                 :            :                  types.  */
    2135                 :    1702260 :               if (!VOID_TYPE_P (type)
    2136                 :    1702260 :                   && TREE_CODE (type) != INTEGER_TYPE
    2137                 :    1702260 :                   && TREE_CODE (type) != REAL_TYPE
    2138                 :          0 :                   && TREE_CODE (type) != BOOLEAN_TYPE)
    2139                 :          0 :                 add_substitution (type);
    2140                 :    1702260 :               return;
    2141                 :            :             }
    2142                 :            : 
    2143                 :  218550000 :           switch (TREE_CODE (type))
    2144                 :            :             {
    2145                 :  115965000 :             case VOID_TYPE:
    2146                 :  115965000 :             case BOOLEAN_TYPE:
    2147                 :  115965000 :             case INTEGER_TYPE:  /* Includes wchar_t.  */
    2148                 :  115965000 :             case REAL_TYPE:
    2149                 :  115965000 :             case FIXED_POINT_TYPE:
    2150                 :  115965000 :               {
    2151                 :            :                 /* If this is a typedef, TYPE may not be one of
    2152                 :            :                    the standard builtin type nodes, but an alias of one.  Use
    2153                 :            :                    TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
    2154                 :  115965000 :                 write_builtin_type (TYPE_MAIN_VARIANT (type));
    2155                 :  115965000 :                 ++is_builtin_type;
    2156                 :            :               }
    2157                 :  115965000 :               break;
    2158                 :            : 
    2159                 :       9819 :             case COMPLEX_TYPE:
    2160                 :       9819 :               write_char ('C');
    2161                 :       9819 :               write_type (TREE_TYPE (type));
    2162                 :       9819 :               break;
    2163                 :            : 
    2164                 :    1809060 :             case FUNCTION_TYPE:
    2165                 :    1809060 :             case METHOD_TYPE:
    2166                 :    1809060 :               write_function_type (type);
    2167                 :    1809060 :               break;
    2168                 :            : 
    2169                 :   56721100 :             case UNION_TYPE:
    2170                 :   56721100 :             case RECORD_TYPE:
    2171                 :   56721100 :             case ENUMERAL_TYPE:
    2172                 :            :               /* A pointer-to-member function is represented as a special
    2173                 :            :                  RECORD_TYPE, so check for this first.  */
    2174                 :   56721100 :               if (TYPE_PTRMEMFUNC_P (type))
    2175                 :     131904 :                 write_pointer_to_member_type (type);
    2176                 :            :               else
    2177                 :   56589200 :                 write_class_enum_type (type);
    2178                 :            :               break;
    2179                 :            : 
    2180                 :     658303 :             case TYPENAME_TYPE:
    2181                 :     658303 :             case UNBOUND_CLASS_TEMPLATE:
    2182                 :            :               /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
    2183                 :            :                  ordinary nested names.  */
    2184                 :     658303 :               write_nested_name (TYPE_STUB_DECL (type));
    2185                 :     658303 :               break;
    2186                 :            : 
    2187                 :   33228200 :             case POINTER_TYPE:
    2188                 :   33228200 :             case REFERENCE_TYPE:
    2189                 :   33228200 :               if (TYPE_PTR_P (type))
    2190                 :   16866400 :                 write_char ('P');
    2191                 :   16361800 :               else if (TYPE_REF_IS_RVALUE (type))
    2192                 :    3520480 :                 write_char ('O');
    2193                 :            :               else
    2194                 :   12841300 :                 write_char ('R');
    2195                 :   33228200 :               {
    2196                 :   33228200 :                 tree target = TREE_TYPE (type);
    2197                 :            :                 /* Attribute const/noreturn are not reflected in mangling.
    2198                 :            :                    We strip them here rather than at a lower level because
    2199                 :            :                    a typedef or template argument can have function type
    2200                 :            :                    with function-cv-quals (that use the same representation),
    2201                 :            :                    but you can't have a pointer/reference to such a type.  */
    2202                 :   33228200 :                 if (TREE_CODE (target) == FUNCTION_TYPE)
    2203                 :            :                   {
    2204                 :    2676860 :                     if (abi_warn_or_compat_version_crosses (5)
    2205                 :    1349780 :                         && TYPE_QUALS (target) != TYPE_UNQUALIFIED)
    2206                 :          4 :                       G.need_abi_warning = 1;
    2207                 :    1326120 :                     if (abi_version_at_least (5))
    2208                 :    1309750 :                       target = build_qualified_type (target, TYPE_UNQUALIFIED);
    2209                 :            :                   }
    2210                 :   33228200 :                 write_type (target);
    2211                 :            :               }
    2212                 :   33228200 :               break;
    2213                 :            : 
    2214                 :    8234630 :             case TEMPLATE_TYPE_PARM:
    2215                 :    8234630 :               if (is_auto (type))
    2216                 :            :                 {
    2217                 :      21599 :                   if (AUTO_IS_DECLTYPE (type))
    2218                 :      10386 :                     write_identifier ("Dc");
    2219                 :            :                   else
    2220                 :      11213 :                     write_identifier ("Da");
    2221                 :            :                   ++is_builtin_type;
    2222                 :            :                   break;
    2223                 :            :                 }
    2224                 :            :               /* fall through.  */
    2225                 :    8213030 :             case TEMPLATE_PARM_INDEX:
    2226                 :    8213030 :               write_template_param (type);
    2227                 :    8213030 :               break;
    2228                 :            : 
    2229                 :         49 :             case TEMPLATE_TEMPLATE_PARM:
    2230                 :         49 :               write_template_template_param (type);
    2231                 :         49 :               break;
    2232                 :            : 
    2233                 :         92 :             case BOUND_TEMPLATE_TEMPLATE_PARM:
    2234                 :         92 :               write_template_template_param (type);
    2235                 :         92 :               write_template_args
    2236                 :         92 :                 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
    2237                 :         92 :               break;
    2238                 :            : 
    2239                 :      61266 :             case VECTOR_TYPE:
    2240                 :      61266 :               if (abi_version_at_least (4))
    2241                 :            :                 {
    2242                 :      61247 :                   write_string ("Dv");
    2243                 :            :                   /* Non-constant vector size would be encoded with
    2244                 :            :                      _ expression, but we don't support that yet.  */
    2245                 :      61247 :                   write_unsigned_number (TYPE_VECTOR_SUBPARTS (type)
    2246                 :            :                                          .to_constant ());
    2247                 :      61247 :                   write_char ('_');
    2248                 :            :                 }
    2249                 :            :               else
    2250                 :         19 :                 write_string ("U8__vector");
    2251                 :      61285 :               if (abi_warn_or_compat_version_crosses (4))
    2252                 :         19 :                 G.need_abi_warning = 1;
    2253                 :      61266 :               write_type (TREE_TYPE (type));
    2254                 :      61266 :               break;
    2255                 :            : 
    2256                 :    1705010 :             case TYPE_PACK_EXPANSION:
    2257                 :    1705010 :               write_string ("Dp");
    2258                 :    3410010 :               write_type (PACK_EXPANSION_PATTERN (type));
    2259                 :    1705010 :               break;
    2260                 :            : 
    2261                 :       4965 :             case DECLTYPE_TYPE:
    2262                 :            :               /* These shouldn't make it into mangling.  */
    2263                 :       4965 :               gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
    2264                 :            :                           && !DECLTYPE_FOR_LAMBDA_PROXY (type));
    2265                 :            : 
    2266                 :            :               /* In ABI <5, we stripped decltype of a plain decl.  */
    2267                 :       4965 :               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
    2268                 :            :                 {
    2269                 :         89 :                   tree expr = DECLTYPE_TYPE_EXPR (type);
    2270                 :         89 :                   tree etype = NULL_TREE;
    2271                 :         89 :                   switch (TREE_CODE (expr))
    2272                 :            :                     {
    2273                 :         65 :                     case VAR_DECL:
    2274                 :         65 :                     case PARM_DECL:
    2275                 :         65 :                     case RESULT_DECL:
    2276                 :         65 :                     case FUNCTION_DECL:
    2277                 :         65 :                     case CONST_DECL:
    2278                 :         65 :                     case TEMPLATE_PARM_INDEX:
    2279                 :         65 :                       etype = TREE_TYPE (expr);
    2280                 :         65 :                       break;
    2281                 :            : 
    2282                 :            :                     default:
    2283                 :            :                       break;
    2284                 :            :                     }
    2285                 :            : 
    2286                 :         65 :                   if (etype && !type_uses_auto (etype))
    2287                 :            :                     {
    2288                 :        110 :                       if (abi_warn_or_compat_version_crosses (5))
    2289                 :          9 :                         G.need_abi_warning = 1;
    2290                 :         65 :                       if (!abi_version_at_least (5))
    2291                 :            :                         {
    2292                 :            :                           write_type (etype);
    2293                 :            :                           return;
    2294                 :            :                         }
    2295                 :            :                     }
    2296                 :            :                 }
    2297                 :            : 
    2298                 :       4956 :               write_char ('D');
    2299                 :       4956 :               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
    2300                 :         80 :                 write_char ('t');
    2301                 :            :               else
    2302                 :       4876 :                 write_char ('T');
    2303                 :       4956 :               ++cp_unevaluated_operand;
    2304                 :       4956 :               write_expression (DECLTYPE_TYPE_EXPR (type));
    2305                 :       4956 :               --cp_unevaluated_operand;
    2306                 :       4956 :               write_char ('E');
    2307                 :       4956 :               break;
    2308                 :            : 
    2309                 :     152931 :             case NULLPTR_TYPE:
    2310                 :     152931 :               write_string ("Dn");
    2311                 :     152931 :               if (abi_version_at_least (7))
    2312                 :     151907 :                 ++is_builtin_type;
    2313                 :     153955 :               if (abi_warn_or_compat_version_crosses (7))
    2314                 :       1770 :                 G.need_abi_warning = 1;
    2315                 :            :               break;
    2316                 :            : 
    2317                 :          4 :             case TYPEOF_TYPE:
    2318                 :          4 :               sorry ("mangling %<typeof%>, use %<decltype%> instead");
    2319                 :          4 :               break;
    2320                 :            : 
    2321                 :         18 :             case UNDERLYING_TYPE:
    2322                 :         18 :               sorry ("mangling %<__underlying_type%>");
    2323                 :         18 :               break;
    2324                 :            : 
    2325                 :          0 :             case LANG_TYPE:
    2326                 :            :               /* fall through.  */
    2327                 :            : 
    2328                 :          0 :             default:
    2329                 :          0 :               gcc_unreachable ();
    2330                 :            :             }
    2331                 :            :         }
    2332                 :            :     }
    2333                 :            : 
    2334                 :            :   /* Types other than builtin types are substitution candidates.  */
    2335                 :  235441000 :   if (!is_builtin_type)
    2336                 :  119324000 :     add_substitution (type);
    2337                 :            : }
    2338                 :            : 
    2339                 :            : /* qsort callback for sorting a vector of attribute entries.  */
    2340                 :            : 
    2341                 :            : static int
    2342                 :          0 : attr_strcmp (const void *p1, const void *p2)
    2343                 :            : {
    2344                 :          0 :   tree a1 = *(const tree*)p1;
    2345                 :          0 :   tree a2 = *(const tree*)p2;
    2346                 :            : 
    2347                 :          0 :   const attribute_spec *as1 = lookup_attribute_spec (get_attribute_name (a1));
    2348                 :          0 :   const attribute_spec *as2 = lookup_attribute_spec (get_attribute_name (a2));
    2349                 :            : 
    2350                 :          0 :   return strcmp (as1->name, as2->name);
    2351                 :            : }
    2352                 :            : 
    2353                 :            : /* Return true if we should mangle a type attribute with name NAME.  */
    2354                 :            : 
    2355                 :            : static bool
    2356                 :      76487 : mangle_type_attribute_p (tree name)
    2357                 :            : {
    2358                 :      76487 :   const attribute_spec *as = lookup_attribute_spec (name);
    2359                 :      76487 :   if (!as || !as->affects_type_identity)
    2360                 :            :     return false;
    2361                 :            : 
    2362                 :            :   /* Skip internal-only attributes, which are distinguished from others
    2363                 :            :      by having a space.  At present, all internal-only attributes that
    2364                 :            :      affect type identity are target-specific and are handled by
    2365                 :            :      targetm.mangle_type instead.
    2366                 :            : 
    2367                 :            :      Another reason to do this is that a space isn't a valid identifier
    2368                 :            :      character for most file formats.  */
    2369                 :         63 :   if (strchr (IDENTIFIER_POINTER (name), ' '))
    2370                 :            :     return false;
    2371                 :            : 
    2372                 :            :   /* The following attributes are mangled specially.  */
    2373                 :         63 :   if (is_attribute_p ("transaction_safe", name))
    2374                 :            :     return false;
    2375                 :         35 :   if (is_attribute_p ("abi_tag", name))
    2376                 :          0 :     return false;
    2377                 :            : 
    2378                 :            :   return true;
    2379                 :            : }
    2380                 :            : 
    2381                 :            : /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
    2382                 :            :    CV-qualifiers written for TYPE.
    2383                 :            : 
    2384                 :            :      <CV-qualifiers> ::= [r] [V] [K]  */
    2385                 :            : 
    2386                 :            : static int
    2387                 :  237297000 : write_CV_qualifiers_for_type (const tree type)
    2388                 :            : {
    2389                 :  237297000 :   int num_qualifiers = 0;
    2390                 :            : 
    2391                 :            :   /* The order is specified by:
    2392                 :            : 
    2393                 :            :        "In cases where multiple order-insensitive qualifiers are
    2394                 :            :        present, they should be ordered 'K' (closest to the base type),
    2395                 :            :        'V', 'r', and 'U' (farthest from the base type) ..."  */
    2396                 :            : 
    2397                 :            :   /* Mangle attributes that affect type identity as extended qualifiers.
    2398                 :            : 
    2399                 :            :      We don't do this with classes and enums because their attributes
    2400                 :            :      are part of their definitions, not something added on.  */
    2401                 :            : 
    2402                 :  297252000 :   if (!OVERLOAD_TYPE_P (type))
    2403                 :            :     {
    2404                 :  346285000 :       auto_vec<tree> vec;
    2405                 :  173219000 :       for (tree a = TYPE_ATTRIBUTES (type); a; a = TREE_CHAIN (a))
    2406                 :      76487 :         if (mangle_type_attribute_p (get_attribute_name (a)))
    2407                 :         35 :           vec.safe_push (a);
    2408                 :  180319000 :       if (abi_warn_or_compat_version_crosses (10) && !vec.is_empty ())
    2409                 :          0 :         G.need_abi_warning = true;
    2410                 :  173142000 :       if (abi_version_at_least (10))
    2411                 :            :         {
    2412                 :  171661000 :           vec.qsort (attr_strcmp);
    2413                 :  171661000 :           while (!vec.is_empty())
    2414                 :            :             {
    2415                 :         35 :               tree a = vec.pop();
    2416                 :         35 :               const attribute_spec *as
    2417                 :         35 :                 = lookup_attribute_spec (get_attribute_name (a));
    2418                 :            : 
    2419                 :         35 :               write_char ('U');
    2420                 :         35 :               write_unsigned_number (strlen (as->name));
    2421                 :         35 :               write_string (as->name);
    2422                 :         35 :               if (TREE_VALUE (a))
    2423                 :            :                 {
    2424                 :          3 :                   write_char ('I');
    2425                 :          9 :                   for (tree args = TREE_VALUE (a); args;
    2426                 :          3 :                        args = TREE_CHAIN (args))
    2427                 :            :                     {
    2428                 :          3 :                       tree arg = TREE_VALUE (args);
    2429                 :          3 :                       write_template_arg (arg);
    2430                 :            :                     }
    2431                 :          3 :                   write_char ('E');
    2432                 :            :                 }
    2433                 :            : 
    2434                 :         35 :               ++num_qualifiers;
    2435                 :            :             }
    2436                 :            :         }
    2437                 :            :     }
    2438                 :            : 
    2439                 :            :   /* Note that we do not use cp_type_quals below; given "const
    2440                 :            :      int[3]", the "const" is emitted with the "int", not with the
    2441                 :            :      array.  */
    2442                 :  237297000 :   cp_cv_quals quals = TYPE_QUALS (type);
    2443                 :            : 
    2444                 :  237297000 :   if (quals & TYPE_QUAL_RESTRICT)
    2445                 :            :     {
    2446                 :         50 :       write_char ('r');
    2447                 :         50 :       ++num_qualifiers;
    2448                 :            :     }
    2449                 :  237297000 :   if (quals & TYPE_QUAL_VOLATILE)
    2450                 :            :     {
    2451                 :      55346 :       write_char ('V');
    2452                 :      55346 :       ++num_qualifiers;
    2453                 :            :     }
    2454                 :  237297000 :   if (quals & TYPE_QUAL_CONST)
    2455                 :            :     {
    2456                 :   16514200 :       write_char ('K');
    2457                 :   16514200 :       ++num_qualifiers;
    2458                 :            :     }
    2459                 :            : 
    2460                 :  237297000 :   return num_qualifiers;
    2461                 :            : }
    2462                 :            : 
    2463                 :            : /* Non-terminal <builtin-type>.
    2464                 :            : 
    2465                 :            :      <builtin-type> ::= v   # void
    2466                 :            :                     ::= b   # bool
    2467                 :            :                     ::= w   # wchar_t
    2468                 :            :                     ::= c   # char
    2469                 :            :                     ::= a   # signed char
    2470                 :            :                     ::= h   # unsigned char
    2471                 :            :                     ::= s   # short
    2472                 :            :                     ::= t   # unsigned short
    2473                 :            :                     ::= i   # int
    2474                 :            :                     ::= j   # unsigned int
    2475                 :            :                     ::= l   # long
    2476                 :            :                     ::= m   # unsigned long
    2477                 :            :                     ::= x   # long long, __int64
    2478                 :            :                     ::= y   # unsigned long long, __int64
    2479                 :            :                     ::= n   # __int128
    2480                 :            :                     ::= o   # unsigned __int128
    2481                 :            :                     ::= f   # float
    2482                 :            :                     ::= d   # double
    2483                 :            :                     ::= e   # long double, __float80
    2484                 :            :                     ::= g   # __float128          [not supported]
    2485                 :            :                     ::= u <source-name>  # vendor extended type */
    2486                 :            : 
    2487                 :            : static void
    2488                 :  115965000 : write_builtin_type (tree type)
    2489                 :            : {
    2490                 :  115965000 :   if (TYPE_CANONICAL (type))
    2491                 :  115965000 :     type = TYPE_CANONICAL (type);
    2492                 :            : 
    2493                 :  115965000 :   switch (TREE_CODE (type))
    2494                 :            :     {
    2495                 :   17280300 :     case VOID_TYPE:
    2496                 :   17280300 :       write_char ('v');
    2497                 :   17280300 :       break;
    2498                 :            : 
    2499                 :    7313580 :     case BOOLEAN_TYPE:
    2500                 :    7313580 :       write_char ('b');
    2501                 :    7313580 :       break;
    2502                 :            : 
    2503                 :   87694500 :     case INTEGER_TYPE:
    2504                 :            :       /* TYPE may still be wchar_t, char8_t, char16_t, or char32_t, since that
    2505                 :            :          isn't in integer_type_nodes.  */
    2506                 :   87694500 :       if (type == wchar_type_node)
    2507                 :    9476500 :         write_char ('w');
    2508                 :   78218000 :       else if (type == char8_type_node)
    2509                 :     449248 :         write_string ("Du");
    2510                 :   77768700 :       else if (type == char16_type_node)
    2511                 :    7591260 :         write_string ("Ds");
    2512                 :   70177500 :       else if (type == char32_type_node)
    2513                 :    7595000 :         write_string ("Di");
    2514                 :            :       else
    2515                 :            :         {
    2516                 :   62582500 :           size_t itk;
    2517                 :            :           /* Assume TYPE is one of the shared integer type nodes.  Find
    2518                 :            :              it in the array of these nodes.  */
    2519                 :   62582500 :         iagain:
    2520                 :  400123000 :           for (itk = 0; itk < itk_none; ++itk)
    2521                 :  399739000 :             if (integer_types[itk] != NULL_TREE
    2522                 :  397433000 :                 && integer_type_codes[itk] != '\0'
    2523                 :  396664000 :                 && type == integer_types[itk])
    2524                 :            :               {
    2525                 :            :                 /* Print the corresponding single-letter code.  */
    2526                 :   62198100 :                 write_char (integer_type_codes[itk]);
    2527                 :   62198100 :                 break;
    2528                 :            :               }
    2529                 :            : 
    2530                 :   62582500 :           if (itk == itk_none)
    2531                 :            :             {
    2532                 :     768674 :               tree t = c_common_type_for_mode (TYPE_MODE (type),
    2533                 :     384337 :                                                TYPE_UNSIGNED (type));
    2534                 :     384337 :               if (type != t)
    2535                 :            :                 {
    2536                 :          0 :                   type = t;
    2537                 :          0 :                   goto iagain;
    2538                 :            :                 }
    2539                 :            : 
    2540                 :     384337 :               if (TYPE_PRECISION (type) == 128)
    2541                 :     384337 :                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
    2542                 :            :               else
    2543                 :            :                 {
    2544                 :            :                   /* Allow for cases where TYPE is not one of the shared
    2545                 :            :                      integer type nodes and write a "vendor extended builtin
    2546                 :            :                      type" with a name the form intN or uintN, respectively.
    2547                 :            :                      Situations like this can happen if you have an
    2548                 :            :                      __attribute__((__mode__(__SI__))) type and use exotic
    2549                 :            :                      switches like '-mint8' on AVR.  Of course, this is
    2550                 :            :                      undefined by the C++ ABI (and '-mint8' is not even
    2551                 :            :                      Standard C conforming), but when using such special
    2552                 :            :                      options you're pretty much in nowhere land anyway.  */
    2553                 :          0 :                   const char *prefix;
    2554                 :          0 :                   char prec[11];        /* up to ten digits for an unsigned */
    2555                 :            : 
    2556                 :          0 :                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
    2557                 :          0 :                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
    2558                 :          0 :                   write_char ('u');     /* "vendor extended builtin type" */
    2559                 :          0 :                   write_unsigned_number (strlen (prefix) + strlen (prec));
    2560                 :          0 :                   write_string (prefix);
    2561                 :          0 :                   write_string (prec);
    2562                 :            :                 }
    2563                 :            :             }
    2564                 :            :         }
    2565                 :            :       break;
    2566                 :            : 
    2567                 :    3676140 :     case REAL_TYPE:
    2568                 :    3676140 :       if (type == float_type_node)
    2569                 :     734295 :         write_char ('f');
    2570                 :    2941850 :       else if (type == double_type_node)
    2571                 :    2925160 :         write_char ('d');
    2572                 :      16692 :       else if (type == long_double_type_node)
    2573                 :          0 :         write_char ('e');
    2574                 :      16692 :       else if (type == dfloat32_type_node || type == fallback_dfloat32_type)
    2575                 :       5684 :         write_string ("Df");
    2576                 :      11008 :       else if (type == dfloat64_type_node || type == fallback_dfloat64_type)
    2577                 :       5526 :         write_string ("Dd");
    2578                 :       5482 :       else if (type == dfloat128_type_node || type == fallback_dfloat128_type)
    2579                 :       5482 :         write_string ("De");
    2580                 :            :       else
    2581                 :          0 :         gcc_unreachable ();
    2582                 :            :       break;
    2583                 :            : 
    2584                 :          0 :     case FIXED_POINT_TYPE:
    2585                 :          0 :       write_string ("DF");
    2586                 :          0 :       if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
    2587                 :          0 :         write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
    2588                 :          0 :       if (type == fract_type_node
    2589                 :          0 :           || type == sat_fract_type_node
    2590                 :          0 :           || type == accum_type_node
    2591                 :          0 :           || type == sat_accum_type_node)
    2592                 :          0 :         write_char ('i');
    2593                 :          0 :       else if (type == unsigned_fract_type_node
    2594                 :          0 :                || type == sat_unsigned_fract_type_node
    2595                 :          0 :                || type == unsigned_accum_type_node
    2596                 :          0 :                || type == sat_unsigned_accum_type_node)
    2597                 :          0 :         write_char ('j');
    2598                 :          0 :       else if (type == short_fract_type_node
    2599                 :          0 :                || type == sat_short_fract_type_node
    2600                 :          0 :                || type == short_accum_type_node
    2601                 :          0 :                || type == sat_short_accum_type_node)
    2602                 :          0 :         write_char ('s');
    2603                 :          0 :       else if (type == unsigned_short_fract_type_node
    2604                 :          0 :                || type == sat_unsigned_short_fract_type_node
    2605                 :          0 :                || type == unsigned_short_accum_type_node
    2606                 :          0 :                || type == sat_unsigned_short_accum_type_node)
    2607                 :          0 :         write_char ('t');
    2608                 :          0 :       else if (type == long_fract_type_node
    2609                 :          0 :                || type == sat_long_fract_type_node
    2610                 :          0 :                || type == long_accum_type_node
    2611                 :          0 :                || type == sat_long_accum_type_node)
    2612                 :          0 :         write_char ('l');
    2613                 :          0 :       else if (type == unsigned_long_fract_type_node
    2614                 :          0 :                || type == sat_unsigned_long_fract_type_node
    2615                 :          0 :                || type == unsigned_long_accum_type_node
    2616                 :          0 :                || type == sat_unsigned_long_accum_type_node)
    2617                 :          0 :         write_char ('m');
    2618                 :          0 :       else if (type == long_long_fract_type_node
    2619                 :          0 :                || type == sat_long_long_fract_type_node
    2620                 :          0 :                || type == long_long_accum_type_node
    2621                 :          0 :                || type == sat_long_long_accum_type_node)
    2622                 :          0 :         write_char ('x');
    2623                 :          0 :       else if (type == unsigned_long_long_fract_type_node
    2624                 :          0 :                || type == sat_unsigned_long_long_fract_type_node
    2625                 :          0 :                || type == unsigned_long_long_accum_type_node
    2626                 :          0 :                || type == sat_unsigned_long_long_accum_type_node)
    2627                 :          0 :         write_char ('y');
    2628                 :            :       else
    2629                 :          0 :         sorry ("mangling unknown fixed point type");
    2630                 :          0 :       write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
    2631                 :          0 :       if (TYPE_SATURATING (type))
    2632                 :          0 :         write_char ('s');
    2633                 :            :       else
    2634                 :          0 :         write_char ('n');
    2635                 :            :       break;
    2636                 :            : 
    2637                 :          0 :     default:
    2638                 :          0 :       gcc_unreachable ();
    2639                 :            :     }
    2640                 :  115965000 : }
    2641                 :            : 
    2642                 :            : /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
    2643                 :            :    METHOD_TYPE.  The return type is mangled before the parameter
    2644                 :            :    types.
    2645                 :            : 
    2646                 :            :      <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E   */
    2647                 :            : 
    2648                 :            : static void
    2649                 :    1809300 : write_function_type (const tree type)
    2650                 :            : {
    2651                 :    1809300 :   MANGLE_TRACE_TREE ("function-type", type);
    2652                 :            : 
    2653                 :            :   /* For a pointer to member function, the function type may have
    2654                 :            :      cv-qualifiers, indicating the quals for the artificial 'this'
    2655                 :            :      parameter.  */
    2656                 :    1809300 :   if (TREE_CODE (type) == METHOD_TYPE)
    2657                 :            :     {
    2658                 :            :       /* The first parameter must be a POINTER_TYPE pointing to the
    2659                 :            :          `this' parameter.  */
    2660                 :     131904 :       tree this_type = class_of_this_parm (type);
    2661                 :     131904 :       write_CV_qualifiers_for_type (this_type);
    2662                 :            :     }
    2663                 :            : 
    2664                 :    1941210 :   write_exception_spec (TYPE_RAISES_EXCEPTIONS (type));
    2665                 :            : 
    2666                 :    1809300 :   if (tx_safe_fn_type_p (type))
    2667                 :         28 :     write_string ("Dx");
    2668                 :            : 
    2669                 :    1809300 :   write_char ('F');
    2670                 :            :   /* We don't track whether or not a type is `extern "C"'.  Note that
    2671                 :            :      you can have an `extern "C"' function that does not have
    2672                 :            :      `extern "C"' type, and vice versa:
    2673                 :            : 
    2674                 :            :        extern "C" typedef void function_t();
    2675                 :            :        function_t f; // f has C++ linkage, but its type is
    2676                 :            :                      // `extern "C"'
    2677                 :            : 
    2678                 :            :        typedef void function_t();
    2679                 :            :        extern "C" function_t f; // Vice versa.
    2680                 :            : 
    2681                 :            :      See [dcl.link].  */
    2682                 :    1809300 :   write_bare_function_type (type, /*include_return_type_p=*/1,
    2683                 :            :                             /*decl=*/NULL);
    2684                 :    3750510 :   if (FUNCTION_REF_QUALIFIED (type))
    2685                 :            :     {
    2686                 :       1013 :       if (FUNCTION_RVALUE_QUALIFIED (type))
    2687                 :         46 :         write_char ('O');
    2688                 :            :       else
    2689                 :        526 :         write_char ('R');
    2690                 :            :     }
    2691                 :    1809300 :   write_char ('E');
    2692                 :    1809300 : }
    2693                 :            : 
    2694                 :            : /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
    2695                 :            :    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
    2696                 :            :    is mangled before the parameter types.  If non-NULL, DECL is
    2697                 :            :    FUNCTION_DECL for the function whose type is being emitted.  */
    2698                 :            : 
    2699                 :            : static void
    2700                 :   42017900 : write_bare_function_type (const tree type, const int include_return_type_p,
    2701                 :            :                           const tree decl)
    2702                 :            : {
    2703                 :   42017900 :   MANGLE_TRACE_TREE ("bare-function-type", type);
    2704                 :            : 
    2705                 :            :   /* Mangle the return type, if requested.  */
    2706                 :   42017900 :   if (include_return_type_p)
    2707                 :    5101960 :     write_type (TREE_TYPE (type));
    2708                 :            : 
    2709                 :            :   /* Now mangle the types of the arguments.  */
    2710                 :   42017900 :   ++G.parm_depth;
    2711                 :   42017900 :   write_method_parms (TYPE_ARG_TYPES (type),
    2712                 :   42017900 :                       TREE_CODE (type) == METHOD_TYPE,
    2713                 :            :                       decl);
    2714                 :   42017900 :   --G.parm_depth;
    2715                 :   42017900 : }
    2716                 :            : 
    2717                 :            : /* Write the mangled representation of a method parameter list of
    2718                 :            :    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
    2719                 :            :    considered a non-static method, and the this parameter is omitted.
    2720                 :            :    If non-NULL, DECL is the FUNCTION_DECL for the function whose
    2721                 :            :    parameters are being emitted.  */
    2722                 :            : 
    2723                 :            : static void
    2724                 :   42159400 : write_method_parms (tree parm_types, const int method_p, const tree decl)
    2725                 :            : {
    2726                 :   42159400 :   tree first_parm_type;
    2727                 :   78350000 :   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
    2728                 :            : 
    2729                 :            :   /* Assume this parameter type list is variable-length.  If it ends
    2730                 :            :      with a void type, then it's not.  */
    2731                 :   42159400 :   int varargs_p = 1;
    2732                 :            : 
    2733                 :            :   /* If this is a member function, skip the first arg, which is the
    2734                 :            :      this pointer.
    2735                 :            :        "Member functions do not encode the type of their implicit this
    2736                 :            :        parameter."
    2737                 :            : 
    2738                 :            :      Similarly, there's no need to mangle artificial parameters, like
    2739                 :            :      the VTT parameters for constructors and destructors.  */
    2740                 :   42159400 :   if (method_p)
    2741                 :            :     {
    2742                 :   33092200 :       parm_types = TREE_CHAIN (parm_types);
    2743                 :   64858800 :       parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
    2744                 :            : 
    2745                 :   55314000 :       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
    2746                 :            :         {
    2747                 :    1256510 :           parm_types = TREE_CHAIN (parm_types);
    2748                 :    1256510 :           parm_decl = DECL_CHAIN (parm_decl);
    2749                 :            :         }
    2750                 :            : 
    2751                 :   33092200 :       if (decl && ctor_omit_inherited_parms (decl))
    2752                 :            :         /* Bring back parameters omitted from an inherited ctor.  */
    2753                 :         72 :         parm_types = FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (decl));
    2754                 :            :     }
    2755                 :            : 
    2756                 :  135551000 :   for (first_parm_type = parm_types;
    2757                 :  135551000 :        parm_types;
    2758                 :   93391900 :        parm_types = TREE_CHAIN (parm_types))
    2759                 :            :     {
    2760                 :   93391900 :       tree parm = TREE_VALUE (parm_types);
    2761                 :   93391900 :       if (parm == void_type_node)
    2762                 :            :         {
    2763                 :            :           /* "Empty parameter lists, whether declared as () or
    2764                 :            :              conventionally as (void), are encoded with a void parameter
    2765                 :            :              (v)."  */
    2766                 :   42119400 :           if (parm_types == first_parm_type)
    2767                 :   14015200 :             write_type (parm);
    2768                 :            :           /* If the parm list is terminated with a void type, it's
    2769                 :            :              fixed-length.  */
    2770                 :   42119400 :           varargs_p = 0;
    2771                 :            :           /* A void type better be the last one.  */
    2772                 :   42119400 :           gcc_assert (TREE_CHAIN (parm_types) == NULL);
    2773                 :            :         }
    2774                 :            :       else
    2775                 :   51272500 :         write_type (parm);
    2776                 :            :     }
    2777                 :            : 
    2778                 :   42159400 :   if (varargs_p)
    2779                 :            :     /* <builtin-type> ::= z  # ellipsis  */
    2780                 :      39909 :     write_char ('z');
    2781                 :   42159400 : }
    2782                 :            : 
    2783                 :            : /* <class-enum-type> ::= <name>  */
    2784                 :            : 
    2785                 :            : static void
    2786                 :   56589200 : write_class_enum_type (const tree type)
    2787                 :            : {
    2788                 :   56589200 :   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
    2789                 :   56589200 : }
    2790                 :            : 
    2791                 :            : /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
    2792                 :            :    arguments.
    2793                 :            : 
    2794                 :            :      <template-args> ::= I <template-arg>* E  */
    2795                 :            : 
    2796                 :            : static void
    2797                 :   83801800 : write_template_args (tree args)
    2798                 :            : {
    2799                 :   83801800 :   int i;
    2800                 :   83801800 :   int length = 0;
    2801                 :            : 
    2802                 :   83801800 :   MANGLE_TRACE_TREE ("template-args", args);
    2803                 :            : 
    2804                 :   83801800 :   write_char ('I');
    2805                 :            : 
    2806                 :   83801800 :   if (args)
    2807                 :   83801800 :     length = TREE_VEC_LENGTH (args);
    2808                 :            : 
    2809                 :   83801800 :   if (args && length && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
    2810                 :            :     {
    2811                 :            :       /* We have nested template args.  We want the innermost template
    2812                 :            :          argument list.  */
    2813                 :    1335940 :       args = TREE_VEC_ELT (args, length - 1);
    2814                 :    1335940 :       length = TREE_VEC_LENGTH (args);
    2815                 :            :     }
    2816                 :  221987000 :   for (i = 0; i < length; ++i)
    2817                 :  138186000 :     write_template_arg (TREE_VEC_ELT (args, i));
    2818                 :            : 
    2819                 :   83801800 :   write_char ('E');
    2820                 :   83801800 : }
    2821                 :            : 
    2822                 :            : /* Write out the
    2823                 :            :    <unqualified-name>
    2824                 :            :    <unqualified-name> <template-args>
    2825                 :            :    part of SCOPE_REF or COMPONENT_REF mangling.  */
    2826                 :            : 
    2827                 :            : static void
    2828                 :     109413 : write_member_name (tree member)
    2829                 :            : {
    2830                 :     109413 :   if (identifier_p (member))
    2831                 :            :     {
    2832                 :     108974 :       if (abi_version_at_least (11) && IDENTIFIER_ANY_OP_P (member))
    2833                 :            :         {
    2834                 :        144 :           write_string ("on");
    2835                 :        144 :           if (abi_warn_or_compat_version_crosses (11))
    2836                 :          0 :             G.need_abi_warning = 1;
    2837                 :            :         }
    2838                 :     108974 :       write_unqualified_id (member);
    2839                 :            :     }
    2840                 :        439 :   else if (DECL_P (member))
    2841                 :        168 :     write_unqualified_name (member);
    2842                 :        271 :   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
    2843                 :            :     {
    2844                 :        192 :       tree name = TREE_OPERAND (member, 0);
    2845                 :        192 :       name = OVL_FIRST (name);
    2846                 :        192 :       write_member_name (name);
    2847                 :        192 :       write_template_args (TREE_OPERAND (member, 1));
    2848                 :            :     }
    2849                 :            :   else
    2850                 :         79 :     write_expression (member);
    2851                 :     109413 : }
    2852                 :            : 
    2853                 :            : /* <expression> ::= <unary operator-name> <expression>
    2854                 :            :                 ::= <binary operator-name> <expression> <expression>
    2855                 :            :                 ::= <expr-primary>
    2856                 :            : 
    2857                 :            :    <expr-primary> ::= <template-param>
    2858                 :            :                   ::= L <type> <value number> E             # literal
    2859                 :            :                   ::= L <mangled-name> E          # external name
    2860                 :            :                   ::= st <type>                           # sizeof
    2861                 :            :                   ::= sr <type> <unqualified-name>  # dependent name
    2862                 :            :                   ::= sr <type> <unqualified-name> <template-args> */
    2863                 :            : 
    2864                 :            : static void
    2865                 :     296805 : write_expression (tree expr)
    2866                 :            : {
    2867                 :     303702 :   enum tree_code code = TREE_CODE (expr);
    2868                 :            : 
    2869                 :     303702 :   if (TREE_CODE (expr) == TARGET_EXPR)
    2870                 :            :     {
    2871                 :         12 :       expr = TARGET_EXPR_INITIAL (expr);
    2872                 :         12 :       code = TREE_CODE (expr);
    2873                 :            :     }
    2874                 :            : 
    2875                 :            :   /* Skip NOP_EXPR and CONVERT_EXPR.  They can occur when (say) a pointer
    2876                 :            :      argument is converted (via qualification conversions) to another type.  */
    2877                 :     307308 :   while (CONVERT_EXPR_CODE_P (code)
    2878                 :     306527 :          || location_wrapper_p (expr)
    2879                 :            :          /* Parentheses aren't mangled.  */
    2880                 :     303704 :          || code == PAREN_EXPR
    2881                 :     303704 :          || code == NON_LVALUE_EXPR
    2882                 :     611012 :          || (code == VIEW_CONVERT_EXPR
    2883                 :          2 :              && TREE_CODE (TREE_OPERAND (expr, 0)) == TEMPLATE_PARM_INDEX))
    2884                 :            :     {
    2885                 :       3606 :       expr = TREE_OPERAND (expr, 0);
    2886                 :       3606 :       code = TREE_CODE (expr);
    2887                 :            :     }
    2888                 :            : 
    2889                 :     303702 :   if (code == BASELINK
    2890                 :     303702 :       && (!type_unknown_p (expr)
    2891                 :        758 :           || !BASELINK_QUALIFIED_P (expr)))
    2892                 :            :     {
    2893                 :        738 :       expr = BASELINK_FUNCTIONS (expr);
    2894                 :        738 :       code = TREE_CODE (expr);
    2895                 :            :     }
    2896                 :            : 
    2897                 :            :   /* Handle pointers-to-members by making them look like expression
    2898                 :            :      nodes.  */
    2899                 :     303702 :   if (code == PTRMEM_CST)
    2900                 :            :     {
    2901                 :        580 :       expr = build_nt (ADDR_EXPR,
    2902                 :            :                        build_qualified_name (/*type=*/NULL_TREE,
    2903                 :        510 :                                              PTRMEM_CST_CLASS (expr),
    2904                 :        290 :                                              PTRMEM_CST_MEMBER (expr),
    2905                 :            :                                              /*template_p=*/false));
    2906                 :        290 :       code = TREE_CODE (expr);
    2907                 :            :     }
    2908                 :            : 
    2909                 :            :   /* Handle template parameters.  */
    2910                 :     303702 :   if (code == TEMPLATE_TYPE_PARM
    2911                 :     303702 :       || code == TEMPLATE_TEMPLATE_PARM
    2912                 :     303702 :       || code == BOUND_TEMPLATE_TEMPLATE_PARM
    2913                 :     301992 :       || code == TEMPLATE_PARM_INDEX)
    2914                 :     136092 :     write_template_param (expr);
    2915                 :            :   /* Handle literals.  */
    2916                 :     167610 :   else if (TREE_CODE_CLASS (code) == tcc_constant
    2917                 :     164409 :            || code == CONST_DECL)
    2918                 :       4012 :     write_template_arg_literal (expr);
    2919                 :     170646 :   else if (code == PARM_DECL && DECL_ARTIFICIAL (expr))
    2920                 :            :     {
    2921                 :        144 :       gcc_assert (id_equal (DECL_NAME (expr), "this"));
    2922                 :        144 :       write_string ("fpT");
    2923                 :            :     }
    2924                 :     163454 :   else if (code == PARM_DECL)
    2925                 :            :     {
    2926                 :            :       /* A function parameter used in a late-specified return type.  */
    2927                 :       6904 :       int index = DECL_PARM_INDEX (expr);
    2928                 :       6904 :       int level = DECL_PARM_LEVEL (expr);
    2929                 :       6904 :       int delta = G.parm_depth - level + 1;
    2930                 :       6904 :       gcc_assert (index >= 1);
    2931                 :       6904 :       write_char ('f');
    2932                 :       6904 :       if (delta != 0)
    2933                 :            :         {
    2934                 :         25 :           if (abi_version_at_least (5))
    2935                 :            :             {
    2936                 :            :               /* Let L be the number of function prototype scopes from the
    2937                 :            :                  innermost one (in which the parameter reference occurs) up
    2938                 :            :                  to (and including) the one containing the declaration of
    2939                 :            :                  the referenced parameter.  If the parameter declaration
    2940                 :            :                  clause of the innermost function prototype scope has been
    2941                 :            :                  completely seen, it is not counted (in that case -- which
    2942                 :            :                  is perhaps the most common -- L can be zero).  */
    2943                 :         22 :               write_char ('L');
    2944                 :         22 :               write_unsigned_number (delta - 1);
    2945                 :            :             }
    2946                 :         46 :           if (abi_warn_or_compat_version_crosses (5))
    2947                 :          9 :             G.need_abi_warning = true;
    2948                 :            :         }
    2949                 :       6904 :       write_char ('p');
    2950                 :       6904 :       write_compact_number (index - 1);
    2951                 :            :     }
    2952                 :     156550 :   else if (DECL_P (expr))
    2953                 :            :     {
    2954                 :        948 :       write_char ('L');
    2955                 :        948 :       write_mangled_name (expr, false);
    2956                 :        948 :       write_char ('E');
    2957                 :            :     }
    2958                 :     155602 :   else if (TREE_CODE (expr) == SIZEOF_EXPR)
    2959                 :            :     {
    2960                 :       1897 :       tree op = TREE_OPERAND (expr, 0);
    2961                 :            : 
    2962                 :       1897 :       if (PACK_EXPANSION_P (op))
    2963                 :            :         {
    2964                 :       1776 :           if (abi_warn_or_compat_version_crosses (11))
    2965                 :          9 :             G.need_abi_warning = true;
    2966                 :       1767 :           if (abi_version_at_least (11))
    2967                 :            :             {
    2968                 :            :               /* sZ rather than szDp.  */
    2969                 :       1758 :               write_string ("sZ");
    2970                 :       3468 :               write_expression (PACK_EXPANSION_PATTERN (op));
    2971                 :       1758 :               return;
    2972                 :            :             }
    2973                 :            :         }
    2974                 :            : 
    2975                 :        139 :       if (SIZEOF_EXPR_TYPE_P (expr))
    2976                 :            :         {
    2977                 :          0 :           write_string ("st");
    2978                 :          0 :           write_type (TREE_TYPE (op));
    2979                 :            :         }
    2980                 :        139 :       else if (ARGUMENT_PACK_P (op))
    2981                 :            :         {
    2982                 :         12 :           tree args = ARGUMENT_PACK_ARGS (op);
    2983                 :          6 :           int length = TREE_VEC_LENGTH (args);
    2984                 :          9 :           if (abi_warn_or_compat_version_crosses (10))
    2985                 :          3 :             G.need_abi_warning = true;
    2986                 :          6 :           if (abi_version_at_least (10))
    2987                 :            :             {
    2988                 :            :               /* sP <template-arg>* E # sizeof...(T), size of a captured
    2989                 :            :                  template parameter pack from an alias template */
    2990                 :          3 :               write_string ("sP");
    2991                 :         12 :               for (int i = 0; i < length; ++i)
    2992                 :          9 :                 write_template_arg (TREE_VEC_ELT (args, i));
    2993                 :          3 :               write_char ('E');
    2994                 :            :             }
    2995                 :            :           else
    2996                 :            :             {
    2997                 :            :               /* In GCC 5 we represented this sizeof wrong, with the effect
    2998                 :            :                  that we mangled it as the last element of the pack.  */
    2999                 :          3 :               tree arg = TREE_VEC_ELT (args, length-1);
    3000                 :          3 :               if (TYPE_P (op))
    3001                 :            :                 {
    3002                 :          3 :                   write_string ("st");
    3003                 :          3 :                   write_type (arg);
    3004                 :            :                 }
    3005                 :            :               else
    3006                 :            :                 {
    3007                 :          0 :                   write_string ("sz");
    3008                 :          0 :                   write_expression (arg);
    3009                 :            :                 }
    3010                 :            :             }
    3011                 :            :         }
    3012                 :        133 :       else if (TYPE_P (TREE_OPERAND (expr, 0)))
    3013                 :            :         {
    3014                 :         26 :           write_string ("st");
    3015                 :         26 :           write_type (TREE_OPERAND (expr, 0));
    3016                 :            :         }
    3017                 :            :       else
    3018                 :        107 :         goto normal_expr;
    3019                 :            :     }
    3020                 :     153705 :   else if (TREE_CODE (expr) == ALIGNOF_EXPR
    3021                 :     153705 :            && TYPE_P (TREE_OPERAND (expr, 0)))
    3022                 :            :     {
    3023                 :          0 :       write_string ("at");
    3024                 :          0 :       write_type (TREE_OPERAND (expr, 0));
    3025                 :            :     }
    3026                 :     153705 :   else if (code == SCOPE_REF
    3027                 :     153705 :            || code == BASELINK)
    3028                 :            :     {
    3029                 :     106394 :       tree scope, member;
    3030                 :     106394 :       if (code == SCOPE_REF)
    3031                 :            :         {
    3032                 :     106367 :           scope = TREE_OPERAND (expr, 0);
    3033                 :     106367 :           member = TREE_OPERAND (expr, 1);
    3034                 :     106367 :           if (BASELINK_P (member))
    3035                 :          3 :             member = BASELINK_FUNCTIONS (member);
    3036                 :            :         }
    3037                 :            :       else
    3038                 :            :         {
    3039                 :         27 :           scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr));
    3040                 :         27 :           member = BASELINK_FUNCTIONS (expr);
    3041                 :            :         }
    3042                 :            : 
    3043                 :            :       /* If the MEMBER is a real declaration, then the qualifying
    3044                 :            :          scope was not dependent.  Ideally, we would not have a
    3045                 :            :          SCOPE_REF in those cases, but sometimes we do.  If the second
    3046                 :            :          argument is a DECL, then the name must not have been
    3047                 :            :          dependent.  */
    3048                 :     106394 :       if (DECL_P (member))
    3049                 :            :         write_expression (member);
    3050                 :            :       else
    3051                 :            :         {
    3052                 :     105951 :           write_string ("sr");
    3053                 :     105951 :           write_type (scope);
    3054                 :     105951 :           write_member_name (member);
    3055                 :            :         }
    3056                 :            :     }
    3057                 :      47311 :   else if (INDIRECT_REF_P (expr)
    3058                 :       4595 :            && TREE_TYPE (TREE_OPERAND (expr, 0))
    3059                 :      51906 :            && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
    3060                 :            :     {
    3061                 :       4299 :       write_expression (TREE_OPERAND (expr, 0));
    3062                 :            :     }
    3063                 :      43012 :   else if (identifier_p (expr))
    3064                 :            :     {
    3065                 :            :       /* An operator name appearing as a dependent name needs to be
    3066                 :            :          specially marked to disambiguate between a use of the operator
    3067                 :            :          name and a use of the operator in an expression.  */
    3068                 :       1260 :       if (IDENTIFIER_ANY_OP_P (expr))
    3069                 :          3 :         write_string ("on");
    3070                 :       1260 :       write_unqualified_id (expr);
    3071                 :            :     }
    3072                 :      41752 :   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
    3073                 :            :     {
    3074                 :       5184 :       tree fn = TREE_OPERAND (expr, 0);
    3075                 :      10368 :       fn = OVL_NAME (fn);
    3076                 :       5184 :       if (IDENTIFIER_ANY_OP_P (fn))
    3077                 :          3 :         write_string ("on");
    3078                 :       5184 :       write_unqualified_id (fn);
    3079                 :       5184 :       write_template_args (TREE_OPERAND (expr, 1));
    3080                 :            :     }
    3081                 :      36568 :   else if (TREE_CODE (expr) == MODOP_EXPR)
    3082                 :            :     {
    3083                 :          3 :       enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1));
    3084                 :          3 :       const char *name = OVL_OP_INFO (true, subop)->mangled_name;
    3085                 :            : 
    3086                 :          3 :       write_string (name);
    3087                 :          3 :       write_expression (TREE_OPERAND (expr, 0));
    3088                 :          3 :       write_expression (TREE_OPERAND (expr, 2));
    3089                 :            :     }
    3090                 :      36565 :   else if (code == NEW_EXPR || code == VEC_NEW_EXPR)
    3091                 :            :     {
    3092                 :            :       /* ::= [gs] nw <expression>* _ <type> E
    3093                 :            :          ::= [gs] nw <expression>* _ <type> <initializer>
    3094                 :            :          ::= [gs] na <expression>* _ <type> E
    3095                 :            :          ::= [gs] na <expression>* _ <type> <initializer>
    3096                 :            :          <initializer> ::= pi <expression>* E  */
    3097                 :        145 :       tree placement = TREE_OPERAND (expr, 0);
    3098                 :        145 :       tree type = TREE_OPERAND (expr, 1);
    3099                 :        145 :       tree nelts = TREE_OPERAND (expr, 2);
    3100                 :        145 :       tree init = TREE_OPERAND (expr, 3);
    3101                 :        145 :       tree t;
    3102                 :            : 
    3103                 :        145 :       gcc_assert (code == NEW_EXPR);
    3104                 :        145 :       if (TREE_OPERAND (expr, 2))
    3105                 :         10 :         code = VEC_NEW_EXPR;
    3106                 :            : 
    3107                 :        145 :       if (NEW_EXPR_USE_GLOBAL (expr))
    3108                 :        123 :         write_string ("gs");
    3109                 :            : 
    3110                 :        145 :       write_string (OVL_OP_INFO (false, code)->mangled_name);
    3111                 :            : 
    3112                 :        268 :       for (t = placement; t; t = TREE_CHAIN (t))
    3113                 :        123 :         write_expression (TREE_VALUE (t));
    3114                 :            : 
    3115                 :        145 :       write_char ('_');
    3116                 :            : 
    3117                 :        145 :       if (nelts)
    3118                 :            :         {
    3119                 :         10 :           tree domain;
    3120                 :         10 :           ++processing_template_decl;
    3121                 :         10 :           domain = compute_array_index_type (NULL_TREE, nelts,
    3122                 :            :                                              tf_warning_or_error);
    3123                 :         10 :           type = build_cplus_array_type (type, domain);
    3124                 :         10 :           --processing_template_decl;
    3125                 :            :         }
    3126                 :        145 :       write_type (type);
    3127                 :            : 
    3128                 :        135 :       if (init && TREE_CODE (init) == TREE_LIST
    3129                 :        274 :           && DIRECT_LIST_INIT_P (TREE_VALUE (init)))
    3130                 :     303702 :         write_expression (TREE_VALUE (init));
    3131                 :            :       else
    3132                 :            :         {
    3133                 :        142 :           if (init)
    3134                 :        132 :             write_string ("pi");
    3135                 :        142 :           if (init && init != void_node)
    3136                 :        252 :             for (t = init; t; t = TREE_CHAIN (t))
    3137                 :        126 :               write_expression (TREE_VALUE (t));
    3138                 :        142 :           write_char ('E');
    3139                 :            :         }
    3140                 :            :     }
    3141                 :      36420 :   else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR)
    3142                 :            :     {
    3143                 :         12 :       gcc_assert (code == DELETE_EXPR);
    3144                 :         12 :       if (DELETE_EXPR_USE_VEC (expr))
    3145                 :          6 :         code = VEC_DELETE_EXPR;
    3146                 :            : 
    3147                 :         12 :       if (DELETE_EXPR_USE_GLOBAL (expr))
    3148                 :          6 :         write_string ("gs");
    3149                 :            : 
    3150                 :         12 :       write_string (OVL_OP_INFO (false, code)->mangled_name);
    3151                 :            : 
    3152                 :         12 :       write_expression (TREE_OPERAND (expr, 0));
    3153                 :            :     }
    3154                 :      36408 :   else if (code == THROW_EXPR)
    3155                 :            :     {
    3156                 :          6 :       tree op = TREE_OPERAND (expr, 0);
    3157                 :          6 :       if (op)
    3158                 :            :         {
    3159                 :          3 :           write_string ("tw");
    3160                 :          3 :           write_expression (op);
    3161                 :            :         }
    3162                 :            :       else
    3163                 :          3 :         write_string ("tr");
    3164                 :            :     }
    3165                 :      36402 :   else if (code == CONSTRUCTOR)
    3166                 :            :     {
    3167                 :       2094 :       bool braced_init = BRACE_ENCLOSED_INITIALIZER_P (expr);
    3168                 :       1047 :       tree etype = TREE_TYPE (expr);
    3169                 :            : 
    3170                 :       1047 :       if (braced_init)
    3171                 :         21 :         write_string ("il");
    3172                 :            :       else
    3173                 :            :         {
    3174                 :       1026 :           write_string ("tl");
    3175                 :       1026 :           write_type (etype);
    3176                 :            :         }
    3177                 :            : 
    3178                 :       1047 :       if (!initializer_zerop (expr) || !trivial_type_p (etype))
    3179                 :            :         {
    3180                 :            :           /* Convert braced initializer lists to STRING_CSTs so that
    3181                 :            :              A<"Foo"> mangles the same as A<{'F', 'o', 'o', 0}> while
    3182                 :            :              still using the latter mangling for strings that
    3183                 :            :              originated as braced initializer lists.  */
    3184                 :        766 :           expr = braced_lists_to_strings (etype, expr);
    3185                 :            : 
    3186                 :        766 :           if (TREE_CODE (expr) == CONSTRUCTOR)
    3187                 :            :             {
    3188                 :        766 :               vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (expr);
    3189                 :        766 :               unsigned last_nonzero = -1, i;
    3190                 :        766 :               tree val;
    3191                 :            : 
    3192                 :       4076 :               FOR_EACH_CONSTRUCTOR_VALUE (elts, i, val)
    3193                 :       1290 :                 if (!initializer_zerop (val))
    3194                 :        894 :                   last_nonzero = i;
    3195                 :            : 
    3196                 :       3866 :               FOR_EACH_CONSTRUCTOR_VALUE (elts, i, val)
    3197                 :            :                 {
    3198                 :       1258 :                   if (i > last_nonzero)
    3199                 :            :                     break;
    3200                 :       1185 :                   write_expression (val);
    3201                 :            :                 }
    3202                 :            :             }
    3203                 :            :           else
    3204                 :            :             {
    3205                 :          0 :               gcc_assert (TREE_CODE (expr) == STRING_CST);
    3206                 :          0 :               write_expression (expr);
    3207                 :            :             }
    3208                 :            :         }
    3209                 :       1047 :       write_char ('E');
    3210                 :            :     }
    3211                 :      35355 :   else if (code == LAMBDA_EXPR)
    3212                 :            :     {
    3213                 :            :       /* [temp.over.link] Two lambda-expressions are never considered
    3214                 :            :          equivalent.
    3215                 :            : 
    3216                 :            :          So just use the closure type mangling.  */
    3217                 :          3 :       write_string ("tl");
    3218                 :          3 :       write_type (LAMBDA_EXPR_CLOSURE (expr));
    3219                 :          3 :       write_char ('E');
    3220                 :            :     }
    3221                 :      35352 :   else if (dependent_name (expr))
    3222                 :            :     {
    3223                 :        702 :       write_unqualified_id (dependent_name (expr));
    3224                 :            :     }
    3225                 :            :   else
    3226                 :            :     {
    3227                 :      34650 :     normal_expr:
    3228                 :      34757 :       int i, len;
    3229                 :      34757 :       const char *name;
    3230                 :            : 
    3231                 :            :       /* When we bind a variable or function to a non-type template
    3232                 :            :          argument with reference type, we create an ADDR_EXPR to show
    3233                 :            :          the fact that the entity's address has been taken.  But, we
    3234                 :            :          don't actually want to output a mangling code for the `&'.  */
    3235                 :      34757 :       if (TREE_CODE (expr) == ADDR_EXPR
    3236                 :        886 :           && TREE_TYPE (expr)
    3237                 :      35286 :           && TYPE_REF_P (TREE_TYPE (expr)))
    3238                 :            :         {
    3239                 :          0 :           expr = TREE_OPERAND (expr, 0);
    3240                 :          0 :           if (DECL_P (expr))
    3241                 :            :             {
    3242                 :            :               write_expression (expr);
    3243                 :            :               return;
    3244                 :            :             }
    3245                 :            : 
    3246                 :          0 :           code = TREE_CODE (expr);
    3247                 :            :         }
    3248                 :            : 
    3249                 :      34757 :       if (code == COMPONENT_REF)
    3250                 :            :         {
    3251                 :       3270 :           tree ob = TREE_OPERAND (expr, 0);
    3252                 :            : 
    3253                 :       3270 :           if (TREE_CODE (ob) == ARROW_EXPR)
    3254                 :            :             {
    3255                 :          9 :               write_string (OVL_OP_INFO (false, code)->mangled_name);
    3256                 :          9 :               ob = TREE_OPERAND (ob, 0);
    3257                 :          9 :               write_expression (ob);
    3258                 :            :             }
    3259                 :       3261 :           else if (!is_dummy_object (ob))
    3260                 :            :             {
    3261                 :       3258 :               write_string ("dt");
    3262                 :       3258 :               write_expression (ob);
    3263                 :            :             }
    3264                 :            :           /* else, for a non-static data member with no associated object (in
    3265                 :            :              unevaluated context), use the unresolved-name mangling.  */
    3266                 :            : 
    3267                 :       3270 :           write_member_name (TREE_OPERAND (expr, 1));
    3268                 :       3270 :           return;
    3269                 :            :         }
    3270                 :            : 
    3271                 :            :       /* If it wasn't any of those, recursively expand the expression.  */
    3272                 :      31487 :       name = OVL_OP_INFO (false, code)->mangled_name;
    3273                 :            : 
    3274                 :            :       /* We used to mangle const_cast and static_cast like a C cast.  */
    3275                 :      31487 :       if (code == CONST_CAST_EXPR
    3276                 :      31487 :           || code == STATIC_CAST_EXPR)
    3277                 :            :         {
    3278                 :        247 :           if (abi_warn_or_compat_version_crosses (6))
    3279                 :         16 :             G.need_abi_warning = 1;
    3280                 :        183 :           if (!abi_version_at_least (6))
    3281                 :         16 :             name = OVL_OP_INFO (false, CAST_EXPR)->mangled_name;
    3282                 :            :         }
    3283                 :            : 
    3284                 :      31487 :       if (name == NULL)
    3285                 :            :         {
    3286                 :          4 :           switch (code)
    3287                 :            :             {
    3288                 :          4 :             case TRAIT_EXPR:
    3289                 :          4 :               error ("use of built-in trait %qE in function signature; "
    3290                 :            :                      "use library traits instead", expr);
    3291                 :          4 :               break;
    3292                 :            : 
    3293                 :          0 :             default:
    3294                 :          0 :               sorry ("mangling %C", code);
    3295                 :          0 :               break;
    3296                 :            :             }
    3297                 :          4 :           return;
    3298                 :            :         }
    3299                 :            :       else
    3300                 :      31483 :         write_string (name);    
    3301                 :            : 
    3302                 :      31483 :       switch (code)
    3303                 :            :         {
    3304                 :       8367 :         case CALL_EXPR:
    3305                 :       8367 :           {
    3306                 :       8367 :             tree fn = CALL_EXPR_FN (expr);
    3307                 :            : 
    3308                 :       8367 :             if (TREE_CODE (fn) == ADDR_EXPR)
    3309                 :          0 :               fn = TREE_OPERAND (fn, 0);
    3310                 :            : 
    3311                 :            :             /* Mangle a dependent name as the name, not whatever happens to
    3312                 :            :                be the first function in the overload set.  */
    3313                 :       8251 :             if (OVL_P (fn)
    3314                 :       9577 :                 && type_dependent_expression_p_push (expr))
    3315                 :       1252 :               fn = OVL_NAME (fn);
    3316                 :            : 
    3317                 :       8367 :             write_expression (fn);
    3318                 :            :           }
    3319                 :            : 
    3320                 :      14773 :           for (i = 0; i < call_expr_nargs (expr); ++i)
    3321                 :       6406 :             write_expression (CALL_EXPR_ARG (expr, i));
    3322                 :       8367 :           write_char ('E');
    3323                 :       8367 :           break;
    3324                 :            : 
    3325                 :        259 :         case CAST_EXPR:
    3326                 :        259 :           write_type (TREE_TYPE (expr));
    3327                 :        259 :           if (list_length (TREE_OPERAND (expr, 0)) == 1)          
    3328                 :        185 :             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
    3329                 :            :           else
    3330                 :            :             {
    3331                 :         74 :               tree args = TREE_OPERAND (expr, 0);
    3332                 :         74 :               write_char ('_');
    3333                 :         74 :               for (; args; args = TREE_CHAIN (args))
    3334                 :          0 :                 write_expression (TREE_VALUE (args));
    3335                 :         74 :               write_char ('E');
    3336                 :            :             }
    3337                 :            :           break;
    3338                 :            : 
    3339                 :        191 :         case DYNAMIC_CAST_EXPR:
    3340                 :        191 :         case REINTERPRET_CAST_EXPR:
    3341                 :        191 :         case STATIC_CAST_EXPR:
    3342                 :        191 :         case CONST_CAST_EXPR:
    3343                 :        191 :           write_type (TREE_TYPE (expr));
    3344                 :        191 :           write_expression (TREE_OPERAND (expr, 0));
    3345                 :        191 :           break;
    3346                 :            : 
    3347                 :         18 :         case PREINCREMENT_EXPR:
    3348                 :         18 :         case PREDECREMENT_EXPR:
    3349                 :         18 :           if (abi_version_at_least (6))
    3350                 :          9 :             write_char ('_');
    3351                 :         51 :           if (abi_warn_or_compat_version_crosses (6))
    3352                 :          9 :             G.need_abi_warning = 1;
    3353                 :            :           /* Fall through.  */
    3354                 :            : 
    3355                 :      22666 :         default:
    3356                 :            :           /* In the middle-end, some expressions have more operands than
    3357                 :            :              they do in templates (and mangling).  */
    3358                 :      22666 :           len = cp_tree_operand_length (expr);
    3359                 :            : 
    3360                 :      49471 :           for (i = 0; i < len; ++i)
    3361                 :            :             {
    3362                 :      26805 :               tree operand = TREE_OPERAND (expr, i);
    3363                 :            :               /* As a GNU extension, the middle operand of a
    3364                 :            :                  conditional may be omitted.  Since expression
    3365                 :            :                  manglings are supposed to represent the input token
    3366                 :            :                  stream, there's no good way to mangle such an
    3367                 :            :                  expression without extending the C++ ABI.  */
    3368                 :      26805 :               if (code == COND_EXPR && i == 1 && !operand)
    3369                 :            :                 {
    3370                 :          4 :                   error ("omitted middle operand to %<?:%> operand "
    3371                 :            :                          "cannot be mangled");
    3372                 :          4 :                   continue;
    3373                 :            :                 }
    3374                 :      26801 :               else if (FOLD_EXPR_P (expr))
    3375                 :            :                 {
    3376                 :            :                   /* The first 'operand' of a fold-expression is the operator
    3377                 :            :                      that it folds over.  */
    3378                 :         36 :                   if (i == 0)
    3379                 :            :                     {
    3380                 :         16 :                       int fcode = TREE_INT_CST_LOW (operand);
    3381                 :         16 :                       write_string (OVL_OP_INFO (false, fcode)->mangled_name);
    3382                 :         16 :                       continue;
    3383                 :            :                     }
    3384                 :         20 :                   else if (code == BINARY_LEFT_FOLD_EXPR)
    3385                 :            :                     {
    3386                 :            :                       /* The order of operands of the binary left and right
    3387                 :            :                          folds is the same, but we want to mangle them in
    3388                 :            :                          lexical order, i.e. non-pack first.  */
    3389                 :          4 :                       if (i == 1)
    3390                 :          2 :                         operand = FOLD_EXPR_INIT (expr);
    3391                 :            :                       else
    3392                 :          2 :                         operand = FOLD_EXPR_PACK (expr);
    3393                 :            :                     }
    3394                 :         20 :                   if (PACK_EXPANSION_P (operand))
    3395                 :         16 :                     operand = PACK_EXPANSION_PATTERN (operand);
    3396                 :            :                 }
    3397                 :      26785 :               write_expression (operand);
    3398                 :            :             }
    3399                 :            :         }
    3400                 :            :     }
    3401                 :            : }
    3402                 :            : 
    3403                 :            : /* Literal subcase of non-terminal <template-arg>.
    3404                 :            : 
    3405                 :            :      "Literal arguments, e.g. "A<42L>", are encoded with their type
    3406                 :            :      and value. Negative integer values are preceded with "n"; for
    3407                 :            :      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
    3408                 :            :      encoded as 0, true as 1."  */
    3409                 :            : 
    3410                 :            : static void
    3411                 :   14786300 : write_template_arg_literal (const tree value)
    3412                 :            : {
    3413                 :   14786300 :   if (TREE_CODE (value) == STRING_CST)
    3414                 :            :     /* Temporarily mangle strings as braced initializer lists.  */
    3415                 :        559 :     write_string ("tl");
    3416                 :            :   else
    3417                 :   14785800 :     write_char ('L');
    3418                 :            : 
    3419                 :   14786300 :   tree valtype = TREE_TYPE (value);
    3420                 :   14786300 :   write_type (valtype);
    3421                 :            : 
    3422                 :            :   /* Write a null member pointer value as (type)0, regardless of its
    3423                 :            :      real representation.  */
    3424                 :   14786300 :   if (null_member_pointer_value_p (value))
    3425                 :        121 :     write_integer_cst (integer_zero_node);
    3426                 :            :   else
    3427                 :   14786200 :     switch (TREE_CODE (value))
    3428                 :            :       {
    3429                 :        811 :       case CONST_DECL:
    3430                 :        811 :         write_integer_cst (DECL_INITIAL (value));
    3431                 :        811 :         break;
    3432                 :            : 
    3433                 :   14784800 :       case INTEGER_CST:
    3434                 :   14784800 :         gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
    3435                 :            :                     || integer_zerop (value) || integer_onep (value));
    3436                 :   14784800 :         if (!(abi_version_at_least (14)
    3437                 :   14737300 :               && NULLPTR_TYPE_P (TREE_TYPE (value))))
    3438                 :   14784800 :           write_integer_cst (value);
    3439                 :            :         break;
    3440                 :            : 
    3441                 :          0 :       case REAL_CST:
    3442                 :          0 :         write_real_cst (value);
    3443                 :          0 :         break;
    3444                 :            : 
    3445                 :          8 :       case COMPLEX_CST:
    3446                 :          8 :         if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST
    3447                 :          8 :             && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST)
    3448                 :            :           {
    3449                 :          4 :             write_integer_cst (TREE_REALPART (value));
    3450                 :          4 :             write_char ('_');
    3451                 :          4 :             write_integer_cst (TREE_IMAGPART (value));
    3452                 :            :           }
    3453                 :          4 :         else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST
    3454                 :          4 :                  && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST)
    3455                 :            :           {
    3456                 :          4 :             write_real_cst (TREE_REALPART (value));
    3457                 :          4 :             write_char ('_');
    3458                 :          4 :             write_real_cst (TREE_IMAGPART (value));
    3459                 :            :           }
    3460                 :            :         else
    3461                 :          0 :           gcc_unreachable ();
    3462                 :            :         break;
    3463                 :            : 
    3464                 :        559 :       case STRING_CST:
    3465                 :        559 :         {
    3466                 :            :           /* Mangle strings the same as braced initializer lists.  */
    3467                 :        559 :           unsigned n = TREE_STRING_LENGTH (value);
    3468                 :        559 :           const char *str = TREE_STRING_POINTER (value);
    3469                 :            : 
    3470                 :            :           /* Count the number of trailing nuls and subtract them from
    3471                 :            :              STRSIZE because they don't need to be mangled.  */
    3472                 :        974 :           for (const char *p = str + n - 1; ; --p)
    3473                 :            :             {
    3474                 :        974 :               if (*p || p == str)
    3475                 :            :                 {
    3476                 :        559 :                   n -= str + n - !!*p - p;
    3477                 :        559 :                   break;
    3478                 :            :                 }
    3479                 :            :             }
    3480                 :        559 :           tree eltype = TREE_TYPE (valtype);
    3481                 :       1586 :           for (const char *p = str; n--; ++p)
    3482                 :            :             {
    3483                 :       1027 :               write_char ('L');
    3484                 :       1027 :               write_type (eltype);
    3485                 :       1027 :               write_unsigned_number (*(const unsigned char*)p);
    3486                 :       1027 :               write_string ("E");
    3487                 :            :             }
    3488                 :            :           break;
    3489                 :            :         }
    3490                 :            : 
    3491                 :          0 :       default:
    3492                 :          0 :         gcc_unreachable ();
    3493                 :            :       }
    3494                 :            : 
    3495                 :   14786300 :   write_char ('E');
    3496                 :   14786300 : }
    3497                 :            : 
    3498                 :            : /* Non-terminal <template-arg>.
    3499                 :            : 
    3500                 :            :      <template-arg> ::= <type>                              # type
    3501                 :            :                     ::= L <type> </value/ number> E # literal
    3502                 :            :                     ::= LZ <name> E                       # external name
    3503                 :            :                     ::= X <expression> E          # expression  */
    3504                 :            : 
    3505                 :            : static void
    3506                 :  142270000 : write_template_arg (tree node)
    3507                 :            : {
    3508                 :  142270000 :   enum tree_code code = TREE_CODE (node);
    3509                 :            : 
    3510                 :  142270000 :   MANGLE_TRACE_TREE ("template-arg", node);
    3511                 :            : 
    3512                 :            :   /* A template template parameter's argument list contains TREE_LIST
    3513                 :            :      nodes of which the value field is the actual argument.  */
    3514                 :  142270000 :   if (code == TREE_LIST)
    3515                 :            :     {
    3516                 :          0 :       node = TREE_VALUE (node);
    3517                 :            :       /* If it's a decl, deal with its type instead.  */
    3518                 :          0 :       if (DECL_P (node))
    3519                 :            :         {
    3520                 :          0 :           node = TREE_TYPE (node);
    3521                 :          0 :           code = TREE_CODE (node);
    3522                 :            :         }
    3523                 :            :     }
    3524                 :            : 
    3525                 :  142270000 :   if (template_parm_object_p (node))
    3526                 :            :     /* We want to mangle the argument, not the var we stored it in.  */
    3527                 :        144 :     node = DECL_INITIAL (node);
    3528                 :            : 
    3529                 :            :   /* Strip a conversion added by convert_nontype_argument.  */
    3530                 :  142270000 :   if (TREE_CODE (node) == IMPLICIT_CONV_EXPR)
    3531                 :         33 :     node = TREE_OPERAND (node, 0);
    3532                 :  142270000 :   if (REFERENCE_REF_P (node))
    3533                 :        234 :     node = TREE_OPERAND (node, 0);
    3534                 :  142270000 :   if (TREE_CODE (node) == NOP_EXPR
    3535                 :  142270000 :       && TYPE_REF_P (TREE_TYPE (node)))
    3536                 :            :     {
    3537                 :            :       /* Template parameters can be of reference type. To maintain
    3538                 :            :          internal consistency, such arguments use a conversion from
    3539                 :            :          address of object to reference type.  */
    3540                 :        234 :       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
    3541                 :        234 :       node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
    3542                 :            :     }
    3543                 :            : 
    3544                 :  142270000 :   if (TREE_CODE (node) == BASELINK
    3545                 :  142270000 :       && !type_unknown_p (node))
    3546                 :            :     {
    3547                 :         45 :       if (abi_version_at_least (6))
    3548                 :         41 :         node = BASELINK_FUNCTIONS (node);
    3549                 :         65 :       if (abi_warn_or_compat_version_crosses (6))
    3550                 :            :         /* We wrongly wrapped a class-scope function in X/E.  */
    3551                 :          4 :         G.need_abi_warning = 1;
    3552                 :            :     }
    3553                 :            : 
    3554                 :  142270000 :   if (ARGUMENT_PACK_P (node))
    3555                 :            :     {
    3556                 :            :       /* Expand the template argument pack. */
    3557                 :    6480800 :       tree args = ARGUMENT_PACK_ARGS (node);
    3558                 :    3245230 :       int i, length = TREE_VEC_LENGTH (args);
    3559                 :    3245230 :       if (abi_version_at_least (6))
    3560                 :    3225370 :         write_char ('J');
    3561                 :            :       else
    3562                 :      19857 :         write_char ('I');
    3563                 :    3349620 :       if (abi_warn_or_compat_version_crosses (6))
    3564                 :      25049 :         G.need_abi_warning = 1;
    3565                 :    7329350 :       for (i = 0; i < length; ++i)
    3566                 :    4084120 :         write_template_arg (TREE_VEC_ELT (args, i));
    3567                 :    3245230 :       write_char ('E');
    3568                 :            :     }
    3569                 :  139024000 :   else if (TYPE_P (node))
    3570                 :  123787000 :     write_type (node);
    3571                 :   15237300 :   else if (code == TEMPLATE_DECL)
    3572                 :            :     /* A template appearing as a template arg is a template template arg.  */
    3573                 :     211792 :     write_template_template_arg (node);
    3574                 :   14782500 :   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
    3575                 :     243266 :            || code == CONST_DECL
    3576                 :   15268800 :            || null_member_pointer_value_p (node))
    3577                 :   14782300 :     write_template_arg_literal (node);
    3578                 :     243221 :   else if (DECL_P (node))
    3579                 :            :     {
    3580                 :        248 :       write_char ('L');
    3581                 :            :       /* Until ABI version 3, the underscore before the mangled name
    3582                 :            :          was incorrectly omitted.  */
    3583                 :        248 :       if (!abi_version_at_least (3))
    3584                 :         25 :         write_char ('Z');
    3585                 :            :       else
    3586                 :        223 :         write_string ("_Z");
    3587                 :        325 :       if (abi_warn_or_compat_version_crosses (3))
    3588                 :         25 :         G.need_abi_warning = 1;
    3589                 :        248 :       write_encoding (node);
    3590                 :        248 :       write_char ('E');
    3591                 :            :     }
    3592                 :            :   else
    3593                 :            :     {
    3594                 :            :       /* Template arguments may be expressions.  */
    3595                 :     242973 :       write_char ('X');
    3596                 :     242973 :       write_expression (node);
    3597                 :     242973 :       write_char ('E');
    3598                 :            :     }
    3599                 :  142270000 : }
    3600                 :            : 
    3601                 :            : /*  <template-template-arg>
    3602                 :            :                         ::= <name>
    3603                 :            :                         ::= <substitution>  */
    3604                 :            : 
    3605                 :            : static void
    3606                 :     211792 : write_template_template_arg (const tree decl)
    3607                 :            : {
    3608                 :     211792 :   MANGLE_TRACE_TREE ("template-template-arg", decl);
    3609                 :            : 
    3610                 :     211792 :   if (find_substitution (decl))
    3611                 :            :     return;
    3612                 :     207108 :   write_name (decl, /*ignore_local_scope=*/0);
    3613                 :     207108 :   add_substitution (decl);
    3614                 :            : }
    3615                 :            : 
    3616                 :            : 
    3617                 :            : /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
    3618                 :            : 
    3619                 :            :      <array-type> ::= A [</dimension/ number>] _ </element/ type>
    3620                 :            :                   ::= A <expression> _ </element/ type>
    3621                 :            : 
    3622                 :            :      "Array types encode the dimension (number of elements) and the
    3623                 :            :      element type.  For variable length arrays, the dimension (but not
    3624                 :            :      the '_' separator) is omitted."
    3625                 :            :      Note that for flexible array members, like for other arrays of
    3626                 :            :      unspecified size, the dimension is also omitted.  */
    3627                 :            : 
    3628                 :            : static void
    3629                 :     381280 : write_array_type (const tree type)
    3630                 :            : {
    3631                 :     381280 :   write_char ('A');
    3632                 :     381280 :   if (TYPE_DOMAIN (type))
    3633                 :            :     {
    3634                 :      20350 :       tree index_type;
    3635                 :            : 
    3636                 :      20350 :       index_type = TYPE_DOMAIN (type);
    3637                 :            :       /* The INDEX_TYPE gives the upper and lower bounds of the array.
    3638                 :            :          It's null for flexible array members which have no upper bound
    3639                 :            :          (this is a change from GCC 5 and prior where such members were
    3640                 :            :          incorrectly mangled as zero-length arrays).  */
    3641                 :      20350 :       if (tree max = TYPE_MAX_VALUE (index_type))
    3642                 :            :         {
    3643                 :      20350 :           if (TREE_CODE (max) == INTEGER_CST)
    3644                 :            :             {
    3645                 :            :               /* The ABI specifies that we should mangle the number of
    3646                 :            :                  elements in the array, not the largest allowed index.  */
    3647                 :      18444 :               offset_int wmax = wi::to_offset (max) + 1;
    3648                 :            :               /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
    3649                 :            :                  number of elements as zero.  */
    3650                 :      18444 :               wmax = wi::zext (wmax, TYPE_PRECISION (TREE_TYPE (max)));
    3651                 :      18444 :               gcc_assert (wi::fits_uhwi_p (wmax));
    3652                 :      18444 :               write_unsigned_number (wmax.to_uhwi ());
    3653                 :            :             }
    3654                 :            :           else
    3655                 :            :             {
    3656                 :       1906 :               max = TREE_OPERAND (max, 0);
    3657                 :       1906 :               write_expression (max);
    3658                 :            :             }
    3659                 :            :         }
    3660                 :            :     }
    3661                 :     381280 :   write_char ('_');
    3662                 :     381280 :   write_type (TREE_TYPE (type));
    3663                 :     381280 : }
    3664                 :            : 
    3665                 :            : /* Non-terminal <pointer-to-member-type> for pointer-to-member
    3666                 :            :    variables.  TYPE is a pointer-to-member POINTER_TYPE.
    3667                 :            : 
    3668                 :            :      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
    3669                 :            : 
    3670                 :            : static void
    3671                 :     139231 : write_pointer_to_member_type (const tree type)
    3672                 :            : {
    3673                 :     139231 :   write_char ('M');
    3674                 :     271135 :   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
    3675                 :     146558 :   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
    3676                 :     139231 : }
    3677                 :            : 
    3678                 :            : /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
    3679                 :            :    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
    3680                 :            :    TEMPLATE_PARM_INDEX.
    3681                 :            : 
    3682                 :            :      <template-param> ::= T </parameter/ number> _  */
    3683                 :            : 
    3684                 :            : static void
    3685                 :    8352620 : write_template_param (const tree parm)
    3686                 :            : {
    3687                 :    8352620 :   int parm_index;
    3688                 :            : 
    3689                 :    8352620 :   MANGLE_TRACE_TREE ("template-parm", parm);
    3690                 :            : 
    3691                 :    8352620 :   switch (TREE_CODE (parm))
    3692                 :            :     {
    3693                 :    8218240 :     case TEMPLATE_TYPE_PARM:
    3694                 :    8218240 :     case TEMPLATE_TEMPLATE_PARM:
    3695                 :    8218240 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
    3696                 :    8219270 :       parm_index = TEMPLATE_TYPE_IDX (parm);
    3697                 :    8218240 :       break;
    3698                 :            : 
    3699                 :     134382 :     case TEMPLATE_PARM_INDEX:
    3700                 :     134382 :       parm_index = TEMPLATE_PARM_IDX (parm);
    3701                 :     134382 :       break;
    3702                 :            : 
    3703                 :          0 :     default:
    3704                 :          0 :       gcc_unreachable ();
    3705                 :            :     }
    3706                 :            : 
    3707                 :    8352620 :   write_char ('T');
    3708                 :            :   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
    3709                 :            :      earliest template param denoted by `_'.  */
    3710                 :    8352620 :   write_compact_number (parm_index);
    3711                 :    8352620 : }
    3712                 :            : 
    3713                 :            : /*  <template-template-param>
    3714                 :            :                         ::= <template-param>
    3715                 :            :                         ::= <substitution>  */
    3716                 :            : 
    3717                 :            : static void
    3718                 :        141 : write_template_template_param (const tree parm)
    3719                 :            : {
    3720                 :        141 :   tree templ = NULL_TREE;
    3721                 :            : 
    3722                 :            :   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
    3723                 :            :      template template parameter.  The substitution candidate here is
    3724                 :            :      only the template.  */
    3725                 :        141 :   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
    3726                 :            :     {
    3727                 :         92 :       templ
    3728                 :         92 :         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
    3729                 :         92 :       if (find_substitution (templ))
    3730                 :            :         return;
    3731                 :            :     }
    3732                 :            : 
    3733                 :            :   /* <template-param> encodes only the template parameter position,
    3734                 :            :      not its template arguments, which is fine here.  */
    3735                 :        141 :   write_template_param (parm);
    3736                 :        141 :   if (templ)
    3737                 :         92 :     add_substitution (templ);
    3738                 :            : }
    3739                 :            : 
    3740                 :            : /* Non-terminal <substitution>.
    3741                 :            : 
    3742                 :            :       <substitution> ::= S <seq-id> _
    3743                 :            :                      ::= S_  */
    3744                 :            : 
    3745                 :            : static void
    3746                 :   30889200 : write_substitution (const int seq_id)
    3747                 :            : {
    3748                 :   30889200 :   MANGLE_TRACE ("substitution", "");
    3749                 :            : 
    3750                 :   30889200 :   write_char ('S');
    3751                 :   30889200 :   if (seq_id > 0)
    3752                 :   28868100 :     write_number (seq_id - 1, /*unsigned=*/1, 36);
    3753                 :   30889200 :   write_char ('_');
    3754                 :   30889200 : }
    3755                 :            : 
    3756                 :            : /* Start mangling ENTITY.  */
    3757                 :            : 
    3758                 :            : static inline void
    3759                 :   48666300 : start_mangling (const tree entity)
    3760                 :            : {
    3761                 :   48666300 :   G.entity = entity;
    3762                 :   48666300 :   G.need_abi_warning = false;
    3763                 :   48666300 :   G.need_cxx17_warning = false;
    3764                 :   48666300 :   obstack_free (&name_obstack, name_base);
    3765                 :   48666300 :   mangle_obstack = &name_obstack;
    3766                 :   48666300 :   name_base = obstack_alloc (&name_obstack, 0);
    3767                 :   48666300 : }
    3768                 :            : 
    3769                 :            : /* Done with mangling. If WARN is true, and the name of G.entity will
    3770                 :            :    be mangled differently in a future version of the ABI, issue a
    3771                 :            :    warning.  */
    3772                 :            : 
    3773                 :            : static void
    3774                 :   48666300 : finish_mangling_internal (void)
    3775                 :            : {
    3776                 :            :   /* Clear all the substitutions.  */
    3777                 :   48666300 :   vec_safe_truncate (G.substitutions, 0);
    3778                 :            : 
    3779                 :            :   /* Null-terminate the string.  */
    3780                 :   48666300 :   write_char ('\0');
    3781                 :   48666300 : }
    3782                 :            : 
    3783                 :            : 
    3784                 :            : /* Like finish_mangling_internal, but return the mangled string.  */
    3785                 :            : 
    3786                 :            : static inline const char *
    3787                 :     163239 : finish_mangling (void)
    3788                 :            : {
    3789                 :     163239 :   finish_mangling_internal ();
    3790                 :     163239 :   return (const char *) obstack_finish (mangle_obstack);
    3791                 :            : }
    3792                 :            : 
    3793                 :            : /* Like finish_mangling_internal, but return an identifier.  */
    3794                 :            : 
    3795                 :            : static tree
    3796                 :   48503100 : finish_mangling_get_identifier (void)
    3797                 :            : {
    3798                 :          0 :   finish_mangling_internal ();
    3799                 :            :   /* Don't obstack_finish here, and the next start_mangling will
    3800                 :            :      remove the identifier.  */
    3801                 :   48503100 :   return get_identifier ((const char *) obstack_base (mangle_obstack));
    3802                 :            : }
    3803                 :            : 
    3804                 :            : /* Initialize data structures for mangling.  */
    3805                 :            : 
    3806                 :            : void
    3807                 :      78233 : init_mangle (void)
    3808                 :            : {
    3809                 :      78233 :   gcc_obstack_init (&name_obstack);
    3810                 :      78233 :   name_base = obstack_alloc (&name_obstack, 0);
    3811                 :      78233 :   vec_alloc (G.substitutions, 0);
    3812                 :            : 
    3813                 :            :   /* Cache these identifiers for quick comparison when checking for
    3814                 :            :      standard substitutions.  */
    3815                 :      78233 :   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
    3816                 :      78233 :   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
    3817                 :      78233 :   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
    3818                 :      78233 :   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
    3819                 :      78233 :   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
    3820                 :      78233 :   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
    3821                 :      78233 : }
    3822                 :            : 
    3823                 :            : /* Generate the mangled name of DECL.  */
    3824                 :            : 
    3825                 :            : static tree
    3826                 :   47851200 : mangle_decl_string (const tree decl)
    3827                 :            : {
    3828                 :   47851200 :   tree result;
    3829                 :   47851200 :   tree saved_fn = NULL_TREE;
    3830                 :   47851200 :   bool template_p = false;
    3831                 :            : 
    3832                 :            :   /* We shouldn't be trying to mangle an uninstantiated template.  */
    3833                 :   47851200 :   gcc_assert (!type_dependent_expression_p (decl));
    3834                 :            : 
    3835                 :   47851200 :   if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
    3836                 :            :     {
    3837                 :   35507700 :       struct tinst_level *tl = current_instantiation ();
    3838                 :    3285500 :       if ((!tl || tl->maybe_get_node () != decl)
    3839                 :   38790500 :           && push_tinst_level (decl))
    3840                 :            :         {
    3841                 :   35504800 :           template_p = true;
    3842                 :   35504800 :           saved_fn = current_function_decl;
    3843                 :   35504800 :           current_function_decl = NULL_TREE;
    3844                 :            :         }
    3845                 :            :     }
    3846                 :   47851200 :   iloc_sentinel ils (DECL_SOURCE_LOCATION (decl));
    3847                 :            : 
    3848                 :   47851200 :   start_mangling (decl);
    3849                 :            : 
    3850                 :   47851200 :   if (TREE_CODE (decl) == TYPE_DECL)
    3851                 :     215701 :     write_type (TREE_TYPE (decl));
    3852                 :            :   else
    3853                 :   47635500 :     write_mangled_name (decl, true);
    3854                 :            : 
    3855                 :   47851200 :   result = finish_mangling_get_identifier ();
    3856                 :   47851200 :   if (DEBUG_MANGLE)
    3857                 :            :     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
    3858                 :            :              IDENTIFIER_POINTER (result));
    3859                 :            : 
    3860                 :   47851200 :   if (template_p)
    3861                 :            :     {
    3862                 :   35504800 :       pop_tinst_level ();
    3863                 :   35504800 :       current_function_decl = saved_fn;
    3864                 :            :     }
    3865                 :            : 
    3866                 :   47851200 :   return result;
    3867                 :            : }
    3868                 :            : 
    3869                 :            : /* Return an identifier for the external mangled name of DECL.  */
    3870                 :            : 
    3871                 :            : static tree
    3872                 :   47602500 : get_mangled_id (tree decl)
    3873                 :            : {
    3874                 :          0 :   tree id = mangle_decl_string (decl);
    3875                 :          0 :   return targetm.mangle_decl_assembler_name (decl, id);
    3876                 :            : }
    3877                 :            : 
    3878                 :            : /* Create an identifier for the external mangled name of DECL.  */
    3879                 :            : 
    3880                 :            : void
    3881                 :   47602800 : mangle_decl (const tree decl)
    3882                 :            : {
    3883                 :   47602800 :   tree id;
    3884                 :   47602800 :   bool dep;
    3885                 :            : 
    3886                 :            :   /* Don't bother mangling uninstantiated templates.  */
    3887                 :   47602800 :   ++processing_template_decl;
    3888                 :   47602800 :   if (TREE_CODE (decl) == TYPE_DECL)
    3889                 :     216059 :     dep = dependent_type_p (TREE_TYPE (decl));
    3890                 :            :   else
    3891                 :   93507400 :     dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
    3892                 :   82698000 :            && any_dependent_template_arguments_p (DECL_TI_ARGS (decl)));
    3893                 :   47602800 :   --processing_template_decl;
    3894                 :   47602800 :   if (dep)
    3895                 :            :     return;
    3896                 :            : 
    3897                 :            :   /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
    3898                 :            :      It is not needed to assign names to anonymous namespace, but we use the
    3899                 :            :      "<anon>" marker to be able to tell if type is C++ ODR type or type
    3900                 :            :      produced by other language.  */
    3901                 :   47602800 :   if (TREE_CODE (decl) == TYPE_DECL
    3902                 :     216059 :       && TYPE_STUB_DECL (TREE_TYPE (decl))
    3903                 :   47802800 :       && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl))))
    3904                 :        358 :     id = get_identifier ("<anon>");
    3905                 :            :   else
    3906                 :            :     {
    3907                 :   47818200 :       gcc_assert (TREE_CODE (decl) != TYPE_DECL
    3908                 :            :                   || !no_linkage_check (TREE_TYPE (decl), true));
    3909                 :   47602500 :       if (abi_version_at_least (10))
    3910                 :   47486000 :         if (tree fn = decl_function_context (decl))
    3911                 :    1156610 :           maybe_check_abi_tags (fn, decl);
    3912                 :   47602500 :       id = get_mangled_id (decl);
    3913                 :            :     }
    3914                 :   47602800 :   SET_DECL_ASSEMBLER_NAME (decl, id);
    3915                 :            : 
    3916                 :   47602800 :   if (G.need_cxx17_warning
    3917                 :   47602800 :       && (TREE_PUBLIC (decl) || DECL_REALLY_EXTERN (decl)))
    3918                 :          6 :     warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wnoexcept_type,
    3919                 :            :                 "mangled name for %qD will change in C++17 because the "
    3920                 :            :                 "exception specification is part of a function type",
    3921                 :            :                 decl);
    3922                 :            : 
    3923                 :   47602800 :   if (id != DECL_NAME (decl)
    3924                 :            :       /* Don't do this for a fake symbol we aren't going to emit anyway.  */
    3925                 :   45585700 :       && TREE_CODE (decl) != TYPE_DECL
    3926                 :   92972500 :       && !DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
    3927                 :            :     {
    3928                 :   38198400 :       int save_ver = flag_abi_version;
    3929                 :   38198400 :       tree id2 = NULL_TREE;
    3930                 :            : 
    3931                 :   38198400 :       if (!DECL_REALLY_EXTERN (decl))
    3932                 :            :         {
    3933                 :   11456700 :           record_mangling (decl, G.need_abi_warning);
    3934                 :            : 
    3935                 :   11456700 :           if (!G.need_abi_warning)
    3936                 :            :             return;
    3937                 :            : 
    3938                 :      19311 :           flag_abi_version = flag_abi_compat_version;
    3939                 :      19311 :           id2 = mangle_decl_string (decl);
    3940                 :      19311 :           id2 = targetm.mangle_decl_assembler_name (decl, id2);
    3941                 :      19311 :           flag_abi_version = save_ver;
    3942                 :            : 
    3943                 :      19311 :           if (id2 != id)
    3944                 :      18433 :             note_mangling_alias (decl, id2);
    3945                 :            :         }
    3946                 :            : 
    3947                 :   26761000 :       if (warn_abi)
    3948                 :            :         {
    3949                 :     248701 :           const char fabi_version[] = "-fabi-version";
    3950                 :            : 
    3951                 :     248701 :           if (flag_abi_compat_version != warn_abi_version
    3952                 :     247255 :               || id2 == NULL_TREE)
    3953                 :            :             {
    3954                 :     229429 :               flag_abi_version = warn_abi_version;
    3955                 :     229429 :               id2 = mangle_decl_string (decl);
    3956                 :     229429 :               id2 = targetm.mangle_decl_assembler_name (decl, id2);
    3957                 :            :             }
    3958                 :     248701 :           flag_abi_version = save_ver;
    3959                 :            : 
    3960                 :     248701 :           if (id2 == id)
    3961                 :            :             /* OK.  */;
    3962                 :      19567 :           else if (warn_abi_version != 0
    3963                 :      19567 :                    && abi_version_at_least (warn_abi_version))
    3964                 :      19529 :             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
    3965                 :            :                         "the mangled name of %qD changed between "
    3966                 :            :                         "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
    3967                 :            :                         G.entity, fabi_version, warn_abi_version, id2,
    3968                 :            :                         fabi_version, save_ver, id);
    3969                 :            :           else
    3970                 :         38 :             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
    3971                 :            :                         "the mangled name of %qD changes between "
    3972                 :            :                         "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
    3973                 :            :                         G.entity, fabi_version, save_ver, id,
    3974                 :            :                         fabi_version, warn_abi_version, id2);
    3975                 :            :         }
    3976                 :            : 
    3977                 :   26761000 :       flag_abi_version = save_ver;
    3978                 :            :     }
    3979                 :            : }
    3980                 :            : 
    3981                 :            : /* Generate the mangled representation of TYPE.  */
    3982                 :            : 
    3983                 :            : const char *
    3984                 :     163239 : mangle_type_string (const tree type)
    3985                 :            : {
    3986                 :     163239 :   const char *result;
    3987                 :            : 
    3988                 :     163239 :   start_mangling (type);
    3989                 :     163239 :   write_type (type);
    3990                 :     163239 :   result = finish_mangling ();
    3991                 :     163239 :   if (DEBUG_MANGLE)
    3992                 :            :     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
    3993                 :     163239 :   return result;
    3994                 :            : }
    3995                 :            : 
    3996                 :            : /* Create an identifier for the mangled name of a special component
    3997                 :            :    for belonging to TYPE.  CODE is the ABI-specified code for this
    3998                 :            :    component.  */
    3999                 :            : 
    4000                 :            : static tree
    4001                 :     584633 : mangle_special_for_type (const tree type, const char *code)
    4002                 :            : {
    4003                 :     584633 :   tree result;
    4004                 :            : 
    4005                 :            :   /* We don't have an actual decl here for the special component, so
    4006                 :            :      we can't just process the <encoded-name>.  Instead, fake it.  */
    4007                 :     584633 :   start_mangling (type);
    4008                 :            : 
    4009                 :            :   /* Start the mangling.  */
    4010                 :     584633 :   write_string ("_Z");
    4011                 :     584633 :   write_string (code);
    4012                 :            : 
    4013                 :            :   /* Add the type.  */
    4014                 :     584633 :   write_type (type);
    4015                 :     584633 :   result = finish_mangling_get_identifier ();
    4016                 :            : 
    4017                 :     584633 :   if (DEBUG_MANGLE)
    4018                 :            :     fprintf (stderr, "mangle_special_for_type = %s\n\n",
    4019                 :            :              IDENTIFIER_POINTER (result));
    4020                 :            : 
    4021                 :     584633 :   return result;
    4022                 :            : }
    4023                 :            : 
    4024                 :            : /* Create an identifier for the mangled representation of the typeinfo
    4025                 :            :    structure for TYPE.  */
    4026                 :            : 
    4027                 :            : tree
    4028                 :     213054 : mangle_typeinfo_for_type (const tree type)
    4029                 :            : {
    4030                 :     213054 :   return mangle_special_for_type (type, "TI");
    4031                 :            : }
    4032                 :            : 
    4033                 :            : /* Create an identifier for the mangled name of the NTBS containing
    4034                 :            :    the mangled name of TYPE.  */
    4035                 :            : 
    4036                 :            : tree
    4037                 :     159000 : mangle_typeinfo_string_for_type (const tree type)
    4038                 :            : {
    4039                 :     159000 :   return mangle_special_for_type (type, "TS");
    4040                 :            : }
    4041                 :            : 
    4042                 :            : /* Create an identifier for the mangled name of the vtable for TYPE.  */
    4043                 :            : 
    4044                 :            : tree
    4045                 :     197165 : mangle_vtbl_for_type (const tree type)
    4046                 :            : {
    4047                 :     197165 :   return mangle_special_for_type (type, "TV");
    4048                 :            : }
    4049                 :            : 
    4050                 :            : /* Returns an identifier for the mangled name of the VTT for TYPE.  */
    4051                 :            : 
    4052                 :            : tree
    4053                 :      15414 : mangle_vtt_for_type (const tree type)
    4054                 :            : {
    4055                 :      15414 :   return mangle_special_for_type (type, "TT");
    4056                 :            : }
    4057                 :            : 
    4058                 :            : /* Returns an identifier for the mangled name of the decomposition
    4059                 :            :    artificial variable DECL.  DECLS is the vector of the VAR_DECLs
    4060                 :            :    for the identifier-list.  */
    4061                 :            : 
    4062                 :            : tree
    4063                 :        122 : mangle_decomp (const tree decl, vec<tree> &decls)
    4064                 :            : {
    4065                 :        122 :   gcc_assert (!type_dependent_expression_p (decl));
    4066                 :            : 
    4067                 :        122 :   location_t saved_loc = input_location;
    4068                 :        122 :   input_location = DECL_SOURCE_LOCATION (decl);
    4069                 :            : 
    4070                 :        122 :   start_mangling (decl);
    4071                 :        122 :   write_string ("_Z");
    4072                 :            : 
    4073                 :        122 :   tree context = decl_mangling_context (decl);
    4074                 :        122 :   gcc_assert (context != NULL_TREE);
    4075                 :            : 
    4076                 :        122 :   bool nested = false;
    4077                 :        122 :   if (DECL_NAMESPACE_STD_P (context))
    4078                 :          6 :     write_string ("St");
    4079                 :        116 :   else if (context != global_namespace)
    4080                 :            :     {
    4081                 :         38 :       nested = true;
    4082                 :         38 :       write_char ('N');
    4083                 :         38 :       write_prefix (decl_mangling_context (decl));
    4084                 :            :     }
    4085                 :            : 
    4086                 :        122 :   write_string ("DC");
    4087                 :        122 :   unsigned int i;
    4088                 :        122 :   tree d;
    4089                 :        418 :   FOR_EACH_VEC_ELT (decls, i, d)
    4090                 :        296 :     write_unqualified_name (d);
    4091                 :        122 :   write_char ('E');
    4092                 :            : 
    4093                 :        122 :   if (nested)
    4094                 :         38 :     write_char ('E');
    4095                 :            : 
    4096                 :        122 :   tree id = finish_mangling_get_identifier ();
    4097                 :        122 :   if (DEBUG_MANGLE)
    4098                 :            :     fprintf (stderr, "mangle_decomp = '%s'\n\n",
    4099                 :            :              IDENTIFIER_POINTER (id));
    4100                 :            : 
    4101                 :        122 :   input_location = saved_loc;
    4102                 :        122 :   return id;
    4103                 :            : }
    4104                 :            : 
    4105                 :            : /* Return an identifier for a construction vtable group.  TYPE is
    4106                 :            :    the most derived class in the hierarchy; BINFO is the base
    4107                 :            :    subobject for which this construction vtable group will be used.
    4108                 :            : 
    4109                 :            :    This mangling isn't part of the ABI specification; in the ABI
    4110                 :            :    specification, the vtable group is dumped in the same COMDAT as the
    4111                 :            :    main vtable, and is referenced only from that vtable, so it doesn't
    4112                 :            :    need an external name.  For binary formats without COMDAT sections,
    4113                 :            :    though, we need external names for the vtable groups.
    4114                 :            : 
    4115                 :            :    We use the production
    4116                 :            : 
    4117                 :            :     <special-name> ::= CT <type> <offset number> _ <base type>  */
    4118                 :            : 
    4119                 :            : tree
    4120                 :      29283 : mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
    4121                 :            : {
    4122                 :      29283 :   tree result;
    4123                 :            : 
    4124                 :      29283 :   start_mangling (type);
    4125                 :            : 
    4126                 :      29283 :   write_string ("_Z");
    4127                 :      29283 :   write_string ("TC");
    4128                 :      29283 :   write_type (type);
    4129                 :      29283 :   write_integer_cst (BINFO_OFFSET (binfo));
    4130                 :      29283 :   write_char ('_');
    4131                 :      29283 :   write_type (BINFO_TYPE (binfo));
    4132                 :            : 
    4133                 :      29283 :   result = finish_mangling_get_identifier ();
    4134                 :      29283 :   if (DEBUG_MANGLE)
    4135                 :            :     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
    4136                 :            :              IDENTIFIER_POINTER (result));
    4137                 :      29283 :   return result;
    4138                 :            : }
    4139                 :            : 
    4140                 :            : /* Mangle a this pointer or result pointer adjustment.
    4141                 :            : 
    4142                 :            :    <call-offset> ::= h <fixed offset number> _
    4143                 :            :                  ::= v <fixed offset number> _ <virtual offset number> _ */
    4144                 :            : 
    4145                 :            : static void
    4146                 :      32563 : mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
    4147                 :            : {
    4148                 :      32563 :   write_char (virtual_offset ? 'v' : 'h');
    4149                 :            : 
    4150                 :            :   /* For either flavor, write the fixed offset.  */
    4151                 :      32563 :   write_integer_cst (fixed_offset);
    4152                 :      32563 :   write_char ('_');
    4153                 :            : 
    4154                 :            :   /* For a virtual thunk, add the virtual offset.  */
    4155                 :      32563 :   if (virtual_offset)
    4156                 :            :     {
    4157                 :      23640 :       write_integer_cst (virtual_offset);
    4158                 :      23640 :       write_char ('_');
    4159                 :            :     }
    4160                 :      32563 : }
    4161                 :            : 
    4162                 :            : /* Return an identifier for the mangled name of a this-adjusting or
    4163                 :            :    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
    4164                 :            :    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
    4165                 :            :    is a virtual thunk, and it is the vtbl offset in
    4166                 :            :    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
    4167                 :            :    zero for a covariant thunk. Note, that FN_DECL might be a covariant
    4168                 :            :    thunk itself. A covariant thunk name always includes the adjustment
    4169                 :            :    for the this pointer, even if there is none.
    4170                 :            : 
    4171                 :            :    <special-name> ::= T <call-offset> <base encoding>
    4172                 :            :                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
    4173                 :            :                                         <base encoding>  */
    4174                 :            : 
    4175                 :            : tree
    4176                 :      32074 : mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
    4177                 :            :               tree virtual_offset, tree thunk)
    4178                 :            : {
    4179                 :      32074 :   tree result;
    4180                 :            : 
    4181                 :      32074 :   if (abi_version_at_least (11))
    4182                 :      32070 :     maybe_check_abi_tags (fn_decl, thunk, 11);
    4183                 :            : 
    4184                 :      32074 :   start_mangling (fn_decl);
    4185                 :            : 
    4186                 :      32074 :   write_string ("_Z");
    4187                 :      32074 :   write_char ('T');
    4188                 :            : 
    4189                 :      32074 :   if (!this_adjusting)
    4190                 :            :     {
    4191                 :            :       /* Covariant thunk with no this adjustment */
    4192                 :        275 :       write_char ('c');
    4193                 :        275 :       mangle_call_offset (integer_zero_node, NULL_TREE);
    4194                 :        275 :       mangle_call_offset (fixed_offset, virtual_offset);
    4195                 :            :     }
    4196                 :      63598 :   else if (!DECL_THUNK_P (fn_decl))
    4197                 :            :     /* Plain this adjusting thunk.  */
    4198                 :      31585 :     mangle_call_offset (fixed_offset, virtual_offset);
    4199                 :            :   else
    4200                 :            :     {
    4201                 :            :       /* This adjusting thunk to covariant thunk.  */
    4202                 :        214 :       write_char ('c');
    4203                 :        214 :       mangle_call_offset (fixed_offset, virtual_offset);
    4204                 :        214 :       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
    4205                 :        214 :       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
    4206                 :        214 :       if (virtual_offset)
    4207                 :        163 :         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
    4208                 :        214 :       mangle_call_offset (fixed_offset, virtual_offset);
    4209                 :        428 :       fn_decl = THUNK_TARGET (fn_decl);
    4210                 :            :     }
    4211                 :            : 
    4212                 :            :   /* Scoped name.  */
    4213                 :      32074 :   write_encoding (fn_decl);
    4214                 :            : 
    4215                 :      32074 :   result = finish_mangling_get_identifier ();
    4216                 :      32074 :   if (DEBUG_MANGLE)
    4217                 :            :     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
    4218                 :      32074 :   return result;
    4219                 :            : }
    4220                 :            : 
    4221                 :            : /* Handle ABI backwards compatibility for past bugs where we didn't call
    4222                 :            :    check_abi_tags in places where it's needed: call check_abi_tags and warn if
    4223                 :            :    it makes a difference.  If FOR_DECL is non-null, it's the declaration
    4224                 :            :    that we're actually trying to mangle; if it's null, we're mangling the
    4225                 :            :    guard variable for T.  */
    4226                 :            : 
    4227                 :            : static void
    4228                 :    1192030 : maybe_check_abi_tags (tree t, tree for_decl, int ver)
    4229                 :            : {
    4230                 :    1192030 :   if (DECL_ASSEMBLER_NAME_SET_P (t))
    4231                 :            :     return;
    4232                 :            : 
    4233                 :     160522 :   tree oldtags = get_abi_tags (t);
    4234                 :            : 
    4235                 :     160522 :   mangle_decl (t);
    4236                 :            : 
    4237                 :     160522 :   tree newtags = get_abi_tags (t);
    4238                 :     160522 :   if (newtags && newtags != oldtags
    4239                 :         32 :       && abi_version_crosses (ver))
    4240                 :            :     {
    4241                 :         24 :       if (for_decl && DECL_THUNK_P (for_decl))
    4242                 :          4 :         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
    4243                 :            :                     "the mangled name of a thunk for %qD changes between "
    4244                 :            :                     "%<-fabi-version=%d%> and %<-fabi-version=%d%>",
    4245                 :            :                     t, flag_abi_version, warn_abi_version);
    4246                 :         12 :       else if (for_decl)
    4247                 :          8 :         warning_at (DECL_SOURCE_LOCATION (for_decl), OPT_Wabi,
    4248                 :            :                     "the mangled name of %qD changes between "
    4249                 :            :                     "%<-fabi-version=%d%> and %<-fabi-version=%d%>",
    4250                 :            :                     for_decl, flag_abi_version, warn_abi_version);
    4251                 :            :       else
    4252                 :          4 :         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
    4253                 :            :                     "the mangled name of the initialization guard variable "
    4254                 :            :                     "for %qD changes between %<-fabi-version=%d%> and "
    4255                 :            :                     "%<-fabi-version=%d%>",
    4256                 :            :                     t, flag_abi_version, warn_abi_version);
    4257                 :            :     }
    4258                 :            : }
    4259                 :            : 
    4260                 :            : /* Write out the appropriate string for this variable when generating
    4261                 :            :    another mangled name based on this one.  */
    4262                 :            : 
    4263                 :            : static void
    4264                 :       4781 : write_guarded_var_name (const tree variable)
    4265                 :            : {
    4266                 :       4781 :   if (DECL_NAME (variable)
    4267                 :       4781 :       && strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
    4268                 :            :     /* The name of a guard variable for a reference temporary should refer
    4269                 :            :        to the reference, not the temporary.  */
    4270                 :          0 :     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
    4271                 :            :   else
    4272                 :       4781 :     write_name (variable, /*ignore_local_scope=*/0);
    4273                 :       4781 : }
    4274                 :            : 
    4275                 :            : /* Return an identifier for the name of an initialization guard
    4276                 :            :    variable for indicated VARIABLE.  */
    4277                 :            : 
    4278                 :            : tree
    4279                 :       3352 : mangle_guard_variable (const tree variable)
    4280                 :            : {
    4281                 :       3352 :   if (abi_version_at_least (10))
    4282                 :       3344 :     maybe_check_abi_tags (variable);
    4283                 :       3352 :   start_mangling (variable);
    4284                 :       3352 :   write_string ("_ZGV");
    4285                 :       3352 :   write_guarded_var_name (variable);
    4286                 :       3352 :   return finish_mangling_get_identifier ();
    4287                 :            : }
    4288                 :            : 
    4289                 :            : /* Return an identifier for the name of a thread_local initialization
    4290                 :            :    function for VARIABLE.  */
    4291                 :            : 
    4292                 :            : tree
    4293                 :        982 : mangle_tls_init_fn (const tree variable)
    4294                 :            : {
    4295                 :        982 :   check_abi_tags (variable);
    4296                 :        982 :   start_mangling (variable);
    4297                 :        982 :   write_string ("_ZTH");
    4298                 :        982 :   write_guarded_var_name (variable);
    4299                 :        982 :   return finish_mangling_get_identifier ();
    4300                 :            : }
    4301                 :            : 
    4302                 :            : /* Return an identifier for the name of a thread_local wrapper
    4303                 :            :    function for VARIABLE.  */
    4304                 :            : 
    4305                 :            : #define TLS_WRAPPER_PREFIX "_ZTW"
    4306                 :            : 
    4307                 :            : tree
    4308                 :        447 : mangle_tls_wrapper_fn (const tree variable)
    4309                 :            : {
    4310                 :        447 :   check_abi_tags (variable);
    4311                 :        447 :   start_mangling (variable);
    4312                 :        447 :   write_string (TLS_WRAPPER_PREFIX);
    4313                 :        447 :   write_guarded_var_name (variable);
    4314                 :        447 :   return finish_mangling_get_identifier ();
    4315                 :            : }
    4316                 :            : 
    4317                 :            : /* Return true iff FN is a thread_local wrapper function.  */
    4318                 :            : 
    4319                 :            : bool
    4320                 :      69378 : decl_tls_wrapper_p (const tree fn)
    4321                 :            : {
    4322                 :      69378 :   if (TREE_CODE (fn) != FUNCTION_DECL)
    4323                 :            :     return false;
    4324                 :      69378 :   tree name = DECL_NAME (fn);
    4325                 :      69378 :   return strncmp (IDENTIFIER_POINTER (name), TLS_WRAPPER_PREFIX,
    4326                 :      69378 :                   strlen (TLS_WRAPPER_PREFIX)) == 0;
    4327                 :            : }
    4328                 :            : 
    4329                 :            : /* Return an identifier for the name of a temporary variable used to
    4330                 :            :    initialize a static reference.  This is now part of the ABI.  */
    4331                 :            : 
    4332                 :            : tree
    4333                 :        369 : mangle_ref_init_variable (const tree variable)
    4334                 :            : {
    4335                 :        369 :   start_mangling (variable);
    4336                 :        369 :   write_string ("_ZGR");
    4337                 :        369 :   check_abi_tags (variable);
    4338                 :        369 :   write_name (variable, /*ignore_local_scope=*/0);
    4339                 :            :   /* Avoid name clashes with aggregate initialization of multiple
    4340                 :            :      references at once.  */
    4341                 :        369 :   write_compact_number (current_ref_temp_count++);
    4342                 :        369 :   return finish_mangling_get_identifier ();
    4343                 :            : }
    4344                 :            : 
    4345                 :            : /* Return an identifier for the mangled name of a C++20 template parameter
    4346                 :            :    object for template argument EXPR.  */
    4347                 :            : 
    4348                 :            : tree
    4349                 :        625 : mangle_template_parm_object (tree expr)
    4350                 :            : {
    4351                 :        625 :   start_mangling (expr);
    4352                 :        625 :   write_string ("_ZTAX");
    4353                 :        625 :   write_expression (expr);
    4354                 :        625 :   write_char ('E');
    4355                 :        625 :   return finish_mangling_get_identifier ();
    4356                 :            : }
    4357                 :            : 
    4358                 :            : /* Given a CLASS_TYPE, such as a record for std::bad_exception this
    4359                 :            :    function generates a mangled name for the vtable map variable of
    4360                 :            :    the class type.  For example, if the class type is
    4361                 :            :    "std::bad_exception", the mangled name for the class is
    4362                 :            :    "St13bad_exception".  This function would generate the name
    4363                 :            :    "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
    4364                 :            :    "_VTV<std::bad_exception>::__vtable_map".  */
    4365                 :            : 
    4366                 :            : 
    4367                 :            : char *
    4368                 :          5 : get_mangled_vtable_map_var_name (tree class_type)
    4369                 :            : {
    4370                 :          5 :   char *var_name = NULL;
    4371                 :          5 :   const char *prefix = "_ZN4_VTVI";
    4372                 :          5 :   const char *postfix = "E12__vtable_mapE";
    4373                 :            : 
    4374                 :          5 :   gcc_assert (TREE_CODE (class_type) == RECORD_TYPE);
    4375                 :            : 
    4376                 :          5 :   tree class_id = DECL_ASSEMBLER_NAME (TYPE_NAME (class_type));
    4377                 :            : 
    4378                 :          5 :   if (strstr (IDENTIFIER_POINTER (class_id), "<anon>") != NULL)
    4379                 :            :     {
    4380                 :          0 :       class_id = get_mangled_id (TYPE_NAME (class_type));
    4381                 :          0 :       vtbl_register_mangled_name (TYPE_NAME (class_type), class_id);
    4382                 :            :     }
    4383                 :            : 
    4384                 :          5 :   unsigned int len = strlen (IDENTIFIER_POINTER (class_id)) +
    4385                 :            :                      strlen (prefix) +
    4386                 :          5 :                      strlen (postfix) + 1;
    4387                 :            : 
    4388                 :          5 :   var_name = (char *) xmalloc (len);
    4389                 :            : 
    4390                 :          5 :   sprintf (var_name, "%s%s%s", prefix, IDENTIFIER_POINTER (class_id), postfix);
    4391                 :            : 
    4392                 :          5 :   return var_name;
    4393                 :            : }
    4394                 :            : 
    4395                 :            : #include "gt-cp-mangle.h"

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.