gcc/cp/mangle.c

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