LCOV - code coverage report
Current view: top level - gcc/cp - mangle.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 94.1 % 2349 2210
Test Date: 2026-11-14 16:39:50 Functions: 97.3 % 112 109
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* Name mangling for the 3.0 C++ ABI.
       2              :    Copyright (C) 2000-2026 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              : #include "contracts.h"
      59              : 
      60              : /* Debugging support.  */
      61              : 
      62              : /* Define DEBUG_MANGLE to enable very verbose trace messages.  */
      63              : #ifndef DEBUG_MANGLE
      64              : #define DEBUG_MANGLE 0
      65              : #endif
      66              : 
      67              : /* Macros for tracing the write_* functions.  */
      68              : #if DEBUG_MANGLE
      69              : # define MANGLE_TRACE(FN, INPUT) \
      70              :   fprintf (stderr, "  %-24s: %-24s\n", (FN), (INPUT))
      71              : # define MANGLE_TRACE_TREE(FN, NODE) \
      72              :   fprintf (stderr, "  %-24s: %-24s (%p)\n", \
      73              :            (FN), get_tree_code_name (TREE_CODE (NODE)), (void *) (NODE))
      74              : #else
      75              : # define MANGLE_TRACE(FN, INPUT)
      76              : # define MANGLE_TRACE_TREE(FN, NODE)
      77              : #endif
      78              : 
      79              : /* Nonzero if NODE is a class template-id.  We can't rely on
      80              :    CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
      81              :    that hard to distinguish A<T> from A, where A<T> is the type as
      82              :    instantiated outside of the template, and A is the type used
      83              :    without parameters inside the template.  */
      84              : #define CLASSTYPE_TEMPLATE_ID_P(NODE)                                   \
      85              :   (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM                     \
      86              :    || (CLASS_TYPE_P (NODE)                                              \
      87              :        && CLASSTYPE_TEMPLATE_INFO (NODE) != NULL                        \
      88              :        && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))
      89              : 
      90              : /* For deciding whether to set G.need_abi_warning, we need to consider both
      91              :    warn_abi_version and flag_abi_compat_version.  */
      92              : #define abi_warn_or_compat_version_crosses(N) \
      93              :   (abi_version_crosses (N) || abi_compat_version_crosses (N))
      94              : 
      95              : /* And sometimes we can simplify the code path if we don't need to worry about
      96              :    previous ABIs.  */
      97              : #define abi_flag_at_least(flag,N) (flag == 0 || flag >= N)
      98              : #define any_abi_below(N) \
      99              :   (!abi_version_at_least (N) \
     100              :    || !abi_flag_at_least (warn_abi_version, (N)) \
     101              :    || !abi_flag_at_least (flag_abi_compat_version, (N)))
     102              : 
     103              : /* Things we only need one of.  This module is not reentrant.  */
     104              : struct GTY(()) globals {
     105              :   /* An array of the current substitution candidates, in the order
     106              :      we've seen them.  Contains NULLS, which correspond to module
     107              :      substitutions.  */
     108              :   vec<tree, va_gc> *substitutions;
     109              : 
     110              :   /* The entity that is being mangled.  */
     111              :   tree GTY ((skip)) entity;
     112              : 
     113              :   /* How many parameter scopes we are inside.  */
     114              :   int parm_depth;
     115              : 
     116              :   /* True if the mangling will be different in a future version of the
     117              :      ABI.  */
     118              :   bool need_abi_warning;
     119              : 
     120              :   /* True if the mangling will be different in C++17 mode.  */
     121              :   bool need_cxx17_warning;
     122              : 
     123              :   /* True if we mangled a module name.  */
     124              :   bool mod;
     125              : };
     126              : 
     127              : static GTY (()) globals G;
     128              : 
     129              : /* The obstack on which we build mangled names.  */
     130              : static struct obstack *mangle_obstack;
     131              : 
     132              : /* The obstack on which we build mangled names that are not going to
     133              :    be IDENTIFIER_NODEs.  */
     134              : static struct obstack name_obstack;
     135              : 
     136              : /* The first object on the name_obstack; we use this to free memory
     137              :    allocated on the name_obstack.  */
     138              : static void *name_base;
     139              : 
     140              : /* Indices into subst_identifiers.  These are identifiers used in
     141              :    special substitution rules.  */
     142              : typedef enum
     143              : {
     144              :   SUBID_ALLOCATOR,
     145              :   SUBID_BASIC_STRING,
     146              :   SUBID_CHAR_TRAITS,
     147              :   SUBID_BASIC_ISTREAM,
     148              :   SUBID_BASIC_OSTREAM,
     149              :   SUBID_BASIC_IOSTREAM,
     150              :   SUBID_MAX
     151              : }
     152              : substitution_identifier_index_t;
     153              : 
     154              : /* For quick substitution checks, look up these common identifiers
     155              :    once only.  */
     156              : static GTY(()) tree subst_identifiers[SUBID_MAX];
     157              : 
     158              : /* Single-letter codes for builtin integer types, defined in
     159              :    <builtin-type>.  These are indexed by integer_type_kind values.  */
     160              : static const char
     161              : integer_type_codes[itk_none] =
     162              : {
     163              :   'c',  /* itk_char */
     164              :   'a',  /* itk_signed_char */
     165              :   'h',  /* itk_unsigned_char */
     166              :   's',  /* itk_short */
     167              :   't',  /* itk_unsigned_short */
     168              :   'i',  /* itk_int */
     169              :   'j',  /* itk_unsigned_int */
     170              :   'l',  /* itk_long */
     171              :   'm',  /* itk_unsigned_long */
     172              :   'x',  /* itk_long_long */
     173              :   'y',  /* itk_unsigned_long_long */
     174              :   /* __intN types are handled separately */
     175              :   '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
     176              : };
     177              : 
     178              : static tree maybe_template_info (const tree);
     179              : 
     180              : /* Functions for handling substitutions.  */
     181              : 
     182              : static inline tree canonicalize_for_substitution (tree);
     183              : static void add_substitution (tree);
     184              : static inline bool is_std_substitution (const tree,
     185              :                                        const substitution_identifier_index_t);
     186              : static inline bool is_std_substitution_char (const tree,
     187              :                                             const substitution_identifier_index_t);
     188              : static int find_substitution (tree);
     189              : static void mangle_call_offset (const tree, const tree);
     190              : 
     191              : /* Functions for emitting mangled representations of things.  */
     192              : 
     193              : static void write_mangled_name (const tree, bool);
     194              : static void write_encoding (const tree);
     195              : static void write_name (tree, const bool = false);
     196              : static void write_abi_tags (tree);
     197              : static void write_unscoped_name (const tree);
     198              : static void write_unscoped_template_name (const tree);
     199              : static void write_nested_name (const tree);
     200              : static void write_prefix (const tree);
     201              : static void write_template_prefix (const tree);
     202              : static void write_unqualified_name (tree);
     203              : static void write_conversion_operator_name (const tree);
     204              : static void write_source_name (tree);
     205              : static void write_literal_operator_name (tree);
     206              : static void write_unnamed_type_name (const tree);
     207              : static void write_unnamed_enum_name (const tree);
     208              : static void write_closure_type_name (const tree);
     209              : static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
     210              :                            const unsigned int);
     211              : static void write_number (unsigned HOST_WIDE_INT, const int,
     212              :                           const unsigned int);
     213              : static void write_compact_number (int num);
     214              : static void write_integer_cst (const tree);
     215              : static void write_real_cst (const tree);
     216              : static void write_identifier (const char *);
     217              : static void write_special_name_constructor (const tree);
     218              : static void write_special_name_destructor (const tree);
     219              : static void write_type (tree);
     220              : static int write_CV_qualifiers_for_type (const tree);
     221              : static void write_builtin_type (tree);
     222              : static void write_function_type (const tree);
     223              : static void write_bare_function_type (const tree, const int, const tree);
     224              : static void write_method_parms (tree, const int, const tree);
     225              : static void write_class_enum_type (const tree);
     226              : static void write_template_args (tree, tree = NULL_TREE);
     227              : static void write_expression (tree);
     228              : static void write_template_arg_literal (const tree);
     229              : static void write_template_arg (tree);
     230              : static void write_template_template_arg (const tree);
     231              : static void write_array_type (const tree);
     232              : static void write_pointer_to_member_type (const tree);
     233              : static void write_template_param (const tree);
     234              : static void write_template_template_param (const tree);
     235              : static void write_substitution (const int);
     236              : static int discriminator_for_local_entity (tree);
     237              : static int discriminator_for_string_literal (tree, tree);
     238              : static void write_discriminator (const int);
     239              : static void write_local_name (tree, const tree, const tree);
     240              : static void dump_substitution_candidates (void);
     241              : static tree mangle_decl_string (const tree);
     242              : static void maybe_check_abi_tags (tree, tree = NULL_TREE, int = 10);
     243              : static void write_splice (tree);
     244              : 
     245              : /* Control functions.  */
     246              : 
     247              : static inline void start_mangling (const tree);
     248              : static tree mangle_special_for_type (const tree, const char *);
     249              : 
     250              : /* Append a single character to the end of the mangled
     251              :    representation.  */
     252              : #define write_char(CHAR)                                                \
     253              :   obstack_1grow (mangle_obstack, (CHAR))
     254              : 
     255              : /* Append a sized buffer to the end of the mangled representation.  */
     256              : #define write_chars(CHAR, LEN)                                          \
     257              :   obstack_grow (mangle_obstack, (CHAR), (LEN))
     258              : 
     259              : /* Append a NUL-terminated string to the end of the mangled
     260              :    representation.  */
     261              : #define write_string(STRING)                                            \
     262              :   obstack_grow (mangle_obstack, (STRING), strlen (STRING))
     263              : 
     264              : /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
     265              :    same purpose (context, which may be a type) and value (template
     266              :    decl).  See write_template_prefix for more information on what this
     267              :    is used for.  */
     268              : #define NESTED_TEMPLATE_MATCH(NODE1, NODE2)                             \
     269              :   (TREE_CODE (NODE1) == TREE_LIST                                       \
     270              :    && TREE_CODE (NODE2) == TREE_LIST                                    \
     271              :    && ((TYPE_P (TREE_PURPOSE (NODE1))                                   \
     272              :         && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2)))    \
     273              :        || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2))                 \
     274              :    && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
     275              : 
     276              : /* Write out an unsigned quantity in base 10.  */
     277              : #define write_unsigned_number(NUMBER)                                   \
     278              :   write_number ((NUMBER), /*unsigned_p=*/1, 10)
     279              : 
     280              : /* Check for -fabi-version dependent mangling and also set the need_abi_warning
     281              :    flag as appropriate.  */
     282              : 
     283              : static bool
     284     14496765 : abi_check (int ver)
     285              : {
     286     72313130 :   if (abi_warn_or_compat_version_crosses (ver))
     287        90563 :     G.need_abi_warning = true;
     288     14496765 :   return abi_version_at_least (ver);
     289              : }
     290              : 
     291              : /* If DECL is a template instance (including the uninstantiated template
     292              :    itself), return its TEMPLATE_INFO.  Otherwise return NULL.  */
     293              : 
     294              : static tree
     295   1393397762 : maybe_template_info (const tree decl)
     296              : {
     297   1393397762 :   if (TREE_CODE (decl) == TYPE_DECL)
     298              :     {
     299              :       /* TYPE_DECLs are handled specially.  Look at its type to decide
     300              :          if this is a template instantiation.  */
     301    531438880 :       const tree type = TREE_TYPE (decl);
     302              : 
     303    531438880 :       if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
     304    422449576 :         return TYPE_TEMPLATE_INFO (type);
     305              :     }
     306              :   else
     307              :     {
     308              :       /* Check if the template is a primary template.  */
     309    861958882 :       if (DECL_LANG_SPECIFIC (decl) != NULL
     310    860656273 :           && VAR_OR_FUNCTION_DECL_P (decl)
     311    732129125 :           && DECL_TEMPLATE_INFO (decl)
     312   1434813260 :           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
     313     89166546 :         return DECL_TEMPLATE_INFO (decl);
     314              :     }
     315              : 
     316              :   /* It's not a template id.  */
     317              :   return NULL_TREE;
     318              : }
     319              : 
     320              : /* Produce debugging output of current substitution candidates.  */
     321              : 
     322              : static void
     323            0 : dump_substitution_candidates (void)
     324              : {
     325            0 :   unsigned i;
     326            0 :   tree el;
     327              : 
     328            0 :   fprintf (stderr, "  ++ substitutions  ");
     329            0 :   FOR_EACH_VEC_ELT (*G.substitutions, i, el)
     330              :     {
     331            0 :       const char *name = "???";
     332              : 
     333            0 :       if (i > 0)
     334            0 :         fprintf (stderr, "                    ");
     335            0 :       if (!el)
     336              :         name = "module";
     337            0 :       else if (DECL_P (el))
     338            0 :         name = IDENTIFIER_POINTER (DECL_NAME (el));
     339            0 :       else if (TREE_CODE (el) == TREE_LIST)
     340            0 :         name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
     341            0 :       else if (TYPE_NAME (el))
     342            0 :         name = TYPE_NAME_STRING (el);
     343            0 :       fprintf (stderr, " S%d_ = ", i - 1);
     344            0 :       if (el)
     345              :         {
     346            0 :           if (TYPE_P (el) &&
     347            0 :               (CP_TYPE_RESTRICT_P (el)
     348            0 :                || CP_TYPE_VOLATILE_P (el)
     349            0 :                || CP_TYPE_CONST_P (el)))
     350            0 :             fprintf (stderr, "CV-");
     351            0 :           fprintf (stderr, "%s (%s at %p)",
     352            0 :                    name, get_tree_code_name (TREE_CODE (el)), (void *) el);
     353              :         }
     354            0 :       fprintf (stderr, "\n");
     355              :     }
     356            0 : }
     357              : 
     358              : /* <exception-spec> ::=
     359              :       Do  -- non-throwing exception specification
     360              :       DO <expression> E  -- computed (instantiation-dependent) noexcept
     361              :       Dw <type>* E  -- throw (types)  */
     362              : 
     363              : static void
     364      3251312 : write_exception_spec (tree spec)
     365              : {
     366              : 
     367      3251312 :   if (!spec || spec == noexcept_false_spec)
     368              :     /* Nothing.  */
     369              :     return;
     370              : 
     371        37381 :   if (!flag_noexcept_type)
     372              :     {
     373           17 :       G.need_cxx17_warning = true;
     374           17 :       return;
     375              :     }
     376              : 
     377        37364 :   if (spec == noexcept_true_spec || spec == empty_except_spec)
     378        37349 :     write_string ("Do");
     379           15 :   else if (tree expr = TREE_PURPOSE (spec))
     380              :     {
     381              :       /* noexcept (expr)  */
     382           15 :       gcc_assert (uses_template_parms (expr));
     383           15 :       write_string ("DO");
     384           15 :       write_expression (expr);
     385           15 :       write_char ('E');
     386              :     }
     387              :   else
     388              :     {
     389              :       /* throw (type-list) */
     390            0 :       write_string ("Dw");
     391            0 :       for (tree t = spec; t; t = TREE_CHAIN (t))
     392            0 :         write_type (TREE_VALUE (t));
     393            0 :       write_char ('E');
     394              :     }
     395              : }
     396              : 
     397              : /* Both decls and types can be substitution candidates, but sometimes
     398              :    they refer to the same thing.  For instance, a TYPE_DECL and
     399              :    RECORD_TYPE for the same class refer to the same thing, and should
     400              :    be treated accordingly in substitutions.  This function returns a
     401              :    canonicalized tree node representing NODE that is used when adding
     402              :    and substitution candidates and finding matches.  */
     403              : 
     404              : static inline tree
     405   4883257054 : canonicalize_for_substitution (tree node)
     406              : {
     407              :   /* For a TYPE_DECL, use the type instead.  */
     408   4883257054 :   if (TREE_CODE (node) == TYPE_DECL)
     409         5104 :     node = TREE_TYPE (node);
     410   4883257054 :   if (TYPE_P (node)
     411   3588782291 :       && TYPE_CANONICAL (node) != node
     412   5288756070 :       && TYPE_MAIN_VARIANT (node) != node)
     413              :     {
     414    114972741 :       tree orig = node;
     415              :       /* Here we want to strip the topmost typedef only.
     416              :          We need to do that so is_std_substitution can do proper
     417              :          name matching.  */
     418    114972741 :       if (TREE_CODE (node) == FUNCTION_TYPE)
     419              :         /* Use build_qualified_type and TYPE_QUALS here to preserve
     420              :            the old buggy mangling of attribute noreturn with abi<5.  */
     421        28282 :         node = build_qualified_type (TYPE_MAIN_VARIANT (node),
     422        28282 :                                      TYPE_QUALS (node));
     423              :       else
     424    114944459 :         node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node),
     425              :                                         cp_type_quals (node));
     426    114972741 :       if (FUNC_OR_METHOD_TYPE_P (node))
     427              :         {
     428        28291 :           node = build_ref_qualified_type (node, type_memfn_rqual (orig));
     429        28291 :           tree r = canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (orig));
     430        28291 :           if (flag_noexcept_type)
     431        28247 :             node = build_exception_variant (node, r);
     432              :           else
     433              :             /* Set the warning flag if appropriate.  */
     434           44 :             write_exception_spec (r);
     435              :         }
     436              :     }
     437   4883257054 :   return node;
     438              : }
     439              : 
     440              : /* Add NODE as a substitution candidate.  NODE must not already be on
     441              :    the list of candidates.  */
     442              : 
     443              : static void
     444   1266269973 : add_substitution (tree node)
     445              : {
     446   1266269973 :   tree c;
     447              : 
     448   1266269973 :   if (DEBUG_MANGLE)
     449              :     fprintf (stderr, "  ++ add_substitution (%s at %10p)\n",
     450              :              get_tree_code_name (TREE_CODE (node)), (void *) node);
     451              : 
     452              :   /* Get the canonicalized substitution candidate for NODE.  */
     453   1266269973 :   c = canonicalize_for_substitution (node);
     454   1266269973 :   if (DEBUG_MANGLE && c != node)
     455              :     fprintf (stderr, "  ++ using candidate (%s at %10p)\n",
     456              :              get_tree_code_name (TREE_CODE (node)), (void *) node);
     457   1266269973 :   node = c;
     458              : 
     459              :   /* Make sure NODE isn't already a candidate.  */
     460   1266269973 :   if (flag_checking)
     461              :     {
     462              :       int i;
     463              :       tree candidate;
     464              : 
     465   6572390075 :       FOR_EACH_VEC_SAFE_ELT (G.substitutions, i, candidate)
     466   5306120218 :         if (candidate)
     467              :           {
     468   5306112698 :             gcc_assert (!(DECL_P (node) && node == candidate));
     469   5306112698 :             gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
     470              :                           && same_type_p (node, candidate)));
     471              :           }
     472              :     }
     473              : 
     474              :   /* Put the decl onto the varray of substitution candidates.  */
     475   1266269973 :   vec_safe_push (G.substitutions, node);
     476              : 
     477   1266269973 :   if (DEBUG_MANGLE)
     478              :     dump_substitution_candidates ();
     479   1266269973 : }
     480              : 
     481              : /* Helper function for find_substitution.  Returns nonzero if NODE,
     482              :    which may be a class or a class template, is a template-id with template
     483              :    name of substitution_index[INDEX] in the ::std namespace, with
     484              :    global module attachment.  */
     485              : 
     486              : static bool
     487   4285853259 : is_std_substitution (const tree node,
     488              :                      const substitution_identifier_index_t index)
     489              : {
     490   4285853259 :   tree type = NULL_TREE;
     491   4285853259 :   tree decl = NULL_TREE;
     492              : 
     493   8546873906 :   auto std_substitution_p = [&] (tree decl, tree type)
     494              :     {
     495   4261020647 :       if (!DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl)))
     496              :         return false;
     497              : 
     498   1645896720 :       if (!(TYPE_LANG_SPECIFIC (type) && TYPE_TEMPLATE_INFO (type)))
     499              :         return false;
     500              : 
     501   1222388766 :       tree tmpl = TYPE_TI_TEMPLATE (type);
     502   1222388766 :       if (DECL_NAME (tmpl) != subst_identifiers[index])
     503              :         return false;
     504              : 
     505    145310257 :       if (modules_p () && get_originating_module (tmpl, true) >= 0)
     506           27 :         return false;
     507              : 
     508              :       return true;
     509   4285853259 :     };
     510              : 
     511   4285853259 :   if (TREE_CODE (node) == TYPE_DECL || DECL_CLASS_TEMPLATE_P (node))
     512              :     {
     513   3384739003 :       type = TREE_TYPE (node);
     514   3384739003 :       decl = node;
     515              :     }
     516    901114256 :   else if (CLASS_TYPE_P (node))
     517              :     {
     518      4765769 :       type = node;
     519      4765769 :       decl = TYPE_NAME (node);
     520              :     }
     521              :   else
     522              :     {
     523              :       /* We used to accept all _DECL nodes in this function but now we
     524              :          only accept classes or class templates.  Verify that we don't
     525              :          return false for something that used to yield true.  */
     526    896348487 :       gcc_checking_assert (!DECL_P (node)
     527              :                            || !std_substitution_p (node, TREE_TYPE (node)));
     528              :       /* These are not the droids you're looking for.  */
     529              :       return false;
     530              :     }
     531              : 
     532   3389504772 :   return std_substitution_p (decl, type);
     533              : }
     534              : 
     535              : /* Return the ABI tags (the TREE_VALUE of the "abi_tag" attribute entry) for T,
     536              :    which can be a decl or type.  */
     537              : 
     538              : static tree
     539   1879135609 : get_abi_tags (tree t)
     540              : {
     541   1879135609 :   if (!t || TREE_CODE (t) == NAMESPACE_DECL)
     542              :     return NULL_TREE;
     543              : 
     544   1751459372 :   if (DECL_P (t) && DECL_DECLARES_TYPE_P (t))
     545    471231665 :     t = TREE_TYPE (t);
     546              : 
     547   1751459372 :   if (TREE_CODE (t) == TEMPLATE_DECL && DECL_TEMPLATE_RESULT (t))
     548              :     {
     549     17398188 :       tree tags = get_abi_tags (DECL_TEMPLATE_RESULT (t));
     550              :       /* We used to overlook abi_tag on function and variable templates.  */
     551     17398188 :       if (tags && abi_check (19))
     552           10 :         return tags;
     553              :       else
     554              :         return NULL_TREE;
     555              :     }
     556              : 
     557   1734061184 :   tree attrs;
     558   1734061184 :   if (TYPE_P (t))
     559   1507557623 :     attrs = TYPE_ATTRIBUTES (t);
     560              :   else
     561    226503561 :     attrs = DECL_ATTRIBUTES (t);
     562              : 
     563   1734061184 :   tree tags = lookup_attribute ("abi_tag", attrs);
     564   1734061184 :   if (tags)
     565     11829286 :     tags = TREE_VALUE (tags);
     566              :   return tags;
     567              : }
     568              : 
     569              : /* Helper function for find_substitution.  Returns nonzero if NODE,
     570              :    which may be a decl or a CLASS_TYPE, is the template-id
     571              :    ::std::identifier<char>, where identifier is
     572              :    substitution_index[INDEX].  */
     573              : 
     574              : static bool
     575      6840626 : is_std_substitution_char (const tree node,
     576              :                           const substitution_identifier_index_t index)
     577              : {
     578      6840626 :   tree args;
     579              :   /* Check NODE's name is ::std::identifier.  */
     580      6840626 :   if (!is_std_substitution (node, index))
     581              :     return 0;
     582              :   /* Figure out its template args.  */
     583      4310349 :   if (DECL_P (node))
     584            0 :     args = DECL_TI_ARGS (node);
     585      4310349 :   else if (CLASS_TYPE_P (node))
     586      4310349 :     args = CLASSTYPE_TI_ARGS (node);
     587              :   else
     588              :     /* Oops, not a template.  */
     589              :     return 0;
     590              :   /* NODE's template arg list should be <char>.  */
     591      4310349 :   return
     592      4310349 :     TREE_VEC_LENGTH (args) == 1
     593      4310349 :     && TREE_VEC_ELT (args, 0) == char_type_node;
     594              : }
     595              : 
     596              : /* Check whether a substitution should be used to represent NODE in
     597              :    the mangling.
     598              : 
     599              :    First, check standard special-case substitutions.
     600              : 
     601              :      <substitution> ::= St
     602              :          # ::std
     603              : 
     604              :                     ::= Sa
     605              :          # ::std::allocator
     606              : 
     607              :                     ::= Sb
     608              :          # ::std::basic_string
     609              : 
     610              :                     ::= Ss
     611              :          # ::std::basic_string<char,
     612              :                                ::std::char_traits<char>,
     613              :                                ::std::allocator<char> >
     614              : 
     615              :                     ::= Si
     616              :          # ::std::basic_istream<char, ::std::char_traits<char> >
     617              : 
     618              :                     ::= So
     619              :          # ::std::basic_ostream<char, ::std::char_traits<char> >
     620              : 
     621              :                     ::= Sd
     622              :          # ::std::basic_iostream<char, ::std::char_traits<char> >
     623              : 
     624              :    Then examine the stack of currently available substitution
     625              :    candidates for entities appearing earlier in the same mangling
     626              : 
     627              :    If a substitution is found, write its mangled representation and
     628              :    return nonzero.  If none is found, just return zero.  */
     629              : 
     630              : static int
     631   2332505809 : find_substitution (tree node)
     632              : {
     633   2332505809 :   int i;
     634   2332505809 :   const int size = vec_safe_length (G.substitutions);
     635   2332505809 :   tree decl;
     636   2332505809 :   tree type;
     637   2332505809 :   const char *abbr = NULL;
     638              : 
     639   2332505809 :   if (DEBUG_MANGLE)
     640              :     fprintf (stderr, "  ++ find_substitution (%s at %p)\n",
     641              :              get_tree_code_name (TREE_CODE (node)), (void *) node);
     642              : 
     643              :   /* Obtain the canonicalized substitution representation for NODE.
     644              :      This is what we'll compare against.  */
     645   2332505809 :   node = canonicalize_for_substitution (node);
     646              : 
     647              :   /* Check for builtin substitutions.  */
     648              : 
     649   2332505809 :   decl = TYPE_P (node) ? TYPE_NAME (node) : node;
     650   2332505809 :   type = TYPE_P (node) ? node : TREE_TYPE (node);
     651              : 
     652              :   /* Check for std::allocator.  */
     653   2332505809 :   if (decl
     654   2165649721 :       && is_std_substitution (decl, SUBID_ALLOCATOR)
     655   2472420702 :       && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
     656              :     abbr = "Sa";
     657              : 
     658              :   /* Check for std::basic_string.  */
     659   2268524939 :   else if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
     660              :     {
     661       155877 :       if (TYPE_P (node))
     662              :         {
     663              :           /* If this is a type (i.e. a fully-qualified template-id),
     664              :              check for
     665              :                  std::basic_string <char,
     666              :                                     std::char_traits<char>,
     667              :                                     std::allocator<char> > .  */
     668       108764 :           if (cp_type_quals (type) == TYPE_UNQUALIFIED
     669       108764 :               && CLASSTYPE_USE_TEMPLATE (type))
     670              :             {
     671        97215 :               tree args = CLASSTYPE_TI_ARGS (type);
     672        97215 :               if (TREE_VEC_LENGTH (args) == 3
     673        97197 :                   && template_args_equal (TREE_VEC_ELT (args, 0), char_type_node)
     674        39521 :                   && is_std_substitution_char (TREE_VEC_ELT (args, 1),
     675              :                                                SUBID_CHAR_TRAITS)
     676       136725 :                   && is_std_substitution_char (TREE_VEC_ELT (args, 2),
     677              :                                                SUBID_ALLOCATOR))
     678              :                 abbr = "Ss";
     679              :             }
     680              :         }
     681              :       else
     682              :         /* Substitute for the template name only if this isn't a type.  */
     683              :         abbr = "Sb";
     684              :     }
     685              : 
     686              :   /* Check for basic_{i,o,io}stream.  */
     687   2268369062 :   else if (TYPE_P (node)
     688   1506732395 :            && cp_type_quals (type) == TYPE_UNQUALIFIED
     689   1420325754 :            && CLASS_TYPE_P (type)
     690    598515085 :            && CLASSTYPE_USE_TEMPLATE (type)
     691   2708992015 :            && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
     692              :     {
     693              :       /* First, check for the template
     694              :          args <char, std::char_traits<char> > .  */
     695    440622953 :       tree args = CLASSTYPE_TI_ARGS (type);
     696    440622953 :       if (TREE_VEC_LENGTH (args) == 2
     697    138277731 :           && template_args_equal (TREE_VEC_ELT (args, 0), char_type_node)
     698    447384548 :           && is_std_substitution_char (TREE_VEC_ELT (args, 1),
     699              :                                        SUBID_CHAR_TRAITS))
     700              :         {
     701              :           /* Got them.  Is this basic_istream?  */
     702      4231324 :           if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
     703              :             abbr = "Si";
     704              :           /* Or basic_ostream?  */
     705      3926444 :           else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
     706              :             abbr = "So";
     707              :           /* Or basic_iostream?  */
     708      3536293 :           else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
     709   2105725061 :             abbr = "Sd";
     710              :         }
     711              :     }
     712              : 
     713              :   /* Check for namespace std.  */
     714   1827746109 :   else if (decl && DECL_NAMESPACE_STD_P (decl))
     715              :     {
     716    226780748 :       write_string ("St");
     717    226780748 :       return 1;
     718              :     }
     719              : 
     720   2105725061 :   tree tags = NULL_TREE;
     721   2105725061 :   if (OVERLOAD_TYPE_P (node) || DECL_CLASS_TEMPLATE_P (node))
     722   1036325958 :     tags = get_abi_tags (type);
     723              :   /* Now check the list of available substitutions for this mangling
     724              :      operation.  */
     725   2105725061 :   if (!abbr || tags)
     726   9143582164 :     for (i = 0; i < size; ++i)
     727   7282290071 :       if (tree candidate = (*G.substitutions)[i])
     728              :         {
     729              :           /* NODE is a matched to a candidate if it's the same decl node or
     730              :              if it's the same type.  */
     731   7282279950 :           if (decl == candidate
     732   7219727045 :               || (TYPE_P (candidate) && type && TYPE_P (node)
     733   3185669755 :                   && same_type_p (type, candidate))
     734  14386186506 :               || NESTED_TEMPLATE_MATCH (node, candidate))
     735              :             {
     736    179436373 :               write_substitution (i);
     737    179436373 :               return 1;
     738              :             }
     739              :         }
     740              : 
     741   1861292093 :   if (!abbr)
     742              :     /* No substitution found.  */
     743              :     return 0;
     744              : 
     745     64996601 :   write_string (abbr);
     746     64996601 :   if (tags)
     747              :     {
     748              :       /* If there are ABI tags on the abbreviation, it becomes
     749              :          a substitution candidate.  */
     750            6 :       write_abi_tags (tags);
     751            6 :       add_substitution (node);
     752              :     }
     753              :   return 1;
     754              : }
     755              : 
     756              : /* Returns whether DECL's symbol name should be the plain unqualified-id
     757              :    rather than a more complicated mangled name.  */
     758              : 
     759              : static bool
     760    221411261 : unmangled_name_p (const tree decl)
     761              : {
     762    221411261 :   if (TREE_CODE (decl) == FUNCTION_DECL)
     763              :     {
     764              :       /* The names of `extern "C"' functions are not mangled.  */
     765    187761936 :       return (DECL_EXTERN_C_FUNCTION_P (decl)
     766              :               /* But overloaded operator names *are* mangled.  */
     767      2239598 :               && !DECL_OVERLOADED_OPERATOR_P (decl));
     768              :     }
     769     33649325 :   else if (VAR_P (decl))
     770              :     {
     771              :       /* extern "C" declarations aren't mangled.  */
     772     33645942 :       if (DECL_NAMESPACE_SCOPE_P (decl) && DECL_EXTERN_C_P (decl))
     773              :         return true;
     774              : 
     775              :       /* static variables are mangled.  */
     776     33438570 :       if (!DECL_EXTERNAL_LINKAGE_P (decl))
     777              :         return false;
     778              : 
     779              :       /* Other variables at non-global scope are mangled.  */
     780     33220215 :       if (CP_DECL_CONTEXT (decl) != global_namespace)
     781              :         return false;
     782              : 
     783              :       /* Variable template instantiations are mangled.  */
     784       124610 :       if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
     785       123156 :           && variable_template_p (DECL_TI_TEMPLATE (decl)))
     786              :         return false;
     787              : 
     788              :       /* Declarations with ABI tags are mangled.  */
     789       113788 :       if (get_abi_tags (decl))
     790              :         return false;
     791              : 
     792              :       // Declarations attached to a named module are mangled
     793       113436 :       if (modules_p () && get_originating_module (decl, true) >= 0)
     794          121 :         return false;
     795              : 
     796              :       /* The names of non-static global variables aren't mangled.  */
     797              :       return true;
     798              :     }
     799              : 
     800              :   return false;
     801              : }
     802              : 
     803              : /* TOP_LEVEL is true, if this is being called at outermost level of
     804              :   mangling. It should be false when mangling a decl appearing in an
     805              :   expression within some other mangling.
     806              : 
     807              :   <mangled-name>      ::= _Z <encoding>  */
     808              : 
     809              : static void
     810    221411261 : write_mangled_name (const tree decl, bool top_level)
     811              : {
     812    221411261 :   MANGLE_TRACE_TREE ("mangled-name", decl);
     813              : 
     814    221411261 :   check_abi_tags (decl);
     815              : 
     816    221411261 :   if (unmangled_name_p (decl))
     817              :     {
     818      2560282 :       if (top_level)
     819      2559995 :         write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
     820              :       else
     821              :         {
     822              :           /* The standard notes: "The <encoding> of an extern "C"
     823              :              function is treated like global-scope data, i.e. as its
     824              :              <source-name> without a type."  We cannot write
     825              :              overloaded operators that way though, because it contains
     826              :              characters invalid in assembler.  */
     827          287 :           write_string ("_Z");
     828          287 :           write_source_name (DECL_NAME (decl));
     829              :         }
     830              :     }
     831              :   else
     832              :     {
     833    218850979 :       write_string ("_Z");
     834    218850979 :       write_encoding (decl);
     835              :     }
     836              : 
     837              :   /* If this is a coroutine helper, then append an appropriate string to
     838              :      identify which.  */
     839    221411261 :   if (tree ramp = DECL_RAMP_FN (decl))
     840              :     {
     841         3082 :       if (DECL_ACTOR_FN (ramp) == decl)
     842         1541 :         write_string (JOIN_STR "actor");
     843         1541 :       else if (DECL_DESTROY_FN (ramp) == decl)
     844         1541 :         write_string (JOIN_STR "destroy");
     845              :       else
     846            0 :         gcc_unreachable ();
     847              :     }
     848    221411261 : }
     849              : 
     850              : /* Returns true if the return type of DECL is part of its signature, and
     851              :    therefore its mangling.  */
     852              : 
     853              : bool
     854    376178079 : mangle_return_type_p (tree decl)
     855              : {
     856    376178079 :   return (!DECL_CONSTRUCTOR_P (decl)
     857    315483021 :           && !DECL_DESTRUCTOR_P (decl)
     858    301247770 :           && !DECL_CONV_FN_P (decl)
     859    674695543 :           && maybe_template_info (decl));
     860              : }
     861              : 
     862              : /* <constraint-expression> ::= <expression> */
     863              : 
     864              : static void
     865      3280673 : write_constraint_expression (tree expr)
     866              : {
     867            0 :   write_expression (expr);
     868            0 : }
     869              : 
     870              : /* Mangle a requires-clause following a template-head, if any.
     871              : 
     872              :    Q <constraint_expression> E  */
     873              : 
     874              : static void
     875    417872485 : write_tparms_constraints (tree constraints)
     876              : {
     877              :   /* In a declaration with shorthand constraints in the template-head, followed
     878              :      by a requires-clause, followed by shorthand constraints in the
     879              :      function-parameter-list, the full constraints will be some && with the
     880              :      parameter constraints on the RHS, around an && with the requires-clause on
     881              :      the RHS.  Find the requires-clause, if any.
     882              : 
     883              :      This logic relies on the && and ... from combine_constraint_expressions,
     884              :      finish_shorthand_constraint, and convert_generic_types_to_packs having
     885              :      UNKNOWN_LOCATION.  If they need to have an actual location, we could move
     886              :      to using a TREE_LANG_FLAG.  */
     887    417872485 :   if (constraints && abi_check (19))
     888              :     {
     889              :       tree probe = constraints;
     890              :       while (probe
     891       344062 :              && !cp_expr_location (probe)
     892       381254 :              && TREE_CODE (probe) == TRUTH_ANDIF_EXPR)
     893              :         {
     894          372 :           tree op1 = TREE_OPERAND (probe, 1);
     895          715 :           probe = (cp_expr_location (op1) ? op1
     896          343 :                    : TREE_OPERAND (probe, 0));
     897              :         }
     898       343690 :       if (probe && cp_expr_location (probe))
     899              :         {
     900       306870 :           write_char ('Q');
     901       306870 :           write_constraint_expression (probe);
     902              :         }
     903              :     }
     904    417872485 : }
     905              : 
     906              : /* <type-constraint> ::= <name> */
     907              : 
     908              : static void
     909       145093 : write_type_constraint (tree cnst)
     910              : {
     911       145093 :   if (!cnst)
     912              :     return;
     913              : 
     914       145093 :   gcc_checking_assert (TREE_CODE (cnst) == TEMPLATE_ID_EXPR);
     915              : 
     916       145093 :   tree concept_decl = get_concept_check_template (cnst);
     917       145093 :   write_name (concept_decl);
     918       145093 :   tree args = TREE_OPERAND (cnst, 1);
     919       145093 :   if (TREE_VEC_LENGTH (args) > 1)
     920              :     {
     921        52533 :       TEMPLATE_ARGS_TYPE_CONSTRAINT_P (args) = true;
     922        52533 :       write_template_args (args);
     923              :     }
     924              : }
     925              : 
     926              : /*   <encoding>           ::= <function name> <bare-function-type>
     927              :                         ::= <data name>  */
     928              : 
     929              : static void
     930    224397881 : write_encoding (const tree decl)
     931              : {
     932    224397881 :   MANGLE_TRACE_TREE ("encoding", decl);
     933              : 
     934    224397881 :   if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
     935              :     {
     936              :       /* For overloaded operators write just the mangled name
     937              :          without arguments.  */
     938        11199 :       if (DECL_OVERLOADED_OPERATOR_P (decl))
     939            3 :         write_name (decl);
     940              :       else
     941        11196 :         write_source_name (DECL_NAME (decl));
     942              :       return;
     943              :     }
     944              : 
     945    224386682 :   write_name (decl);
     946    224386682 :   if (TREE_CODE (decl) == FUNCTION_DECL)
     947              :     {
     948    191057841 :       tree fn_type;
     949    191057841 :       tree d;
     950              : 
     951    191057841 :       if (maybe_template_info (decl))
     952              :         {
     953     17349819 :           fn_type = get_mostly_instantiated_function_type (decl);
     954              :           /* FN_TYPE will not have parameter types for in-charge or
     955              :              VTT parameters.  Therefore, we pass NULL_TREE to
     956              :              write_bare_function_type -- otherwise, it will get
     957              :              confused about which artificial parameters to skip.  */
     958     17349819 :           d = NULL_TREE;
     959              :         }
     960              :       else
     961              :         {
     962    173708022 :           fn_type = TREE_TYPE (decl);
     963    173708022 :           d = decl;
     964              :         }
     965              : 
     966    191057841 :       write_bare_function_type (fn_type,
     967    191057841 :                                 mangle_return_type_p (decl),
     968              :                                 d);
     969              : 
     970    191057841 :       if (tree c = get_trailing_function_requirements (decl))
     971      2993440 :         if (abi_check (19))
     972              :           {
     973      2973797 :             ++G.parm_depth;
     974      2973797 :             write_char ('Q');
     975      2973797 :             write_constraint_expression (c);
     976      2973797 :             --G.parm_depth;
     977              :           }
     978              :     }
     979              : }
     980              : 
     981              : /* Interface to substitution and identifier mangling, used by the
     982              :    module name mangler.  */
     983              : 
     984              : void
     985          425 : mangle_module_substitution (int v)
     986              : {
     987          425 :   write_substitution (v - 1);
     988          425 : }
     989              : 
     990              : int
     991         8601 : mangle_module_component (tree comp, bool partition_p)
     992              : {
     993         8601 :   write_char ('W');
     994         8601 :   if (partition_p)
     995          226 :     write_char ('P');
     996         8601 :   write_source_name (comp);
     997              : 
     998              :   // Module substitutions use the same number-space as entity
     999              :   // substitutions, but are orthogonal.
    1000         8601 :   vec_safe_push (G.substitutions, NULL_TREE);
    1001         8601 :   return G.substitutions->length ();
    1002              : }
    1003              : 
    1004              : /* If the outermost non-namespace context (including DECL itself) is
    1005              :    a module-linkage decl, mangle the module information.  For module
    1006              :    global initializers we need to include the partition part.
    1007              : 
    1008              :    <module-name> ::= <module-sub>
    1009              :                  || <subst>
    1010              :                  || <module-name> <module-sub>
    1011              :    <module-sub> :: W [P] <unqualified-name>
    1012              : */
    1013              : 
    1014              : static void
    1015         8344 : write_module (int m, bool include_partition)
    1016              : {
    1017         8344 :   G.mod = true;
    1018            0 :   mangle_module (m, include_partition);
    1019            0 : }
    1020              : 
    1021              : static void
    1022      1858544 : maybe_write_module (tree decl)
    1023              : {
    1024      1858544 :   if (!DECL_NAMESPACE_SCOPE_P (decl))
    1025              :     return;
    1026              : 
    1027      1325513 :   if (!TREE_PUBLIC (STRIP_TEMPLATE (decl)))
    1028              :     return;
    1029              : 
    1030      1316270 :   if (TREE_CODE (decl) == NAMESPACE_DECL)
    1031              :     return;
    1032              : 
    1033       999972 :   int m = get_originating_module (decl, true);
    1034       999972 :   if (m >= 0)
    1035         6242 :     write_module (m, false);
    1036              : }
    1037              : 
    1038              : /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
    1039              :    or PARM_DECL context, which doesn't belong in DECL_CONTEXT.  */
    1040              : 
    1041              : static tree
    1042   2080137892 : decl_mangling_context (tree decl)
    1043              : {
    1044   2080138040 :   tree tcontext = targetm.cxx.decl_mangling_context (decl);
    1045              : 
    1046   2080138040 :   if (tcontext != NULL_TREE)
    1047              :     return tcontext;
    1048              : 
    1049   2080138040 :   if (TREE_CODE (decl) == TEMPLATE_DECL
    1050   2080138040 :       && DECL_TEMPLATE_RESULT (decl))
    1051              :     decl = DECL_TEMPLATE_RESULT (decl);
    1052              : 
    1053   2080138040 :   if (TREE_CODE (decl) == TYPE_DECL
    1054   3059793382 :       && LAMBDA_TYPE_P (TREE_TYPE (decl)))
    1055              :     {
    1056      6032003 :       tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl));
    1057      6032003 :       if (extra)
    1058              :         return extra;
    1059         6081 :       tcontext = CP_DECL_CONTEXT (decl);
    1060         6251 :       if (LAMBDA_TYPE_P (tcontext))
    1061              :         /* Lambda type context means this lambda appears between the
    1062              :            lambda-introducer and the open brace of another lambda (c++/119175).
    1063              :            That isn't a real scope; look further into the enclosing scope.  */
    1064           60 :         return decl_mangling_context (TYPE_NAME (tcontext));
    1065              :     }
    1066   2074106037 :   else if (template_type_parameter_p (decl))
    1067              :      /* template type parms have no mangling context.  */
    1068              :       return NULL_TREE;
    1069              : 
    1070   2074111072 :   tcontext = CP_DECL_CONTEXT (decl);
    1071              : 
    1072   2074111072 :   if (member_like_constrained_friend_p (decl))
    1073        90024 :     tcontext = DECL_FRIEND_CONTEXT (decl);
    1074              : 
    1075              :   /* Ignore the artificial declare reduction functions.  */
    1076   2074111072 :   if (tcontext
    1077   2074111072 :       && TREE_CODE (tcontext) == FUNCTION_DECL
    1078   2079927068 :       && DECL_OMP_DECLARE_REDUCTION_P (tcontext))
    1079              :     return decl_mangling_context (tcontext);
    1080              : 
    1081              :   return tcontext;
    1082              : }
    1083              : 
    1084              : /* <name> ::= <unscoped-name>
    1085              :           ::= <unscoped-template-name> <template-args>
    1086              :           ::= <nested-name>
    1087              :           ::= <local-name>
    1088              : 
    1089              :    If IGNORE_LOCAL_SCOPE is true, this production of <name> is
    1090              :    called from <local-name>, which mangles the enclosing scope
    1091              :    elsewhere and then uses this function to mangle just the part
    1092              :    underneath the function scope.  So don't use the <local-name>
    1093              :    production, to avoid an infinite recursion.  */
    1094              : 
    1095              : static void
    1096    553889001 : write_name (tree decl, const bool ignore_local_scope/*=false*/)
    1097              : {
    1098    553889001 :   tree context;
    1099              : 
    1100    553889001 :   MANGLE_TRACE_TREE ("name", decl);
    1101              : 
    1102    553889001 :   if (TREE_CODE (decl) == TYPE_DECL)
    1103              :     {
    1104              :       /* In case this is a typedef, fish out the corresponding
    1105              :          TYPE_DECL for the main variant.  */
    1106    324985485 :       decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
    1107              :     }
    1108              : 
    1109    553889001 :   context = decl_mangling_context (decl);
    1110              : 
    1111    553889001 :   gcc_assert (context != NULL_TREE);
    1112              : 
    1113   2768964064 :   if (abi_warn_or_compat_version_crosses (7)
    1114       160059 :       && ignore_local_scope
    1115           40 :       && TREE_CODE (context) == PARM_DECL)
    1116            0 :     G.need_abi_warning = 1;
    1117              : 
    1118              :   /* A decl in :: or ::std scope is treated specially.  The former is
    1119              :      mangled using <unscoped-name> or <unscoped-template-name>, the
    1120              :      latter with a special substitution.  Also, a name that is
    1121              :      directly in a local function scope is also mangled with
    1122              :      <unscoped-name> rather than a full <nested-name>.  */
    1123    553889001 :   if (context == global_namespace
    1124    542196718 :       || DECL_NAMESPACE_STD_P (context)
    1125    323187332 :       || (ignore_local_scope
    1126      5063933 :           && (TREE_CODE (context) == FUNCTION_DECL
    1127      3488732 :               || (abi_version_at_least (7)
    1128      3488732 :                   && TREE_CODE (context) == PARM_DECL))))
    1129              :     {
    1130              :       /* Is this a template instance?  */
    1131    232276900 :       if (tree info = maybe_template_info (decl))
    1132              :         {
    1133              :           /* Yes: use <unscoped-template-name>.  */
    1134    193568038 :           write_unscoped_template_name (TI_TEMPLATE (info));
    1135              :           /* Pass down the parms of a function template in case we need to
    1136              :              mangle them; we don't mangle the parms of a non-overloadable
    1137              :              template.  */
    1138    193568038 :           tree parms = (TREE_CODE (decl) == FUNCTION_DECL
    1139    198490991 :                         ? DECL_TEMPLATE_PARMS (TI_TEMPLATE (info))
    1140      4922953 :                         : NULL_TREE);
    1141    193568038 :           write_template_args (TI_ARGS (info), parms);
    1142              :         }
    1143              :       else
    1144              :         /* Everything else gets an <unqualified-name>.  */
    1145     38708862 :         write_unscoped_name (decl);
    1146              :     }
    1147              :   else
    1148              :     {
    1149              :       /* Handle local names, unless we asked not to (that is, invoked
    1150              :          under <local-name>, to handle only the part of the name under
    1151              :          the local scope).  */
    1152    321612101 :       if (!ignore_local_scope)
    1153              :         {
    1154              :           /* Scan up the list of scope context, looking for a
    1155              :              function.  If we find one, this entity is in local
    1156              :              function scope.  local_entity tracks context one scope
    1157              :              level down, so it will contain the element that's
    1158              :              directly in that function's scope, either decl or one of
    1159              :              its enclosing scopes.  */
    1160              :           tree local_entity = decl;
    1161   1014751311 :           while (context != global_namespace)
    1162              :             {
    1163              :               /* Make sure we're always dealing with decls.  */
    1164    701691845 :               if (TYPE_P (context))
    1165    222355706 :                 context = TYPE_NAME (context);
    1166              :               /* Is this a function?  */
    1167    701691845 :               if (TREE_CODE (context) == FUNCTION_DECL
    1168    696628278 :                   || TREE_CODE (context) == PARM_DECL)
    1169              :                 {
    1170              :                   /* Yes, we have local scope.  Use the <local-name>
    1171              :                      production for the innermost function scope.  */
    1172      5063933 :                   write_local_name (context, local_entity, decl);
    1173      5063933 :                   return;
    1174              :                 }
    1175              :               /* Up one scope level.  */
    1176    696627912 :               local_entity = context;
    1177    696627912 :               context = decl_mangling_context (context);
    1178              :             }
    1179              : 
    1180              :           /* No local scope found?  Fall through to <nested-name>.  */
    1181              :         }
    1182              : 
    1183              :       /* Other decls get a <nested-name> to encode their scope.  */
    1184    316548168 :       write_nested_name (decl);
    1185              :     }
    1186              : }
    1187              : 
    1188              : /* <unscoped-name> ::= <unqualified-name>
    1189              :                    ::= St <unqualified-name>   # ::std::  */
    1190              : 
    1191              : static void
    1192    165706266 : write_unscoped_name (const tree decl)
    1193              : {
    1194    165706266 :   tree context = decl_mangling_context (decl);
    1195              : 
    1196    165706266 :   MANGLE_TRACE_TREE ("unscoped-name", decl);
    1197              : 
    1198              :   /* Is DECL in ::std?  */
    1199    165706266 :   if (DECL_NAMESPACE_STD_P (context))
    1200              :     {
    1201    155392413 :       write_string ("St");
    1202    155392413 :       write_unqualified_name (decl);
    1203              :     }
    1204              :   else
    1205              :     {
    1206              :       /* If not, it should be either in the global namespace, or directly
    1207              :          in a local function scope.  A lambda can also be mangled in the
    1208              :          scope of a default argument.  */
    1209     10313853 :       gcc_assert (context == global_namespace
    1210              :                   || TREE_CODE (context) == PARM_DECL
    1211              :                   || TREE_CODE (context) == FUNCTION_DECL);
    1212              : 
    1213     10313853 :       write_unqualified_name (decl);
    1214              :     }
    1215    165706266 : }
    1216              : 
    1217              : /* <unscoped-template-name> ::= <unscoped-name>
    1218              :                             ::= <substitution>  */
    1219              : 
    1220              : static void
    1221    193568038 : write_unscoped_template_name (const tree decl)
    1222              : {
    1223    193568038 :   MANGLE_TRACE_TREE ("unscoped-template-name", decl);
    1224              : 
    1225    193568038 :   if (find_substitution (decl))
    1226              :     return;
    1227    126997404 :   write_unscoped_name (decl);
    1228    126997404 :   add_substitution (decl);
    1229              : }
    1230              : 
    1231              : /* Write the nested name, including CV-qualifiers, of DECL.
    1232              : 
    1233              :    <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
    1234              :                  ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
    1235              : 
    1236              :    <ref-qualifier> ::= R # & ref-qualifier
    1237              :                    ::= O # && ref-qualifier
    1238              :    <CV-qualifiers> ::= [r] [V] [K]  */
    1239              : 
    1240              : static void
    1241    319249197 : write_nested_name (const tree decl)
    1242              : {
    1243    319249197 :   MANGLE_TRACE_TREE ("nested-name", decl);
    1244              : 
    1245    319249197 :   write_char ('N');
    1246              : 
    1247              :   /* Write CV-qualifiers, if this is an iobj member function.  */
    1248    319249197 :   if (TREE_CODE (decl) == FUNCTION_DECL
    1249    319249197 :       && DECL_IOBJ_MEMBER_FUNCTION_P (decl))
    1250              :     {
    1251    150717822 :       if (DECL_VOLATILE_MEMFUNC_P (decl))
    1252      8813968 :         write_char ('V');
    1253    150717822 :       if (DECL_CONST_MEMFUNC_P (decl))
    1254     45604461 :         write_char ('K');
    1255    150717822 :       if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl)))
    1256              :         {
    1257       155504 :           if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
    1258        97227 :             write_char ('O');
    1259              :           else
    1260        58277 :             write_char ('R');
    1261              :         }
    1262              :     }
    1263    139951939 :   else if (DECL_DECLARES_FUNCTION_P (decl)
    1264    168531375 :            && DECL_XOBJ_MEMBER_FUNCTION_P (decl))
    1265         5471 :     write_char ('H');
    1266              : 
    1267              :   /* Is this a template instance?  */
    1268    319249197 :   if (tree info = maybe_template_info (decl))
    1269              :     {
    1270              :       /* Yes, use <template-prefix>.  */
    1271     55437896 :       write_template_prefix (decl);
    1272     55437896 :       write_template_args (TI_ARGS (info));
    1273              :     }
    1274    263811301 :   else if ((!abi_version_at_least (10) || TREE_CODE (decl) == TYPE_DECL)
    1275    341977237 :            && TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
    1276              :     {
    1277      2701026 :       tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
    1278      2701026 :       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
    1279              :         {
    1280        50656 :           write_template_prefix (decl);
    1281        50656 :           write_template_args (TREE_OPERAND (name, 1));
    1282              :         }
    1283              :       else
    1284              :         {
    1285      2650370 :           write_prefix (decl_mangling_context (decl));
    1286      2650370 :           write_unqualified_name (decl);
    1287              :         }
    1288              :     }
    1289              :   else
    1290              :     {
    1291              :       /* No, just use <prefix>  */
    1292    261110275 :       write_prefix (decl_mangling_context (decl));
    1293    261110275 :       write_unqualified_name (decl);
    1294              :     }
    1295    319249197 :   write_char ('E');
    1296    319249197 : }
    1297              : 
    1298              : /* <prefix> ::= <prefix> <unqualified-name>
    1299              :             ::= <template-param>
    1300              :             ::= <template-prefix> <template-args>
    1301              :             ::= <decltype>
    1302              :             ::= # empty
    1303              :             ::= <substitution>
    1304              :             ::= <splice>      # C++26 dependent splice [proposed]  */
    1305              : 
    1306              : static void
    1307    657807804 : write_prefix (const tree node)
    1308              : {
    1309    657807804 :   tree decl;
    1310              : 
    1311    657807804 :   if (node == NULL
    1312    657807804 :       || node == global_namespace)
    1313              :     return;
    1314              : 
    1315    634198865 :   MANGLE_TRACE_TREE ("prefix", node);
    1316              : 
    1317    634198865 :   if (TREE_CODE (node) == DECLTYPE_TYPE
    1318    634198757 :       || TREE_CODE (node) == TRAIT_TYPE)
    1319              :     {
    1320          111 :       write_type (node);
    1321          111 :       return;
    1322              :     }
    1323              : 
    1324    634198754 :   if (TREE_CODE (node) == SPLICE_SCOPE)
    1325              :     {
    1326           10 :       write_splice (node);
    1327           10 :       return;
    1328              :     }
    1329              : 
    1330    634198744 :   if (find_substitution (node))
    1331              :     return;
    1332              : 
    1333    348164399 :   tree template_info = NULL_TREE;
    1334    348164399 :   if (DECL_P (node))
    1335              :     {
    1336              :       /* If this is a function or parm decl, that means we've hit function
    1337              :          scope, so this prefix must be for a local name.  In this
    1338              :          case, we're under the <local-name> production, which encodes
    1339              :          the enclosing function scope elsewhere.  So don't continue
    1340              :          here.  */
    1341    131233564 :       if (TREE_CODE (node) == FUNCTION_DECL
    1342    127745836 :           || TREE_CODE (node) == PARM_DECL)
    1343              :         return;
    1344              : 
    1345    127745500 :       decl = node;
    1346    127745500 :       template_info = maybe_template_info (decl);
    1347              :     }
    1348              :   else
    1349              :     {
    1350              :       /* Node is a type.  */
    1351    216930835 :       decl = TYPE_NAME (node);
    1352              :       /* The DECL might not point at the node.  */
    1353    216930835 :       if (CLASSTYPE_TEMPLATE_ID_P (node))
    1354    163825463 :         template_info = TYPE_TEMPLATE_INFO (node);
    1355              :     }
    1356              : 
    1357    344676335 :   if (TREE_CODE (node) == TEMPLATE_TYPE_PARM)
    1358        12438 :     write_template_param (node);
    1359    344663897 :   else if (template_info)
    1360              :     /* Templated.  */
    1361              :     {
    1362    163867794 :       write_template_prefix (decl);
    1363    163867794 :       write_template_args (TI_ARGS (template_info));
    1364              :     }
    1365    180796103 :   else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
    1366              :     {
    1367       136814 :       tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
    1368       136814 :       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
    1369              :         {
    1370       118231 :           write_template_prefix (decl);
    1371       118231 :           write_template_args (TREE_OPERAND (name, 1));
    1372              :         }
    1373              :       else
    1374              :         {
    1375        18583 :           write_prefix (decl_mangling_context (decl));
    1376        18583 :           write_unqualified_name (decl);
    1377              :         }
    1378              :     }
    1379              :   else
    1380              :     /* Not templated.  */
    1381              :     {
    1382    180659289 :       write_prefix (decl_mangling_context (decl));
    1383    180659289 :       write_unqualified_name (decl);
    1384    180659289 :       if (VAR_P (decl)
    1385    180659289 :           || TREE_CODE (decl) == FIELD_DECL)
    1386              :         {
    1387              :           /* <data-member-prefix> := <member source-name> M */
    1388        26885 :           write_char ('M');
    1389              : 
    1390              :           /* Before ABI 18, we did not count these as substitution
    1391              :              candidates.  This leads to incorrect demanglings (and
    1392              :              ABI divergence to other compilers).  */
    1393        26885 :           if (!abi_check (18))
    1394              :             return;
    1395              :         }
    1396              :     }
    1397              : 
    1398    344676203 :   add_substitution (node);
    1399              : }
    1400              : 
    1401              : /* <template-prefix> ::= <prefix> <template component>
    1402              :                      ::= <template-param>
    1403              :                      ::= <substitution>  */
    1404              : 
    1405              : static void
    1406    219474577 : write_template_prefix (const tree node)
    1407              : {
    1408    219474577 :   tree decl = DECL_P (node) ? node : TYPE_NAME (node);
    1409    219474577 :   tree type = DECL_P (node) ? TREE_TYPE (node) : node;
    1410    219474577 :   tree context = decl_mangling_context (decl);
    1411    219474577 :   tree templ;
    1412    219474577 :   tree substitution;
    1413              : 
    1414    219474577 :   MANGLE_TRACE_TREE ("template-prefix", node);
    1415              : 
    1416              :   /* Find the template decl.  */
    1417    219474577 :   if (tree info = maybe_template_info (decl))
    1418    219304704 :     templ = TI_TEMPLATE (info);
    1419       169873 :   else if (TREE_CODE (type) == TYPENAME_TYPE)
    1420              :     /* For a typename type, all we have is the name.  */
    1421       168887 :     templ = DECL_NAME (decl);
    1422              :   else
    1423              :     {
    1424          986 :       gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
    1425              : 
    1426          986 :       templ = TYPE_TI_TEMPLATE (type);
    1427              :     }
    1428              : 
    1429              :   /* For a member template, though, the template name for the
    1430              :      innermost name must have all the outer template levels
    1431              :      instantiated.  For instance, consider
    1432              : 
    1433              :        template<typename T> struct Outer {
    1434              :          template<typename U> struct Inner {};
    1435              :        };
    1436              : 
    1437              :      The template name for `Inner' in `Outer<int>::Inner<float>' is
    1438              :      `Outer<int>::Inner<U>'.  In g++, we don't instantiate the template
    1439              :      levels separately, so there's no TEMPLATE_DECL available for this
    1440              :      (there's only `Outer<T>::Inner<U>').
    1441              : 
    1442              :      In order to get the substitutions right, we create a special
    1443              :      TREE_LIST to represent the substitution candidate for a nested
    1444              :      template.  The TREE_PURPOSE is the template's context, fully
    1445              :      instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
    1446              :      template.
    1447              : 
    1448              :      So, for the example above, `Outer<int>::Inner' is represented as a
    1449              :      substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
    1450              :      and whose value is `Outer<T>::Inner<U>'.  */
    1451    219474577 :   if (context && TYPE_P (context))
    1452     11386712 :     substitution = build_tree_list (context, templ);
    1453              :   else
    1454              :     substitution = templ;
    1455              : 
    1456    219474577 :   if (find_substitution (substitution))
    1457              :     return;
    1458              : 
    1459    213369459 :   if (TREE_TYPE (templ)
    1460    213369459 :       && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM)
    1461          986 :     write_template_param (TREE_TYPE (templ));
    1462              :   else
    1463              :     {
    1464    213368473 :       write_prefix (context);
    1465    213368473 :       write_unqualified_name (decl);
    1466              :     }
    1467              : 
    1468    213369459 :   add_substitution (substitution);
    1469              : }
    1470              : 
    1471              : /* "For the purposes of mangling, the name of an anonymous union is considered
    1472              :    to be the name of the first named data member found by a pre-order,
    1473              :    depth-first, declaration-order walk of the data members of the anonymous
    1474              :    union. If there is no such data member (i.e., if all of the data members in
    1475              :    the union are unnamed), then there is no way for a program to refer to the
    1476              :    anonymous union, and there is therefore no need to mangle its name."  */
    1477              : 
    1478              : static tree
    1479           51 : anon_aggr_naming_decl (tree type)
    1480              : {
    1481           51 :   tree field = next_aggregate_field (TYPE_FIELDS (type));
    1482          102 :   for (; field; field = next_aggregate_field (DECL_CHAIN (field)))
    1483              :     {
    1484           21 :       if (DECL_NAME (field))
    1485              :         return field;
    1486            0 :       if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
    1487            0 :         if (tree sub = anon_aggr_naming_decl (TREE_TYPE (field)))
    1488              :           return sub;
    1489              :     }
    1490              :   return NULL_TREE;
    1491              : }
    1492              : 
    1493              : /* We don't need to handle thunks, vtables, or VTTs here.  Those are
    1494              :    mangled through special entry points.
    1495              : 
    1496              :     <unqualified-name>  ::= [<module-name>] <operator-name>
    1497              :                         ::= <special-name>
    1498              :                         ::= [<module-name>] <source-name>
    1499              :                         ::= [<module-name>] <unnamed-type-name>
    1500              :                         ::= <local-source-name>
    1501              :                         ::= F <source-name> # member-like constrained friend
    1502              : 
    1503              :     <local-source-name>   ::= L <source-name> <discriminator> */
    1504              : 
    1505              : static void
    1506      5005722 : write_unqualified_id (tree identifier)
    1507              : {
    1508      5005722 :   if (IDENTIFIER_CONV_OP_P (identifier))
    1509           15 :     write_conversion_operator_name (TREE_TYPE (identifier));
    1510      5005707 :   else if (IDENTIFIER_OVL_OP_P (identifier))
    1511              :     {
    1512        53499 :       const ovl_op_info_t *ovl_op = IDENTIFIER_OVL_OP_INFO (identifier);
    1513        53499 :       write_string (ovl_op->mangled_name);
    1514        53499 :     }
    1515      4952208 :   else if (UDLIT_OPER_P (identifier))
    1516            0 :     write_literal_operator_name (identifier);
    1517              :   else
    1518      4952208 :     write_source_name (identifier);
    1519      5005722 : }
    1520              : 
    1521              : static void
    1522    823517324 : write_unqualified_name (tree decl)
    1523              : {
    1524    823517324 :   MANGLE_TRACE_TREE ("unqualified-name", decl);
    1525              : 
    1526    823517324 :   if (modules_p ())
    1527      1858544 :     maybe_write_module (decl);
    1528              : 
    1529    823517324 :   if (identifier_p (decl))
    1530              :     {
    1531            0 :       write_unqualified_id (decl);
    1532            0 :       return;
    1533              :     }
    1534              : 
    1535    823517324 :   bool found = false;
    1536              : 
    1537    823517324 :   if (DECL_NAME (decl) == NULL_TREE
    1538    823517324 :       && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
    1539           21 :     decl = anon_aggr_naming_decl (TREE_TYPE (decl));
    1540    823517303 :   else if (DECL_NAME (decl) == NULL_TREE)
    1541              :     {
    1542        11643 :       found = true;
    1543        11643 :       gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
    1544        11643 :       write_source_name (DECL_ASSEMBLER_NAME (decl));
    1545              :     }
    1546    823505660 :   else if (DECL_DECLARES_FUNCTION_P (decl))
    1547              :     {
    1548    191057305 :       found = true;
    1549              : 
    1550              :       /* A constrained hidden friend is mangled like a member function, with
    1551              :          the name prefixed by 'F'.  */
    1552    191057305 :       if (member_like_constrained_friend_p (decl))
    1553        22506 :         write_char ('F');
    1554              : 
    1555    382114610 :       if (DECL_CONSTRUCTOR_P (decl))
    1556     30461952 :         write_special_name_constructor (decl);
    1557    160595353 :       else if (DECL_DESTRUCTOR_P (decl))
    1558      7357084 :         write_special_name_destructor (decl);
    1559    153238269 :       else if (DECL_CONV_FN_P (decl))
    1560              :         {
    1561              :           /* Conversion operator. Handle it right here.
    1562              :              <operator> ::= cv <type>  */
    1563      2725029 :           tree type;
    1564      2725029 :           if (maybe_template_info (decl))
    1565              :             {
    1566          588 :               tree fn_type;
    1567          588 :               fn_type = get_mostly_instantiated_function_type (decl);
    1568          588 :               type = TREE_TYPE (fn_type);
    1569              :             }
    1570      2724441 :           else if (FNDECL_USED_AUTO (decl))
    1571           60 :             type = DECL_SAVED_AUTO_RETURN_TYPE (decl);
    1572              :           else
    1573      2724381 :             type = DECL_CONV_FN_TYPE (decl);
    1574      2725029 :           write_conversion_operator_name (type);
    1575              :         }
    1576    150513240 :       else if (DECL_OVERLOADED_OPERATOR_P (decl))
    1577              :         {
    1578     34489300 :           tree t;
    1579     34489300 :           if (!(t = DECL_RAMP_FN (decl)))
    1580     34488908 :             t = decl;
    1581     34489300 :           const char *mangled_name
    1582     34489300 :             = (ovl_op_info[DECL_ASSIGNMENT_OPERATOR_P (t)]
    1583     34489300 :                [DECL_OVERLOADED_OPERATOR_CODE_RAW (t)].mangled_name);
    1584     34489300 :           write_string (mangled_name);
    1585              :         }
    1586    116023940 :       else if (UDLIT_OPER_P (DECL_NAME (decl)))
    1587       303207 :         write_literal_operator_name (DECL_NAME (decl));
    1588              :       else
    1589              :         found = false;
    1590              :     }
    1591              : 
    1592     75348236 :   if (found)
    1593              :     /* OK */;
    1594    748169109 :   else if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
    1595       125739 :            && DECL_NAMESPACE_SCOPE_P (decl)
    1596    748241008 :            && decl_linkage (decl) == lk_internal)
    1597              :     {
    1598        60528 :       MANGLE_TRACE_TREE ("local-source-name", decl);
    1599        60528 :       write_char ('L');
    1600        60528 :       write_source_name (DECL_NAME (decl));
    1601              :       /* The default discriminator is 1, and that's all we ever use,
    1602              :          so there's no code to output one here.  */
    1603              :     }
    1604              :   else
    1605              :     {
    1606    748108581 :       tree type = TREE_TYPE (decl);
    1607              : 
    1608    748108581 :       if (TREE_CODE (decl) == TYPE_DECL
    1609    748108581 :           && enum_with_enumerator_for_linkage_p (type))
    1610           20 :         write_unnamed_enum_name (type);
    1611   1111248646 :       else if (TREE_CODE (decl) == TYPE_DECL && TYPE_UNNAMED_P (type))
    1612         1553 :         write_unnamed_type_name (type);
    1613   1084612543 :       else if (TREE_CODE (decl) == TYPE_DECL && LAMBDA_TYPE_P (type))
    1614      2351226 :         write_closure_type_name (type);
    1615              :       else
    1616    745755782 :         write_source_name (DECL_NAME (decl));
    1617              :     }
    1618              : 
    1619              :   /* We use the ABI tags from the primary class template, ignoring tags on any
    1620              :      specializations.  This is necessary because C++ doesn't require a
    1621              :      specialization to be declared before it is used unless the use requires a
    1622              :      complete type, but we need to get the tags right on incomplete types as
    1623              :      well.  */
    1624    823517324 :   if (tree tmpl = most_general_template (decl))
    1625              :     {
    1626    483890024 :       tree res = DECL_TEMPLATE_RESULT (tmpl);
    1627    483890024 :       if (res == NULL_TREE)
    1628              :         /* UNBOUND_CLASS_TEMPLATE.  */;
    1629    483890021 :       else if (DECL_DECLARES_TYPE_P (decl))
    1630              :         decl = res;
    1631    167646982 :       else if (any_abi_below (11))
    1632              :         {
    1633              :           /* ABI v10 implicit tags on the template.  */
    1634        81578 :           tree mtags = missing_abi_tags (res);
    1635              :           /* Explicit tags on the template.  */
    1636        81578 :           tree ttags = get_abi_tags (res);
    1637              :           /* Tags on the instantiation.  */
    1638        81578 :           tree dtags = get_abi_tags (decl);
    1639              : 
    1640        81656 :           if (mtags && abi_warn_or_compat_version_crosses (10))
    1641            6 :             G.need_abi_warning = 1;
    1642              : 
    1643              :           /* Add the v10 tags to the explicit tags now.  */
    1644        81578 :           mtags = chainon (mtags, ttags);
    1645              : 
    1646        81578 :           if (!G.need_abi_warning
    1647       163058 :               && abi_warn_or_compat_version_crosses (11)
    1648       163062 :               && !equal_abi_tags (dtags, mtags, /*ignore_inherited_p=*/false))
    1649            6 :             G.need_abi_warning = 1;
    1650              : 
    1651        81578 :           if (!abi_version_at_least (10))
    1652              :             /* In abi <10, we only got the explicit tags.  */
    1653              :             decl = res;
    1654          911 :           else if (flag_abi_version == 10)
    1655              :             {
    1656              :               /* In ABI 10, we want explicit and implicit tags.  */
    1657           72 :               write_abi_tags (mtags);
    1658           72 :               return;
    1659              :             }
    1660              :         }
    1661              :     }
    1662              : 
    1663    823517252 :   tree tags = get_abi_tags (decl);
    1664    186134594 :   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CONV_FN_P (decl)
    1665    826242281 :       && any_abi_below (11))
    1666         2731 :     if (tree mtags = missing_abi_tags (decl))
    1667              :       {
    1668            9 :         if (!abi_check (11))
    1669            6 :           tags = chainon (mtags, tags);
    1670              :       }
    1671    823517252 :   write_abi_tags (tags);
    1672              : }
    1673              : 
    1674              : /* Write the unqualified-name for a conversion operator to TYPE.  */
    1675              : 
    1676              : static void
    1677      2725044 : write_conversion_operator_name (const tree type)
    1678              : {
    1679      2725044 :   write_string ("cv");
    1680      2725044 :   write_type (type);
    1681      2725044 : }
    1682              : 
    1683              : /* Non-terminal <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
    1684              : 
    1685              :      <source-name> ::= </length/ number> <identifier>  */
    1686              : 
    1687              : static void
    1688    750800655 : write_source_name (tree identifier)
    1689              : {
    1690    750800655 :   MANGLE_TRACE_TREE ("source-name", identifier);
    1691              : 
    1692    750800655 :   write_unsigned_number (IDENTIFIER_LENGTH (identifier));
    1693    750800655 :   write_identifier (IDENTIFIER_POINTER (identifier));
    1694    750800655 : }
    1695              : 
    1696              : /* Compare two TREE_STRINGs like strcmp.  */
    1697              : 
    1698              : static int
    1699          306 : tree_string_cmp (const void *p1, const void *p2)
    1700              : {
    1701          306 :   if (p1 == p2)
    1702              :     return 0;
    1703          306 :   tree s1 = *(const tree*)p1;
    1704          306 :   tree s2 = *(const tree*)p2;
    1705          306 :   return strcmp (TREE_STRING_POINTER (s1),
    1706          306 :                  TREE_STRING_POINTER (s2));
    1707              : }
    1708              : 
    1709              : /* Return the TREE_LIST of TAGS as a sorted VEC.  */
    1710              : 
    1711              : static vec<tree, va_gc> *
    1712       502095 : sorted_abi_tags (tree tags, bool ignore_inherited_p)
    1713              : {
    1714       502095 :   vec<tree, va_gc> * vec = make_tree_vector();
    1715              : 
    1716       841288 :   for (tree t = tags; t; t = TREE_CHAIN (t))
    1717              :     {
    1718       339193 :       if (ABI_TAG_NOT_MANGLED (t)
    1719       339193 :           || (ignore_inherited_p && ABI_TAG_INHERITED (t)))
    1720            6 :         continue;
    1721       339187 :       tree str = TREE_VALUE (t);
    1722       339187 :       vec_safe_push (vec, str);
    1723              :     }
    1724              : 
    1725       502095 :   vec->qsort (tree_string_cmp);
    1726              : 
    1727       502095 :   return vec;
    1728              : }
    1729              : 
    1730              : /* ID is the name of a function or type with abi_tags attribute TAGS.
    1731              :    Write out the name, suitably decorated.  */
    1732              : 
    1733              : static void
    1734    823517360 : write_abi_tags (tree tags)
    1735              : {
    1736    823517360 :   if (tags == NULL_TREE)
    1737    823517360 :     return;
    1738              : 
    1739       339061 :   vec<tree, va_gc> * vec = sorted_abi_tags (tags, /*ignore_inherited_p=*/false);
    1740              : 
    1741       339061 :   unsigned i; tree str;
    1742      1017210 :   FOR_EACH_VEC_ELT (*vec, i, str)
    1743              :     {
    1744       339088 :       write_string ("B");
    1745       339088 :       write_unsigned_number (TREE_STRING_LENGTH (str) - 1);
    1746       339088 :       write_identifier (TREE_STRING_POINTER (str));
    1747              :     }
    1748              : 
    1749       339061 :   release_tree_vector (vec);
    1750              : }
    1751              : 
    1752              : /* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent.  */
    1753              : 
    1754              : bool
    1755        81517 : equal_abi_tags (tree t1, tree t2, bool ignore_inherited_p)
    1756              : {
    1757        81517 :   releasing_vec v1 = sorted_abi_tags (t1, ignore_inherited_p);
    1758        81517 :   releasing_vec v2 = sorted_abi_tags (t2, ignore_inherited_p);
    1759              : 
    1760        81517 :   unsigned len1 = v1->length();
    1761        81517 :   if (len1 != v2->length())
    1762              :     return false;
    1763        81511 :   for (unsigned i = 0; i < len1; ++i)
    1764           21 :     if (strcmp (TREE_STRING_POINTER (v1[i]),
    1765           21 :                 TREE_STRING_POINTER (v2[i])) != 0)
    1766              :       return false;
    1767              :   return true;
    1768        81517 : }
    1769              : 
    1770              : /* Write a user-defined literal operator.
    1771              :           ::= li <source-name>    # "" <source-name>
    1772              :    IDENTIFIER is an LITERAL_IDENTIFIER_NODE.  */
    1773              : 
    1774              : static void
    1775       303207 : write_literal_operator_name (tree identifier)
    1776              : {
    1777       303207 :   const char* suffix = UDLIT_OP_SUFFIX (identifier);
    1778       303207 :   write_identifier (UDLIT_OP_MANGLED_PREFIX);
    1779       303207 :   write_unsigned_number (strlen (suffix));
    1780       303207 :   write_identifier (suffix);
    1781       303207 : }
    1782              : 
    1783              : /* Encode 0 as _, and 1+ as n-1_.  */
    1784              : 
    1785              : static void
    1786     31731154 : write_compact_number (int num)
    1787              : {
    1788     31731154 :   gcc_checking_assert (num >= 0);
    1789     31731154 :   if (num > 0)
    1790     12236331 :     write_unsigned_number (num - 1);
    1791     31731154 :   write_char ('_');
    1792     31731154 : }
    1793              : 
    1794              : /* Return how many unnamed types precede TYPE in its enclosing class.  */
    1795              : 
    1796              : static int
    1797          839 : nested_anon_class_index (tree type)
    1798              : {
    1799          839 :   int index = 0;
    1800          839 :   tree member = TYPE_FIELDS (TYPE_CONTEXT (type));
    1801        22181 :   for (; member; member = DECL_CHAIN (member))
    1802        22181 :     if (DECL_IMPLICIT_TYPEDEF_P (member))
    1803              :       {
    1804         1299 :         tree memtype = TREE_TYPE (member);
    1805         1299 :         if (memtype == type)
    1806              :           return index;
    1807         1124 :         else if (TYPE_UNNAMED_P (memtype))
    1808          204 :           ++index;
    1809              :       }
    1810              : 
    1811            0 :   if (seen_error ())
    1812              :     return -1;
    1813              : 
    1814            0 :   gcc_unreachable ();
    1815              : }
    1816              : 
    1817              : /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
    1818              : 
    1819              : static void
    1820         1553 : write_unnamed_type_name (const tree type)
    1821              : {
    1822         1553 :   int discriminator;
    1823         1553 :   MANGLE_TRACE_TREE ("unnamed-type-name", type);
    1824              : 
    1825         1553 :   if (TYPE_FUNCTION_SCOPE_P (type))
    1826          358 :     discriminator = discriminator_for_local_entity (TYPE_NAME (type));
    1827         1195 :   else if (TYPE_CLASS_SCOPE_P (type))
    1828          839 :     discriminator = nested_anon_class_index (type);
    1829              :   else
    1830              :     {
    1831          356 :       gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
    1832              :       /* Just use the old mangling at namespace scope.  */
    1833          356 :       write_source_name (TYPE_IDENTIFIER (type));
    1834          356 :       return;
    1835              :     }
    1836              : 
    1837         1197 :   write_string ("Ut");
    1838         1197 :   write_compact_number (discriminator);
    1839              : }
    1840              : 
    1841              : /* <unnamed-enum-name> ::= Ue <underlying type> <enumerator source-name> */
    1842              : 
    1843              : static void
    1844           20 : write_unnamed_enum_name (const tree type)
    1845              : {
    1846           20 :   MANGLE_TRACE_TREE ("unnamed-enum-name", type);
    1847           20 :   write_string ("Ue");
    1848           20 :   write_type (ENUM_UNDERLYING_TYPE (type));
    1849           20 :   write_source_name (DECL_NAME (TREE_VALUE (TYPE_VALUES (type))));
    1850           20 : }
    1851              : 
    1852              : /* ABI issue #47: if a function template parameter is not "natural" for its
    1853              :    argument we must mangle the parameter.  */
    1854              : 
    1855              : static bool
    1856      8521693 : template_parm_natural_p (tree arg, tree parm)
    1857              : {
    1858      8521693 :   tree decl = TREE_VALUE (parm);
    1859              : 
    1860              :   /* A template parameter is "natural" if: */
    1861              : 
    1862      8521693 :   if (template_parameter_pack_p (decl))
    1863              :     {
    1864       834141 :       tree args = ARGUMENT_PACK_ARGS (arg);
    1865       834141 :       if (TREE_VEC_LENGTH (args) == 0)
    1866              :         {
    1867              : #if 0
    1868              :           /* the argument is an empty pack and the parameter is an
    1869              :              unconstrained template type parameter pack; */
    1870              :           if (TREE_CODE (decl) != TYPE_DECL)
    1871              :             return false;
    1872              : #else
    1873              :           /* Defer changing the mangling of C++11 code like
    1874              :              template <int i> int max();
    1875              :              template <int i, int j, int... rest> int max();  */
    1876              :           return true;
    1877              : #endif
    1878              :         }
    1879              :       else
    1880              :         /* the argument is a non-empty pack and a non-pack variant of the
    1881              :            parameter would be natural for the first element of the pack; */
    1882       652872 :         arg = TREE_VEC_ELT (args, 0);
    1883              :     }
    1884              : 
    1885              :   /* the argument is a template and the parameter has the exact
    1886              :      same template head; */
    1887      8340424 :   if (TREE_CODE (decl) == TEMPLATE_DECL)
    1888         9144 :     return template_heads_equivalent_p (arg, decl);
    1889              : 
    1890              :   /* the argument is a type and the parameter is unconstrained; or */
    1891      8331280 :   else if (TREE_CODE (decl) == TYPE_DECL)
    1892      7308357 :     return !TEMPLATE_PARM_CONSTRAINTS (parm);
    1893              : 
    1894              :   /* the argument is a non-type template argument and the declared parameter
    1895              :      type neither is instantiation dependent nor contains deduced types.  */
    1896      1022923 :   else if (TREE_CODE (decl) == PARM_DECL)
    1897              :     {
    1898              : #if 0
    1899              :       return !uses_template_parms (TREE_TYPE (decl));
    1900              : #else
    1901              :       /* Defer changing the mangling of C++98 code like
    1902              :          template <class T, T V> ....  */
    1903      1022923 :       return !type_uses_auto (TREE_TYPE (decl));
    1904              : #endif
    1905              :     }
    1906              : 
    1907            0 :   gcc_unreachable ();
    1908              : }
    1909              : 
    1910              : /* Used for lambda template head and non-natural function template parameters.
    1911              : 
    1912              :    <template-param-decl> ::= Ty               # template type parameter
    1913              :         ::= Tk <type-constraint>              # constrained type parameter
    1914              :         ::= Tn <type>                         # template non-type parameter
    1915              :         ::= Tt <template-param-decl>* [Q <constraint-expression] E  # ttp
    1916              :         ::= Tp <non-pack template-param-decl> # template parameter pack */
    1917              : 
    1918              : static void
    1919       115488 : write_template_param_decl (tree parm)
    1920              : {
    1921       115488 :   tree decl = TREE_VALUE (parm);
    1922              : 
    1923       115488 :   if (template_parameter_pack_p (decl))
    1924        41221 :     write_string ("Tp");
    1925              : 
    1926       115488 :   switch (TREE_CODE (decl))
    1927              :     {
    1928        48236 :     case PARM_DECL:
    1929        48236 :       {
    1930        48236 :         write_string ("Tn");
    1931              : 
    1932        48236 :         tree type = TREE_TYPE (decl);
    1933              :         /* TODO: We need to also mangle constrained auto*, auto&, etc, but
    1934              :            it's not clear how.  See finish_constrained_parameter.  */
    1935        48236 :         if (tree c = (is_auto (type)
    1936        52700 :                       ? TEMPLATE_PARM_CONSTRAINTS (parm)
    1937         4464 :                       : NULL_TREE))
    1938              :           {
    1939           22 :             if (TREE_CODE (c) == UNARY_LEFT_FOLD_EXPR)
    1940              :               {
    1941            3 :                 c = FOLD_EXPR_PACK (c);
    1942            3 :                 c = PACK_EXPANSION_PATTERN (c);
    1943              :               }
    1944           22 :             if (AUTO_IS_DECLTYPE (type))
    1945            0 :               write_string ("DK");
    1946              :             else
    1947           22 :               write_string ("Dk");
    1948           22 :             write_type_constraint (c);
    1949              :           }
    1950              :         else
    1951        48214 :           write_type (type);
    1952              :       }
    1953              :       break;
    1954              : 
    1955          351 :     case TEMPLATE_DECL:
    1956          351 :       {
    1957          351 :         write_string ("Tt");
    1958          351 :         tree parms = DECL_INNERMOST_TEMPLATE_PARMS (decl);
    1959          812 :         for (tree node : tree_vec_range (parms))
    1960          461 :           write_template_param_decl (node);
    1961          351 :         write_char ('E');
    1962              :       }
    1963          351 :       break;
    1964              : 
    1965        66901 :     case TYPE_DECL:
    1966        66901 :       if (tree c = TEMPLATE_PARM_CONSTRAINTS (parm))
    1967              :         {
    1968        37167 :           if (TREE_CODE (c) == UNARY_LEFT_FOLD_EXPR)
    1969              :             {
    1970           70 :               c = FOLD_EXPR_PACK (c);
    1971           70 :               c = PACK_EXPANSION_PATTERN (c);
    1972              :             }
    1973        37167 :           if (TREE_CODE (decl) == TYPE_DECL)
    1974              :             {
    1975        37167 :               write_string ("Tk");
    1976        37167 :               write_type_constraint (c);
    1977              :             }
    1978              :         }
    1979              :       else
    1980        29734 :         write_string ("Ty");
    1981              :       break;
    1982              : 
    1983            0 :     default:
    1984            0 :       gcc_unreachable ();
    1985              :     }
    1986       115488 : }
    1987              : 
    1988              : // A template head, for templated lambdas.
    1989              : // New in ABI=18. Returns true iff we emitted anything -- used for ABI
    1990              : // version warning.
    1991              : 
    1992              : static bool
    1993       517205 : write_closure_template_head (tree tmpl)
    1994              : {
    1995       517205 :   bool any = false;
    1996              : 
    1997              :   // We only need one level of template parms
    1998       517205 :   tree parms = DECL_TEMPLATE_PARMS (tmpl);
    1999       517205 :   tree inner = INNERMOST_TEMPLATE_PARMS (parms);
    2000              : 
    2001       590694 :   for (int ix = 0, len = TREE_VEC_LENGTH (inner); ix != len; ix++)
    2002              :     {
    2003       535593 :       tree parm = TREE_VEC_ELT (inner, ix);
    2004       535593 :       if (parm == error_mark_node)
    2005            0 :         continue;
    2006              : 
    2007       535593 :       if (DECL_IMPLICIT_TEMPLATE_PARM_P (TREE_VALUE (parm)))
    2008              :         // A synthetic parm, we're done.
    2009              :         break;
    2010              : 
    2011        73489 :       any = true;
    2012        73489 :       if (abi_version_at_least (18))
    2013        73249 :         write_template_param_decl (parm);
    2014              :     }
    2015              : 
    2016       517205 :   write_tparms_constraints (TEMPLATE_PARMS_CONSTRAINTS (parms));
    2017              : 
    2018       517205 :   return any;
    2019              : }
    2020              : 
    2021              : /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
    2022              :    <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters */
    2023              : 
    2024              : static void
    2025      2351226 : write_closure_type_name (const tree type)
    2026              : {
    2027      2351226 :   tree fn = lambda_function (type);
    2028      2351226 :   tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
    2029      2351226 :   tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
    2030              : 
    2031      2351226 :   MANGLE_TRACE_TREE ("closure-type-name", type);
    2032              : 
    2033      2351226 :   write_string ("Ul");
    2034              : 
    2035      2351226 :   if (auto ti = maybe_template_info (fn))
    2036       517205 :     if (write_closure_template_head (TI_TEMPLATE (ti)))
    2037              :       // If there were any explicit template parms, we may need to
    2038              :       // issue a mangling diagnostic.
    2039       361005 :       if (abi_warn_or_compat_version_crosses (18))
    2040          198 :         G.need_abi_warning = true;
    2041              : 
    2042      2351226 :   write_method_parms (parms, TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE, fn);
    2043      2351226 :   write_char ('E');
    2044      2351226 :   if ((LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR (lambda)
    2045      2351226 :        != LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR (lambda))
    2046      3196898 :       && abi_warn_or_compat_version_crosses (18))
    2047          288 :     G.need_abi_warning = true;
    2048      4702452 :   write_compact_number (abi_version_at_least (18)
    2049      2350704 :                         ? LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR (lambda)
    2050          522 :                         : LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR (lambda));
    2051      2351226 : }
    2052              : 
    2053              : /* Convert NUMBER to ascii using base BASE and generating at least
    2054              :    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
    2055              :    into which to store the characters. Returns the number of
    2056              :    characters generated (these will be laid out in advance of where
    2057              :    BUFFER points).  */
    2058              : 
    2059              : static int
    2060   1016160653 : hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
    2061              :                 char *buffer, const unsigned int min_digits)
    2062              : {
    2063   1016160653 :   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    2064   1016160653 :   unsigned digits = 0;
    2065              : 
    2066   2528645111 :   while (number)
    2067              :     {
    2068   1512484458 :       unsigned HOST_WIDE_INT d = number / base;
    2069              : 
    2070   1512484458 :       *--buffer = base_digits[number - d * base];
    2071   1512484458 :       digits++;
    2072   1512484458 :       number = d;
    2073              :     }
    2074   1070224358 :   while (digits < min_digits)
    2075              :     {
    2076     54063705 :       *--buffer = base_digits[0];
    2077     54063705 :       digits++;
    2078              :     }
    2079   1016160653 :   return digits;
    2080              : }
    2081              : 
    2082              : /* Non-terminal <number>.
    2083              : 
    2084              :      <number> ::= [n] </decimal integer/>  */
    2085              : 
    2086              : static void
    2087   1016160353 : write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
    2088              :               const unsigned int base)
    2089              : {
    2090   1016160353 :   char buffer[sizeof (HOST_WIDE_INT) * 8];
    2091   1016160353 :   unsigned count = 0;
    2092              : 
    2093   1016160353 :   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
    2094              :     {
    2095            0 :       write_char ('n');
    2096            0 :       number = -((HOST_WIDE_INT) number);
    2097              :     }
    2098   1016160353 :   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
    2099   1016160353 :   write_chars (buffer + sizeof (buffer) - count, count);
    2100   1016160353 : }
    2101              : 
    2102              : /* Write out an integral CST in decimal. Most numbers are small, and
    2103              :    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
    2104              :    bigger than that, which we must deal with.  */
    2105              : 
    2106              : static inline void
    2107     95866862 : write_integer_cst (const tree cst)
    2108              : {
    2109     95866862 :   int sign = tree_int_cst_sgn (cst);
    2110     95866862 :   widest_int abs_value = wi::abs (wi::to_widest (cst));
    2111     95866862 :   if (!wi::fits_uhwi_p (abs_value))
    2112              :     {
    2113              :       /* A bignum. We do this in chunks, each of which fits in a
    2114              :          HOST_WIDE_INT.  */
    2115          100 :       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
    2116          100 :       unsigned HOST_WIDE_INT chunk;
    2117          100 :       unsigned chunk_digits;
    2118          100 :       char *ptr = buffer + sizeof (buffer);
    2119          100 :       unsigned count = 0;
    2120          100 :       tree n, base, type;
    2121          100 :       int done;
    2122              : 
    2123              :       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
    2124              :          representable.  */
    2125          100 :       chunk = 1000000000;
    2126          100 :       chunk_digits = 9;
    2127              : 
    2128          100 :       if (sizeof (HOST_WIDE_INT) >= 8)
    2129              :         {
    2130              :           /* It is at least 64 bits, so 10^18 is representable.  */
    2131          100 :           chunk_digits = 18;
    2132          100 :           chunk *= chunk;
    2133              :         }
    2134              : 
    2135          100 :       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
    2136          100 :       base = build_int_cstu (type, chunk);
    2137          100 :       n = wide_int_to_tree (type, wi::to_wide (cst));
    2138              : 
    2139          100 :       if (sign < 0)
    2140              :         {
    2141            0 :           write_char ('n');
    2142            0 :           n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
    2143              :         }
    2144          300 :       do
    2145              :         {
    2146          300 :           tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
    2147          300 :           tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
    2148          300 :           unsigned c;
    2149              : 
    2150          300 :           done = integer_zerop (d);
    2151          300 :           tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
    2152          400 :           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
    2153              :                               done ? 1 : chunk_digits);
    2154          300 :           ptr -= c;
    2155          300 :           count += c;
    2156          300 :           n = d;
    2157              :         }
    2158          300 :       while (!done);
    2159          100 :       write_chars (ptr, count);
    2160              :     }
    2161              :   else
    2162              :     {
    2163              :       /* A small num.  */
    2164     95866762 :       if (sign < 0)
    2165       488075 :         write_char ('n');
    2166     95866762 :       write_unsigned_number (abs_value.to_uhwi ());
    2167              :     }
    2168     95866862 : }
    2169              : 
    2170              : /* Write out a floating-point literal.
    2171              : 
    2172              :     "Floating-point literals are encoded using the bit pattern of the
    2173              :     target processor's internal representation of that number, as a
    2174              :     fixed-length lowercase hexadecimal string, high-order bytes first
    2175              :     (even if the target processor would store low-order bytes first).
    2176              :     The "n" prefix is not used for floating-point literals; the sign
    2177              :     bit is encoded with the rest of the number.
    2178              : 
    2179              :     Here are some examples, assuming the IEEE standard representation
    2180              :     for floating point numbers.  (Spaces are for readability, not
    2181              :     part of the encoding.)
    2182              : 
    2183              :         1.0f                    Lf 3f80 0000 E
    2184              :        -1.0f                    Lf bf80 0000 E
    2185              :         1.17549435e-38f         Lf 0080 0000 E
    2186              :         1.40129846e-45f         Lf 0000 0001 E
    2187              :         0.0f                    Lf 0000 0000 E"
    2188              : 
    2189              :    Caller is responsible for the Lx and the E.  */
    2190              : static void
    2191         2549 : write_real_cst (const tree value)
    2192              : {
    2193         2549 :   long target_real[4];  /* largest supported float */
    2194              :   /* Buffer for eight hex digits in a 32-bit number but big enough
    2195              :      even for 64-bit long to avoid warnings.  */
    2196         2549 :   char buffer[17];
    2197         2549 :   int i, limit, dir;
    2198              : 
    2199         2549 :   tree type = TREE_TYPE (value);
    2200         2549 :   int bits = GET_MODE_BITSIZE (SCALAR_FLOAT_TYPE_MODE (type));
    2201         2549 :   int words = bits / 32;
    2202              : 
    2203         2549 :   real_to_target (target_real, &TREE_REAL_CST (value),
    2204         2549 :                   TYPE_MODE (type));
    2205              : 
    2206         2549 :   if (words == 0)
    2207              :     {
    2208              :       /* _Float16 and std::bfloat16_t are the only supported types smaller than
    2209              :          32 bits.  */
    2210          382 :       gcc_assert (bits == 16);
    2211          382 :       sprintf (buffer, "%04lx", (unsigned long) target_real[0]);
    2212          382 :       write_chars (buffer, 4);
    2213          382 :       return;
    2214              :     }
    2215              : 
    2216         2167 :   gcc_assert (bits % 32 == 0);
    2217              : 
    2218              :   /* The value in target_real is in the target word order,
    2219              :      so we must write it out backward if that happens to be
    2220              :      little-endian.  write_number cannot be used, it will
    2221              :      produce uppercase.  */
    2222         2167 :   if (FLOAT_WORDS_BIG_ENDIAN)
    2223              :     i = 0, limit = words, dir = 1;
    2224              :   else
    2225         2167 :     i = words - 1, limit = -1, dir = -1;
    2226              : 
    2227         2195 :   if (GET_MODE_PRECISION (SCALAR_FLOAT_TYPE_MODE (type)) == 80
    2228         2167 :       && abi_check (21))
    2229              :     {
    2230              :       /* For -fabi-version=21 and above mangle
    2231              :          Intel/Motorola extended format 1.0L as
    2232              :          3fff8000000000000000
    2233              :          rather than the previous
    2234              :          0000000000003fff8000000000000000 (x86_64)
    2235              :          00003fff8000000000000000 (ia32)
    2236              :          3fff00008000000000000000 (m68k -mc68020)
    2237              :          i.e. without any embedded padding bits.  */
    2238           30 :       if (words == 4)
    2239              :         i += dir;
    2240              :       else
    2241            0 :         gcc_assert (words == 3);
    2242           30 :       unsigned long val = (unsigned long) target_real[i];
    2243           30 :       if (REAL_MODE_FORMAT (SCALAR_FLOAT_TYPE_MODE (type))->signbit_ro == 95)
    2244            0 :         val >>= 16;
    2245           30 :       sprintf (buffer, "%04lx", val);
    2246           30 :       write_chars (buffer, 4);
    2247           30 :       i += dir;
    2248              :     }
    2249              : 
    2250         6033 :   for (; i != limit; i += dir)
    2251              :     {
    2252         3866 :       sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
    2253         3866 :       write_chars (buffer, 8);
    2254              :     }
    2255              : }
    2256              : 
    2257              : /* Non-terminal <identifier>.
    2258              : 
    2259              :      <identifier> ::= </unqualified source code identifier>  */
    2260              : 
    2261              : static void
    2262    752624120 : write_identifier (const char *identifier)
    2263              : {
    2264    752624120 :   MANGLE_TRACE ("identifier", identifier);
    2265    752624120 :   write_string (identifier);
    2266    752624120 : }
    2267              : 
    2268              : /* Handle constructor productions of non-terminal <special-name>.
    2269              :    CTOR is a constructor FUNCTION_DECL.
    2270              : 
    2271              :      <special-name> ::= C1   # complete object constructor
    2272              :                     ::= C2   # base object constructor
    2273              :                     ::= C3   # complete object allocating constructor
    2274              : 
    2275              :    Currently, allocating constructors are never used.  */
    2276              : 
    2277              : static void
    2278     30461952 : write_special_name_constructor (const tree ctor)
    2279              : {
    2280     30461952 :   write_char ('C');
    2281     30461952 :   bool new_inh = (flag_new_inheriting_ctors
    2282     60908177 :                   && DECL_INHERITED_CTOR (ctor));
    2283       161772 :   if (new_inh)
    2284       161772 :     write_char ('I');
    2285     30461952 :   if (DECL_BASE_CONSTRUCTOR_P (ctor))
    2286      6285297 :     write_char ('2');
    2287              :   /* This is the old-style "[unified]" constructor.
    2288              :      In some cases, we may emit this function and call
    2289              :      it from the clones in order to share code and save space.  */
    2290     24176655 :   else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
    2291     17894449 :     write_char ('4');
    2292              :   else
    2293              :     {
    2294      6282206 :       gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor));
    2295      6282206 :       write_char ('1');
    2296              :     }
    2297     30461952 :   if (new_inh)
    2298       323544 :     write_type (DECL_INHERITED_CTOR_BASE (ctor));
    2299     30461952 : }
    2300              : 
    2301              : /* Handle destructor productions of non-terminal <special-name>.
    2302              :    DTOR is a destructor FUNCTION_DECL.
    2303              : 
    2304              :      <special-name> ::= D0 # deleting (in-charge) destructor
    2305              :                     ::= D1 # complete object (in-charge) destructor
    2306              :                     ::= D2 # base object (not-in-charge) destructor  */
    2307              : 
    2308              : static void
    2309      7357084 : write_special_name_destructor (const tree dtor)
    2310              : {
    2311      7357084 :   if (DECL_DELETING_DESTRUCTOR_P (dtor))
    2312       620050 :     write_string ("D0");
    2313      6737034 :   else if (DECL_BASE_DESTRUCTOR_P (dtor))
    2314      1606011 :     write_string ("D2");
    2315      5131023 :   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
    2316              :     /* This is the old-style "[unified]" destructor.
    2317              :        In some cases, we may emit this function and call
    2318              :        it from the clones in order to share code and save space.  */
    2319      2929516 :     write_string ("D4");
    2320              :   else
    2321              :     {
    2322      2201507 :       gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor));
    2323      2201507 :       write_string ("D1");
    2324              :     }
    2325      7357084 : }
    2326              : 
    2327              : /* Return the discriminator for ENTITY appearing inside
    2328              :    FUNCTION.  The discriminator is the lexical ordinal of VAR or TYPE among
    2329              :    entities with the same name and kind in the same FUNCTION.  */
    2330              : 
    2331              : static int
    2332      2784914 : discriminator_for_local_entity (tree entity)
    2333              : {
    2334      2784914 :   if (!DECL_LANG_SPECIFIC (entity))
    2335              :     {
    2336              :       /* Some decls, like __FUNCTION__, don't need a discriminator.  */
    2337        32156 :       gcc_checking_assert (DECL_ARTIFICIAL (entity));
    2338              :       return 0;
    2339              :     }
    2340      5360782 :   else if (tree disc = DECL_DISCRIMINATOR (entity))
    2341          511 :     return TREE_INT_CST_LOW (disc);
    2342              :   else
    2343              :     /* The first entity with a particular name doesn't get
    2344              :        DECL_DISCRIMINATOR set up.  */
    2345              :     return 0;
    2346              : }
    2347              : 
    2348              : /* Return the discriminator for STRING, a string literal used inside
    2349              :    FUNCTION.  The discriminator is the lexical ordinal of STRING among
    2350              :    string literals used in FUNCTION.  */
    2351              : 
    2352              : static int
    2353            0 : discriminator_for_string_literal (tree /*function*/,
    2354              :                                   tree /*string*/)
    2355              : {
    2356              :   /* For now, we don't discriminate amongst string literals.  */
    2357            0 :   return 0;
    2358              : }
    2359              : 
    2360              : /*   <discriminator> := _ <number>    # when number < 10
    2361              :                      := __ <number> _ # when number >= 10
    2362              : 
    2363              :    The discriminator is used only for the second and later occurrences
    2364              :    of the same name within a single function. In this case <number> is
    2365              :    n - 2, if this is the nth occurrence, in lexical order.  */
    2366              : 
    2367              : static void
    2368      2784556 : write_discriminator (const int discriminator)
    2369              : {
    2370              :   /* If discriminator is zero, don't write anything.  Otherwise...  */
    2371      2784556 :   if (discriminator > 0)
    2372              :     {
    2373          478 :       write_char ('_');
    2374          478 :       if (discriminator - 1 >= 10)
    2375              :         {
    2376            6 :           if (abi_check (11))
    2377            6 :             write_char ('_');
    2378              :         }
    2379          478 :       write_unsigned_number (discriminator - 1);
    2380          478 :       if (abi_version_at_least (11) && discriminator - 1 >= 10)
    2381            6 :         write_char ('_');
    2382              :     }
    2383      2784556 : }
    2384              : 
    2385              : /* Mangle the name of a function-scope entity.  FUNCTION is the
    2386              :    FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
    2387              :    default argument scope.  ENTITY is the decl for the entity itself.
    2388              :    LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
    2389              :    either ENTITY itself or an enclosing scope of ENTITY.
    2390              : 
    2391              :      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
    2392              :                   := Z <function encoding> E s [<discriminator>]
    2393              :                   := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
    2394              : 
    2395              : static void
    2396      5063933 : write_local_name (tree function, const tree local_entity,
    2397              :                   const tree entity)
    2398              : {
    2399      5063933 :   tree parm = NULL_TREE;
    2400              : 
    2401      5063933 :   MANGLE_TRACE_TREE ("local-name", entity);
    2402              : 
    2403      5063933 :   if (TREE_CODE (function) == PARM_DECL)
    2404              :     {
    2405          366 :       parm = function;
    2406          366 :       function = DECL_CONTEXT (parm);
    2407              :     }
    2408              : 
    2409      5063933 :   write_char ('Z');
    2410      5063933 :   write_encoding (function);
    2411      5063933 :   write_char ('E');
    2412              : 
    2413              :   /* For this purpose, parameters are numbered from right-to-left.  */
    2414      5063933 :   if (parm)
    2415              :     {
    2416          366 :       int i = list_length (parm);
    2417          366 :       write_char ('d');
    2418          366 :       write_compact_number (i - 1);
    2419              :     }
    2420              : 
    2421      5063933 :   if (TREE_CODE (entity) == STRING_CST)
    2422              :     {
    2423            0 :       write_char ('s');
    2424            0 :       write_discriminator (discriminator_for_string_literal (function,
    2425              :                                                              entity));
    2426              :     }
    2427              :   else
    2428              :     {
    2429              :       /* Now the <entity name>.  Let write_name know its being called
    2430              :          from <local-name>, so it doesn't try to process the enclosing
    2431              :          function scope again.  */
    2432      5063933 :       write_name (entity, /*ignore_local_scope=*/true);
    2433      5063933 :       if (DECL_DISCRIMINATOR_P (local_entity)
    2434     15014236 :           && !(TREE_CODE (local_entity) == TYPE_DECL
    2435     14660523 :                && TYPE_ANON_P (TREE_TYPE (local_entity))))
    2436      2784287 :         write_discriminator (discriminator_for_local_entity (local_entity));
    2437              :     }
    2438      5063933 : }
    2439              : 
    2440              : /* Non-terminals <type> and <CV-qualifier>.
    2441              : 
    2442              :      <type> ::= <builtin-type>
    2443              :             ::= <function-type>
    2444              :             ::= <class-enum-type>
    2445              :             ::= <array-type>
    2446              :             ::= <pointer-to-member-type>
    2447              :             ::= <template-param>
    2448              :             ::= <substitution>
    2449              :             ::= <CV-qualifier>
    2450              :             ::= P <type>    # pointer-to
    2451              :             ::= R <type>    # reference-to
    2452              :             ::= C <type>    # complex pair (C 2000)
    2453              :             ::= G <type>    # imaginary (C 2000)     [not supported]
    2454              :             ::= U <source-name> <type>   # vendor extended type qualifier
    2455              : 
    2456              :    C++11 extensions
    2457              : 
    2458              :      <type> ::= RR <type>   # rvalue reference-to
    2459              :      <type> ::= Dt <expression> # decltype of an id-expression or
    2460              :                                 # class member access
    2461              :      <type> ::= DT <expression> # decltype of an expression
    2462              :      <type> ::= Dn              # decltype of nullptr
    2463              :      <type> ::= Dm                # decltype of ^^int
    2464              :      <type> ::= <splice>    # C++26 dependent splice [proposed]
    2465              : 
    2466              :    TYPE is a type node.  */
    2467              : 
    2468              : static void
    2469   1284481278 : write_type (tree type)
    2470              : {
    2471              :   /* This gets set to nonzero if TYPE turns out to be a (possibly
    2472              :      CV-qualified) builtin type.  */
    2473   1284481287 :   int is_builtin_type = 0;
    2474              : 
    2475   1284481287 :   MANGLE_TRACE_TREE ("type", type);
    2476              : 
    2477   1284481287 :   if (type == error_mark_node)
    2478              :     return;
    2479              : 
    2480   1284481272 :   type = canonicalize_for_substitution (type);
    2481   1284481272 :   if (find_substitution (type))
    2482              :     return;
    2483              : 
    2484              : 
    2485   1172060397 :   if (write_CV_qualifiers_for_type (type) > 0)
    2486              :     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
    2487              :        mangle the unqualified type.  The recursive call is needed here
    2488              :        since both the qualified and unqualified types are substitution
    2489              :        candidates.  */
    2490              :     {
    2491     82651794 :       tree t = TYPE_MAIN_VARIANT (type);
    2492     82651794 :       if (TYPE_ATTRIBUTES (t) && !OVERLOAD_TYPE_P (t))
    2493              :         {
    2494           99 :           tree attrs = NULL_TREE;
    2495           99 :           if (tx_safe_fn_type_p (type))
    2496            3 :             attrs = tree_cons (get_identifier ("transaction_safe"),
    2497              :                                NULL_TREE, attrs);
    2498           99 :           t = cp_build_type_attribute_variant (t, attrs);
    2499              :         }
    2500     82651794 :       gcc_assert (t != type);
    2501     82651794 :       if (FUNC_OR_METHOD_TYPE_P (t))
    2502              :         {
    2503         6725 :           t = build_ref_qualified_type (t, type_memfn_rqual (type));
    2504         6725 :           if (flag_noexcept_type)
    2505              :             {
    2506         6704 :               tree r = TYPE_RAISES_EXCEPTIONS (type);
    2507         6704 :               t = build_exception_variant (t, r);
    2508              :             }
    2509         6725 :           if (abi_version_at_least (8)
    2510         6749 :               || type == TYPE_MAIN_VARIANT (type))
    2511              :             /* Avoid adding the unqualified function type as a substitution.  */
    2512         6701 :             write_function_type (t);
    2513              :           else
    2514           24 :             write_type (t);
    2515        33508 :           if (abi_warn_or_compat_version_crosses (8))
    2516           39 :             G.need_abi_warning = 1;
    2517              :         }
    2518              :       else
    2519     82645069 :         write_type (t);
    2520              :     }
    2521   1089408603 :   else if (TREE_CODE (type) == ARRAY_TYPE)
    2522              :     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
    2523              :        so that the cv-qualification of the element type is available
    2524              :        in write_array_type.  */
    2525      1568769 :     write_array_type (type);
    2526              :   else
    2527              :     {
    2528   1087839834 :       tree type_orig = type;
    2529              : 
    2530              :       /* See through any typedefs.  */
    2531   1087839834 :       type = TYPE_MAIN_VARIANT (type);
    2532   1087839834 :       if (FUNC_OR_METHOD_TYPE_P (type))
    2533      3244567 :         type = cxx_copy_lang_qualifiers (type, type_orig);
    2534              : 
    2535              :       /* According to the C++ ABI, some library classes are passed the
    2536              :          same as the scalar type of their single member and use the same
    2537              :          mangling.  */
    2538   1087839834 :       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
    2539        16206 :         type = TREE_TYPE (first_field (type));
    2540              : 
    2541   1087839834 :       if (TYPE_PTRDATAMEM_P (type))
    2542        17088 :         write_pointer_to_member_type (type);
    2543              :       else
    2544              :         {
    2545              :           /* Handle any target-specific fundamental types.  */
    2546   1087822746 :           const char *target_mangling
    2547   1087822746 :             = targetm.mangle_type (type_orig);
    2548              : 
    2549   1087822746 :           if (target_mangling)
    2550              :             {
    2551      9757192 :               write_string (target_mangling);
    2552              :               /* Add substitutions for types other than fundamental
    2553              :                  types.  */
    2554      9757192 :               if (!VOID_TYPE_P (type)
    2555              :                   && TREE_CODE (type) != INTEGER_TYPE
    2556              :                   && TREE_CODE (type) != REAL_TYPE
    2557              :                   && TREE_CODE (type) != BOOLEAN_TYPE)
    2558            0 :                 add_substitution (type);
    2559              :               return;
    2560              :             }
    2561              : 
    2562   1078065554 :           switch (TREE_CODE (type))
    2563              :             {
    2564    579873976 :             case VOID_TYPE:
    2565    579873976 :             case BOOLEAN_TYPE:
    2566    579873976 :             case INTEGER_TYPE:  /* Includes wchar_t.  */
    2567    579873976 :             case REAL_TYPE:
    2568    579873976 :             case FIXED_POINT_TYPE:
    2569    579873976 :               {
    2570              :                 /* If this is a typedef, TYPE may not be one of
    2571              :                    the standard builtin type nodes, but an alias of one.  Use
    2572              :                    TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
    2573    579873976 :                 write_builtin_type (TYPE_MAIN_VARIANT (type));
    2574    579873976 :                 ++is_builtin_type;
    2575              :               }
    2576    579873976 :               break;
    2577              : 
    2578       687031 :             case COMPLEX_TYPE:
    2579       687031 :               write_char ('C');
    2580       687031 :               write_type (TREE_TYPE (type));
    2581       687031 :               break;
    2582              : 
    2583      3244567 :             case FUNCTION_TYPE:
    2584      3244567 :             case METHOD_TYPE:
    2585      3244567 :               write_function_type (type);
    2586      3244567 :               break;
    2587              : 
    2588    323852700 :             case UNION_TYPE:
    2589    323852700 :             case RECORD_TYPE:
    2590    323852700 :             case ENUMERAL_TYPE:
    2591              :               /* A pointer-to-member function is represented as a special
    2592              :                  RECORD_TYPE, so check for this first.  */
    2593    323852700 :               if (TYPE_PTRMEMFUNC_P (type))
    2594       266877 :                 write_pointer_to_member_type (type);
    2595              :               else
    2596    323585823 :                 write_class_enum_type (type);
    2597              :               break;
    2598              : 
    2599      2701029 :             case TYPENAME_TYPE:
    2600      2701029 :             case UNBOUND_CLASS_TEMPLATE:
    2601              :               /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
    2602              :                  ordinary nested names.  */
    2603      2701029 :               write_nested_name (TYPE_STUB_DECL (type));
    2604      2701029 :               break;
    2605              : 
    2606    133718693 :             case POINTER_TYPE:
    2607    133718693 :             case REFERENCE_TYPE:
    2608    133718693 :               if (TYPE_PTR_P (type))
    2609     57347276 :                 write_char ('P');
    2610     76371417 :               else if (TYPE_REF_IS_RVALUE (type))
    2611     12848989 :                 write_char ('O');
    2612              :               else
    2613     63522428 :                 write_char ('R');
    2614    133718693 :               {
    2615    133718693 :                 tree target = TREE_TYPE (type);
    2616              :                 /* Attribute const/noreturn are not reflected in mangling.
    2617              :                    We strip them here rather than at a lower level because
    2618              :                    a typedef or template argument can have function type
    2619              :                    with function-cv-quals (that use the same representation),
    2620              :                    but you can't have a pointer/reference to such a type.  */
    2621    133718693 :                 if (TREE_CODE (target) == FUNCTION_TYPE)
    2622              :                   {
    2623     11078970 :                     if (abi_warn_or_compat_version_crosses (5)
    2624      2216148 :                         && TYPE_QUALS (target) != TYPE_UNQUALIFIED)
    2625            3 :                       G.need_abi_warning = 1;
    2626      2216142 :                     if (abi_version_at_least (5))
    2627      2215713 :                       target = build_qualified_type (target, TYPE_UNQUALIFIED);
    2628              :                   }
    2629    133718693 :                 write_type (target);
    2630              :               }
    2631    133718693 :               break;
    2632              : 
    2633     29068007 :             case TEMPLATE_TYPE_PARM:
    2634     29068007 :               if (is_auto (type))
    2635              :                 {
    2636       877996 :                   if (template_placeholder_p (type)
    2637       877996 :                       && abi_check (19))
    2638              :                     {
    2639              :                       /* ABI #109: placeholder is mangled as its template.  */
    2640           33 :                       type = CLASS_PLACEHOLDER_TEMPLATE (type);
    2641           33 :                       if (find_substitution (type))
    2642              :                         return;
    2643           33 :                       write_name (type);
    2644           33 :                       break;
    2645              :                     }
    2646       877963 :                   if (AUTO_IS_DECLTYPE (type))
    2647        22907 :                     write_identifier ("Dc");
    2648              :                   else
    2649       855056 :                     write_identifier ("Da");
    2650              :                   ++is_builtin_type;
    2651              :                   break;
    2652              :                 }
    2653              :               /* fall through.  */
    2654     28190011 :             case TEMPLATE_PARM_INDEX:
    2655     28190011 :               write_template_param (type);
    2656     28190011 :               break;
    2657              : 
    2658           93 :             case TEMPLATE_TEMPLATE_PARM:
    2659           93 :               write_template_template_param (type);
    2660           93 :               break;
    2661              : 
    2662          536 :             case BOUND_TEMPLATE_TEMPLATE_PARM:
    2663          536 :               write_template_template_param (type);
    2664          536 :               write_template_args
    2665          536 :                 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
    2666          536 :               break;
    2667              : 
    2668        35177 :             case VECTOR_TYPE:
    2669        35177 :               if (abi_version_at_least (4))
    2670              :                 {
    2671        35162 :                   write_string ("Dv");
    2672              :                   /* Non-constant vector size would be encoded with
    2673              :                      _ expression, but we don't support that yet.  */
    2674        35162 :                   write_unsigned_number (TYPE_VECTOR_SUBPARTS (type)
    2675              :                                          .to_constant ());
    2676        35162 :                   write_char ('_');
    2677        35162 :                 }
    2678              :               else
    2679           15 :                 write_string ("U8__vector");
    2680       175840 :               if (abi_warn_or_compat_version_crosses (4))
    2681           15 :                 G.need_abi_warning = 1;
    2682        35177 :               write_type (TREE_TYPE (type));
    2683        35177 :               break;
    2684              : 
    2685      3408618 :             case TYPE_PACK_EXPANSION:
    2686      3408618 :               write_string ("Dp");
    2687      3408618 :               write_type (PACK_EXPANSION_PATTERN (type));
    2688      3408618 :               break;
    2689              : 
    2690       450273 :             case DECLTYPE_TYPE:
    2691              :               /* These shouldn't make it into mangling.  */
    2692       450273 :               gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
    2693              :                           && !DECLTYPE_FOR_LAMBDA_PROXY (type));
    2694              : 
    2695              :               /* In ABI <5, we stripped decltype of a plain decl.  */
    2696       450273 :               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
    2697              :                 {
    2698          555 :                   tree expr = DECLTYPE_TYPE_EXPR (type);
    2699          555 :                   tree etype = NULL_TREE;
    2700          555 :                   switch (TREE_CODE (expr))
    2701              :                     {
    2702          119 :                     case VAR_DECL:
    2703          119 :                     case PARM_DECL:
    2704          119 :                     case RESULT_DECL:
    2705          119 :                     case FUNCTION_DECL:
    2706          119 :                     case CONST_DECL:
    2707          119 :                     case TEMPLATE_PARM_INDEX:
    2708          119 :                       etype = TREE_TYPE (expr);
    2709          119 :                       break;
    2710              : 
    2711              :                     default:
    2712              :                       break;
    2713              :                     }
    2714              : 
    2715          119 :                   if (etype && !type_uses_auto (etype))
    2716              :                     {
    2717          117 :                       if (!abi_check (5))
    2718              :                         {
    2719              :                           write_type (etype);
    2720              :                           return;
    2721              :                         }
    2722              :                     }
    2723              :                 }
    2724              : 
    2725       450264 :               write_char ('D');
    2726       450264 :               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
    2727          546 :                 write_char ('t');
    2728              :               else
    2729       449718 :                 write_char ('T');
    2730       450264 :               ++cp_unevaluated_operand;
    2731       450264 :               write_expression (DECLTYPE_TYPE_EXPR (type));
    2732       450264 :               --cp_unevaluated_operand;
    2733       450264 :               write_char ('E');
    2734       450264 :               break;
    2735              : 
    2736       797203 :             case NULLPTR_TYPE:
    2737       797203 :               write_string ("Dn");
    2738       797203 :               if (abi_check (7))
    2739              :                 ++is_builtin_type;
    2740              :               break;
    2741              : 
    2742           48 :             case SPLICE_SCOPE:
    2743           48 :               write_splice (type);
    2744           48 :               break;
    2745              : 
    2746            3 :             case TYPEOF_TYPE:
    2747            3 :               sorry ("mangling %<typeof%>, use %<decltype%> instead");
    2748            3 :               break;
    2749              : 
    2750           21 :             case TRAIT_TYPE:
    2751           21 :               error ("use of built-in trait %qT in function signature; "
    2752              :                      "use library traits instead", type);
    2753           21 :               break;
    2754              : 
    2755           29 :             case PACK_INDEX_TYPE:
    2756              :               /* https://github.com/itanium-cxx-abi/cxx-abi/issues/175.  */
    2757           29 :               write_string ("Dy");
    2758           29 :               if (TREE_CODE (PACK_INDEX_PACK (type)) == TREE_VEC)
    2759              :                 {
    2760            6 :                   write_char ('J');
    2761           40 :                   for (int i = 0; i < TREE_VEC_LENGTH (PACK_INDEX_PACK (type));
    2762              :                        ++i)
    2763           14 :                     write_template_arg (TREE_VEC_ELT (PACK_INDEX_PACK (type),
    2764              :                                                       i));
    2765            6 :                   write_char ('E');
    2766              :                 }
    2767              :               else
    2768              :                 /* Dy rather than DyDp.  */
    2769           23 :                 write_type (PACK_EXPANSION_PATTERN (PACK_INDEX_PACK (type)));
    2770           29 :               write_expression (PACK_INDEX_INDEX (type));
    2771           29 :               break;
    2772              : 
    2773       227550 :             case OPAQUE_TYPE:
    2774       227550 :               if (REFLECTION_TYPE_P (type))
    2775              :                 {
    2776       227550 :                   write_string ("Dm");
    2777       227550 :                   ++is_builtin_type;
    2778       227550 :                   break;
    2779              :                 }
    2780              :               /* fall through.  */
    2781              : 
    2782            0 :             default:
    2783            0 :               gcc_unreachable ();
    2784              :             }
    2785              :         }
    2786              :     }
    2787              : 
    2788              :   /* Types other than builtin types are substitution candidates.  */
    2789   1161499307 :   if (!is_builtin_type)
    2790    580526506 :     add_substitution (type);
    2791              : }
    2792              : 
    2793              : /* qsort callback for sorting a vector of attribute entries.  */
    2794              : 
    2795              : static int
    2796            0 : attr_strcmp (const void *p1, const void *p2)
    2797              : {
    2798            0 :   tree a1 = *(const tree*)p1;
    2799            0 :   tree a2 = *(const tree*)p2;
    2800              : 
    2801            0 :   const attribute_spec *as1 = lookup_attribute_spec (get_attribute_name (a1));
    2802            0 :   const attribute_spec *as2 = lookup_attribute_spec (get_attribute_name (a2));
    2803              : 
    2804            0 :   return strcmp (as1->name, as2->name);
    2805              : }
    2806              : 
    2807              : /* Return true if we should mangle a type attribute with name NAME.  */
    2808              : 
    2809              : static bool
    2810        12128 : mangle_type_attribute_p (tree name)
    2811              : {
    2812        12128 :   const attribute_spec *as = lookup_attribute_spec (name);
    2813        12128 :   if (!as || !as->affects_type_identity)
    2814              :     return false;
    2815              : 
    2816              :   /* Skip internal-only attributes, which are distinguished from others
    2817              :      by having a space.  At present, all internal-only attributes that
    2818              :      affect type identity are target-specific and are handled by
    2819              :      targetm.mangle_type instead.
    2820              : 
    2821              :      Another reason to do this is that a space isn't a valid identifier
    2822              :      character for most file formats.  */
    2823           57 :   if (strchr (IDENTIFIER_POINTER (name), ' '))
    2824              :     return false;
    2825              : 
    2826              :   /* The following attributes are mangled specially.  */
    2827           57 :   if (is_attribute_p ("transaction_safe", name))
    2828              :     return false;
    2829           33 :   if (is_attribute_p ("abi_tag", name))
    2830            0 :     return false;
    2831              : 
    2832              :   return true;
    2833              : }
    2834              : 
    2835              : /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
    2836              :    CV-qualifiers written for TYPE.
    2837              : 
    2838              :      <CV-qualifiers> ::= [r] [V] [K]  */
    2839              : 
    2840              : static int
    2841   1172327274 : write_CV_qualifiers_for_type (const tree type)
    2842              : {
    2843   1172327274 :   int num_qualifiers = 0;
    2844              : 
    2845              :   /* The order is specified by:
    2846              : 
    2847              :        "In cases where multiple order-insensitive qualifiers are
    2848              :        present, they should be ordered 'K' (closest to the base type),
    2849              :        'V', 'r', and 'U' (farthest from the base type) ..."  */
    2850              : 
    2851              :   /* Mangle attributes that affect type identity as extended qualifiers.
    2852              : 
    2853              :      We don't do this with classes and enums because their attributes
    2854              :      are part of their definitions, not something added on.  */
    2855              : 
    2856   1172327274 :   if (!OVERLOAD_TYPE_P (type))
    2857              :     {
    2858    813380524 :       auto_vec<tree> vec;
    2859    813392652 :       for (tree a = TYPE_ATTRIBUTES (type); a; a = TREE_CHAIN (a))
    2860        12128 :         if (mangle_type_attribute_p (get_attribute_name (a)))
    2861           33 :           vec.safe_push (a);
    2862   4066142397 :       if (abi_warn_or_compat_version_crosses (10) && !vec.is_empty ())
    2863            0 :         G.need_abi_warning = true;
    2864    813380524 :       if (abi_version_at_least (10))
    2865              :         {
    2866    813131867 :           vec.qsort (attr_strcmp);
    2867    813380590 :           while (!vec.is_empty())
    2868              :             {
    2869           33 :               tree a = vec.pop();
    2870           33 :               const attribute_spec *as
    2871           33 :                 = lookup_attribute_spec (get_attribute_name (a));
    2872              : 
    2873           33 :               write_char ('U');
    2874           33 :               write_unsigned_number (strlen (as->name));
    2875           33 :               write_string (as->name);
    2876           33 :               if (TREE_VALUE (a))
    2877              :                 {
    2878            3 :                   write_char ('I');
    2879            6 :                   for (tree args = TREE_VALUE (a); args;
    2880            3 :                        args = TREE_CHAIN (args))
    2881              :                     {
    2882            3 :                       tree arg = TREE_VALUE (args);
    2883            3 :                       write_template_arg (arg);
    2884              :                     }
    2885            3 :                   write_char ('E');
    2886              :                 }
    2887              : 
    2888           33 :               ++num_qualifiers;
    2889              :             }
    2890              :         }
    2891    813380524 :     }
    2892              : 
    2893              :   /* Note that we do not use cp_type_quals below; given "const
    2894              :      int[3]", the "const" is emitted with the "int", not with the
    2895              :      array.  */
    2896   1172327274 :   cv_qualifier quals;
    2897   1172327274 :   addr_space_t as;
    2898   1172327274 :   std::tie (quals, as) = TYPE_QUALS (type).split ();
    2899              : 
    2900              :   /* No address space support yet.  */
    2901   1172327274 :   gcc_checking_assert (ADDR_SPACE_GENERIC_P (as));
    2902              : 
    2903   1172327274 :   if (quals & TYPE_QUAL_RESTRICT)
    2904              :     {
    2905           43 :       write_char ('r');
    2906           43 :       ++num_qualifiers;
    2907              :     }
    2908   1172327274 :   if (quals & TYPE_QUAL_VOLATILE)
    2909              :     {
    2910       540181 :       write_char ('V');
    2911       540181 :       ++num_qualifiers;
    2912              :     }
    2913   1172327274 :   if (quals & TYPE_QUAL_CONST)
    2914              :     {
    2915     82582242 :       write_char ('K');
    2916     82582242 :       ++num_qualifiers;
    2917              :     }
    2918              : 
    2919   1172327274 :   return num_qualifiers;
    2920              : }
    2921              : 
    2922              : /* Non-terminal <builtin-type>.
    2923              : 
    2924              :      <builtin-type> ::= v   # void
    2925              :                     ::= b   # bool
    2926              :                     ::= w   # wchar_t
    2927              :                     ::= c   # char
    2928              :                     ::= a   # signed char
    2929              :                     ::= h   # unsigned char
    2930              :                     ::= s   # short
    2931              :                     ::= t   # unsigned short
    2932              :                     ::= i   # int
    2933              :                     ::= j   # unsigned int
    2934              :                     ::= l   # long
    2935              :                     ::= m   # unsigned long
    2936              :                     ::= x   # long long, __int64
    2937              :                     ::= y   # unsigned long long, __int64
    2938              :                     ::= n   # __int128
    2939              :                     ::= o   # unsigned __int128
    2940              :                     ::= f   # float
    2941              :                     ::= d   # double
    2942              :                     ::= e   # long double, __float80
    2943              :                     ::= g   # __float128          [not supported]
    2944              :                     ::= u <source-name>  # vendor extended type */
    2945              : 
    2946              : static void
    2947    579873976 : write_builtin_type (tree type)
    2948              : {
    2949    579873976 :   if (TYPE_CANONICAL (type))
    2950    579873976 :     type = TYPE_CANONICAL (type);
    2951              : 
    2952    579873976 :   switch (TREE_CODE (type))
    2953              :     {
    2954     78489118 :     case VOID_TYPE:
    2955     78489118 :       write_char ('v');
    2956     78489118 :       break;
    2957              : 
    2958     49926783 :     case BOOLEAN_TYPE:
    2959     49926783 :       write_char ('b');
    2960     49926783 :       break;
    2961              : 
    2962    433080905 :     case INTEGER_TYPE:
    2963              :       /* TYPE may still be wchar_t, char8_t, char16_t, or char32_t, since that
    2964              :          isn't in integer_type_nodes.  */
    2965    433080905 :       if (type == wchar_type_node)
    2966     43349663 :         write_char ('w');
    2967    389731242 :       else if (type == char8_type_node)
    2968     22638684 :         write_string ("Du");
    2969    367092558 :       else if (type == char16_type_node)
    2970     22389183 :         write_string ("Ds");
    2971    344703375 :       else if (type == char32_type_node)
    2972     25062119 :         write_string ("Di");
    2973              :       else
    2974              :         {
    2975    319641270 :           size_t itk;
    2976              :           /* Assume TYPE is one of the shared integer type nodes.  Find
    2977              :              it in the array of these nodes.  */
    2978    319641256 :         iagain:
    2979   2032789402 :           for (itk = 0; itk < itk_none; ++itk)
    2980   2031196457 :             if (integer_types[itk] != NULL_TREE
    2981   2021638787 :                 && integer_type_codes[itk] != '\0'
    2982   2018452897 :                 && type == integer_types[itk])
    2983              :               {
    2984              :                 /* Print the corresponding single-letter code.  */
    2985    318048325 :                 write_char (integer_type_codes[itk]);
    2986    318048325 :                 break;
    2987              :               }
    2988              : 
    2989    319641270 :           if (itk == itk_none)
    2990              :             {
    2991      1592945 :               tree t = c_common_type_for_mode (TYPE_MODE (type),
    2992      1592945 :                                                TYPE_UNSIGNED (type));
    2993      1592945 :               if (type != t)
    2994              :                 {
    2995           14 :                   type = t;
    2996           14 :                   goto iagain;
    2997              :                 }
    2998              : 
    2999      1592931 :               if (TYPE_PRECISION (type) == 128)
    3000      2225071 :                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
    3001              :               else
    3002              :                 {
    3003              :                   /* Allow for cases where TYPE is not one of the shared
    3004              :                      integer type nodes and write a "vendor extended builtin
    3005              :                      type" with a name the form intN or uintN, respectively.
    3006              :                      Situations like this can happen if you have an
    3007              :                      __attribute__((__mode__(__SI__))) type and use exotic
    3008              :                      switches like '-mint8' on AVR.  Of course, this is
    3009              :                      undefined by the C++ ABI (and '-mint8' is not even
    3010              :                      Standard C conforming), but when using such special
    3011              :                      options you're pretty much in nowhere land anyway.  */
    3012            0 :                   const char *prefix;
    3013            0 :                   char prec[11];        /* up to ten digits for an unsigned */
    3014              : 
    3015            0 :                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
    3016            0 :                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
    3017            0 :                   write_char ('u');     /* "vendor extended builtin type" */
    3018            0 :                   write_unsigned_number (strlen (prefix) + strlen (prec));
    3019            0 :                   write_string (prefix);
    3020            0 :                   write_string (prec);
    3021              :                 }
    3022              :             }
    3023              :         }
    3024              :       break;
    3025              : 
    3026     18377170 :     case REAL_TYPE:
    3027     18377170 :       if (type == float_type_node)
    3028      5965793 :         write_char ('f');
    3029     12411377 :       else if (type == double_type_node)
    3030      9954408 :         write_char ('d');
    3031      2456969 :       else if (type == long_double_type_node)
    3032            0 :         write_char ('e');
    3033      2456969 :       else if (type == dfloat32_type_node)
    3034         6152 :         write_string ("Df");
    3035      2450817 :       else if (type == dfloat64_type_node)
    3036         6041 :         write_string ("Dd");
    3037      2444776 :       else if (type == dfloat128_type_node)
    3038         6008 :         write_string ("De");
    3039      2438768 :       else if (type == float16_type_node)
    3040            0 :         write_string ("DF16_");
    3041      2438768 :       else if (type == float32_type_node)
    3042       806062 :         write_string ("DF32_");
    3043      1632706 :       else if (type == float64_type_node)
    3044       807806 :         write_string ("DF64_");
    3045       824900 :       else if (type == float128_type_node)
    3046       765714 :         write_string ("DF128_");
    3047        59186 :       else if (type == float32x_type_node)
    3048        29593 :         write_string ("DF32x");
    3049        29593 :       else if (type == float64x_type_node)
    3050        29593 :         write_string ("DF64x");
    3051            0 :       else if (type == float128x_type_node)
    3052            0 :         write_string ("DF128x");
    3053            0 :       else if (type == bfloat16_type_node)
    3054            0 :         write_string ("DF16b");
    3055              :       else
    3056            0 :         gcc_unreachable ();
    3057              :       break;
    3058              : 
    3059            0 :     default:
    3060            0 :       gcc_unreachable ();
    3061              :     }
    3062    579873976 : }
    3063              : 
    3064              : /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
    3065              :    METHOD_TYPE.  The return type is mangled before the parameter
    3066              :    types.
    3067              : 
    3068              :      <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E   */
    3069              : 
    3070              : static void
    3071      3251268 : write_function_type (const tree type)
    3072              : {
    3073      3251268 :   MANGLE_TRACE_TREE ("function-type", type);
    3074              : 
    3075              :   /* For a pointer to member function, the function type may have
    3076              :      cv-qualifiers, indicating the quals for the artificial 'this'
    3077              :      parameter.  */
    3078      3251268 :   if (TREE_CODE (type) == METHOD_TYPE)
    3079              :     {
    3080              :       /* The first parameter must be a POINTER_TYPE pointing to the
    3081              :          `this' parameter.  */
    3082       266877 :       tree this_type = class_of_this_parm (type);
    3083       266877 :       write_CV_qualifiers_for_type (this_type);
    3084              :     }
    3085              : 
    3086      3251268 :   write_exception_spec (TYPE_RAISES_EXCEPTIONS (type));
    3087              : 
    3088      3251268 :   if (tx_safe_fn_type_p (type))
    3089           24 :     write_string ("Dx");
    3090              : 
    3091      3251268 :   write_char ('F');
    3092              :   /* We don't track whether or not a type is `extern "C"'.  Note that
    3093              :      you can have an `extern "C"' function that does not have
    3094              :      `extern "C"' type, and vice versa:
    3095              : 
    3096              :        extern "C" typedef void function_t();
    3097              :        function_t f; // f has C++ linkage, but its type is
    3098              :                      // `extern "C"'
    3099              : 
    3100              :        typedef void function_t();
    3101              :        extern "C" function_t f; // Vice versa.
    3102              : 
    3103              :      See [dcl.link].  */
    3104      3251268 :   write_bare_function_type (type, /*include_return_type_p=*/1,
    3105              :                             /*decl=*/NULL);
    3106      3251268 :   if (FUNCTION_REF_QUALIFIED (type))
    3107              :     {
    3108         2156 :       if (FUNCTION_RVALUE_QUALIFIED (type))
    3109          865 :         write_char ('O');
    3110              :       else
    3111         1291 :         write_char ('R');
    3112              :     }
    3113      3251268 :   write_char ('E');
    3114      3251268 : }
    3115              : 
    3116              : /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
    3117              :    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
    3118              :    is mangled before the parameter types.  If non-NULL, DECL is
    3119              :    FUNCTION_DECL for the function whose type is being emitted.  */
    3120              : 
    3121              : static void
    3122    194309109 : write_bare_function_type (const tree type, const int include_return_type_p,
    3123              :                           const tree decl)
    3124              : {
    3125    194309109 :   MANGLE_TRACE_TREE ("bare-function-type", type);
    3126              : 
    3127              :   /* Mangle the return type, if requested.  */
    3128    194309109 :   if (include_return_type_p)
    3129     17637395 :     write_type (TREE_TYPE (type));
    3130              : 
    3131              :   /* Now mangle the types of the arguments.  */
    3132    194309109 :   ++G.parm_depth;
    3133    194309109 :   write_method_parms (TYPE_ARG_TYPES (type),
    3134    194309109 :                       TREE_CODE (type) == METHOD_TYPE,
    3135              :                       decl);
    3136    194309109 :   --G.parm_depth;
    3137    194309109 : }
    3138              : 
    3139              : /* Write the mangled representation of a method parameter list of
    3140              :    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
    3141              :    considered a non-static method, and the this parameter is omitted.
    3142              :    If non-NULL, DECL is the FUNCTION_DECL for the function whose
    3143              :    parameters are being emitted.  */
    3144              : 
    3145              : static void
    3146    196660335 : write_method_parms (tree parm_types, const int method_p, const tree decl)
    3147              : {
    3148    196660335 :   tree first_parm_type;
    3149    372719583 :   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
    3150              : 
    3151              :   /* Assume this parameter type list is variable-length.  If it ends
    3152              :      with a void type, then it's not.  */
    3153    196660335 :   int varargs_p = 1;
    3154              : 
    3155              :   /* If this is a member function, skip the first arg, which is the
    3156              :      this pointer.
    3157              :        "Member functions do not encode the type of their implicit this
    3158              :        parameter."
    3159              : 
    3160              :      Similarly, there's no need to mangle artificial parameters, like
    3161              :      the VTT parameters for constructors and destructors.  */
    3162    196660335 :   if (method_p)
    3163              :     {
    3164    153333281 :       parm_types = TREE_CHAIN (parm_types);
    3165    153333281 :       parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
    3166              : 
    3167    153374277 :       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
    3168              :         {
    3169        40996 :           parm_types = TREE_CHAIN (parm_types);
    3170        40996 :           parm_decl = DECL_CHAIN (parm_decl);
    3171              :         }
    3172              : 
    3173    153333281 :       if (decl && ctor_omit_inherited_parms (decl))
    3174              :         /* Bring back parameters omitted from an inherited ctor.  */
    3175           54 :         parm_types = FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (decl));
    3176              :     }
    3177              : 
    3178    196660335 :   for (first_parm_type = parm_types;
    3179    614639247 :        parm_types;
    3180    417978912 :        parm_types = TREE_CHAIN (parm_types))
    3181              :     {
    3182    417978912 :       tree parm = TREE_VALUE (parm_types);
    3183    417978912 :       if (parm == void_type_node)
    3184              :         {
    3185              :           /* "Empty parameter lists, whether declared as () or
    3186              :              conventionally as (void), are encoded with a void parameter
    3187              :              (v)."  */
    3188    196616015 :           if (parm_types == first_parm_type)
    3189     65929259 :             write_type (parm);
    3190              :           /* If the parm list is terminated with a void type, it's
    3191              :              fixed-length.  */
    3192    196616015 :           varargs_p = 0;
    3193              :           /* A void type better be the last one.  */
    3194    196616015 :           gcc_assert (TREE_CHAIN (parm_types) == NULL);
    3195              :         }
    3196              :       else
    3197    221362897 :         write_type (parm);
    3198              :     }
    3199              : 
    3200    196660335 :   if (varargs_p)
    3201              :     /* <builtin-type> ::= z  # ellipsis  */
    3202        44320 :     write_char ('z');
    3203    196660335 : }
    3204              : 
    3205              : /* <class-enum-type> ::= <name>  */
    3206              : 
    3207              : static void
    3208    323585823 : write_class_enum_type (const tree type)
    3209              : {
    3210    323585823 :   write_name (TYPE_NAME (type));
    3211    323585823 : }
    3212              : 
    3213              : /* Mangle a requirement REQ in a requires-expression.  */
    3214              : 
    3215              : static void
    3216       556482 : write_requirement (tree req)
    3217              : {
    3218       556482 :   tree op = TREE_OPERAND (req, 0);
    3219              : 
    3220       556482 :   switch (tree_code code = TREE_CODE (req))
    3221              :     {
    3222              :       /* # simple-requirement or compound-requirement
    3223              :          <requirement> ::= X <expression> [ N ] [ R <type-constraint> ]
    3224              :                            X <expression> C <expression>
    3225              :                              [ R <type-constraint> ]  */
    3226       556049 :     case SIMPLE_REQ:
    3227       556049 :     case COMPOUND_REQ:
    3228       556049 :       write_char ('X');
    3229       556049 :       write_expression (op);
    3230       556049 :       if (code == SIMPLE_REQ)
    3231              :         break;
    3232       107919 :       if (operand_equal_p (TREE_OPERAND (req, 2), boolean_true_node))
    3233           15 :         write_char ('N');
    3234       107904 :       else if (TREE_OPERAND (req, 2) != error_mark_node
    3235       107904 :                && !operand_equal_p (TREE_OPERAND (req, 2), boolean_false_node))
    3236              :         {
    3237            6 :           write_char ('C');
    3238            6 :           write_expression (TREE_OPERAND (req, 2));
    3239              :         }
    3240       107919 :       if (tree constr = TREE_OPERAND (req, 1))
    3241              :         {
    3242       107904 :           write_char ('R');
    3243       107904 :           write_type_constraint (PLACEHOLDER_TYPE_CONSTRAINTS (constr));
    3244              :         }
    3245              :       break;
    3246              : 
    3247              :       /* <requirement> ::= T <type> # type-requirement */
    3248          427 :     case TYPE_REQ:
    3249          427 :       write_char ('T');
    3250          427 :       write_type (op);
    3251          427 :       break;
    3252              : 
    3253              :       /* <requirement> ::= Q <constraint-expression> # nested-requirement */
    3254            6 :     case NESTED_REQ:
    3255            6 :       write_char ('Q');
    3256            6 :       write_constraint_expression (op);
    3257            6 :       break;
    3258              : 
    3259            0 :     default:
    3260            0 :       gcc_unreachable ();
    3261              :     }
    3262       556482 : }
    3263              : 
    3264              : /* # requires { ... }
    3265              :    <expression> ::= rq <requirement>+ E
    3266              :    # requires (...) { ... }
    3267              :    <expression> ::= rQ <bare-function-type> _ <requirement>+ E */
    3268              : 
    3269              : static void
    3270       528682 : write_requires_expr (tree expr)
    3271              : {
    3272       528682 :   tree parms = REQUIRES_EXPR_PARMS (expr);
    3273       528682 :   if (parms)
    3274              :     {
    3275        91190 :       write_string ("rQ");
    3276        91190 :       ++G.parm_depth;
    3277       182829 :       for (; parms; parms = DECL_CHAIN (parms))
    3278        91639 :         write_type (cv_unqualified (TREE_TYPE (parms)));
    3279        91190 :       --G.parm_depth;
    3280        91190 :       write_char ('_');
    3281              :     }
    3282              :   else
    3283       437492 :     write_string ("rq");
    3284              : 
    3285      1085164 :   for (tree reqs = REQUIRES_EXPR_REQS (expr); reqs;
    3286       556482 :        reqs = TREE_CHAIN (reqs))
    3287       556482 :     write_requirement (TREE_VALUE (reqs));
    3288              : 
    3289       528682 :   write_char ('E');
    3290       528682 : }
    3291              : 
    3292              : /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
    3293              :    arguments.
    3294              : 
    3295              :      <template-args> ::= I <template-arg>* [Q <constraint-expr>] E  */
    3296              : 
    3297              : static void
    3298    417355280 : write_template_args (tree args, tree parms /*= NULL_TREE*/)
    3299              : {
    3300    417355280 :   int i;
    3301    417355280 :   int length = 0;
    3302              : 
    3303    417355280 :   MANGLE_TRACE_TREE ("template-args", args);
    3304              : 
    3305    417355280 :   write_char ('I');
    3306              : 
    3307    417355280 :   if (args)
    3308    417355280 :     length = TREE_VEC_LENGTH (args);
    3309              : 
    3310    417355280 :   tree constraints = NULL_TREE;
    3311    417355280 :   if (parms)
    3312              :     {
    3313      4922953 :       constraints = TEMPLATE_PARMS_CONSTRAINTS (parms);
    3314      4922953 :       parms = INNERMOST_TEMPLATE_PARMS (parms);
    3315              :     }
    3316              : 
    3317    417355280 :   if (args && length && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
    3318              :     {
    3319              :       /* We have nested template args.  We want the innermost template
    3320              :          argument list.  */
    3321      6183258 :       args = TREE_VEC_ELT (args, length - 1);
    3322      6183258 :       length = TREE_VEC_LENGTH (args);
    3323              :     }
    3324    417355280 :   if (TEMPLATE_ARGS_TYPE_CONSTRAINT_P (args))
    3325              :     /* Skip the constrained type.  */
    3326              :     i = 1;
    3327              :   else
    3328    417302747 :     i = 0;
    3329    417355280 :   bool implicit_parm_scope = false;
    3330   1160134930 :   for (; i < length; ++i)
    3331              :     {
    3332    742779650 :       tree arg = TREE_VEC_ELT (args, i);
    3333    742779650 :       if (parms)
    3334              :         {
    3335      8521693 :           tree parm = TREE_VEC_ELT (parms, i);
    3336      8521693 :           tree decl = TREE_VALUE (parm);
    3337      8521693 :           if (DECL_IMPLICIT_TEMPLATE_PARM_P (decl)
    3338      8521693 :               && !implicit_parm_scope)
    3339              :             {
    3340              :               /* The rest of the template parameters are based on generic
    3341              :                  function parameters, so any expressions in their
    3342              :                  type-constraints are in parameter scope.  */
    3343         9797 :               implicit_parm_scope = true;
    3344         9797 :               ++G.parm_depth;
    3345              :             }
    3346      8521693 :           if (!template_parm_natural_p (arg, parm)
    3347      8521693 :               && abi_check (19))
    3348        41778 :             write_template_param_decl (parm);
    3349              :         }
    3350    742779650 :       write_template_arg (arg);
    3351              :     }
    3352    417355280 :   if (implicit_parm_scope)
    3353         9797 :     --G.parm_depth;
    3354              : 
    3355    417355280 :   write_tparms_constraints (constraints);
    3356              : 
    3357    417355280 :   write_char ('E');
    3358    417355280 : }
    3359              : 
    3360              : /* Write out the
    3361              :    <unqualified-name>
    3362              :    <unqualified-name> <template-args>
    3363              :    part of SCOPE_REF or COMPONENT_REF mangling.  */
    3364              : 
    3365              : static void
    3366       509976 : write_member_name (tree member)
    3367              : {
    3368       509976 :   if (identifier_p (member))
    3369              :     {
    3370       371305 :       if (IDENTIFIER_ANY_OP_P (member))
    3371              :         {
    3372        53495 :           if (abi_check (11))
    3373        53471 :             write_string ("on");
    3374              :         }
    3375       371305 :       write_unqualified_id (member);
    3376              :     }
    3377       138671 :   else if (DECL_P (member))
    3378              :     {
    3379         1296 :       if (ANON_AGGR_TYPE_P (TREE_TYPE (member)))
    3380              :         ;
    3381         1290 :       else if (DECL_OVERLOADED_OPERATOR_P (member))
    3382              :         {
    3383           15 :           if (abi_check (16))
    3384            9 :             write_string ("on");
    3385              :         }
    3386         1296 :       write_unqualified_name (member);
    3387              :     }
    3388       137375 :   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
    3389              :     {
    3390          271 :       tree name = TREE_OPERAND (member, 0);
    3391          271 :       name = OVL_FIRST (name);
    3392          271 :       write_member_name (name);
    3393          271 :       write_template_args (TREE_OPERAND (member, 1));
    3394              :     }
    3395              :   else
    3396       137104 :     write_expression (member);
    3397       509976 : }
    3398              : 
    3399              : /* EXPR is a base COMPONENT_REF; write the minimized base conversion path for
    3400              :    converting to BASE, or just the conversion of EXPR if BASE is null.
    3401              : 
    3402              :    "Given a fully explicit base path P := C_n -> ... -> C_0, the minimized base
    3403              :    path Min(P) is defined as follows: let C_i be the last element for which the
    3404              :    conversion to C_0 is unambiguous; if that element is C_n, the minimized path
    3405              :    is C_n -> C_0; otherwise, the minimized path is Min(C_n -> ... -> C_i) ->
    3406              :    C_0."
    3407              : 
    3408              :    We mangle the conversion to C_i if it's different from C_n.  */
    3409              : 
    3410              : static bool
    3411       199146 : write_base_ref (tree expr, tree base = NULL_TREE)
    3412              : {
    3413       199146 :   if (TREE_CODE (expr) != COMPONENT_REF)
    3414              :     return false;
    3415              : 
    3416       199140 :   tree field = TREE_OPERAND (expr, 1);
    3417              : 
    3418       199140 :   if (TREE_CODE (field) != FIELD_DECL || !DECL_FIELD_IS_BASE (field))
    3419              :     return false;
    3420              : 
    3421           18 :   tree object = TREE_OPERAND (expr, 0);
    3422              : 
    3423           18 :   tree binfo = NULL_TREE;
    3424           18 :   if (base)
    3425              :     {
    3426            9 :       tree cur = TREE_TYPE (object);
    3427            9 :       binfo = lookup_base (cur, base, ba_unique, NULL, tf_none);
    3428              :     }
    3429              :   else
    3430              :     /* We're at the end of the base conversion chain, so it can't be
    3431              :        ambiguous.  */
    3432            9 :     base = TREE_TYPE (field);
    3433              : 
    3434           18 :   if (binfo == error_mark_node)
    3435              :     {
    3436              :       /* cur->base is ambiguous, so make the conversion to
    3437              :          last explicit, expressed as a cast (last&)object.  */
    3438            3 :       tree last = TREE_TYPE (expr);
    3439            3 :       write_string (OVL_OP_INFO (false, CAST_EXPR)->mangled_name);
    3440            3 :       write_type (build_reference_type (last));
    3441            3 :       write_expression (object);
    3442              :     }
    3443           15 :   else if (write_base_ref (object, base))
    3444              :     /* cur->base is unambiguous, but we had another base conversion
    3445              :        underneath and wrote it out.  */;
    3446              :   else
    3447              :     /* No more base conversions, just write out the object.  */
    3448            6 :     write_expression (object);
    3449              : 
    3450              :   return true;
    3451              : }
    3452              : 
    3453              : /* The number of elements spanned by a RANGE_EXPR.  */
    3454              : 
    3455              : unsigned HOST_WIDE_INT
    3456           24 : range_expr_nelts (tree expr)
    3457              : {
    3458           24 :   tree lo = TREE_OPERAND (expr, 0);
    3459           24 :   tree hi = TREE_OPERAND (expr, 1);
    3460           24 :   return tree_to_uhwi (hi) - tree_to_uhwi (lo) + 1;
    3461              : }
    3462              : 
    3463              : /* <expression> ::= <unary operator-name> <expression>
    3464              :                 ::= <binary operator-name> <expression> <expression>
    3465              :                 ::= <expr-primary>
    3466              : 
    3467              :    <expr-primary> ::= <template-param>
    3468              :                   ::= L <type> <value number> E             # literal
    3469              :                   ::= L <mangled-name> E          # external name
    3470              :                   ::= st <type>                           # sizeof
    3471              :                   ::= sr <type> <unqualified-name>  # dependent name
    3472              :                   ::= sr <type> <unqualified-name> <template-args>
    3473              :                   ::= L Dm <value reflection> E           # C++26 reflection
    3474              :                                                         # value [proposed]
    3475              :                   ::= <splice>            # C++26 dependent splice [proposed]  */
    3476              : 
    3477              : static void
    3478     12569932 : write_expression (tree expr)
    3479              : {
    3480     13001030 :   enum tree_code code = TREE_CODE (expr);
    3481              : 
    3482     13001030 :   if (TREE_CODE (expr) == TARGET_EXPR)
    3483              :     {
    3484            0 :       expr = TARGET_EXPR_INITIAL (expr);
    3485            0 :       code = TREE_CODE (expr);
    3486              :     }
    3487              : 
    3488              :   /* Skip NOP_EXPR and CONVERT_EXPR.  They can occur when (say) a pointer
    3489              :      argument is converted (via qualification conversions) to another type.  */
    3490     13565306 :   while (CONVERT_EXPR_CODE_P (code)
    3491     13442365 :          || code == IMPLICIT_CONV_EXPR
    3492     13442233 :          || location_wrapper_p (expr)
    3493              :          /* Parentheses aren't mangled.  */
    3494     13001396 :          || code == PAREN_EXPR
    3495     13001396 :          || code == NON_LVALUE_EXPR
    3496     26566702 :          || (code == VIEW_CONVERT_EXPR
    3497          366 :              && TREE_CODE (TREE_OPERAND (expr, 0)) == TEMPLATE_PARM_INDEX))
    3498              :     {
    3499       564276 :       expr = TREE_OPERAND (expr, 0);
    3500       564276 :       code = TREE_CODE (expr);
    3501              :     }
    3502              : 
    3503     13001030 :   if (code == BASELINK
    3504     13001030 :       && (!type_unknown_p (expr)
    3505       766152 :           || !BASELINK_QUALIFIED_P (expr)))
    3506              :     {
    3507       783103 :       expr = BASELINK_FUNCTIONS (expr);
    3508       783103 :       code = TREE_CODE (expr);
    3509              :     }
    3510              : 
    3511              :   /* Handle pointers-to-members by making them look like expression
    3512              :      nodes.  */
    3513     13001030 :   if (code == PTRMEM_CST)
    3514              :     {
    3515         7790 :       expr = build_nt (ADDR_EXPR,
    3516              :                        build_qualified_name (/*type=*/NULL_TREE,
    3517         3895 :                                              PTRMEM_CST_CLASS (expr),
    3518         3895 :                                              PTRMEM_CST_MEMBER (expr),
    3519              :                                              /*template_p=*/false));
    3520         3895 :       code = TREE_CODE (expr);
    3521              :     }
    3522              : 
    3523              :   /* Handle template parameters.  */
    3524     13001030 :   if (code == TEMPLATE_TYPE_PARM
    3525     13001030 :       || code == TEMPLATE_TEMPLATE_PARM
    3526     13001030 :       || code == BOUND_TEMPLATE_TEMPLATE_PARM
    3527     12997016 :       || code == TEMPLATE_PARM_INDEX)
    3528       785186 :     write_template_param (expr);
    3529              :   /* Handle literals.  */
    3530     12215844 :   else if (TREE_CODE_CLASS (code) == tcc_constant
    3531     11836170 :            || code == CONST_DECL
    3532     11836170 :            || code == REFLECT_EXPR)
    3533       404234 :     write_template_arg_literal (expr);
    3534     11811610 :   else if (code == EXCESS_PRECISION_EXPR
    3535     11811610 :            && TREE_CODE (TREE_OPERAND (expr, 0)) == REAL_CST)
    3536            0 :     write_template_arg_literal (fold_convert (TREE_TYPE (expr),
    3537              :                                               TREE_OPERAND (expr, 0)));
    3538     11811610 :   else if (code == PARM_DECL && DECL_ARTIFICIAL (expr))
    3539              :     {
    3540       121575 :       gcc_assert (id_equal (DECL_NAME (expr), "this"));
    3541       121575 :       write_string ("fpT");
    3542              :     }
    3543     11690035 :   else if (code == PARM_DECL)
    3544              :     {
    3545              :       /* A function parameter used in a late-specified return type.  */
    3546       359483 :       int index = DECL_PARM_INDEX (expr);
    3547       359483 :       int level = DECL_PARM_LEVEL (expr);
    3548       359483 :       int delta = G.parm_depth - level + 1;
    3549       359483 :       gcc_assert (index >= 1);
    3550       359483 :       write_char ('f');
    3551       359483 :       if (delta != 0)
    3552              :         {
    3553       172204 :           gcc_checking_assert (delta > 0);
    3554       172204 :           if (abi_check (5))
    3555              :             {
    3556              :               /* Let L be the number of function prototype scopes from the
    3557              :                  innermost one (in which the parameter reference occurs) up
    3558              :                  to (and including) the one containing the declaration of
    3559              :                  the referenced parameter.  If the parameter declaration
    3560              :                  clause of the innermost function prototype scope has been
    3561              :                  completely seen, it is not counted (in that case -- which
    3562              :                  is perhaps the most common -- L can be zero).  */
    3563       172201 :               write_char ('L');
    3564       172201 :               write_unsigned_number (delta - 1);
    3565              :             }
    3566              :         }
    3567       359483 :       write_char ('p');
    3568       359483 :       write_compact_number (index - 1);
    3569              :     }
    3570     11330552 :   else if (DECL_P (expr))
    3571              :     {
    3572       378087 :       write_char ('L');
    3573       378087 :       write_mangled_name (expr, false);
    3574       378087 :       write_char ('E');
    3575              :     }
    3576     10952465 :   else if (TREE_CODE (expr) == SIZEOF_EXPR)
    3577              :     {
    3578         6971 :       tree op = TREE_OPERAND (expr, 0);
    3579              : 
    3580         6971 :       if (PACK_EXPANSION_P (op))
    3581              :         {
    3582         5462 :     sizeof_pack:
    3583         5465 :           if (abi_check (11))
    3584              :             {
    3585              :               /* sZ rather than szDp.  */
    3586         5456 :               write_string ("sZ");
    3587         5456 :               write_expression (PACK_EXPANSION_PATTERN (op));
    3588              :               return;
    3589              :             }
    3590              :         }
    3591              : 
    3592         1518 :       if (SIZEOF_EXPR_TYPE_P (expr))
    3593              :         {
    3594            0 :           write_string ("st");
    3595            0 :           write_type (TREE_TYPE (op));
    3596              :         }
    3597         1518 :       else if (ARGUMENT_PACK_P (op))
    3598              :         {
    3599           15 :           tree args = ARGUMENT_PACK_ARGS (op);
    3600           15 :           int length = TREE_VEC_LENGTH (args);
    3601           15 :           if (abi_check (10))
    3602              :             {
    3603              :               /* Before v19 we wrongly mangled all single pack expansions with
    3604              :                  sZ, but now only for expressions, as types ICEd (95298).  */
    3605           12 :               if (length == 1)
    3606              :                 {
    3607            9 :                   tree arg = TREE_VEC_ELT (args, 0);
    3608            9 :                   if (TREE_CODE (arg) == EXPR_PACK_EXPANSION
    3609            9 :                       && !abi_check (19))
    3610              :                     {
    3611            3 :                       op = arg;
    3612            3 :                       goto sizeof_pack;
    3613              :                     }
    3614              :                 }
    3615              : 
    3616              :               /* sP <template-arg>* E # sizeof...(T), size of a captured
    3617              :                  template parameter pack from an alias template */
    3618            9 :               write_string ("sP");
    3619           24 :               for (int i = 0; i < length; ++i)
    3620           15 :                 write_template_arg (TREE_VEC_ELT (args, i));
    3621            9 :               write_char ('E');
    3622              :             }
    3623              :           else
    3624              :             {
    3625              :               /* In GCC 5 we represented this sizeof wrong, with the effect
    3626              :                  that we mangled it as the last element of the pack.  */
    3627            3 :               tree arg = TREE_VEC_ELT (args, length-1);
    3628            3 :               if (TYPE_P (op))
    3629              :                 {
    3630            3 :                   write_string ("st");
    3631            3 :                   write_type (arg);
    3632              :                 }
    3633              :               else
    3634              :                 {
    3635            0 :                   write_string ("sz");
    3636            0 :                   write_expression (arg);
    3637              :                 }
    3638              :             }
    3639              :         }
    3640         1503 :       else if (TYPE_P (TREE_OPERAND (expr, 0)))
    3641              :         {
    3642         1381 :           write_string ("st");
    3643         1381 :           write_type (TREE_OPERAND (expr, 0));
    3644              :         }
    3645              :       else
    3646          122 :         goto normal_expr;
    3647              :     }
    3648     10945494 :   else if (code == PACK_INDEX_EXPR)
    3649              :     {
    3650              :       /* https://github.com/itanium-cxx-abi/cxx-abi/issues/175.  */
    3651           37 :       write_string ("sy");
    3652           37 :       if (TREE_CODE (PACK_INDEX_PACK (expr)) == TREE_VEC)
    3653              :         {
    3654            2 :           write_char ('J');
    3655           20 :           for (int i = 0; i < TREE_VEC_LENGTH (PACK_INDEX_PACK (expr));
    3656              :                ++i)
    3657            8 :             write_template_arg (TREE_VEC_ELT (PACK_INDEX_PACK (expr), i));
    3658            2 :           write_char ('E');
    3659              :         }
    3660              :       else
    3661              :         /* sy rather than sysp.  */
    3662           35 :         write_expression (PACK_EXPANSION_PATTERN (PACK_INDEX_PACK (expr)));
    3663           37 :       write_expression (PACK_INDEX_INDEX (expr));
    3664              :     }
    3665     10945457 :   else if (TREE_CODE (expr) == ALIGNOF_EXPR)
    3666              :     {
    3667           36 :       if (!ALIGNOF_EXPR_STD_P (expr))
    3668              :         {
    3669           24 :           if (abi_check (16))
    3670              :             {
    3671              :               /* We used to mangle __alignof__ like alignof.  */
    3672           18 :               write_string ("u11__alignof__");
    3673           18 :               write_template_arg (TREE_OPERAND (expr, 0));
    3674           18 :               write_char ('E');
    3675           18 :               return;
    3676              :             }
    3677              :         }
    3678           18 :       if (TYPE_P (TREE_OPERAND (expr, 0)))
    3679              :         {
    3680            9 :           write_string ("at");
    3681            9 :           write_type (TREE_OPERAND (expr, 0));
    3682              :         }
    3683              :       else
    3684            9 :         goto normal_expr;
    3685              :     }
    3686     10945421 :   else if (code == SCOPE_REF
    3687     10945421 :            || code == BASELINK)
    3688              :     {
    3689       314488 :       tree scope, member;
    3690       314488 :       if (code == SCOPE_REF)
    3691              :         {
    3692       314455 :           scope = TREE_OPERAND (expr, 0);
    3693       314455 :           member = TREE_OPERAND (expr, 1);
    3694       314455 :           if (BASELINK_P (member))
    3695           21 :             member = BASELINK_FUNCTIONS (member);
    3696              :         }
    3697              :       else
    3698              :         {
    3699           33 :           scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr));
    3700           33 :           member = BASELINK_FUNCTIONS (expr);
    3701              :         }
    3702              : 
    3703              :       /* If the MEMBER is a real declaration, then the qualifying
    3704              :          scope was not dependent.  Ideally, we would not have a
    3705              :          SCOPE_REF in those cases, but sometimes we do.  If the second
    3706              :          argument is a DECL, then the name must not have been
    3707              :          dependent.  */
    3708       314488 :       if (DECL_P (member))
    3709              :         write_expression (member);
    3710              :       else
    3711              :         {
    3712       310290 :           gcc_assert (code != BASELINK || BASELINK_QUALIFIED_P (expr));
    3713       310257 :           write_string ("sr");
    3714       310257 :           write_type (scope);
    3715       310257 :           write_member_name (member);
    3716              :         }
    3717              :     }
    3718     10630933 :   else if (INDIRECT_REF_P (expr)
    3719       468529 :            && TREE_TYPE (TREE_OPERAND (expr, 0))
    3720     11016819 :            && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
    3721              :     {
    3722       263199 :       write_expression (TREE_OPERAND (expr, 0));
    3723              :     }
    3724     10367734 :   else if (identifier_p (expr))
    3725              :     {
    3726              :       /* An operator name appearing as a dependent name needs to be
    3727              :          specially marked to disambiguate between a use of the operator
    3728              :          name and a use of the operator in an expression.  */
    3729       254559 :       if (IDENTIFIER_ANY_OP_P (expr))
    3730            7 :         write_string ("on");
    3731       254559 :       write_unqualified_id (expr);
    3732              :     }
    3733     10113175 :   else if (dependent_splice_p (expr))
    3734           44 :     write_splice (expr);
    3735     10113131 :   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
    3736              :     {
    3737      4259317 :       tree fn = TREE_OPERAND (expr, 0);
    3738      5627166 :       if (!identifier_p (fn))
    3739      4259314 :         fn = OVL_NAME (fn);
    3740      4259317 :       if (IDENTIFIER_ANY_OP_P (fn))
    3741            3 :         write_string ("on");
    3742      4259317 :       write_unqualified_id (fn);
    3743      4259317 :       write_template_args (TREE_OPERAND (expr, 1));
    3744              :     }
    3745      5853814 :   else if (TREE_CODE (expr) == MODOP_EXPR)
    3746              :     {
    3747           87 :       enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1));
    3748           87 :       const char *name = OVL_OP_INFO (true, subop)->mangled_name;
    3749              : 
    3750           87 :       write_string (name);
    3751           87 :       write_expression (TREE_OPERAND (expr, 0));
    3752           87 :       write_expression (TREE_OPERAND (expr, 2));
    3753              :     }
    3754      5853727 :   else if (code == NEW_EXPR || code == VEC_NEW_EXPR)
    3755              :     {
    3756              :       /* ::= [gs] nw <expression>* _ <type> E
    3757              :          ::= [gs] nw <expression>* _ <type> <initializer>
    3758              :          ::= [gs] na <expression>* _ <type> E
    3759              :          ::= [gs] na <expression>* _ <type> <initializer>
    3760              :          <initializer> ::= pi <expression>* E  */
    3761       156109 :       tree placement = TREE_OPERAND (expr, 0);
    3762       156109 :       tree type = TREE_OPERAND (expr, 1);
    3763       156109 :       tree nelts = TREE_OPERAND (expr, 2);
    3764       156109 :       tree init = TREE_OPERAND (expr, 3);
    3765       156109 :       tree t;
    3766              : 
    3767       156109 :       gcc_assert (code == NEW_EXPR);
    3768       156109 :       if (TREE_OPERAND (expr, 2))
    3769           12 :         code = VEC_NEW_EXPR;
    3770              : 
    3771       156109 :       if (NEW_EXPR_USE_GLOBAL (expr))
    3772       156084 :         write_string ("gs");
    3773              : 
    3774       156109 :       write_string (OVL_OP_INFO (false, code)->mangled_name);
    3775              : 
    3776       312193 :       for (t = placement; t; t = TREE_CHAIN (t))
    3777       156084 :         write_expression (TREE_VALUE (t));
    3778              : 
    3779       156109 :       write_char ('_');
    3780              : 
    3781       156109 :       if (nelts)
    3782              :         {
    3783           12 :           ++processing_template_decl;
    3784              :           /* Avoid compute_array_index_type complaints about
    3785              :              non-constant nelts.  */
    3786           12 :           tree max = cp_build_binary_op (input_location, MINUS_EXPR,
    3787              :                                          fold_convert (sizetype, nelts),
    3788              :                                          size_one_node,
    3789              :                                          tf_warning_or_error);
    3790           12 :           max = maybe_constant_value (max);
    3791           12 :           tree domain = build_index_type (max);
    3792           12 :           type = build_cplus_array_type (type, domain);
    3793           12 :           --processing_template_decl;
    3794              :         }
    3795       156109 :       write_type (type);
    3796              : 
    3797       156097 :       if (init && TREE_CODE (init) == TREE_LIST
    3798       312200 :           && DIRECT_LIST_INIT_P (TREE_VALUE (init)))
    3799              :         write_expression (TREE_VALUE (init));
    3800              :       else
    3801              :         {
    3802       156106 :           if (init)
    3803       156094 :             write_string ("pi");
    3804       156094 :           if (init && init != void_node)
    3805       312176 :             for (t = init; t; t = TREE_CHAIN (t))
    3806       156088 :               write_expression (TREE_VALUE (t));
    3807       156106 :           write_char ('E');
    3808              :         }
    3809              :     }
    3810              :   else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR)
    3811              :     {
    3812           12 :       gcc_assert (code == DELETE_EXPR);
    3813           12 :       if (DELETE_EXPR_USE_VEC (expr))
    3814            6 :         code = VEC_DELETE_EXPR;
    3815              : 
    3816           12 :       if (DELETE_EXPR_USE_GLOBAL (expr))
    3817            6 :         write_string ("gs");
    3818              : 
    3819           12 :       write_string (OVL_OP_INFO (false, code)->mangled_name);
    3820              : 
    3821           12 :       write_expression (TREE_OPERAND (expr, 0));
    3822              :     }
    3823              :   else if (code == THROW_EXPR)
    3824              :     {
    3825            8 :       tree op = TREE_OPERAND (expr, 0);
    3826            8 :       if (op)
    3827              :         {
    3828            5 :           write_string ("tw");
    3829            5 :           write_expression (op);
    3830              :         }
    3831              :       else
    3832            3 :         write_string ("tr");
    3833              :     }
    3834              :   else if (code == NOEXCEPT_EXPR)
    3835              :     {
    3836            6 :       write_string ("nx");
    3837            6 :       write_expression (TREE_OPERAND (expr, 0));
    3838              :     }
    3839              :   else if (code == CONSTRUCTOR)
    3840              :     {
    3841       177050 :       bool braced_init = BRACE_ENCLOSED_INITIALIZER_P (expr);
    3842       177050 :       tree etype = TREE_TYPE (expr);
    3843              : 
    3844       177050 :       if (braced_init)
    3845           98 :         write_string ("il");
    3846              :       else
    3847              :         {
    3848       176952 :           write_string ("tl");
    3849       176952 :           write_type (etype);
    3850              :         }
    3851              : 
    3852              :       /* If this is an undigested initializer, mangle it as written.
    3853              :          COMPOUND_LITERAL_P doesn't actually distinguish between digested and
    3854              :          undigested braced casts, but it should work to use it to distinguish
    3855              :          between braced casts in a template signature (undigested) and template
    3856              :          parm object values (digested), and all CONSTRUCTORS that get here
    3857              :          should be one of those two cases.  */
    3858       177050 :       bool undigested = braced_init || COMPOUND_LITERAL_P (expr);
    3859       176647 :       if (undigested || !zero_init_expr_p (expr))
    3860              :         {
    3861              :           /* Convert braced initializer lists to STRING_CSTs so that
    3862              :              A<"Foo"> mangles the same as A<{'F', 'o', 'o', 0}> while
    3863              :              still using the latter mangling for strings that
    3864              :              originated as braced initializer lists.  */
    3865       156203 :           expr = braced_lists_to_strings (etype, expr);
    3866              : 
    3867       156203 :           if (TREE_CODE (expr) == CONSTRUCTOR)
    3868              :             {
    3869       156195 :               vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (expr);
    3870       156195 :               unsigned last_nonzero = UINT_MAX;
    3871       156195 :               constructor_elt *ce;
    3872              : 
    3873       156195 :               if (!undigested)
    3874       376035 :                 for (HOST_WIDE_INT i = 0; vec_safe_iterate (elts, i, &ce); ++i)
    3875       220243 :                   if ((TREE_CODE (etype) == UNION_TYPE
    3876           37 :                        && ce->index != first_field (etype))
    3877       220269 :                       || !zero_init_expr_p (ce->value))
    3878              :                     last_nonzero = i;
    3879              : 
    3880       156195 :               tree prev_field = NULL_TREE;
    3881       156195 :               if (undigested || last_nonzero != UINT_MAX)
    3882       374093 :                 for (HOST_WIDE_INT i = 0; vec_safe_iterate (elts, i, &ce); ++i)
    3883              :                   {
    3884       220214 :                     if (i > last_nonzero)
    3885              :                       break;
    3886       217733 :                     if (!undigested && !CONSTRUCTOR_NO_CLEARING (expr)
    3887       217898 :                         && (TREE_CODE (etype) == RECORD_TYPE
    3888       215861 :                             || TREE_CODE (etype) == ARRAY_TYPE))
    3889              :                       {
    3890              :                         /* Write out any implicit non-trailing zeros
    3891              :                            (which we neglected to do before v21).  */
    3892       215824 :                         if (TREE_CODE (etype) == RECORD_TYPE)
    3893              :                           {
    3894       133486 :                             tree field;
    3895       133486 :                             if (i == 0)
    3896       120193 :                               field = first_field (etype);
    3897              :                             else
    3898        13293 :                               field = DECL_CHAIN (prev_field);
    3899       133898 :                             for (;;)
    3900              :                               {
    3901       133692 :                                 field = next_subobject_field (field);
    3902       133692 :                                 if (field == ce->index)
    3903              :                                   break;
    3904          206 :                                 if (abi_check (21))
    3905              :                                   {
    3906          196 :                                     tree type = TREE_TYPE (field), expr;
    3907          196 :                                     if (REFLECTION_TYPE_P (type))
    3908            0 :                                       expr = get_null_reflection ();
    3909              :                                     else
    3910          196 :                                       expr = build_zero_cst (type);
    3911          196 :                                     write_expression (expr);
    3912              :                                   }
    3913          206 :                                 field = DECL_CHAIN (field);
    3914          206 :                               }
    3915              :                           }
    3916        82338 :                         else if (TREE_CODE (etype) == ARRAY_TYPE)
    3917              :                           {
    3918        82338 :                             unsigned HOST_WIDE_INT j;
    3919        82338 :                             if (i == 0)
    3920              :                               j = 0;
    3921              :                             else
    3922        47400 :                               j = 1 + tree_to_uhwi (prev_field);
    3923        82338 :                             unsigned HOST_WIDE_INT k;
    3924        82338 :                             if (TREE_CODE (ce->index) == RANGE_EXPR)
    3925           12 :                               k = tree_to_uhwi (TREE_OPERAND (ce->index, 0));
    3926              :                             else
    3927        82326 :                               k = tree_to_uhwi (ce->index);
    3928        82338 :                             tree zero = NULL_TREE;
    3929        84108 :                             for (; j < k; ++j)
    3930         1770 :                               if (abi_check (21))
    3931              :                                 {
    3932         1188 :                                   if (!zero)
    3933           30 :                                     zero = build_zero_cst (TREE_TYPE (etype));
    3934         1188 :                                   write_expression (zero);
    3935              :                                 }
    3936              :                           }
    3937              :                       }
    3938              : 
    3939       217898 :                     if (!undigested && TREE_CODE (etype) == UNION_TYPE)
    3940              :                       {
    3941              :                         /* Express the active member as a designator.  */
    3942           37 :                         write_string ("di");
    3943           37 :                         write_unqualified_name (ce->index);
    3944              :                       }
    3945       217898 :                     unsigned reps = 1;
    3946       217898 :                     if (ce->index && TREE_CODE (ce->index) == RANGE_EXPR)
    3947           12 :                       reps = range_expr_nelts (ce->index);
    3948       217898 :                     if (TREE_CODE (ce->value) == RAW_DATA_CST)
    3949              :                       {
    3950           30 :                         gcc_assert (reps == 1);
    3951           30 :                         unsigned int len = RAW_DATA_LENGTH (ce->value);
    3952              :                         /* If this is the last non-zero element, skip
    3953              :                            zeros at the end.  */
    3954           30 :                         if (i == last_nonzero)
    3955          282 :                           while (len)
    3956              :                             {
    3957          282 :                               if (RAW_DATA_POINTER (ce->value)[len - 1])
    3958              :                                 break;
    3959              :                               --len;
    3960              :                             }
    3961           30 :                         tree valtype = TREE_TYPE (ce->value);
    3962         3906 :                         for (unsigned int i = 0; i < len; ++i)
    3963              :                           {
    3964         3876 :                             write_char ('L');
    3965         3876 :                             write_type (valtype);
    3966         3876 :                             unsigned HOST_WIDE_INT v;
    3967         3876 :                             if (!TYPE_UNSIGNED (valtype)
    3968          780 :                                 && TYPE_PRECISION (valtype) == BITS_PER_UNIT
    3969         4656 :                                 && RAW_DATA_SCHAR_ELT (ce->value, i) < 0)
    3970              :                               {
    3971            0 :                                 write_char ('n');
    3972            0 :                                 v = -RAW_DATA_SCHAR_ELT (ce->value, i);
    3973              :                               }
    3974              :                             else
    3975         3876 :                               v = RAW_DATA_UCHAR_ELT (ce->value, i);
    3976         3876 :                             write_unsigned_number (v);
    3977         3876 :                             write_char ('E');
    3978              :                           }
    3979              :                       }
    3980              :                     else
    3981       435754 :                       for (unsigned j = 0; j < reps; ++j)
    3982       217886 :                         write_expression (ce->value);
    3983       217898 :                     prev_field = ce->index;
    3984       217898 :                     if (prev_field && TREE_CODE (prev_field) == RANGE_EXPR)
    3985           12 :                       prev_field = TREE_OPERAND (prev_field, 1);
    3986              :                   }
    3987              :             }
    3988              :           else
    3989              :             {
    3990            8 :               gcc_assert (TREE_CODE (expr) == STRING_CST);
    3991            8 :               write_expression (expr);
    3992              :             }
    3993              :         }
    3994       177050 :       write_char ('E');
    3995              :     }
    3996              :   else if (code == LAMBDA_EXPR)
    3997              :     {
    3998              :       /* [temp.over.link] Two lambda-expressions are never considered
    3999              :          equivalent.
    4000              : 
    4001              :          So just use the closure type mangling.  */
    4002         1408 :       write_char ('L');
    4003         1408 :       write_type (LAMBDA_EXPR_CLOSURE (expr));
    4004         1408 :       write_char ('E');
    4005              :     }
    4006              :   else if (code == REQUIRES_EXPR)
    4007       528682 :     write_requires_expr (expr);
    4008      4990452 :   else if (dependent_name (expr))
    4009              :     {
    4010       120461 :       tree name = dependent_name (expr);
    4011       120461 :       if (IDENTIFIER_ANY_OP_P (name))
    4012              :         {
    4013            9 :           if (abi_check (16))
    4014            6 :             write_string ("on");
    4015              :         }
    4016       120461 :       write_unqualified_id (name);
    4017              :     }
    4018              :   else
    4019              :     {
    4020      4869991 :     normal_expr:
    4021      4870122 :       int i, len;
    4022      4870122 :       const char *name;
    4023              : 
    4024              :       /* When we bind a variable or function to a non-type template
    4025              :          argument with reference type, we create an ADDR_EXPR to show
    4026              :          the fact that the entity's address has been taken.  But, we
    4027              :          don't actually want to output a mangling code for the `&'.  */
    4028      4870122 :       if (TREE_CODE (expr) == ADDR_EXPR
    4029         7364 :           && TREE_TYPE (expr)
    4030      4873591 :           && TYPE_REF_P (TREE_TYPE (expr)))
    4031              :         {
    4032            0 :           expr = TREE_OPERAND (expr, 0);
    4033            0 :           if (DECL_P (expr))
    4034              :             {
    4035              :               write_expression (expr);
    4036              :               return;
    4037              :             }
    4038              : 
    4039            0 :           code = TREE_CODE (expr);
    4040              :         }
    4041              : 
    4042      4870122 :       if (code == COMPONENT_REF)
    4043              :         {
    4044       199457 :           tree ob = TREE_OPERAND (expr, 0);
    4045              : 
    4046       199457 :           if (TREE_CODE (ob) == ARROW_EXPR)
    4047              :             {
    4048          326 :               write_string (OVL_OP_INFO (false, code)->mangled_name);
    4049          326 :               ob = TREE_OPERAND (ob, 0);
    4050          326 :               write_expression (ob);
    4051              :             }
    4052       199131 :           else if (write_base_ref (expr))
    4053              :             return;
    4054       199122 :           else if (!is_dummy_object (ob))
    4055              :             {
    4056       199116 :               write_string ("dt");
    4057       199116 :               write_expression (ob);
    4058              :             }
    4059              :           /* else, for a non-static data member with no associated object (in
    4060              :              unevaluated context), use the unresolved-name mangling.  */
    4061              : 
    4062       199448 :           write_member_name (TREE_OPERAND (expr, 1));
    4063       199448 :           return;
    4064              :         }
    4065              : 
    4066              :       /* If it wasn't any of those, recursively expand the expression.  */
    4067      4670665 :       name = OVL_OP_INFO (false, code)->mangled_name;
    4068              : 
    4069              :       /* We used to mangle const_cast and static_cast like a C cast.  */
    4070      4670665 :       if (code == CONST_CAST_EXPR
    4071      4670665 :           || code == STATIC_CAST_EXPR)
    4072              :         {
    4073          265 :           if (!abi_check (6))
    4074           15 :             name = OVL_OP_INFO (false, CAST_EXPR)->mangled_name;
    4075              :         }
    4076              : 
    4077      4670665 :       if (name == NULL)
    4078              :         {
    4079            3 :           switch (code)
    4080              :             {
    4081            3 :             case TRAIT_EXPR:
    4082            3 :               error ("use of built-in trait %qE in function signature; "
    4083              :                      "use library traits instead", expr);
    4084            3 :               break;
    4085              : 
    4086            0 :             case ERROR_MARK:
    4087            0 :               if (seen_error ())
    4088              :                 break;
    4089              :               /* FALLTHROUGH */
    4090            0 :             default:
    4091            0 :               sorry ("mangling %C", code);
    4092            0 :               break;
    4093              :             }
    4094              :           return;
    4095              :         }
    4096              :       else
    4097      4670662 :         write_string (name);
    4098              : 
    4099      4670662 :       switch (code)
    4100              :         {
    4101      2112793 :         case CALL_EXPR:
    4102      2112793 :           if (tree fn = CALL_EXPR_FN (expr))
    4103              :             {
    4104      2112787 :               if (TREE_CODE (fn) == ADDR_EXPR)
    4105            0 :                 fn = TREE_OPERAND (fn, 0);
    4106              : 
    4107              :               /* Mangle a dependent name as the name, not whatever happens to
    4108              :                  be the first function in the overload set.  */
    4109      2112064 :               if (OVL_P (fn)
    4110      2367139 :                   && type_dependent_expression_p_push (expr))
    4111       254456 :                 fn = OVL_NAME (fn);
    4112              : 
    4113      2112787 :               write_expression (fn);
    4114              :             }
    4115              :           else
    4116            6 :             switch (CALL_EXPR_IFN (expr))
    4117              :               {
    4118              :               /* Calls to __builtin_bswapg/__builtin_bitreverseg/__builtin_clmulg
    4119              :                  are parsed as IFN_BSWAP/IFN_BITREVERSE/IFN_CLMUL calls because
    4120              :                  we don't have those builtins but instead keywords.  Pretend
    4121              :                  they are builtin function template.  */
    4122            3 :               case IFN_BSWAP:
    4123            3 :                 write_source_name (get_identifier ("__builtin_bswapg"));
    4124            3 :                 break;
    4125            3 :               case IFN_BITREVERSE:
    4126            3 :                 write_source_name (get_identifier ("__builtin_bitreverseg"));
    4127            3 :                 break;
    4128            0 :               case IFN_CLMUL:
    4129            0 :                 write_source_name (get_identifier ("__builtin_clmulg"));
    4130            0 :                 break;
    4131            0 :               default:
    4132            0 :                 gcc_unreachable ();
    4133              :               }
    4134              : 
    4135      2760472 :           for (i = 0; i < call_expr_nargs (expr); ++i)
    4136       647679 :             write_expression (CALL_EXPR_ARG (expr, i));
    4137      2112793 :           write_char ('E');
    4138      2112793 :           break;
    4139              : 
    4140       157969 :         case CAST_EXPR:
    4141       157969 :           write_type (TREE_TYPE (expr));
    4142       157969 :           if (list_length (TREE_OPERAND (expr, 0)) == 1)
    4143       157791 :             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
    4144              :           else
    4145              :             {
    4146          178 :               tree args = TREE_OPERAND (expr, 0);
    4147          178 :               write_char ('_');
    4148          190 :               for (; args; args = TREE_CHAIN (args))
    4149           12 :                 write_expression (TREE_VALUE (args));
    4150          178 :               write_char ('E');
    4151              :             }
    4152              :           break;
    4153              : 
    4154          271 :         case DYNAMIC_CAST_EXPR:
    4155          271 :         case REINTERPRET_CAST_EXPR:
    4156          271 :         case STATIC_CAST_EXPR:
    4157          271 :         case CONST_CAST_EXPR:
    4158          271 :           write_type (TREE_TYPE (expr));
    4159          271 :           write_expression (TREE_OPERAND (expr, 0));
    4160          271 :           break;
    4161              : 
    4162         7551 :         case PREINCREMENT_EXPR:
    4163         7551 :         case PREDECREMENT_EXPR:
    4164         7551 :           if (abi_check (6))
    4165         7542 :             write_char ('_');
    4166              :           /* Fall through.  */
    4167              : 
    4168      2399629 :         default:
    4169              :           /* In the middle-end, some expressions have more operands than
    4170              :              they do in templates (and mangling).  */
    4171      2399629 :           len = cp_tree_operand_length (expr);
    4172              : 
    4173      8672390 :           for (i = 0; i < len; ++i)
    4174              :             {
    4175      3873132 :               tree operand = TREE_OPERAND (expr, i);
    4176              :               /* As a GNU extension, the middle operand of a
    4177              :                  conditional may be omitted.  Since expression
    4178              :                  manglings are supposed to represent the input token
    4179              :                  stream, there's no good way to mangle such an
    4180              :                  expression without extending the C++ ABI.  */
    4181      3873132 :               if (code == COND_EXPR && i == 1 && !operand)
    4182              :                 {
    4183            3 :                   error ("omitted middle operand to %<?:%> operand "
    4184              :                          "cannot be mangled");
    4185            3 :                   continue;
    4186              :                 }
    4187      3873129 :               else if (FOLD_EXPR_P (expr))
    4188              :                 {
    4189              :                   /* The first 'operand' of a fold-expression is the operator
    4190              :                      that it folds over.  */
    4191       510396 :                   if (i == 0)
    4192              :                     {
    4193       255061 :                       int fcode = TREE_INT_CST_LOW (operand);
    4194       255061 :                       write_string (OVL_OP_INFO (false, fcode)->mangled_name);
    4195       255061 :                       continue;
    4196       255061 :                     }
    4197       255335 :                   else if (code == BINARY_LEFT_FOLD_EXPR)
    4198              :                     {
    4199              :                       /* The order of operands of the binary left and right
    4200              :                          folds is the same, but we want to mangle them in
    4201              :                          lexical order, i.e. non-pack first.  */
    4202          542 :                       if (i == 1)
    4203          271 :                         operand = FOLD_EXPR_INIT (expr);
    4204              :                       else
    4205          271 :                         operand = FOLD_EXPR_PACK (expr);
    4206              :                     }
    4207       255335 :                   if (PACK_EXPANSION_P (operand))
    4208       255061 :                     operand = PACK_EXPANSION_PATTERN (operand);
    4209              :                 }
    4210      3618068 :               write_expression (operand);
    4211              :             }
    4212              :         }
    4213              :     }
    4214              : }
    4215              : 
    4216              : /* Non-terminal <reflection>.
    4217              : 
    4218              :      <reflection> ::= nu                          # null reflection
    4219              :                   ::= vl <expression>                     # value
    4220              :                   ::= ob <expression>                     # object
    4221              :                   ::= vr <variable name>          # variable
    4222              :                   ::= sb <sb name>                        # structured binding
    4223              :                   ::= fn <function encoding>              # function
    4224              :                   ::= pa [ <nonnegative number> ] _ <encoding>      # fn param
    4225              :                   ::= en <prefix> <unqualified-name>        # enumerator
    4226              :                   ::= an [ <nonnegative number> ] _       # annotation
    4227              :                   ::= ta <alias prefix> <alias unqualified-name>
    4228              :                       [ <alias template-args> ] _ <type> # type alias
    4229              :                   ::= ty <type>                           # type
    4230              :                   ::= dm <prefix> <unqualified-name>        # ns data member
    4231              :                   ::= da <prefix> [ <nonnegative number> ] _ # empty anon union
    4232              :                                                              # data member
    4233              :                   ::= un <prefix> [ <nonnegative number> ] _ # unnamed bitfld
    4234              :                   ::= ct [ <prefix> ] <unqualified-name> # class template
    4235              :                   ::= ft [ <prefix> ] <unqualified-name> # function template
    4236              :                   ::= vt [ <prefix> ] <unqualified-name> # variable template
    4237              :                   ::= at [ <prefix> ] <unqualified-name> # alias template
    4238              :                   ::= co [ <prefix> ] <unqualified-name> # concept
    4239              :                   ::= na [ <prefix> ] <unqualified-name> # namespace alias
    4240              :                   ::= ns [ <prefix> ] <unqualified-name> # namespace
    4241              :                   ::= gs                                 # ^^::
    4242              :                   ::= tt <template-template-param>         # templ templ param
    4243              :                   ::= de <expression>                      # dependent expr
    4244              :                   ::= ba [ <nonnegative number> ] _ <type> # dir. base cls rel
    4245              :                   ::= ds <type> _ [ <unqualified-name> ] _
    4246              :                       [ <alignment number> ] _ [ <bit-width number> ] _
    4247              :                       [ n ] [ <template-arg>* ]           # data member spec  */
    4248              : 
    4249              : static void
    4250         1750 : write_reflection (tree refl)
    4251              : {
    4252         1750 :   char prefix[3];
    4253         1750 :   tree arg = reflection_mangle_prefix (refl, prefix);
    4254         1750 :   if (strcmp (prefix, "dm") == 0
    4255          234 :       && DECL_NAME (arg) == NULL_TREE
    4256           12 :       && ANON_AGGR_TYPE_P (TREE_TYPE (arg))
    4257         1762 :       && anon_aggr_naming_decl (TREE_TYPE (arg)) == NULL_TREE)
    4258           12 :     strcpy (prefix, "da");
    4259         1750 :   write_string (prefix);
    4260              :   /* If there is no argument, nothing further needs to be mangled.  */
    4261         1750 :   if (arg == NULL_TREE)
    4262           62 :     return;
    4263         1688 :   if (strcmp (prefix, "vl") == 0 || strcmp (prefix, "ob") == 0)
    4264           22 :     write_expression (arg);
    4265         1666 :   else if (strcmp (prefix, "vr") == 0 || strcmp (prefix, "sb") == 0)
    4266          234 :     write_name (arg);
    4267         1432 :   else if (strcmp (prefix, "fn") == 0)
    4268          196 :     write_encoding (arg);
    4269         1236 :   else if (strcmp (prefix, "pa") == 0)
    4270              :     {
    4271           82 :       tree fn = DECL_CONTEXT (arg);
    4272              :       /* DECL_PARM_INDEX is 1-based but here we want a 0-based index.  */
    4273           82 :       const int idx = DECL_PARM_INDEX (arg) - 1;
    4274           82 :       write_compact_number (idx);
    4275           82 :       write_encoding (fn);
    4276              :     }
    4277         1154 :   else if (strcmp (prefix, "en") == 0)
    4278              :     {
    4279           26 :       write_prefix (decl_mangling_context (arg));
    4280           26 :       write_unqualified_name (arg);
    4281              :     }
    4282         1128 :   else if (strcmp (prefix, "an") == 0)
    4283           10 :     write_compact_number (tree_to_uhwi (arg));
    4284         1118 :   else if (strcmp (prefix, "ta") == 0)
    4285              :     {
    4286           28 :       arg = TYPE_NAME (arg);
    4287              :       /* Can't use write_prefix (arg) here instead of
    4288              :          write_prefix + write_unqualified_name + optional
    4289              :          write_template_args, it shouldn't be
    4290              :          remembered among substitutions.  */
    4291           28 :       write_prefix (decl_mangling_context (arg));
    4292           28 :       if (modules_p ())
    4293            0 :         maybe_write_module (arg);
    4294           28 :       write_source_name (DECL_NAME (arg));
    4295           28 :       tree template_info = maybe_template_info (arg);
    4296           28 :       if (template_info)
    4297            4 :         write_template_args (TI_ARGS (template_info));
    4298           28 :       write_char ('_');
    4299           28 :       write_type (DECL_ORIGINAL_TYPE (arg));
    4300              :     }
    4301         1090 :   else if (strcmp (prefix, "ty") == 0)
    4302          314 :     write_type (arg);
    4303          776 :   else if (strcmp (prefix, "dm") == 0)
    4304              :     {
    4305          222 :       tree ctx = decl_mangling_context (arg);
    4306          452 :       while (ctx && ANON_UNION_TYPE_P (ctx))
    4307            8 :         ctx = decl_mangling_context (TYPE_NAME (ctx));
    4308          222 :       write_prefix (ctx);
    4309          222 :       write_unqualified_name (arg);
    4310              :     }
    4311          554 :   else if (strcmp (prefix, "da") == 0)
    4312              :     {
    4313           12 :       int idx = 0;
    4314           12 :       tree ctx = decl_mangling_context (arg);
    4315          198 :       for (tree f = TYPE_FIELDS (ctx); f; f = DECL_CHAIN (f))
    4316          198 :         if (f == arg)
    4317              :           break;
    4318          186 :         else if (TREE_CODE (f) == FIELD_DECL
    4319           18 :                  && DECL_NAME (f) == NULL_TREE
    4320           18 :                  && ANON_AGGR_TYPE_P (TREE_TYPE (f))
    4321          204 :                  && anon_aggr_naming_decl (TREE_TYPE (f)) == NULL_TREE)
    4322           18 :           ++idx;
    4323           12 :       write_prefix (ctx);
    4324           12 :       write_compact_number (idx);
    4325              :     }
    4326          542 :   else if (strcmp (prefix, "un") == 0)
    4327              :     {
    4328            8 :       tree ctx = DECL_CONTEXT (arg);
    4329            8 :       int idx = 0;
    4330          142 :       for (tree f = TYPE_FIELDS (ctx); f; f = DECL_CHAIN (f))
    4331          142 :         if (f == arg)
    4332              :           break;
    4333          134 :         else if (TREE_CODE (f) == FIELD_DECL && DECL_UNNAMED_BIT_FIELD (f))
    4334            6 :           ++idx;
    4335            8 :       write_prefix (decl_mangling_context (arg));
    4336            8 :       write_compact_number (idx);
    4337              :     }
    4338          534 :   else if (strcmp (prefix, "ct") == 0
    4339          484 :            || strcmp (prefix, "ft") == 0
    4340          434 :            || strcmp (prefix, "vt") == 0
    4341          406 :            || strcmp (prefix, "at") == 0
    4342          380 :            || strcmp (prefix, "co") == 0
    4343          358 :            || strcmp (prefix, "na") == 0
    4344          320 :            || strcmp (prefix, "ns") == 0)
    4345              :     {
    4346          418 :       write_prefix (decl_mangling_context (arg));
    4347          418 :       write_unqualified_name (STRIP_TEMPLATE (arg));
    4348              :     }
    4349          116 :   else if (strcmp (prefix, "ba") == 0)
    4350              :     {
    4351           26 :       gcc_assert (TREE_CODE (arg) == TREE_BINFO);
    4352              :       tree c = arg, base_binfo;
    4353           52 :       while (BINFO_INHERITANCE_CHAIN (c))
    4354              :         c = BINFO_INHERITANCE_CHAIN (c);
    4355              : 
    4356              :       unsigned idx;
    4357           30 :       for (idx = 0; BINFO_BASE_ITERATE (c, idx, base_binfo); idx++)
    4358           30 :         if (base_binfo == arg)
    4359              :           break;
    4360           26 :       write_compact_number (idx);
    4361           26 :       write_type (BINFO_TYPE (c));
    4362              :     }
    4363           90 :   else if (strcmp (prefix, "ds") == 0)
    4364              :     {
    4365           84 :       gcc_assert (TREE_CODE (arg) == TREE_VEC);
    4366           84 :       write_type (TREE_VEC_ELT (arg, 0));
    4367           84 :       write_char ('_');
    4368           84 :       if (TREE_VEC_ELT (arg, 1))
    4369           80 :         write_unqualified_id (TREE_VEC_ELT (arg, 1));
    4370           84 :       write_char ('_');
    4371           84 :       if (TREE_VEC_ELT (arg, 2))
    4372            2 :         write_number (tree_to_shwi (TREE_VEC_ELT (arg, 2)), 0, 10);
    4373           84 :       write_char ('_');
    4374           84 :       if (TREE_VEC_ELT (arg, 3))
    4375            6 :         write_number (tree_to_shwi (TREE_VEC_ELT (arg, 3)), 0, 10);
    4376           84 :       write_char ('_');
    4377           84 :       if (integer_nonzerop (TREE_VEC_ELT (arg, 4)))
    4378            2 :         write_char ('n');
    4379           90 :       for (int i = 5; i < TREE_VEC_LENGTH (arg); ++i)
    4380            6 :         write_template_arg (REFLECT_EXPR_HANDLE (TREE_VEC_ELT (arg, i)));
    4381              :     }
    4382            6 :   else if (strcmp (prefix, "tt") == 0)
    4383              :     {
    4384            2 :       gcc_assert (DECL_TEMPLATE_TEMPLATE_PARM_P (arg));
    4385            2 :       write_template_template_param (TREE_TYPE (arg));
    4386              :     }
    4387            4 :   else if (strcmp (prefix, "de") == 0)
    4388            4 :     write_expression (arg);
    4389              :   else
    4390            0 :     gcc_unreachable ();
    4391              : }
    4392              : 
    4393              : /* Mangle a dependent splice.
    4394              : 
    4395              :      <splice> ::= DS <expression> [ <template-args> ] E
    4396              : 
    4397              :    TODO: This is only a proposed mangling.
    4398              :    See <https://github.com/itanium-cxx-abi/cxx-abi/issues/208>.  */
    4399              : 
    4400              : static void
    4401          102 : write_splice (tree sp)
    4402              : {
    4403          102 :   write_string ("DS");
    4404              : 
    4405          102 :   if (TREE_CODE (sp) == SPLICE_SCOPE)
    4406           58 :     sp = SPLICE_SCOPE_EXPR (sp);
    4407          102 :   gcc_assert (dependent_splice_p (sp));
    4408          102 :   if (TREE_CODE (sp) == TEMPLATE_ID_EXPR)
    4409              :     {
    4410            4 :       write_expression (TREE_OPERAND (TREE_OPERAND (sp, 0), 0));
    4411            4 :       write_template_args (TREE_OPERAND (sp, 1));
    4412              :     }
    4413              :   else
    4414           98 :     write_expression (TREE_OPERAND (sp, 0));
    4415              : 
    4416          102 :   write_char ('E');
    4417          102 : }
    4418              : 
    4419              : /* Literal subcase of non-terminal <template-arg>.
    4420              : 
    4421              :      "Literal arguments, e.g. "A<42L>", are encoded with their type
    4422              :      and value. Negative integer values are preceded with "n"; for
    4423              :      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
    4424              :      encoded as 0, true as 1."  */
    4425              : 
    4426              : static void
    4427     94775931 : write_template_arg_literal (const tree value)
    4428              : {
    4429     94775931 :   if (TREE_CODE (value) == STRING_CST)
    4430              :     /* Temporarily mangle strings as braced initializer lists.  */
    4431         1667 :     write_string ("tl");
    4432              :   else
    4433     94774264 :     write_char ('L');
    4434              : 
    4435     94775931 :   tree valtype = TREE_TYPE (value);
    4436     94775931 :   write_type (valtype);
    4437              : 
    4438              :   /* Write a null member pointer value as (type)0, regardless of its
    4439              :      real representation.  */
    4440     94775931 :   if (null_member_pointer_value_p (value))
    4441          264 :     write_integer_cst (integer_zero_node);
    4442              :   else
    4443     94775667 :     switch (TREE_CODE (value))
    4444              :       {
    4445        24300 :       case CONST_DECL:
    4446        24300 :         write_integer_cst (DECL_INITIAL (value));
    4447        24300 :         break;
    4448              : 
    4449     94745401 :       case INTEGER_CST:
    4450     94745401 :         gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
    4451              :                     || integer_zerop (value) || integer_onep (value));
    4452     94745401 :         if (!(abi_version_at_least (14)
    4453     94738531 :               && NULLPTR_TYPE_P (TREE_TYPE (value))))
    4454     94745339 :           write_integer_cst (value);
    4455              :         break;
    4456              : 
    4457         2543 :       case REAL_CST:
    4458         2543 :         write_real_cst (value);
    4459         2543 :         break;
    4460              : 
    4461            6 :       case COMPLEX_CST:
    4462            6 :         if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST
    4463            6 :             && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST)
    4464              :           {
    4465            3 :             write_integer_cst (TREE_REALPART (value));
    4466            3 :             write_char ('_');
    4467            3 :             write_integer_cst (TREE_IMAGPART (value));
    4468              :           }
    4469            3 :         else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST
    4470            3 :                  && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST)
    4471              :           {
    4472            3 :             write_real_cst (TREE_REALPART (value));
    4473            3 :             write_char ('_');
    4474            3 :             write_real_cst (TREE_IMAGPART (value));
    4475              :           }
    4476              :         else
    4477            0 :           gcc_unreachable ();
    4478              :         break;
    4479              : 
    4480         1667 :       case STRING_CST:
    4481         1667 :         {
    4482              :           /* Mangle strings the same as braced initializer lists.  */
    4483         1667 :           unsigned n = TREE_STRING_LENGTH (value);
    4484         1667 :           const char *str = TREE_STRING_POINTER (value);
    4485              : 
    4486              :           /* Count the number of trailing nuls and subtract them from
    4487              :              STRSIZE because they don't need to be mangled.  */
    4488         4638 :           for (const char *p = str + n - 1; ; --p)
    4489              :             {
    4490         4638 :               if (*p || p == str)
    4491              :                 {
    4492         1667 :                   n -= str + n - !!*p - p;
    4493         1667 :                   break;
    4494              :                 }
    4495              :             }
    4496         1667 :           tree eltype = TREE_TYPE (valtype);
    4497        11784 :           for (const char *p = str; n--; ++p)
    4498              :             {
    4499        10117 :               write_char ('L');
    4500        10117 :               write_type (eltype);
    4501        10117 :               write_unsigned_number (*(const unsigned char*)p);
    4502        10117 :               write_string ("E");
    4503              :             }
    4504              :           break;
    4505              :         }
    4506              : 
    4507         1750 :       case REFLECT_EXPR:
    4508         1750 :         write_reflection (value);
    4509         1750 :         break;
    4510              : 
    4511            0 :       default:
    4512            0 :         gcc_unreachable ();
    4513              :       }
    4514              : 
    4515     94775931 :   write_char ('E');
    4516     94775931 : }
    4517              : 
    4518              : /* Non-terminal <template-arg>.
    4519              : 
    4520              :      <template-arg> ::= <type>                              # type
    4521              :                     ::= L <type> </value/ number> E # literal
    4522              :                     ::= LZ <name> E                       # external name
    4523              :                     ::= X <expression> E          # expression  */
    4524              : 
    4525              : static void
    4526    757239258 : write_template_arg (tree node)
    4527              : {
    4528    757239258 :   enum tree_code code = TREE_CODE (node);
    4529              : 
    4530    757239258 :   MANGLE_TRACE_TREE ("template-arg", node);
    4531              : 
    4532              :   /* A template template parameter's argument list contains TREE_LIST
    4533              :      nodes of which the value field is the actual argument.  */
    4534    757239258 :   if (code == TREE_LIST)
    4535              :     {
    4536            0 :       node = TREE_VALUE (node);
    4537              :       /* If it's a decl, deal with its type instead.  */
    4538            0 :       if (DECL_P (node))
    4539              :         {
    4540            0 :           node = TREE_TYPE (node);
    4541            0 :           code = TREE_CODE (node);
    4542              :         }
    4543              :     }
    4544              : 
    4545    757239258 :   if (VAR_P (node) && DECL_NTTP_OBJECT_P (node))
    4546              :     /* We want to mangle the argument, not the var we stored it in.  */
    4547        51639 :     node = tparm_object_argument (node);
    4548              : 
    4549              :   /* Strip a conversion added by convert_nontype_argument.  */
    4550    757239258 :   if (TREE_CODE (node) == IMPLICIT_CONV_EXPR)
    4551           78 :     node = TREE_OPERAND (node, 0);
    4552    757239258 :   if (REFERENCE_REF_P (node))
    4553          282 :     node = TREE_OPERAND (node, 0);
    4554    757239258 :   if (TREE_CODE (node) == NOP_EXPR
    4555    757239258 :       && TYPE_REF_P (TREE_TYPE (node)))
    4556              :     {
    4557              :       /* Template parameters can be of reference type. To maintain
    4558              :          internal consistency, such arguments use a conversion from
    4559              :          address of object to reference type.  */
    4560          276 :       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
    4561          276 :       node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
    4562              :     }
    4563              : 
    4564    757239258 :   if (TREE_CODE (node) == BASELINK
    4565    757239258 :       && !type_unknown_p (node))
    4566              :     {
    4567              :       /* Before v6 we wrongly wrapped a class-scope function in X/E.  */
    4568           18 :       if (abi_check (6))
    4569           12 :         node = BASELINK_FUNCTIONS (node);
    4570              :     }
    4571              : 
    4572    757239258 :   if (ARGUMENT_PACK_P (node))
    4573              :     {
    4574              :       /* Expand the template argument pack. */
    4575     10004301 :       tree args = ARGUMENT_PACK_ARGS (node);
    4576     10004301 :       int i, length = TREE_VEC_LENGTH (args);
    4577     10004301 :       if (abi_check (6))
    4578     10004283 :         write_char ('J');
    4579              :       else
    4580           18 :         write_char ('I');
    4581     24463845 :       for (i = 0; i < length; ++i)
    4582     14459544 :         write_template_arg (TREE_VEC_ELT (args, i));
    4583     10004301 :       write_char ('E');
    4584              :     }
    4585    747234957 :   else if (TYPE_P (node))
    4586    651274320 :     write_type (node);
    4587     95960637 :   else if (code == TEMPLATE_DECL)
    4588              :     /* A template appearing as a template arg is a template template arg.  */
    4589       782609 :     write_template_template_arg (node);
    4590     94373793 :   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
    4591       804235 :            || code == CONST_DECL
    4592       807969 :            || null_member_pointer_value_p (node)
    4593     95985849 :            || code == REFLECT_EXPR)
    4594     94371697 :     write_template_arg_literal (node);
    4595       806331 :   else if (code == EXCESS_PRECISION_EXPR
    4596       806331 :            && TREE_CODE (TREE_OPERAND (node, 0)) == REAL_CST)
    4597            0 :     write_template_arg_literal (fold_convert (TREE_TYPE (node),
    4598              :                                               TREE_OPERAND (node, 0)));
    4599       806331 :   else if (DECL_P (node))
    4600              :     {
    4601          295 :       write_char ('L');
    4602              :       /* Until ABI version 3, the underscore before the mangled name
    4603              :          was incorrectly omitted.  */
    4604          295 :       if (!abi_check (3))
    4605           21 :         write_char ('Z');
    4606              :       else
    4607          274 :         write_string ("_Z");
    4608          295 :       write_encoding (node);
    4609          295 :       write_char ('E');
    4610              :     }
    4611              :   else
    4612              :     {
    4613              :       /* Template arguments may be expressions.  */
    4614       806036 :       write_char ('X');
    4615       806036 :       write_expression (node);
    4616       806036 :       write_char ('E');
    4617              :     }
    4618    757239258 : }
    4619              : 
    4620              : /*  <template-template-arg>
    4621              :                         ::= <name>
    4622              :                         ::= <substitution>  */
    4623              : 
    4624              : static void
    4625       782609 : write_template_template_arg (const tree decl)
    4626              : {
    4627       782609 :   MANGLE_TRACE_TREE ("template-template-arg", decl);
    4628              : 
    4629       782609 :   if (find_substitution (decl))
    4630              :     return;
    4631       699859 :   write_name (decl);
    4632       699859 :   add_substitution (decl);
    4633              : }
    4634              : 
    4635              : 
    4636              : /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
    4637              : 
    4638              :      <array-type> ::= A [</dimension/ number>] _ </element/ type>
    4639              :                   ::= A <expression> _ </element/ type>
    4640              : 
    4641              :      "Array types encode the dimension (number of elements) and the
    4642              :      element type.  For variable length arrays, the dimension (but not
    4643              :      the '_' separator) is omitted."
    4644              :      Note that for flexible array members, like for other arrays of
    4645              :      unspecified size, the dimension is also omitted.  */
    4646              : 
    4647              : static void
    4648      1568769 : write_array_type (const tree type)
    4649              : {
    4650      1568769 :   write_char ('A');
    4651      1568769 :   if (TYPE_DOMAIN (type))
    4652              :     {
    4653       399543 :       tree index_type;
    4654              : 
    4655       399543 :       index_type = TYPE_DOMAIN (type);
    4656              :       /* The INDEX_TYPE gives the upper and lower bounds of the array.
    4657              :          It's null for flexible array members which have no upper bound
    4658              :          (this is a change from GCC 5 and prior where such members were
    4659              :          incorrectly mangled as zero-length arrays).  */
    4660       399543 :       if (tree max = TYPE_MAX_VALUE (index_type))
    4661              :         {
    4662       399543 :           if (TREE_CODE (max) == INTEGER_CST)
    4663              :             {
    4664              :               /* The ABI specifies that we should mangle the number of
    4665              :                  elements in the array, not the largest allowed index.  */
    4666       237299 :               offset_int wmax = wi::to_offset (max) + 1;
    4667              :               /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
    4668              :                  number of elements as zero.  */
    4669       237299 :               wmax = wi::zext (wmax, TYPE_PRECISION (TREE_TYPE (max)));
    4670       237299 :               gcc_assert (wi::fits_uhwi_p (wmax));
    4671       237299 :               write_unsigned_number (wmax.to_uhwi ());
    4672              :             }
    4673              :           else
    4674              :             {
    4675       162244 :               gcc_checking_assert (TREE_CODE (max) == MINUS_EXPR
    4676              :                                    && integer_onep (TREE_OPERAND (max, 1)));
    4677       162244 :               max = TREE_OPERAND (max, 0);
    4678       162244 :               write_expression (max);
    4679              :             }
    4680              :         }
    4681              :     }
    4682      1568769 :   write_char ('_');
    4683      1568769 :   write_type (TREE_TYPE (type));
    4684      1568769 : }
    4685              : 
    4686              : /* Non-terminal <pointer-to-member-type> for pointer-to-member
    4687              :    variables.  TYPE is a pointer-to-member POINTER_TYPE.
    4688              : 
    4689              :      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
    4690              : 
    4691              : static void
    4692       283965 : write_pointer_to_member_type (const tree type)
    4693              : {
    4694       283965 :   write_char ('M');
    4695       283965 :   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
    4696       283965 :   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
    4697       283965 : }
    4698              : 
    4699              : /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
    4700              :    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
    4701              :    TEMPLATE_PARM_INDEX.
    4702              : 
    4703              :      <template-param> ::= T </parameter/ number> _  */
    4704              : 
    4705              : static void
    4706     28989252 : write_template_param (const tree parm)
    4707              : {
    4708     28989252 :   int parm_index;
    4709     28989252 :   int level;
    4710              : 
    4711     28989252 :   MANGLE_TRACE_TREE ("template-parm", parm);
    4712              : 
    4713     28989252 :   switch (TREE_CODE (parm))
    4714              :     {
    4715     28208080 :     case TEMPLATE_TYPE_PARM:
    4716     28208080 :     case TEMPLATE_TEMPLATE_PARM:
    4717     28208080 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
    4718     28208080 :       parm_index = TEMPLATE_TYPE_IDX (parm);
    4719     28208080 :       level = TEMPLATE_TYPE_LEVEL (parm);
    4720     28208080 :       break;
    4721              : 
    4722       781172 :     case TEMPLATE_PARM_INDEX:
    4723       781172 :       parm_index = TEMPLATE_PARM_IDX (parm);
    4724       781172 :       level = TEMPLATE_PARM_LEVEL (parm);
    4725       781172 :       break;
    4726              : 
    4727            0 :     default:
    4728            0 :       gcc_unreachable ();
    4729              :     }
    4730              : 
    4731     28989252 :   write_char ('T');
    4732     28989252 :   if (level > 1)
    4733              :     {
    4734        28675 :       if (abi_check (19))
    4735              :         {
    4736        28663 :           write_char ('L');
    4737        28663 :           write_compact_number (level - 1);
    4738              :         }
    4739              :     }
    4740              :   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
    4741              :      earliest template param denoted by `_'.  */
    4742     28989252 :   write_compact_number (parm_index);
    4743     28989252 : }
    4744              : 
    4745              : /*  <template-template-param>
    4746              :                         ::= <template-param>
    4747              :                         ::= <substitution>  */
    4748              : 
    4749              : static void
    4750          631 : write_template_template_param (const tree parm)
    4751              : {
    4752          631 :   tree templ = NULL_TREE;
    4753              : 
    4754              :   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
    4755              :      template template parameter.  The substitution candidate here is
    4756              :      only the template.  */
    4757          631 :   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
    4758              :     {
    4759          536 :       templ
    4760          536 :         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
    4761          536 :       if (find_substitution (templ))
    4762              :         return;
    4763              :     }
    4764              : 
    4765              :   /* <template-param> encodes only the template parameter position,
    4766              :      not its template arguments, which is fine here.  */
    4767          631 :   write_template_param (parm);
    4768          631 :   if (templ)
    4769          536 :     add_substitution (templ);
    4770              : }
    4771              : 
    4772              : /* Non-terminal <substitution>.
    4773              : 
    4774              :       <substitution> ::= S <seq-id> _
    4775              :                      ::= S_  */
    4776              : 
    4777              : static void
    4778    179436798 : write_substitution (const int seq_id)
    4779              : {
    4780    179436798 :   MANGLE_TRACE ("substitution", "");
    4781              : 
    4782    179436798 :   write_char ('S');
    4783    179436798 :   if (seq_id > 0)
    4784    156155136 :     write_number (seq_id - 1, /*unsigned=*/1, 36);
    4785    179436798 :   write_char ('_');
    4786    179436798 : }
    4787              : 
    4788              : /* Start mangling ENTITY.  */
    4789              : 
    4790              : static inline void
    4791    228364663 : start_mangling (const tree entity)
    4792              : {
    4793    228364663 :   G = {};
    4794    228364663 :   G.entity = entity;
    4795    228364663 :   obstack_free (&name_obstack, name_base);
    4796    228364663 :   mangle_obstack = &name_obstack;
    4797    228364663 :   name_base = obstack_alloc (&name_obstack, 0);
    4798    228364663 : }
    4799              : 
    4800              : /* Done with mangling.  Release the data.  */
    4801              : 
    4802              : static void
    4803    228364663 : finish_mangling_internal (void)
    4804              : {
    4805              :   /* Clear all the substitutions.  */
    4806    228364663 :   vec_safe_truncate (G.substitutions, 0);
    4807              : 
    4808    228364663 :   if (G.mod)
    4809         7873 :     mangle_module_fini ();
    4810              : 
    4811              :   /* Null-terminate the string.  */
    4812    228364663 :   write_char ('\0');
    4813    228364663 : }
    4814              : 
    4815              : 
    4816              : /* Like finish_mangling_internal, but return the mangled string.  */
    4817              : 
    4818              : static inline const char *
    4819       451733 : finish_mangling (void)
    4820              : {
    4821       451733 :   finish_mangling_internal ();
    4822       451733 :   return (const char *) obstack_finish (mangle_obstack);
    4823              : }
    4824              : 
    4825              : /* Like finish_mangling_internal, but return an identifier.  */
    4826              : 
    4827              : static tree
    4828    227912930 : finish_mangling_get_identifier (void)
    4829              : {
    4830    227912930 :   finish_mangling_internal ();
    4831              :   /* Don't obstack_finish here, and the next start_mangling will
    4832              :      remove the identifier.  */
    4833    227912930 :   return get_identifier ((const char *) obstack_base (mangle_obstack));
    4834              : }
    4835              : 
    4836              : /* Initialize data structures for mangling.  */
    4837              : 
    4838              : void
    4839       100969 : init_mangle (void)
    4840              : {
    4841       100969 :   gcc_obstack_init (&name_obstack);
    4842       100969 :   name_base = obstack_alloc (&name_obstack, 0);
    4843       100969 :   vec_alloc (G.substitutions, 0);
    4844              : 
    4845              :   /* Cache these identifiers for quick comparison when checking for
    4846              :      standard substitutions.  */
    4847       100969 :   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
    4848       100969 :   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
    4849       100969 :   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
    4850       100969 :   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
    4851       100969 :   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
    4852       100969 :   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
    4853       100969 : }
    4854              : 
    4855              : /* Generate a mangling for MODULE's global initializer fn.  */
    4856              : 
    4857              : tree
    4858         2102 : mangle_module_global_init (int module)
    4859              : {
    4860         2102 :   start_mangling (NULL_TREE);
    4861              : 
    4862         2102 :   write_string ("_ZGI");
    4863         2102 :   write_module (module, true);
    4864              : 
    4865         2102 :   return finish_mangling_get_identifier ();
    4866              : }
    4867              : 
    4868              : /* Generate the mangled name of DECL.  */
    4869              : 
    4870              : static tree
    4871    221361797 : mangle_decl_string (const tree decl)
    4872              : {
    4873    221361797 :   tree result;
    4874    221361797 :   tree saved_fn = current_function_decl;
    4875              : 
    4876              :   /* We shouldn't be trying to mangle an uninstantiated template.  */
    4877    221361797 :   gcc_assert (!type_dependent_expression_p (decl));
    4878              : 
    4879    221361797 :   current_function_decl = NULL_TREE;
    4880    221361797 :   iloc_sentinel ils (DECL_SOURCE_LOCATION (decl));
    4881              : 
    4882    221361797 :   start_mangling (decl);
    4883              : 
    4884    221361797 :   if (TREE_CODE (decl) == TYPE_DECL)
    4885       328623 :     write_type (TREE_TYPE (decl));
    4886              :   else
    4887    221033174 :     write_mangled_name (decl, true);
    4888              : 
    4889    221361797 :   result = finish_mangling_get_identifier ();
    4890    221361797 :   if (DEBUG_MANGLE)
    4891              :     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
    4892              :              IDENTIFIER_POINTER (result));
    4893              : 
    4894    221361797 :   current_function_decl = saved_fn;
    4895    221361797 :   return result;
    4896    221361797 : }
    4897              : 
    4898              : /* Return an identifier for the external mangled name of DECL.  */
    4899              : 
    4900              : static tree
    4901    165644781 : get_mangled_id (tree decl)
    4902              : {
    4903    165644781 :   tree id = mangle_decl_string (decl);
    4904    165644781 :   return targetm.mangle_decl_assembler_name (decl, id);
    4905              : }
    4906              : 
    4907              : /* Create an identifier for the external mangled name of DECL.  */
    4908              : 
    4909              : void
    4910    165653526 : mangle_decl (const tree decl)
    4911              : {
    4912    165653526 :   tree id;
    4913    165653526 :   bool dep;
    4914              : 
    4915              :   /* Don't bother mangling uninstantiated templates.  */
    4916    165653526 :   ++processing_template_decl;
    4917    165653526 :   if (TREE_CODE (decl) == TYPE_DECL)
    4918       329110 :     dep = dependent_type_p (TREE_TYPE (decl));
    4919              :   else
    4920    329329909 :     dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
    4921    275657957 :            && any_dependent_template_arguments_p (DECL_TI_ARGS (decl)));
    4922    165653526 :   --processing_template_decl;
    4923    165653526 :   if (dep)
    4924              :     return;
    4925              : 
    4926              :   /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
    4927              :      It is not needed to assign names to anonymous namespace, but we use the
    4928              :      "<anon>" marker to be able to tell if type is C++ ODR type or type
    4929              :      produced by other language.  */
    4930    165645268 :   if (TREE_CODE (decl) == TYPE_DECL
    4931       329110 :       && TYPE_STUB_DECL (TREE_TYPE (decl))
    4932    165963656 :       && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl))))
    4933          487 :     id = get_identifier ("<anon>");
    4934              :   else
    4935              :     {
    4936    165644781 :       gcc_assert (TREE_CODE (decl) != TYPE_DECL
    4937              :                   || !no_linkage_check (TREE_TYPE (decl), true));
    4938    165644781 :       if (abi_version_at_least (10))
    4939    165526743 :         if (tree fn = decl_function_context (decl))
    4940      3598746 :           maybe_check_abi_tags (fn, decl);
    4941    165644781 :       id = get_mangled_id (decl);
    4942              :     }
    4943    165645268 :   SET_DECL_ASSEMBLER_NAME (decl, id);
    4944              : 
    4945    165645268 :   if (G.need_cxx17_warning
    4946    165645268 :       && (TREE_PUBLIC (decl) || DECL_REALLY_EXTERN (decl)))
    4947           10 :     warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wnoexcept_type,
    4948              :                 "mangled name for %qD will change in C++17 because the "
    4949              :                 "exception specification is part of a function type",
    4950              :                 decl);
    4951              : 
    4952    165645268 :   if (id != DECL_NAME (decl)
    4953              :       /* Don't do this for a fake symbol we aren't going to emit anyway.  */
    4954    163085301 :       && TREE_CODE (decl) != TYPE_DECL
    4955    328401459 :       && !DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
    4956              :     {
    4957    142168736 :       int save_ver = flag_abi_version;
    4958    142168736 :       tree id2 = NULL_TREE;
    4959              : 
    4960    142168736 :       if (!DECL_REALLY_EXTERN (decl))
    4961              :         {
    4962     85707573 :           record_mangling (decl, G.need_abi_warning);
    4963              : 
    4964     85707573 :           if (!G.need_abi_warning)
    4965              :             return;
    4966              : 
    4967        38369 :           flag_abi_version = flag_abi_compat_version;
    4968        38369 :           id2 = mangle_decl_string (decl);
    4969        38369 :           id2 = targetm.mangle_decl_assembler_name (decl, id2);
    4970        38369 :           flag_abi_version = save_ver;
    4971              : 
    4972        38369 :           if (id2 != id)
    4973        38253 :             note_mangling_alias (decl, id2);
    4974              :         }
    4975              : 
    4976     56499532 :       if (warn_abi)
    4977              :         {
    4978     55678842 :           const char fabi_version[] = "-fabi-version";
    4979              : 
    4980     55678842 :           if (flag_abi_compat_version != warn_abi_version
    4981     55678115 :               || id2 == NULL_TREE)
    4982              :             {
    4983     55678647 :               flag_abi_version = warn_abi_version;
    4984     55678647 :               id2 = mangle_decl_string (decl);
    4985     55678647 :               id2 = targetm.mangle_decl_assembler_name (decl, id2);
    4986              :             }
    4987     55678842 :           flag_abi_version = save_ver;
    4988              : 
    4989     55678842 :           if (id2 == id)
    4990              :             /* OK.  */;
    4991          266 :           else if (warn_abi_version != 0
    4992          266 :                    && abi_version_at_least (warn_abi_version))
    4993          222 :             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
    4994              :                         "the mangled name of %qD changed between "
    4995              :                         "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
    4996              :                         G.entity, fabi_version, warn_abi_version, id2,
    4997              :                         fabi_version, save_ver, id);
    4998              :           else
    4999           44 :             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
    5000              :                         "the mangled name of %qD changes between "
    5001              :                         "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
    5002              :                         G.entity, fabi_version, save_ver, id,
    5003              :                         fabi_version, warn_abi_version, id2);
    5004              :         }
    5005              : 
    5006     56499532 :       flag_abi_version = save_ver;
    5007              :     }
    5008              : }
    5009              : 
    5010              : /* Generate the mangled representation of TYPE.  */
    5011              : 
    5012              : const char *
    5013       451733 : mangle_type_string (const tree type)
    5014              : {
    5015       451733 :   const char *result;
    5016              : 
    5017       451733 :   start_mangling (type);
    5018       451733 :   write_type (type);
    5019       451733 :   result = finish_mangling ();
    5020       451733 :   if (DEBUG_MANGLE)
    5021              :     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
    5022       451733 :   return result;
    5023              : }
    5024              : 
    5025              : /* Create an identifier for the mangled name of a special component
    5026              :    for belonging to TYPE.  CODE is the ABI-specified code for this
    5027              :    component.  */
    5028              : 
    5029              : static tree
    5030      5737394 : mangle_special_for_type (const tree type, const char *code)
    5031              : {
    5032      5737394 :   tree result;
    5033              : 
    5034              :   /* We don't have an actual decl here for the special component, so
    5035              :      we can't just process the <encoded-name>.  Instead, fake it.  */
    5036      5737394 :   start_mangling (type);
    5037              : 
    5038              :   /* Start the mangling.  */
    5039      5737394 :   write_string ("_Z");
    5040      5737394 :   write_string (code);
    5041              : 
    5042              :   /* Add the type.  */
    5043      5737394 :   write_type (type);
    5044      5737394 :   result = finish_mangling_get_identifier ();
    5045              : 
    5046      5737394 :   if (DEBUG_MANGLE)
    5047              :     fprintf (stderr, "mangle_special_for_type = %s\n\n",
    5048              :              IDENTIFIER_POINTER (result));
    5049              : 
    5050      5737394 :   return result;
    5051              : }
    5052              : 
    5053              : /* Create an identifier for the mangled representation of the typeinfo
    5054              :    structure for TYPE.  */
    5055              : 
    5056              : tree
    5057      3285007 : mangle_typeinfo_for_type (const tree type)
    5058              : {
    5059      3285007 :   return mangle_special_for_type (type, "TI");
    5060              : }
    5061              : 
    5062              : /* Create an identifier for the mangled name of the NTBS containing
    5063              :    the mangled name of TYPE.  */
    5064              : 
    5065              : tree
    5066       443286 : mangle_typeinfo_string_for_type (const tree type)
    5067              : {
    5068       443286 :   return mangle_special_for_type (type, "TS");
    5069              : }
    5070              : 
    5071              : /* Create an identifier for the mangled name of the vtable for TYPE.  */
    5072              : 
    5073              : tree
    5074      1824681 : mangle_vtbl_for_type (const tree type)
    5075              : {
    5076      1824681 :   return mangle_special_for_type (type, "TV");
    5077              : }
    5078              : 
    5079              : /* Returns an identifier for the mangled name of the VTT for TYPE.  */
    5080              : 
    5081              : tree
    5082       184420 : mangle_vtt_for_type (const tree type)
    5083              : {
    5084       184420 :   return mangle_special_for_type (type, "TT");
    5085              : }
    5086              : 
    5087              : /* Returns an identifier for the mangled name of the decomposition
    5088              :    artificial variable DECL.  DECLS is the vector of the VAR_DECLs
    5089              :    for the identifier-list.  */
    5090              : 
    5091              : tree
    5092          897 : mangle_decomp (const tree decl, vec<tree> &decls)
    5093              : {
    5094          897 :   gcc_assert (!type_dependent_expression_p (decl));
    5095              : 
    5096          897 :   location_t saved_loc = input_location;
    5097          897 :   input_location = DECL_SOURCE_LOCATION (decl);
    5098              : 
    5099          897 :   check_abi_tags (decl);
    5100          897 :   start_mangling (decl);
    5101          897 :   write_string ("_Z");
    5102              : 
    5103          897 :   tree context = decl_mangling_context (decl);
    5104          897 :   gcc_assert (context != NULL_TREE);
    5105              : 
    5106          897 :   bool nested = false;
    5107          897 :   bool local = false;
    5108          897 :   if (DECL_NAMESPACE_STD_P (context))
    5109            9 :     write_string ("St");
    5110          888 :   else if (TREE_CODE (context) == FUNCTION_DECL)
    5111              :     {
    5112          269 :       local = true;
    5113          269 :       write_char ('Z');
    5114          269 :       write_encoding (context);
    5115          269 :       write_char ('E');
    5116              :     }
    5117          619 :   else if (context != global_namespace)
    5118              :     {
    5119          100 :       nested = true;
    5120          100 :       write_char ('N');
    5121          100 :       write_prefix (context);
    5122              :     }
    5123              : 
    5124          897 :   write_string ("DC");
    5125          897 :   unsigned int i;
    5126          897 :   tree d;
    5127         2966 :   FOR_EACH_VEC_ELT (decls, i, d)
    5128         2069 :     write_unqualified_name (d);
    5129          897 :   write_char ('E');
    5130              : 
    5131          897 :   if (tree tags = get_abi_tags (decl))
    5132              :     {
    5133              :       /* We didn't emit ABI tags for structured bindings before ABI 19.  */
    5134           30 :       if (!G.need_abi_warning
    5135           30 :           && TREE_PUBLIC (decl)
    5136          120 :           && abi_warn_or_compat_version_crosses (19))
    5137           30 :         G.need_abi_warning = 1;
    5138              : 
    5139           30 :       if (abi_version_at_least (19))
    5140           30 :         write_abi_tags (tags);
    5141              :     }
    5142              : 
    5143          897 :   if (nested)
    5144          100 :     write_char ('E');
    5145          797 :   else if (local && DECL_DISCRIMINATOR_P (decl))
    5146          269 :     write_discriminator (discriminator_for_local_entity (decl));
    5147              : 
    5148          897 :   tree id = finish_mangling_get_identifier ();
    5149          897 :   if (DEBUG_MANGLE)
    5150              :     fprintf (stderr, "mangle_decomp = '%s'\n\n",
    5151              :              IDENTIFIER_POINTER (id));
    5152              : 
    5153          897 :   input_location = saved_loc;
    5154              : 
    5155          897 :   if (warn_abi && G.need_abi_warning)
    5156              :     {
    5157            0 :       const char fabi_version[] = "-fabi-version";
    5158            0 :       tree id2 = id;
    5159            0 :       int save_ver = flag_abi_version;
    5160              : 
    5161            0 :       if (flag_abi_version != warn_abi_version)
    5162              :         {
    5163            0 :           flag_abi_version = warn_abi_version;
    5164            0 :           id2 = mangle_decomp (decl, decls);
    5165            0 :           flag_abi_version = save_ver;
    5166              :         }
    5167              : 
    5168            0 :       if (id2 == id)
    5169              :         /* OK.  */;
    5170            0 :       else if (warn_abi_version != 0
    5171            0 :                && abi_version_at_least (warn_abi_version))
    5172            0 :         warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
    5173              :                     "the mangled name of %qD changed between "
    5174              :                     "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
    5175              :                     G.entity, fabi_version, warn_abi_version, id2,
    5176              :                     fabi_version, save_ver, id);
    5177              :       else
    5178            0 :         warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
    5179              :                     "the mangled name of %qD changes between "
    5180              :                     "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
    5181              :                     G.entity, fabi_version, save_ver, id,
    5182              :                     fabi_version, warn_abi_version, id2);
    5183              :     }
    5184              : 
    5185          897 :   return id;
    5186              : }
    5187              : 
    5188              : /* Return an identifier for a construction vtable group.  TYPE is
    5189              :    the most derived class in the hierarchy; BINFO is the base
    5190              :    subobject for which this construction vtable group will be used.
    5191              : 
    5192              :    This mangling isn't part of the ABI specification; in the ABI
    5193              :    specification, the vtable group is dumped in the same COMDAT as the
    5194              :    main vtable, and is referenced only from that vtable, so it doesn't
    5195              :    need an external name.  For binary formats without COMDAT sections,
    5196              :    though, we need external names for the vtable groups.
    5197              : 
    5198              :    We use the production
    5199              : 
    5200              :     <special-name> ::= TC <type> <offset number> _ <base type>  */
    5201              : 
    5202              : tree
    5203       253179 : mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
    5204              : {
    5205       253179 :   tree result;
    5206              : 
    5207       253179 :   start_mangling (type);
    5208              : 
    5209       253179 :   write_string ("_Z");
    5210       253179 :   write_string ("TC");
    5211       253179 :   write_type (type);
    5212       253179 :   write_integer_cst (BINFO_OFFSET (binfo));
    5213       253179 :   write_char ('_');
    5214       253179 :   write_type (BINFO_TYPE (binfo));
    5215              : 
    5216       253179 :   result = finish_mangling_get_identifier ();
    5217       253179 :   if (DEBUG_MANGLE)
    5218              :     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
    5219              :              IDENTIFIER_POINTER (result));
    5220       253179 :   return result;
    5221              : }
    5222              : 
    5223              : /* Mangle a this pointer or result pointer adjustment.
    5224              : 
    5225              :    <call-offset> ::= h <fixed offset number> _
    5226              :                  ::= v <fixed offset number> _ <virtual offset number> _ */
    5227              : 
    5228              : static void
    5229       482514 : mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
    5230              : {
    5231       482514 :   write_char (virtual_offset ? 'v' : 'h');
    5232              : 
    5233              :   /* For either flavor, write the fixed offset.  */
    5234       482514 :   write_integer_cst (fixed_offset);
    5235       482514 :   write_char ('_');
    5236              : 
    5237              :   /* For a virtual thunk, add the virtual offset.  */
    5238       482514 :   if (virtual_offset)
    5239              :     {
    5240       361260 :       write_integer_cst (virtual_offset);
    5241       361260 :       write_char ('_');
    5242              :     }
    5243       482514 : }
    5244              : 
    5245              : /* Return an identifier for the mangled name of a this-adjusting or
    5246              :    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
    5247              :    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
    5248              :    is a virtual thunk, and it is the vtbl offset in
    5249              :    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
    5250              :    zero for a covariant thunk. Note, that FN_DECL might be a covariant
    5251              :    thunk itself. A covariant thunk name always includes the adjustment
    5252              :    for the this pointer, even if there is none.
    5253              : 
    5254              :    <special-name> ::= T <call-offset> <base encoding>
    5255              :                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
    5256              :                                         <base encoding>  */
    5257              : 
    5258              : tree
    5259       482127 : mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
    5260              :               tree virtual_offset, tree thunk)
    5261              : {
    5262       482127 :   tree result;
    5263              : 
    5264       482127 :   if (abi_version_at_least (11))
    5265       482124 :     maybe_check_abi_tags (fn_decl, thunk, 11);
    5266              : 
    5267       482127 :   start_mangling (fn_decl);
    5268              : 
    5269       482127 :   write_string ("_Z");
    5270       482127 :   write_char ('T');
    5271              : 
    5272       482127 :   if (!this_adjusting)
    5273              :     {
    5274              :       /* Covariant thunk with no this adjustment */
    5275          217 :       write_char ('c');
    5276          217 :       mangle_call_offset (integer_zero_node, NULL_TREE);
    5277          217 :       mangle_call_offset (fixed_offset, virtual_offset);
    5278              :     }
    5279       481910 :   else if (!DECL_THUNK_P (fn_decl))
    5280              :     /* Plain this adjusting thunk.  */
    5281       481740 :     mangle_call_offset (fixed_offset, virtual_offset);
    5282              :   else
    5283              :     {
    5284              :       /* This adjusting thunk to covariant thunk.  */
    5285          170 :       write_char ('c');
    5286          170 :       mangle_call_offset (fixed_offset, virtual_offset);
    5287          170 :       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
    5288          170 :       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
    5289          170 :       if (virtual_offset)
    5290          124 :         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
    5291          170 :       mangle_call_offset (fixed_offset, virtual_offset);
    5292          170 :       fn_decl = THUNK_TARGET (fn_decl);
    5293              :     }
    5294              : 
    5295              :   /* Scoped name.  */
    5296       482127 :   write_encoding (fn_decl);
    5297              : 
    5298       482127 :   result = finish_mangling_get_identifier ();
    5299       482127 :   if (DEBUG_MANGLE)
    5300              :     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
    5301       482127 :   return result;
    5302              : }
    5303              : 
    5304              : /* Handle ABI backwards compatibility for past bugs where we didn't call
    5305              :    check_abi_tags in places where it's needed: call check_abi_tags and warn if
    5306              :    it makes a difference.  If FOR_DECL is non-null, it's the declaration
    5307              :    that we're actually trying to mangle; if it's null, we're mangling the
    5308              :    guard variable for T.  */
    5309              : 
    5310              : static void
    5311      4085715 : maybe_check_abi_tags (tree t, tree for_decl, int ver)
    5312              : {
    5313      4085715 :   if (DECL_ASSEMBLER_NAME_SET_P (t))
    5314              :     return;
    5315              : 
    5316       808185 :   tree oldtags = get_abi_tags (t);
    5317              : 
    5318       808185 :   mangle_decl (t);
    5319              : 
    5320       808185 :   tree newtags = get_abi_tags (t);
    5321       808185 :   if (newtags && newtags != oldtags
    5322           48 :       && abi_version_crosses (ver))
    5323              :     {
    5324           12 :       if (for_decl && DECL_THUNK_P (for_decl))
    5325            3 :         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
    5326              :                     "the mangled name of a thunk for %qD changes between "
    5327              :                     "%<-fabi-version=%d%> and %<-fabi-version=%d%>",
    5328              :                     t, flag_abi_version, warn_abi_version);
    5329            9 :       else if (for_decl)
    5330            6 :         warning_at (DECL_SOURCE_LOCATION (for_decl), OPT_Wabi,
    5331              :                     "the mangled name of %qD changes between "
    5332              :                     "%<-fabi-version=%d%> and %<-fabi-version=%d%>",
    5333              :                     for_decl, flag_abi_version, warn_abi_version);
    5334              :       else
    5335            3 :         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
    5336              :                     "the mangled name of the initialization guard variable "
    5337              :                     "for %qD changes between %<-fabi-version=%d%> and "
    5338              :                     "%<-fabi-version=%d%>",
    5339              :                     t, flag_abi_version, warn_abi_version);
    5340              :     }
    5341              : }
    5342              : 
    5343              : /* Write out the appropriate string for this variable when generating
    5344              :    another mangled name based on this one.  */
    5345              : 
    5346              : static void
    5347         7619 : write_guarded_var_name (const tree variable)
    5348              : {
    5349         7619 :   if (DECL_NAME (variable)
    5350         7619 :       && startswith (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR"))
    5351              :     /* The name of a guard variable for a reference temporary should refer
    5352              :        to the reference, not the temporary.  */
    5353            6 :     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
    5354         7613 :   else if (DECL_DECOMPOSITION_P (variable)
    5355          751 :            && DECL_NAME (variable) == NULL_TREE
    5356         7885 :            && startswith (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (variable)),
    5357              :                           "_Z"))
    5358              :     /* The name of a guard variable for a structured binding needs special
    5359              :        casing.  */
    5360          272 :     write_string (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (variable)) + 2);
    5361              :   else
    5362         7341 :     write_name (variable);
    5363         7619 : }
    5364              : 
    5365              : /* Return an identifier for the name of an initialization guard
    5366              :    variable for indicated VARIABLE.  */
    5367              : 
    5368              : tree
    5369         4851 : mangle_guard_variable (const tree variable)
    5370              : {
    5371         4851 :   if (abi_version_at_least (10))
    5372         4845 :     maybe_check_abi_tags (variable);
    5373         4851 :   start_mangling (variable);
    5374         4851 :   write_string ("_ZGV");
    5375         4851 :   write_guarded_var_name (variable);
    5376         4851 :   return finish_mangling_get_identifier ();
    5377              : }
    5378              : 
    5379              : /* Return an identifier for the name of a thread_local initialization
    5380              :    function for VARIABLE.  */
    5381              : 
    5382              : tree
    5383         1190 : mangle_tls_init_fn (const tree variable)
    5384              : {
    5385         1190 :   check_abi_tags (variable);
    5386         1190 :   start_mangling (variable);
    5387         1190 :   write_string ("_ZTH");
    5388         1190 :   write_guarded_var_name (variable);
    5389         1190 :   return finish_mangling_get_identifier ();
    5390              : }
    5391              : 
    5392              : /* Return an identifier for the name of a thread_local wrapper
    5393              :    function for VARIABLE.  */
    5394              : 
    5395              : #define TLS_WRAPPER_PREFIX "_ZTW"
    5396              : 
    5397              : tree
    5398          749 : mangle_tls_wrapper_fn (const tree variable)
    5399              : {
    5400          749 :   check_abi_tags (variable);
    5401          749 :   start_mangling (variable);
    5402          749 :   write_string (TLS_WRAPPER_PREFIX);
    5403          749 :   write_guarded_var_name (variable);
    5404          749 :   return finish_mangling_get_identifier ();
    5405              : }
    5406              : 
    5407              : /* Return true iff FN is a thread_local wrapper function.  */
    5408              : 
    5409              : bool
    5410      2515117 : decl_tls_wrapper_p (const tree fn)
    5411              : {
    5412      2515117 :   if (TREE_CODE (fn) != FUNCTION_DECL)
    5413              :     return false;
    5414      2141792 :   tree name = DECL_NAME (fn);
    5415      2141792 :   return startswith (IDENTIFIER_POINTER (name), TLS_WRAPPER_PREFIX);
    5416              : }
    5417              : 
    5418              : /* Return an identifier for the name of a temporary variable used to
    5419              :    initialize a static reference.  This is now part of the ABI.  */
    5420              : 
    5421              : tree
    5422          829 : mangle_ref_init_variable (const tree variable)
    5423              : {
    5424          829 :   start_mangling (variable);
    5425          829 :   write_string ("_ZGR");
    5426          829 :   check_abi_tags (variable);
    5427          829 :   write_guarded_var_name (variable);
    5428              :   /* Avoid name clashes with aggregate initialization of multiple
    5429              :      references at once.  */
    5430          829 :   write_compact_number (current_ref_temp_count++);
    5431          829 :   return finish_mangling_get_identifier ();
    5432              : }
    5433              : 
    5434              : /* Return an identifier for the mangled name of a C++20 template parameter
    5435              :    object for template argument EXPR.  */
    5436              : 
    5437              : tree
    5438        67815 : mangle_template_parm_object (tree expr)
    5439              : {
    5440        67815 :   start_mangling (expr);
    5441        67815 :   write_string ("_ZTAX");
    5442        67815 :   write_expression (expr);
    5443        67815 :   write_char ('E');
    5444        67815 :   return finish_mangling_get_identifier ();
    5445              : }
    5446              : 
    5447              : /* Given a CLASS_TYPE, such as a record for std::bad_exception this
    5448              :    function generates a mangled name for the vtable map variable of
    5449              :    the class type.  For example, if the class type is
    5450              :    "std::bad_exception", the mangled name for the class is
    5451              :    "St13bad_exception".  This function would generate the name
    5452              :    "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
    5453              :    "_VTV<std::bad_exception>::__vtable_map".  */
    5454              : 
    5455              : 
    5456              : char *
    5457            6 : get_mangled_vtable_map_var_name (tree class_type)
    5458              : {
    5459            6 :   char *var_name = NULL;
    5460            6 :   const char *prefix = "_ZN4_VTVI";
    5461            6 :   const char *postfix = "E12__vtable_mapE";
    5462              : 
    5463            6 :   gcc_assert (TREE_CODE (class_type) == RECORD_TYPE);
    5464              : 
    5465            6 :   tree class_id = DECL_ASSEMBLER_NAME (TYPE_NAME (class_type));
    5466              : 
    5467            6 :   if (strstr (IDENTIFIER_POINTER (class_id), "<anon>") != NULL)
    5468              :     {
    5469            0 :       class_id = get_mangled_id (TYPE_NAME (class_type));
    5470            0 :       vtbl_register_mangled_name (TYPE_NAME (class_type), class_id);
    5471              :     }
    5472              : 
    5473            6 :   unsigned int len = strlen (IDENTIFIER_POINTER (class_id)) +
    5474              :                      strlen (prefix) +
    5475            6 :                      strlen (postfix) + 1;
    5476              : 
    5477            6 :   var_name = (char *) xmalloc (len);
    5478              : 
    5479            6 :   sprintf (var_name, "%s%s%s", prefix, IDENTIFIER_POINTER (class_id), postfix);
    5480              : 
    5481            6 :   return var_name;
    5482              : }
    5483              : 
    5484              : #include "gt-cp-mangle.h"
        

Generated by: LCOV version 2.5.0-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.