gcc/cp/mangle.c

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