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   /* Copy constructor is deliberately declared but not defined,
1559      copies must always be elided.  */
1560   releasing_vec (const releasing_vec &);
1561
1562   vec_t &operator* () const { return *v; }
1563   vec_t *operator-> () const { return v; }
1564   vec_t *get () const { return v; }
1565   operator vec_t *() const { return v; }
1566   tree& operator[] (unsigned i) const { return (*v)[i]; }
1567
1568   ~releasing_vec() { release_tree_vector (v); }
1569 private:
1570   vec_t *v;
1571 };
1572
1573 /* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent.  */
1574
1575 static bool
1576 equal_abi_tags (tree t1, tree t2)
1577 {
1578   releasing_vec v1 = sorted_abi_tags (t1);
1579   releasing_vec v2 = sorted_abi_tags (t2);
1580
1581   unsigned len1 = v1->length();
1582   if (len1 != v2->length())
1583     return false;
1584   for (unsigned i = 0; i < len1; ++i)
1585     if (tree_string_cmp (v1[i], v2[i]) != 0)
1586       return false;
1587   return true;
1588 }
1589
1590 /* Write a user-defined literal operator.
1591           ::= li <source-name>    # "" <source-name>
1592    IDENTIFIER is an LITERAL_IDENTIFIER_NODE.  */
1593
1594 static void
1595 write_literal_operator_name (tree identifier)
1596 {
1597   const char* suffix = UDLIT_OP_SUFFIX (identifier);
1598   write_identifier (UDLIT_OP_MANGLED_PREFIX);
1599   write_unsigned_number (strlen (suffix));
1600   write_identifier (suffix);
1601 }
1602
1603 /* Encode 0 as _, and 1+ as n-1_.  */
1604
1605 static void
1606 write_compact_number (int num)
1607 {
1608   if (num > 0)
1609     write_unsigned_number (num - 1);
1610   write_char ('_');
1611 }
1612
1613 /* Return how many unnamed types precede TYPE in its enclosing class.  */
1614
1615 static int
1616 nested_anon_class_index (tree type)
1617 {
1618   int index = 0;
1619   tree member = TYPE_FIELDS (TYPE_CONTEXT (type));
1620   for (; member; member = DECL_CHAIN (member))
1621     if (DECL_IMPLICIT_TYPEDEF_P (member))
1622       {
1623         tree memtype = TREE_TYPE (member);
1624         if (memtype == type)
1625           return index;
1626         else if (TYPE_UNNAMED_P (memtype))
1627           ++index;
1628       }
1629
1630   if (seen_error ())
1631     return -1;
1632
1633   gcc_unreachable ();
1634 }
1635
1636 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1637
1638 static void
1639 write_unnamed_type_name (const tree type)
1640 {
1641   int discriminator;
1642   MANGLE_TRACE_TREE ("unnamed-type-name", type);
1643
1644   if (TYPE_FUNCTION_SCOPE_P (type))
1645     discriminator = local_class_index (type);
1646   else if (TYPE_CLASS_SCOPE_P (type))
1647     discriminator = nested_anon_class_index (type);
1648   else
1649     {
1650       gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
1651       /* Just use the old mangling at namespace scope.  */
1652       write_source_name (TYPE_IDENTIFIER (type));
1653       return;
1654     }
1655
1656   write_string ("Ut");
1657   write_compact_number (discriminator);
1658 }
1659
1660 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1661    <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters */
1662
1663 static void
1664 write_closure_type_name (const tree type)
1665 {
1666   tree fn = lambda_function (type);
1667   tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
1668   tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
1669
1670   MANGLE_TRACE_TREE ("closure-type-name", type);
1671
1672   write_string ("Ul");
1673   write_method_parms (parms, /*method_p=*/1, fn);
1674   write_char ('E');
1675   write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda));
1676 }
1677
1678 /* Convert NUMBER to ascii using base BASE and generating at least
1679    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1680    into which to store the characters. Returns the number of
1681    characters generated (these will be laid out in advance of where
1682    BUFFER points).  */
1683
1684 static int
1685 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1686                 char *buffer, const unsigned int min_digits)
1687 {
1688   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1689   unsigned digits = 0;
1690
1691   while (number)
1692     {
1693       unsigned HOST_WIDE_INT d = number / base;
1694
1695       *--buffer = base_digits[number - d * base];
1696       digits++;
1697       number = d;
1698     }
1699   while (digits < min_digits)
1700     {
1701       *--buffer = base_digits[0];
1702       digits++;
1703     }
1704   return digits;
1705 }
1706
1707 /* Non-terminal <number>.
1708
1709      <number> ::= [n] </decimal integer/>  */
1710
1711 static void
1712 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1713               const unsigned int base)
1714 {
1715   char buffer[sizeof (HOST_WIDE_INT) * 8];
1716   unsigned count = 0;
1717
1718   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1719     {
1720       write_char ('n');
1721       number = -((HOST_WIDE_INT) number);
1722     }
1723   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1724   write_chars (buffer + sizeof (buffer) - count, count);
1725 }
1726
1727 /* Write out an integral CST in decimal. Most numbers are small, and
1728    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1729    bigger than that, which we must deal with.  */
1730
1731 static inline void
1732 write_integer_cst (const tree cst)
1733 {
1734   int sign = tree_int_cst_sgn (cst);
1735   widest_int abs_value = wi::abs (wi::to_widest (cst));
1736   if (!wi::fits_uhwi_p (abs_value))
1737     {
1738       /* A bignum. We do this in chunks, each of which fits in a
1739          HOST_WIDE_INT.  */
1740       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1741       unsigned HOST_WIDE_INT chunk;
1742       unsigned chunk_digits;
1743       char *ptr = buffer + sizeof (buffer);
1744       unsigned count = 0;
1745       tree n, base, type;
1746       int done;
1747
1748       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1749          representable.  */
1750       chunk = 1000000000;
1751       chunk_digits = 9;
1752
1753       if (sizeof (HOST_WIDE_INT) >= 8)
1754         {
1755           /* It is at least 64 bits, so 10^18 is representable.  */
1756           chunk_digits = 18;
1757           chunk *= chunk;
1758         }
1759
1760       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1761       base = build_int_cstu (type, chunk);
1762       n = wide_int_to_tree (type, wi::to_wide (cst));
1763
1764       if (sign < 0)
1765         {
1766           write_char ('n');
1767           n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
1768         }
1769       do
1770         {
1771           tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
1772           tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
1773           unsigned c;
1774
1775           done = integer_zerop (d);
1776           tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
1777           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1778                               done ? 1 : chunk_digits);
1779           ptr -= c;
1780           count += c;
1781           n = d;
1782         }
1783       while (!done);
1784       write_chars (ptr, count);
1785     }
1786   else
1787     {
1788       /* A small num.  */
1789       if (sign < 0)
1790         write_char ('n');
1791       write_unsigned_number (abs_value.to_uhwi ());
1792     }
1793 }
1794
1795 /* Write out a floating-point literal.
1796
1797     "Floating-point literals are encoded using the bit pattern of the
1798     target processor's internal representation of that number, as a
1799     fixed-length lowercase hexadecimal string, high-order bytes first
1800     (even if the target processor would store low-order bytes first).
1801     The "n" prefix is not used for floating-point literals; the sign
1802     bit is encoded with the rest of the number.
1803
1804     Here are some examples, assuming the IEEE standard representation
1805     for floating point numbers.  (Spaces are for readability, not
1806     part of the encoding.)
1807
1808         1.0f                    Lf 3f80 0000 E
1809        -1.0f                    Lf bf80 0000 E
1810         1.17549435e-38f         Lf 0080 0000 E
1811         1.40129846e-45f         Lf 0000 0001 E
1812         0.0f                    Lf 0000 0000 E"
1813
1814    Caller is responsible for the Lx and the E.  */
1815 static void
1816 write_real_cst (const tree value)
1817 {
1818   long target_real[4];  /* largest supported float */
1819   /* Buffer for eight hex digits in a 32-bit number but big enough
1820      even for 64-bit long to avoid warnings.  */
1821   char buffer[17];
1822   int i, limit, dir;
1823
1824   tree type = TREE_TYPE (value);
1825   int words = GET_MODE_BITSIZE (SCALAR_FLOAT_TYPE_MODE (type)) / 32;
1826
1827   real_to_target (target_real, &TREE_REAL_CST (value),
1828                   TYPE_MODE (type));
1829
1830   /* The value in target_real is in the target word order,
1831      so we must write it out backward if that happens to be
1832      little-endian.  write_number cannot be used, it will
1833      produce uppercase.  */
1834   if (FLOAT_WORDS_BIG_ENDIAN)
1835     i = 0, limit = words, dir = 1;
1836   else
1837     i = words - 1, limit = -1, dir = -1;
1838
1839   for (; i != limit; i += dir)
1840     {
1841       sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1842       write_chars (buffer, 8);
1843     }
1844 }
1845
1846 /* Non-terminal <identifier>.
1847
1848      <identifier> ::= </unqualified source code identifier>  */
1849
1850 static void
1851 write_identifier (const char *identifier)
1852 {
1853   MANGLE_TRACE ("identifier", identifier);
1854   write_string (identifier);
1855 }
1856
1857 /* Handle constructor productions of non-terminal <special-name>.
1858    CTOR is a constructor FUNCTION_DECL.
1859
1860      <special-name> ::= C1   # complete object constructor
1861                     ::= C2   # base object constructor
1862                     ::= C3   # complete object allocating constructor
1863
1864    Currently, allocating constructors are never used.  */
1865
1866 static void
1867 write_special_name_constructor (const tree ctor)
1868 {
1869   write_char ('C');
1870   bool new_inh = (flag_new_inheriting_ctors
1871                   && DECL_INHERITED_CTOR (ctor));
1872   if (new_inh)
1873     write_char ('I');
1874   if (DECL_BASE_CONSTRUCTOR_P (ctor))
1875     write_char ('2');
1876   /* This is the old-style "[unified]" constructor.
1877      In some cases, we may emit this function and call
1878      it from the clones in order to share code and save space.  */
1879   else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
1880     write_char ('4');
1881   else
1882     {
1883       gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor));
1884       write_char ('1');
1885     }
1886   if (new_inh)
1887     write_type (DECL_INHERITED_CTOR_BASE (ctor));
1888 }
1889
1890 /* Handle destructor productions of non-terminal <special-name>.
1891    DTOR is a destructor FUNCTION_DECL.
1892
1893      <special-name> ::= D0 # deleting (in-charge) destructor
1894                     ::= D1 # complete object (in-charge) destructor
1895                     ::= D2 # base object (not-in-charge) destructor  */
1896
1897 static void
1898 write_special_name_destructor (const tree dtor)
1899 {
1900   if (DECL_DELETING_DESTRUCTOR_P (dtor))
1901     write_string ("D0");
1902   else if (DECL_BASE_DESTRUCTOR_P (dtor))
1903     write_string ("D2");
1904   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
1905     /* This is the old-style "[unified]" destructor.
1906        In some cases, we may emit this function and call
1907        it from the clones in order to share code and save space.  */
1908     write_string ("D4");
1909   else
1910     {
1911       gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor));
1912       write_string ("D1");
1913     }
1914 }
1915
1916 /* Scan the vector of local classes and return how many others with the
1917    same name (or same no name) and context precede ENTITY.  */
1918
1919 static int
1920 local_class_index (tree entity)
1921 {
1922   int ix, discriminator = 0;
1923   tree name = (TYPE_UNNAMED_P (entity) ? NULL_TREE
1924                : TYPE_IDENTIFIER (entity));
1925   tree ctx = TYPE_CONTEXT (entity);
1926   for (ix = 0; ; ix++)
1927     {
1928       tree type = (*local_classes)[ix];
1929       if (type == entity)
1930         return discriminator;
1931       if (TYPE_CONTEXT (type) == ctx
1932           && (name ? TYPE_IDENTIFIER (type) == name
1933               : TYPE_UNNAMED_P (type)))
1934         ++discriminator;
1935     }
1936   gcc_unreachable ();
1937 }
1938
1939 /* Return the discriminator for ENTITY appearing inside
1940    FUNCTION.  The discriminator is the lexical ordinal of VAR among
1941    entities with the same name in the same FUNCTION.  */
1942
1943 static int
1944 discriminator_for_local_entity (tree entity)
1945 {
1946   if (DECL_DISCRIMINATOR_P (entity))
1947     {
1948       if (DECL_DISCRIMINATOR_SET_P (entity))
1949         return DECL_DISCRIMINATOR (entity);
1950       else
1951         /* The first entity with a particular name doesn't get
1952            DECL_DISCRIMINATOR set up.  */
1953         return 0;
1954     }
1955   else if (TREE_CODE (entity) == TYPE_DECL)
1956     {
1957       /* Scan the list of local classes.  */
1958       entity = TREE_TYPE (entity);
1959
1960       /* Lambdas and unnamed types have their own discriminators.  */
1961       if (LAMBDA_TYPE_P (entity) || TYPE_UNNAMED_P (entity))
1962         return 0;
1963
1964       return local_class_index (entity);
1965     }
1966   else
1967     gcc_unreachable ();
1968 }
1969
1970 /* Return the discriminator for STRING, a string literal used inside
1971    FUNCTION.  The discriminator is the lexical ordinal of STRING among
1972    string literals used in FUNCTION.  */
1973
1974 static int
1975 discriminator_for_string_literal (tree /*function*/,
1976                                   tree /*string*/)
1977 {
1978   /* For now, we don't discriminate amongst string literals.  */
1979   return 0;
1980 }
1981
1982 /*   <discriminator> := _ <number>    # when number < 10
1983                      := __ <number> _ # when number >= 10
1984
1985    The discriminator is used only for the second and later occurrences
1986    of the same name within a single function. In this case <number> is
1987    n - 2, if this is the nth occurrence, in lexical order.  */
1988
1989 static void
1990 write_discriminator (const int discriminator)
1991 {
1992   /* If discriminator is zero, don't write anything.  Otherwise...  */
1993   if (discriminator > 0)
1994     {
1995       write_char ('_');
1996       if (discriminator - 1 >= 10)
1997         {
1998           if (abi_warn_or_compat_version_crosses (11))
1999             G.need_abi_warning = 1;
2000           if (abi_version_at_least (11))
2001             write_char ('_');
2002         }
2003       write_unsigned_number (discriminator - 1);
2004       if (abi_version_at_least (11) && discriminator - 1 >= 10)
2005         write_char ('_');
2006     }
2007 }
2008
2009 /* Mangle the name of a function-scope entity.  FUNCTION is the
2010    FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
2011    default argument scope.  ENTITY is the decl for the entity itself.
2012    LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
2013    either ENTITY itself or an enclosing scope of ENTITY.
2014
2015      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
2016                   := Z <function encoding> E s [<discriminator>]
2017                   := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
2018
2019 static void
2020 write_local_name (tree function, const tree local_entity,
2021                   const tree entity)
2022 {
2023   tree parm = NULL_TREE;
2024
2025   MANGLE_TRACE_TREE ("local-name", entity);
2026
2027   if (TREE_CODE (function) == PARM_DECL)
2028     {
2029       parm = function;
2030       function = DECL_CONTEXT (parm);
2031     }
2032
2033   write_char ('Z');
2034   write_encoding (function);
2035   write_char ('E');
2036
2037   /* For this purpose, parameters are numbered from right-to-left.  */
2038   if (parm)
2039     {
2040       tree t;
2041       int i = 0;
2042       for (t = DECL_ARGUMENTS (function); t; t = DECL_CHAIN (t))
2043         {
2044           if (t == parm)
2045             i = 1;
2046           else if (i)
2047             ++i;
2048         }
2049       write_char ('d');
2050       write_compact_number (i - 1);
2051     }
2052
2053   if (TREE_CODE (entity) == STRING_CST)
2054     {
2055       write_char ('s');
2056       write_discriminator (discriminator_for_string_literal (function,
2057                                                              entity));
2058     }
2059   else
2060     {
2061       /* Now the <entity name>.  Let write_name know its being called
2062          from <local-name>, so it doesn't try to process the enclosing
2063          function scope again.  */
2064       write_name (entity, /*ignore_local_scope=*/1);
2065       write_discriminator (discriminator_for_local_entity (local_entity));
2066     }
2067 }
2068
2069 /* Non-terminals <type> and <CV-qualifier>.
2070
2071      <type> ::= <builtin-type>
2072             ::= <function-type>
2073             ::= <class-enum-type>
2074             ::= <array-type>
2075             ::= <pointer-to-member-type>
2076             ::= <template-param>
2077             ::= <substitution>
2078             ::= <CV-qualifier>
2079             ::= P <type>    # pointer-to
2080             ::= R <type>    # reference-to
2081             ::= C <type>    # complex pair (C 2000)
2082             ::= G <type>    # imaginary (C 2000)     [not supported]
2083             ::= U <source-name> <type>   # vendor extended type qualifier
2084
2085    C++0x extensions
2086
2087      <type> ::= RR <type>   # rvalue reference-to
2088      <type> ::= Dt <expression> # decltype of an id-expression or
2089                                 # class member access
2090      <type> ::= DT <expression> # decltype of an expression
2091      <type> ::= Dn              # decltype of nullptr
2092
2093    TYPE is a type node.  */
2094
2095 static void
2096 write_type (tree type)
2097 {
2098   /* This gets set to nonzero if TYPE turns out to be a (possibly
2099      CV-qualified) builtin type.  */
2100   int is_builtin_type = 0;
2101
2102   MANGLE_TRACE_TREE ("type", type);
2103
2104   if (type == error_mark_node)
2105     return;
2106
2107   type = canonicalize_for_substitution (type);
2108   if (find_substitution (type))
2109     return;
2110
2111
2112   if (write_CV_qualifiers_for_type (type) > 0)
2113     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
2114        mangle the unqualified type.  The recursive call is needed here
2115        since both the qualified and unqualified types are substitution
2116        candidates.  */
2117     {
2118       tree t = TYPE_MAIN_VARIANT (type);
2119       if (TYPE_ATTRIBUTES (t) && !OVERLOAD_TYPE_P (t))
2120         {
2121           tree attrs = NULL_TREE;
2122           if (tx_safe_fn_type_p (type))
2123             attrs = tree_cons (get_identifier ("transaction_safe"),
2124                                NULL_TREE, attrs);
2125           t = cp_build_type_attribute_variant (t, attrs);
2126         }
2127       gcc_assert (t != type);
2128       if (TREE_CODE (t) == FUNCTION_TYPE
2129           || TREE_CODE (t) == METHOD_TYPE)
2130         {
2131           t = build_ref_qualified_type (t, type_memfn_rqual (type));
2132           if (flag_noexcept_type)
2133             {
2134               tree r = TYPE_RAISES_EXCEPTIONS (type);
2135               t = build_exception_variant (t, r);
2136             }
2137           if (abi_version_at_least (8)
2138               || type == TYPE_MAIN_VARIANT (type))
2139             /* Avoid adding the unqualified function type as a substitution.  */
2140             write_function_type (t);
2141           else
2142             write_type (t);
2143           if (abi_warn_or_compat_version_crosses (8))
2144             G.need_abi_warning = 1;
2145         }
2146       else
2147         write_type (t);
2148     }
2149   else if (TREE_CODE (type) == ARRAY_TYPE)
2150     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
2151        so that the cv-qualification of the element type is available
2152        in write_array_type.  */
2153     write_array_type (type);
2154   else
2155     {
2156       tree type_orig = type;
2157
2158       /* See through any typedefs.  */
2159       type = TYPE_MAIN_VARIANT (type);
2160       if (TREE_CODE (type) == FUNCTION_TYPE
2161           || TREE_CODE (type) == METHOD_TYPE)
2162         type = cxx_copy_lang_qualifiers (type, type_orig);
2163
2164       /* According to the C++ ABI, some library classes are passed the
2165          same as the scalar type of their single member and use the same
2166          mangling.  */
2167       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
2168         type = TREE_TYPE (first_field (type));
2169
2170       if (TYPE_PTRDATAMEM_P (type))
2171         write_pointer_to_member_type (type);
2172       else
2173         {
2174           /* Handle any target-specific fundamental types.  */
2175           const char *target_mangling
2176             = targetm.mangle_type (type_orig);
2177
2178           if (target_mangling)
2179             {
2180               write_string (target_mangling);
2181               /* Add substitutions for types other than fundamental
2182                  types.  */
2183               if (!VOID_TYPE_P (type)
2184                   && TREE_CODE (type) != INTEGER_TYPE
2185                   && TREE_CODE (type) != REAL_TYPE
2186                   && TREE_CODE (type) != BOOLEAN_TYPE)
2187                 add_substitution (type);
2188               return;
2189             }
2190
2191           switch (TREE_CODE (type))
2192             {
2193             case VOID_TYPE:
2194             case BOOLEAN_TYPE:
2195             case INTEGER_TYPE:  /* Includes wchar_t.  */
2196             case REAL_TYPE:
2197             case FIXED_POINT_TYPE:
2198               {
2199                 /* If this is a typedef, TYPE may not be one of
2200                    the standard builtin type nodes, but an alias of one.  Use
2201                    TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
2202                 write_builtin_type (TYPE_MAIN_VARIANT (type));
2203                 ++is_builtin_type;
2204               }
2205               break;
2206
2207             case COMPLEX_TYPE:
2208               write_char ('C');
2209               write_type (TREE_TYPE (type));
2210               break;
2211
2212             case FUNCTION_TYPE:
2213             case METHOD_TYPE:
2214               write_function_type (type);
2215               break;
2216
2217             case UNION_TYPE:
2218             case RECORD_TYPE:
2219             case ENUMERAL_TYPE:
2220               /* A pointer-to-member function is represented as a special
2221                  RECORD_TYPE, so check for this first.  */
2222               if (TYPE_PTRMEMFUNC_P (type))
2223                 write_pointer_to_member_type (type);
2224               else
2225                 write_class_enum_type (type);
2226               break;
2227
2228             case TYPENAME_TYPE:
2229             case UNBOUND_CLASS_TEMPLATE:
2230               /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2231                  ordinary nested names.  */
2232               write_nested_name (TYPE_STUB_DECL (type));
2233               break;
2234
2235             case POINTER_TYPE:
2236             case REFERENCE_TYPE:
2237               if (TYPE_PTR_P (type))
2238                 write_char ('P');
2239               else if (TYPE_REF_IS_RVALUE (type))
2240                 write_char ('O');
2241               else
2242                 write_char ('R');
2243               {
2244                 tree target = TREE_TYPE (type);
2245                 /* Attribute const/noreturn are not reflected in mangling.
2246                    We strip them here rather than at a lower level because
2247                    a typedef or template argument can have function type
2248                    with function-cv-quals (that use the same representation),
2249                    but you can't have a pointer/reference to such a type.  */
2250                 if (TREE_CODE (target) == FUNCTION_TYPE)
2251                   {
2252                     if (abi_warn_or_compat_version_crosses (5)
2253                         && TYPE_QUALS (target) != TYPE_UNQUALIFIED)
2254                       G.need_abi_warning = 1;
2255                     if (abi_version_at_least (5))
2256                       target = build_qualified_type (target, TYPE_UNQUALIFIED);
2257                   }
2258                 write_type (target);
2259               }
2260               break;
2261
2262             case TEMPLATE_TYPE_PARM:
2263               if (is_auto (type))
2264                 {
2265                   if (AUTO_IS_DECLTYPE (type))
2266                     write_identifier ("Dc");
2267                   else
2268                     write_identifier ("Da");
2269                   ++is_builtin_type;
2270                   break;
2271                 }
2272               /* fall through.  */
2273             case TEMPLATE_PARM_INDEX:
2274               write_template_param (type);
2275               break;
2276
2277             case TEMPLATE_TEMPLATE_PARM:
2278               write_template_template_param (type);
2279               break;
2280
2281             case BOUND_TEMPLATE_TEMPLATE_PARM:
2282               write_template_template_param (type);
2283               write_template_args
2284                 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
2285               break;
2286
2287             case VECTOR_TYPE:
2288               if (abi_version_at_least (4))
2289                 {
2290                   write_string ("Dv");
2291                   /* Non-constant vector size would be encoded with
2292                      _ expression, but we don't support that yet.  */
2293                   write_unsigned_number (TYPE_VECTOR_SUBPARTS (type)
2294                                          .to_constant ());
2295                   write_char ('_');
2296                 }
2297               else
2298                 write_string ("U8__vector");
2299               if (abi_warn_or_compat_version_crosses (4))
2300                 G.need_abi_warning = 1;
2301               write_type (TREE_TYPE (type));
2302               break;
2303
2304             case TYPE_PACK_EXPANSION:
2305               write_string ("Dp");
2306               write_type (PACK_EXPANSION_PATTERN (type));
2307               break;
2308
2309             case DECLTYPE_TYPE:
2310               /* These shouldn't make it into mangling.  */
2311               gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
2312                           && !DECLTYPE_FOR_LAMBDA_PROXY (type));
2313
2314               /* In ABI <5, we stripped decltype of a plain decl.  */
2315               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2316                 {
2317                   tree expr = DECLTYPE_TYPE_EXPR (type);
2318                   tree etype = NULL_TREE;
2319                   switch (TREE_CODE (expr))
2320                     {
2321                     case VAR_DECL:
2322                     case PARM_DECL:
2323                     case RESULT_DECL:
2324                     case FUNCTION_DECL:
2325                     case CONST_DECL:
2326                     case TEMPLATE_PARM_INDEX:
2327                       etype = TREE_TYPE (expr);
2328                       break;
2329
2330                     default:
2331                       break;
2332                     }
2333
2334                   if (etype && !type_uses_auto (etype))
2335                     {
2336                       if (abi_warn_or_compat_version_crosses (5))
2337                         G.need_abi_warning = 1;
2338                       if (!abi_version_at_least (5))
2339                         {
2340                           write_type (etype);
2341                           return;
2342                         }
2343                     }
2344                 }
2345
2346               write_char ('D');
2347               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2348                 write_char ('t');
2349               else
2350                 write_char ('T');
2351               ++cp_unevaluated_operand;
2352               write_expression (DECLTYPE_TYPE_EXPR (type));
2353               --cp_unevaluated_operand;
2354               write_char ('E');
2355               break;
2356
2357             case NULLPTR_TYPE:
2358               write_string ("Dn");
2359               if (abi_version_at_least (7))
2360                 ++is_builtin_type;
2361               if (abi_warn_or_compat_version_crosses (7))
2362                 G.need_abi_warning = 1;
2363               break;
2364
2365             case TYPEOF_TYPE:
2366               sorry ("mangling typeof, use decltype instead");
2367               break;
2368
2369             case UNDERLYING_TYPE:
2370               sorry ("mangling __underlying_type");
2371               break;
2372
2373             case LANG_TYPE:
2374               /* fall through.  */
2375
2376             default:
2377               gcc_unreachable ();
2378             }
2379         }
2380     }
2381
2382   /* Types other than builtin types are substitution candidates.  */
2383   if (!is_builtin_type)
2384     add_substitution (type);
2385 }
2386
2387 /* qsort callback for sorting a vector of attribute entries.  */
2388
2389 static int
2390 attr_strcmp (const void *p1, const void *p2)
2391 {
2392   tree a1 = *(const tree*)p1;
2393   tree a2 = *(const tree*)p2;
2394
2395   const attribute_spec *as1 = lookup_attribute_spec (get_attribute_name (a1));
2396   const attribute_spec *as2 = lookup_attribute_spec (get_attribute_name (a2));
2397
2398   return strcmp (as1->name, as2->name);
2399 }
2400
2401 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
2402    CV-qualifiers written for TYPE.
2403
2404      <CV-qualifiers> ::= [r] [V] [K]  */
2405
2406 static int
2407 write_CV_qualifiers_for_type (const tree type)
2408 {
2409   int num_qualifiers = 0;
2410
2411   /* The order is specified by:
2412
2413        "In cases where multiple order-insensitive qualifiers are
2414        present, they should be ordered 'K' (closest to the base type),
2415        'V', 'r', and 'U' (farthest from the base type) ..."  */
2416
2417   /* Mangle attributes that affect type identity as extended qualifiers.
2418
2419      We don't do this with classes and enums because their attributes
2420      are part of their definitions, not something added on.  */
2421
2422   if (!OVERLOAD_TYPE_P (type))
2423     {
2424       auto_vec<tree> vec;
2425       for (tree a = TYPE_ATTRIBUTES (type); a; a = TREE_CHAIN (a))
2426         {
2427           tree name = get_attribute_name (a);
2428           const attribute_spec *as = lookup_attribute_spec (name);
2429           if (as && as->affects_type_identity
2430               && !is_attribute_p ("transaction_safe", name)
2431               && !is_attribute_p ("abi_tag", name))
2432             vec.safe_push (a);
2433         }
2434       if (abi_warn_or_compat_version_crosses (10) && !vec.is_empty ())
2435         G.need_abi_warning = true;
2436       if (abi_version_at_least (10))
2437         {
2438           vec.qsort (attr_strcmp);
2439           while (!vec.is_empty())
2440             {
2441               tree a = vec.pop();
2442               const attribute_spec *as
2443                 = lookup_attribute_spec (get_attribute_name (a));
2444
2445               write_char ('U');
2446               write_unsigned_number (strlen (as->name));
2447               write_string (as->name);
2448               if (TREE_VALUE (a))
2449                 {
2450                   write_char ('I');
2451                   for (tree args = TREE_VALUE (a); args;
2452                        args = TREE_CHAIN (args))
2453                     {
2454                       tree arg = TREE_VALUE (args);
2455                       write_template_arg (arg);
2456                     }
2457                   write_char ('E');
2458                 }
2459
2460               ++num_qualifiers;
2461             }
2462         }
2463     }
2464
2465   /* Note that we do not use cp_type_quals below; given "const
2466      int[3]", the "const" is emitted with the "int", not with the
2467      array.  */
2468   cp_cv_quals quals = TYPE_QUALS (type);
2469
2470   if (quals & TYPE_QUAL_RESTRICT)
2471     {
2472       write_char ('r');
2473       ++num_qualifiers;
2474     }
2475   if (quals & TYPE_QUAL_VOLATILE)
2476     {
2477       write_char ('V');
2478       ++num_qualifiers;
2479     }
2480   if (quals & TYPE_QUAL_CONST)
2481     {
2482       write_char ('K');
2483       ++num_qualifiers;
2484     }
2485
2486   return num_qualifiers;
2487 }
2488
2489 /* Non-terminal <builtin-type>.
2490
2491      <builtin-type> ::= v   # void
2492                     ::= b   # bool
2493                     ::= w   # wchar_t
2494                     ::= c   # char
2495                     ::= a   # signed char
2496                     ::= h   # unsigned char
2497                     ::= s   # short
2498                     ::= t   # unsigned short
2499                     ::= i   # int
2500                     ::= j   # unsigned int
2501                     ::= l   # long
2502                     ::= m   # unsigned long
2503                     ::= x   # long long, __int64
2504                     ::= y   # unsigned long long, __int64
2505                     ::= n   # __int128
2506                     ::= o   # unsigned __int128
2507                     ::= f   # float
2508                     ::= d   # double
2509                     ::= e   # long double, __float80
2510                     ::= g   # __float128          [not supported]
2511                     ::= u <source-name>  # vendor extended type */
2512
2513 static void
2514 write_builtin_type (tree type)
2515 {
2516   if (TYPE_CANONICAL (type))
2517     type = TYPE_CANONICAL (type);
2518
2519   switch (TREE_CODE (type))
2520     {
2521     case VOID_TYPE:
2522       write_char ('v');
2523       break;
2524
2525     case BOOLEAN_TYPE:
2526       write_char ('b');
2527       break;
2528
2529     case INTEGER_TYPE:
2530       /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2531          isn't in integer_type_nodes.  */
2532       if (type == wchar_type_node)
2533         write_char ('w');
2534       else if (type == char16_type_node)
2535         write_string ("Ds");
2536       else if (type == char32_type_node)
2537         write_string ("Di");
2538       else
2539         {
2540           size_t itk;
2541           /* Assume TYPE is one of the shared integer type nodes.  Find
2542              it in the array of these nodes.  */
2543         iagain:
2544           for (itk = 0; itk < itk_none; ++itk)
2545             if (integer_types[itk] != NULL_TREE
2546                 && integer_type_codes[itk] != '\0'
2547                 && type == integer_types[itk])
2548               {
2549                 /* Print the corresponding single-letter code.  */
2550                 write_char (integer_type_codes[itk]);
2551                 break;
2552               }
2553
2554           if (itk == itk_none)
2555             {
2556               tree t = c_common_type_for_mode (TYPE_MODE (type),
2557                                                TYPE_UNSIGNED (type));
2558               if (type != t)
2559                 {
2560                   type = t;
2561                   goto iagain;
2562                 }
2563
2564               if (TYPE_PRECISION (type) == 128)
2565                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
2566               else
2567                 {
2568                   /* Allow for cases where TYPE is not one of the shared
2569                      integer type nodes and write a "vendor extended builtin
2570                      type" with a name the form intN or uintN, respectively.
2571                      Situations like this can happen if you have an
2572                      __attribute__((__mode__(__SI__))) type and use exotic
2573                      switches like '-mint8' on AVR.  Of course, this is
2574                      undefined by the C++ ABI (and '-mint8' is not even
2575                      Standard C conforming), but when using such special
2576                      options you're pretty much in nowhere land anyway.  */
2577                   const char *prefix;
2578                   char prec[11];        /* up to ten digits for an unsigned */
2579
2580                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
2581                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
2582                   write_char ('u');     /* "vendor extended builtin type" */
2583                   write_unsigned_number (strlen (prefix) + strlen (prec));
2584                   write_string (prefix);
2585                   write_string (prec);
2586                 }
2587             }
2588         }
2589       break;
2590
2591     case REAL_TYPE:
2592       if (type == float_type_node)
2593         write_char ('f');
2594       else if (type == double_type_node)
2595         write_char ('d');
2596       else if (type == long_double_type_node)
2597         write_char ('e');
2598       else if (type == dfloat32_type_node)
2599         write_string ("Df");
2600       else if (type == dfloat64_type_node)
2601         write_string ("Dd");
2602       else if (type == dfloat128_type_node)
2603         write_string ("De");
2604       else
2605         gcc_unreachable ();
2606       break;
2607
2608     case FIXED_POINT_TYPE:
2609       write_string ("DF");
2610       if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
2611         write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
2612       if (type == fract_type_node
2613           || type == sat_fract_type_node
2614           || type == accum_type_node
2615           || type == sat_accum_type_node)
2616         write_char ('i');
2617       else if (type == unsigned_fract_type_node
2618                || type == sat_unsigned_fract_type_node
2619                || type == unsigned_accum_type_node
2620                || type == sat_unsigned_accum_type_node)
2621         write_char ('j');
2622       else if (type == short_fract_type_node
2623                || type == sat_short_fract_type_node
2624                || type == short_accum_type_node
2625                || type == sat_short_accum_type_node)
2626         write_char ('s');
2627       else if (type == unsigned_short_fract_type_node
2628                || type == sat_unsigned_short_fract_type_node
2629                || type == unsigned_short_accum_type_node
2630                || type == sat_unsigned_short_accum_type_node)
2631         write_char ('t');
2632       else if (type == long_fract_type_node
2633                || type == sat_long_fract_type_node
2634                || type == long_accum_type_node
2635                || type == sat_long_accum_type_node)
2636         write_char ('l');
2637       else if (type == unsigned_long_fract_type_node
2638                || type == sat_unsigned_long_fract_type_node
2639                || type == unsigned_long_accum_type_node
2640                || type == sat_unsigned_long_accum_type_node)
2641         write_char ('m');
2642       else if (type == long_long_fract_type_node
2643                || type == sat_long_long_fract_type_node
2644                || type == long_long_accum_type_node
2645                || type == sat_long_long_accum_type_node)
2646         write_char ('x');
2647       else if (type == unsigned_long_long_fract_type_node
2648                || type == sat_unsigned_long_long_fract_type_node
2649                || type == unsigned_long_long_accum_type_node
2650                || type == sat_unsigned_long_long_accum_type_node)
2651         write_char ('y');
2652       else
2653         sorry ("mangling unknown fixed point type");
2654       write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
2655       if (TYPE_SATURATING (type))
2656         write_char ('s');
2657       else
2658         write_char ('n');
2659       break;
2660
2661     default:
2662       gcc_unreachable ();
2663     }
2664 }
2665
2666 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
2667    METHOD_TYPE.  The return type is mangled before the parameter
2668    types.
2669
2670      <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E   */
2671
2672 static void
2673 write_function_type (const tree type)
2674 {
2675   MANGLE_TRACE_TREE ("function-type", type);
2676
2677   /* For a pointer to member function, the function type may have
2678      cv-qualifiers, indicating the quals for the artificial 'this'
2679      parameter.  */
2680   if (TREE_CODE (type) == METHOD_TYPE)
2681     {
2682       /* The first parameter must be a POINTER_TYPE pointing to the
2683          `this' parameter.  */
2684       tree this_type = class_of_this_parm (type);
2685       write_CV_qualifiers_for_type (this_type);
2686     }
2687
2688   write_exception_spec (TYPE_RAISES_EXCEPTIONS (type));
2689
2690   if (tx_safe_fn_type_p (type))
2691     write_string ("Dx");
2692
2693   write_char ('F');
2694   /* We don't track whether or not a type is `extern "C"'.  Note that
2695      you can have an `extern "C"' function that does not have
2696      `extern "C"' type, and vice versa:
2697
2698        extern "C" typedef void function_t();
2699        function_t f; // f has C++ linkage, but its type is
2700                      // `extern "C"'
2701
2702        typedef void function_t();
2703        extern "C" function_t f; // Vice versa.
2704
2705      See [dcl.link].  */
2706   write_bare_function_type (type, /*include_return_type_p=*/1,
2707                             /*decl=*/NULL);
2708   if (FUNCTION_REF_QUALIFIED (type))
2709     {
2710       if (FUNCTION_RVALUE_QUALIFIED (type))
2711         write_char ('O');
2712       else
2713         write_char ('R');
2714     }
2715   write_char ('E');
2716 }
2717
2718 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
2719    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
2720    is mangled before the parameter types.  If non-NULL, DECL is
2721    FUNCTION_DECL for the function whose type is being emitted.  */
2722
2723 static void
2724 write_bare_function_type (const tree type, const int include_return_type_p,
2725                           const tree decl)
2726 {
2727   MANGLE_TRACE_TREE ("bare-function-type", type);
2728
2729   /* Mangle the return type, if requested.  */
2730   if (include_return_type_p)
2731     write_type (TREE_TYPE (type));
2732
2733   /* Now mangle the types of the arguments.  */
2734   ++G.parm_depth;
2735   write_method_parms (TYPE_ARG_TYPES (type),
2736                       TREE_CODE (type) == METHOD_TYPE,
2737                       decl);
2738   --G.parm_depth;
2739 }
2740
2741 /* Write the mangled representation of a method parameter list of
2742    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
2743    considered a non-static method, and the this parameter is omitted.
2744    If non-NULL, DECL is the FUNCTION_DECL for the function whose
2745    parameters are being emitted.  */
2746
2747 static void
2748 write_method_parms (tree parm_types, const int method_p, const tree decl)
2749 {
2750   tree first_parm_type;
2751   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2752
2753   /* Assume this parameter type list is variable-length.  If it ends
2754      with a void type, then it's not.  */
2755   int varargs_p = 1;
2756
2757   /* If this is a member function, skip the first arg, which is the
2758      this pointer.
2759        "Member functions do not encode the type of their implicit this
2760        parameter."
2761
2762      Similarly, there's no need to mangle artificial parameters, like
2763      the VTT parameters for constructors and destructors.  */
2764   if (method_p)
2765     {
2766       parm_types = TREE_CHAIN (parm_types);
2767       parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
2768
2769       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2770         {
2771           parm_types = TREE_CHAIN (parm_types);
2772           parm_decl = DECL_CHAIN (parm_decl);
2773         }
2774
2775       if (decl && ctor_omit_inherited_parms (decl))
2776         /* Bring back parameters omitted from an inherited ctor.  */
2777         parm_types = FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (decl));
2778     }
2779
2780   for (first_parm_type = parm_types;
2781        parm_types;
2782        parm_types = TREE_CHAIN (parm_types))
2783     {
2784       tree parm = TREE_VALUE (parm_types);
2785       if (parm == void_type_node)
2786         {
2787           /* "Empty parameter lists, whether declared as () or
2788              conventionally as (void), are encoded with a void parameter
2789              (v)."  */
2790           if (parm_types == first_parm_type)
2791             write_type (parm);
2792           /* If the parm list is terminated with a void type, it's
2793              fixed-length.  */
2794           varargs_p = 0;
2795           /* A void type better be the last one.  */
2796           gcc_assert (TREE_CHAIN (parm_types) == NULL);
2797         }
2798       else
2799         write_type (parm);
2800     }
2801
2802   if (varargs_p)
2803     /* <builtin-type> ::= z  # ellipsis  */
2804     write_char ('z');
2805 }
2806
2807 /* <class-enum-type> ::= <name>  */
2808
2809 static void
2810 write_class_enum_type (const tree type)
2811 {
2812   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2813 }
2814
2815 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
2816    arguments.
2817
2818      <template-args> ::= I <template-arg>* E  */
2819
2820 static void
2821 write_template_args (tree args)
2822 {
2823   int i;
2824   int length = 0;
2825
2826   MANGLE_TRACE_TREE ("template-args", args);
2827
2828   write_char ('I');
2829
2830   if (args)
2831     length = TREE_VEC_LENGTH (args);
2832
2833   if (args && length && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2834     {
2835       /* We have nested template args.  We want the innermost template
2836          argument list.  */
2837       args = TREE_VEC_ELT (args, length - 1);
2838       length = TREE_VEC_LENGTH (args);
2839     }
2840   for (i = 0; i < length; ++i)
2841     write_template_arg (TREE_VEC_ELT (args, i));
2842
2843   write_char ('E');
2844 }
2845
2846 /* Write out the
2847    <unqualified-name>
2848    <unqualified-name> <template-args>
2849    part of SCOPE_REF or COMPONENT_REF mangling.  */
2850
2851 static void
2852 write_member_name (tree member)
2853 {
2854   if (identifier_p (member))
2855     {
2856       if (abi_version_at_least (11) && IDENTIFIER_ANY_OP_P (member))
2857         {
2858           write_string ("on");
2859           if (abi_warn_or_compat_version_crosses (11))
2860             G.need_abi_warning = 1;
2861         }
2862       write_unqualified_id (member);
2863     }
2864   else if (DECL_P (member))
2865     write_unqualified_name (member);
2866   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2867     {
2868       tree name = TREE_OPERAND (member, 0);
2869       name = OVL_FIRST (name);
2870       write_member_name (name);
2871       write_template_args (TREE_OPERAND (member, 1));
2872     }
2873   else
2874     write_expression (member);
2875 }
2876
2877 /* <expression> ::= <unary operator-name> <expression>
2878                 ::= <binary operator-name> <expression> <expression>
2879                 ::= <expr-primary>
2880
2881    <expr-primary> ::= <template-param>
2882                   ::= L <type> <value number> E         # literal
2883                   ::= L <mangled-name> E                # external name
2884                   ::= st <type>                         # sizeof
2885                   ::= sr <type> <unqualified-name>      # dependent name
2886                   ::= sr <type> <unqualified-name> <template-args> */
2887
2888 static void
2889 write_expression (tree expr)
2890 {
2891   enum tree_code code = TREE_CODE (expr);
2892
2893   /* Skip NOP_EXPR and CONVERT_EXPR.  They can occur when (say) a pointer
2894      argument is converted (via qualification conversions) to another type.  */
2895   while (CONVERT_EXPR_CODE_P (code)
2896          || location_wrapper_p (expr)
2897          /* Parentheses aren't mangled.  */
2898          || code == PAREN_EXPR
2899          || code == NON_LVALUE_EXPR)
2900     {
2901       expr = TREE_OPERAND (expr, 0);
2902       code = TREE_CODE (expr);
2903     }
2904
2905   if (code == BASELINK
2906       && (!type_unknown_p (expr)
2907           || !BASELINK_QUALIFIED_P (expr)))
2908     {
2909       expr = BASELINK_FUNCTIONS (expr);
2910       code = TREE_CODE (expr);
2911     }
2912
2913   /* Handle pointers-to-members by making them look like expression
2914      nodes.  */
2915   if (code == PTRMEM_CST)
2916     {
2917       expr = build_nt (ADDR_EXPR,
2918                        build_qualified_name (/*type=*/NULL_TREE,
2919                                              PTRMEM_CST_CLASS (expr),
2920                                              PTRMEM_CST_MEMBER (expr),
2921                                              /*template_p=*/false));
2922       code = TREE_CODE (expr);
2923     }
2924
2925   /* Handle template parameters.  */
2926   if (code == TEMPLATE_TYPE_PARM
2927       || code == TEMPLATE_TEMPLATE_PARM
2928       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2929       || code == TEMPLATE_PARM_INDEX)
2930     write_template_param (expr);
2931   /* Handle literals.  */
2932   else if (TREE_CODE_CLASS (code) == tcc_constant
2933            || code == CONST_DECL)
2934     write_template_arg_literal (expr);
2935   else if (code == PARM_DECL && DECL_ARTIFICIAL (expr))
2936     {
2937       gcc_assert (id_equal (DECL_NAME (expr), "this"));
2938       write_string ("fpT");
2939     }
2940   else if (code == PARM_DECL)
2941     {
2942       /* A function parameter used in a late-specified return type.  */
2943       int index = DECL_PARM_INDEX (expr);
2944       int level = DECL_PARM_LEVEL (expr);
2945       int delta = G.parm_depth - level + 1;
2946       gcc_assert (index >= 1);
2947       write_char ('f');
2948       if (delta != 0)
2949         {
2950           if (abi_version_at_least (5))
2951             {
2952               /* Let L be the number of function prototype scopes from the
2953                  innermost one (in which the parameter reference occurs) up
2954                  to (and including) the one containing the declaration of
2955                  the referenced parameter.  If the parameter declaration
2956                  clause of the innermost function prototype scope has been
2957                  completely seen, it is not counted (in that case -- which
2958                  is perhaps the most common -- L can be zero).  */
2959               write_char ('L');
2960               write_unsigned_number (delta - 1);
2961             }
2962           if (abi_warn_or_compat_version_crosses (5))
2963             G.need_abi_warning = true;
2964         }
2965       write_char ('p');
2966       write_compact_number (index - 1);
2967     }
2968   else if (DECL_P (expr))
2969     {
2970       write_char ('L');
2971       write_mangled_name (expr, false);
2972       write_char ('E');
2973     }
2974   else if (TREE_CODE (expr) == SIZEOF_EXPR)
2975     {
2976       tree op = TREE_OPERAND (expr, 0);
2977
2978       if (PACK_EXPANSION_P (op))
2979         {
2980           if (abi_warn_or_compat_version_crosses (11))
2981             G.need_abi_warning = true;
2982           if (abi_version_at_least (11))
2983             {
2984               /* sZ rather than szDp.  */
2985               write_string ("sZ");
2986               write_expression (PACK_EXPANSION_PATTERN (op));
2987               return;
2988             }
2989         }
2990
2991       if (SIZEOF_EXPR_TYPE_P (expr))
2992         {
2993           write_string ("st");
2994           write_type (TREE_TYPE (op));
2995         }
2996       else if (ARGUMENT_PACK_P (op))
2997         {
2998           tree args = ARGUMENT_PACK_ARGS (op);
2999           int length = TREE_VEC_LENGTH (args);
3000           if (abi_warn_or_compat_version_crosses (10))
3001             G.need_abi_warning = true;
3002           if (abi_version_at_least (10))
3003             {
3004               /* sP <template-arg>* E # sizeof...(T), size of a captured
3005                  template parameter pack from an alias template */
3006               write_string ("sP");
3007               for (int i = 0; i < length; ++i)
3008                 write_template_arg (TREE_VEC_ELT (args, i));
3009               write_char ('E');
3010             }
3011           else
3012             {
3013               /* In GCC 5 we represented this sizeof wrong, with the effect
3014                  that we mangled it as the last element of the pack.  */
3015               tree arg = TREE_VEC_ELT (args, length-1);
3016               if (TYPE_P (op))
3017                 {
3018                   write_string ("st");
3019                   write_type (arg);
3020                 }
3021               else
3022                 {
3023                   write_string ("sz");
3024                   write_expression (arg);
3025                 }
3026             }
3027         }
3028       else if (TYPE_P (TREE_OPERAND (expr, 0)))
3029         {
3030           write_string ("st");
3031           write_type (TREE_OPERAND (expr, 0));
3032         }
3033       else
3034         goto normal_expr;
3035     }
3036   else if (TREE_CODE (expr) == ALIGNOF_EXPR
3037            && TYPE_P (TREE_OPERAND (expr, 0)))
3038     {
3039       write_string ("at");
3040       write_type (TREE_OPERAND (expr, 0));
3041     }
3042   else if (code == SCOPE_REF
3043            || code == BASELINK)
3044     {
3045       tree scope, member;
3046       if (code == SCOPE_REF)
3047         {
3048           scope = TREE_OPERAND (expr, 0);
3049           member = TREE_OPERAND (expr, 1);
3050           gcc_assert (!BASELINK_P (member));
3051         }
3052       else
3053         {
3054           scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr));
3055           member = BASELINK_FUNCTIONS (expr);
3056         }
3057
3058       /* If the MEMBER is a real declaration, then the qualifying
3059          scope was not dependent.  Ideally, we would not have a
3060          SCOPE_REF in those cases, but sometimes we do.  If the second
3061          argument is a DECL, then the name must not have been
3062          dependent.  */
3063       if (DECL_P (member))
3064         write_expression (member);
3065       else
3066         {
3067           write_string ("sr");
3068           write_type (scope);
3069           write_member_name (member);
3070         }
3071     }
3072   else if (INDIRECT_REF_P (expr)
3073            && TREE_TYPE (TREE_OPERAND (expr, 0))
3074            && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
3075     {
3076       write_expression (TREE_OPERAND (expr, 0));
3077     }
3078   else if (identifier_p (expr))
3079     {
3080       /* An operator name appearing as a dependent name needs to be
3081          specially marked to disambiguate between a use of the operator
3082          name and a use of the operator in an expression.  */
3083       if (IDENTIFIER_ANY_OP_P (expr))
3084         write_string ("on");
3085       write_unqualified_id (expr);
3086     }
3087   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
3088     {
3089       tree fn = TREE_OPERAND (expr, 0);
3090       fn = OVL_NAME (fn);
3091       if (IDENTIFIER_ANY_OP_P (fn))
3092         write_string ("on");
3093       write_unqualified_id (fn);
3094       write_template_args (TREE_OPERAND (expr, 1));
3095     }
3096   else if (TREE_CODE (expr) == MODOP_EXPR)
3097     {
3098       enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1));
3099       const char *name = OVL_OP_INFO (true, subop)->mangled_name;
3100
3101       write_string (name);
3102       write_expression (TREE_OPERAND (expr, 0));
3103       write_expression (TREE_OPERAND (expr, 2));
3104     }
3105   else if (code == NEW_EXPR || code == VEC_NEW_EXPR)
3106     {
3107       /* ::= [gs] nw <expression>* _ <type> E
3108          ::= [gs] nw <expression>* _ <type> <initializer>
3109          ::= [gs] na <expression>* _ <type> E
3110          ::= [gs] na <expression>* _ <type> <initializer>
3111          <initializer> ::= pi <expression>* E  */
3112       tree placement = TREE_OPERAND (expr, 0);
3113       tree type = TREE_OPERAND (expr, 1);
3114       tree nelts = TREE_OPERAND (expr, 2);
3115       tree init = TREE_OPERAND (expr, 3);
3116       tree t;
3117
3118       gcc_assert (code == NEW_EXPR);
3119       if (TREE_OPERAND (expr, 2))
3120         code = VEC_NEW_EXPR;
3121
3122       if (NEW_EXPR_USE_GLOBAL (expr))
3123         write_string ("gs");
3124
3125       write_string (OVL_OP_INFO (false, code)->mangled_name);
3126
3127       for (t = placement; t; t = TREE_CHAIN (t))
3128         write_expression (TREE_VALUE (t));
3129
3130       write_char ('_');
3131
3132       if (nelts)
3133         {
3134           tree domain;
3135           ++processing_template_decl;
3136           domain = compute_array_index_type (NULL_TREE, nelts,
3137                                              tf_warning_or_error);
3138           type = build_cplus_array_type (type, domain);
3139           --processing_template_decl;
3140         }
3141       write_type (type);
3142
3143       if (init && TREE_CODE (init) == TREE_LIST
3144           && DIRECT_LIST_INIT_P (TREE_VALUE (init)))
3145         write_expression (TREE_VALUE (init));
3146       else
3147         {
3148           if (init)
3149             write_string ("pi");
3150           if (init && init != void_node)
3151             for (t = init; t; t = TREE_CHAIN (t))
3152               write_expression (TREE_VALUE (t));
3153           write_char ('E');
3154         }
3155     }
3156   else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR)
3157     {
3158       gcc_assert (code == DELETE_EXPR);
3159       if (DELETE_EXPR_USE_VEC (expr))
3160         code = VEC_DELETE_EXPR;
3161
3162       if (DELETE_EXPR_USE_GLOBAL (expr))
3163         write_string ("gs");
3164
3165       write_string (OVL_OP_INFO (false, code)->mangled_name);
3166
3167       write_expression (TREE_OPERAND (expr, 0));
3168     }
3169   else if (code == THROW_EXPR)
3170     {
3171       tree op = TREE_OPERAND (expr, 0);
3172       if (op)
3173         {
3174           write_string ("tw");
3175           write_expression (op);
3176         }
3177       else
3178         write_string ("tr");
3179     }
3180   else if (code == CONSTRUCTOR)
3181     {
3182       vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (expr);
3183       unsigned i; tree val;
3184
3185       if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3186         write_string ("il");
3187       else
3188         {
3189           write_string ("tl");
3190           write_type (TREE_TYPE (expr));
3191         }
3192       FOR_EACH_CONSTRUCTOR_VALUE (elts, i, val)
3193         write_expression (val);
3194       write_char ('E');
3195     }
3196   else if (dependent_name (expr))
3197     {
3198       write_unqualified_id (dependent_name (expr));
3199     }
3200   else
3201     {
3202     normal_expr:
3203       int i, len;
3204       const char *name;
3205
3206       /* When we bind a variable or function to a non-type template
3207          argument with reference type, we create an ADDR_EXPR to show
3208          the fact that the entity's address has been taken.  But, we
3209          don't actually want to output a mangling code for the `&'.  */
3210       if (TREE_CODE (expr) == ADDR_EXPR
3211           && TREE_TYPE (expr)
3212           && TYPE_REF_P (TREE_TYPE (expr)))
3213         {
3214           expr = TREE_OPERAND (expr, 0);
3215           if (DECL_P (expr))
3216             {
3217               write_expression (expr);
3218               return;
3219             }
3220
3221           code = TREE_CODE (expr);
3222         }
3223
3224       if (code == COMPONENT_REF)
3225         {
3226           tree ob = TREE_OPERAND (expr, 0);
3227
3228           if (TREE_CODE (ob) == ARROW_EXPR)
3229             {
3230               write_string (OVL_OP_INFO (false, code)->mangled_name);
3231               ob = TREE_OPERAND (ob, 0);
3232               write_expression (ob);
3233             }
3234           else if (!is_dummy_object (ob))
3235             {
3236               write_string ("dt");
3237               write_expression (ob);
3238             }
3239           /* else, for a non-static data member with no associated object (in
3240              unevaluated context), use the unresolved-name mangling.  */
3241
3242           write_member_name (TREE_OPERAND (expr, 1));
3243           return;
3244         }
3245
3246       /* If it wasn't any of those, recursively expand the expression.  */
3247       name = OVL_OP_INFO (false, code)->mangled_name;
3248
3249       /* We used to mangle const_cast and static_cast like a C cast.  */
3250       if (code == CONST_CAST_EXPR
3251           || code == STATIC_CAST_EXPR)
3252         {
3253           if (abi_warn_or_compat_version_crosses (6))
3254             G.need_abi_warning = 1;
3255           if (!abi_version_at_least (6))
3256             name = OVL_OP_INFO (false, CAST_EXPR)->mangled_name;
3257         }
3258
3259       if (name == NULL)
3260         {
3261           switch (code)
3262             {
3263             case TRAIT_EXPR:
3264               error ("use of built-in trait %qE in function signature; "
3265                      "use library traits instead", expr);
3266               break;
3267
3268             default:
3269               sorry ("mangling %C", code);
3270               break;
3271             }
3272           return;
3273         }
3274       else
3275         write_string (name);
3276
3277       switch (code)
3278         {
3279         case CALL_EXPR:
3280           {
3281             tree fn = CALL_EXPR_FN (expr);
3282
3283             if (TREE_CODE (fn) == ADDR_EXPR)
3284               fn = TREE_OPERAND (fn, 0);
3285
3286             /* Mangle a dependent name as the name, not whatever happens to
3287                be the first function in the overload set.  */
3288             if ((TREE_CODE (fn) == FUNCTION_DECL
3289                  || TREE_CODE (fn) == OVERLOAD)
3290                 && type_dependent_expression_p_push (expr))
3291               fn = OVL_NAME (fn);
3292
3293             write_expression (fn);
3294           }
3295
3296           for (i = 0; i < call_expr_nargs (expr); ++i)
3297             write_expression (CALL_EXPR_ARG (expr, i));
3298           write_char ('E');
3299           break;
3300
3301         case CAST_EXPR:
3302           write_type (TREE_TYPE (expr));
3303           if (list_length (TREE_OPERAND (expr, 0)) == 1)
3304             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
3305           else
3306             {
3307               tree args = TREE_OPERAND (expr, 0);
3308               write_char ('_');
3309               for (; args; args = TREE_CHAIN (args))
3310                 write_expression (TREE_VALUE (args));
3311               write_char ('E');
3312             }
3313           break;
3314
3315         case DYNAMIC_CAST_EXPR:
3316         case REINTERPRET_CAST_EXPR:
3317         case STATIC_CAST_EXPR:
3318         case CONST_CAST_EXPR:
3319           write_type (TREE_TYPE (expr));
3320           write_expression (TREE_OPERAND (expr, 0));
3321           break;
3322
3323         case PREINCREMENT_EXPR:
3324         case PREDECREMENT_EXPR:
3325           if (abi_version_at_least (6))
3326             write_char ('_');
3327           if (abi_warn_or_compat_version_crosses (6))
3328             G.need_abi_warning = 1;
3329           /* Fall through.  */
3330
3331         default:
3332           /* In the middle-end, some expressions have more operands than
3333              they do in templates (and mangling).  */
3334           len = cp_tree_operand_length (expr);
3335
3336           for (i = 0; i < len; ++i)
3337             {
3338               tree operand = TREE_OPERAND (expr, i);
3339               /* As a GNU extension, the middle operand of a
3340                  conditional may be omitted.  Since expression
3341                  manglings are supposed to represent the input token
3342                  stream, there's no good way to mangle such an
3343                  expression without extending the C++ ABI.  */
3344               if (code == COND_EXPR && i == 1 && !operand)
3345                 {
3346                   error ("omitted middle operand to %<?:%> operand "
3347                          "cannot be mangled");
3348                   continue;
3349                 }
3350               else if (FOLD_EXPR_P (expr))
3351                 {
3352                   /* The first 'operand' of a fold-expression is the operator
3353                      that it folds over.  */
3354                   if (i == 0)
3355                     {
3356                       int fcode = TREE_INT_CST_LOW (operand);
3357                       write_string (OVL_OP_INFO (false, fcode)->mangled_name);
3358                       continue;
3359                     }
3360                   else if (code == BINARY_LEFT_FOLD_EXPR)
3361                     {
3362                       /* The order of operands of the binary left and right
3363                          folds is the same, but we want to mangle them in
3364                          lexical order, i.e. non-pack first.  */
3365                       if (i == 1)
3366                         operand = FOLD_EXPR_INIT (expr);
3367                       else
3368                         operand = FOLD_EXPR_PACK (expr);
3369                     }
3370                   if (PACK_EXPANSION_P (operand))
3371                     operand = PACK_EXPANSION_PATTERN (operand);
3372                 }
3373               write_expression (operand);
3374             }
3375         }
3376     }
3377 }
3378
3379 /* Literal subcase of non-terminal <template-arg>.
3380
3381      "Literal arguments, e.g. "A<42L>", are encoded with their type
3382      and value. Negative integer values are preceded with "n"; for
3383      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
3384      encoded as 0, true as 1."  */
3385
3386 static void
3387 write_template_arg_literal (const tree value)
3388 {
3389   write_char ('L');
3390   write_type (TREE_TYPE (value));
3391
3392   /* Write a null member pointer value as (type)0, regardless of its
3393      real representation.  */
3394   if (null_member_pointer_value_p (value))
3395     write_integer_cst (integer_zero_node);
3396   else
3397     switch (TREE_CODE (value))
3398       {
3399       case CONST_DECL:
3400         write_integer_cst (DECL_INITIAL (value));
3401         break;
3402
3403       case INTEGER_CST:
3404         gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
3405                     || integer_zerop (value) || integer_onep (value));
3406         write_integer_cst (value);
3407         break;
3408
3409       case REAL_CST:
3410         write_real_cst (value);
3411         break;
3412
3413       case COMPLEX_CST:
3414         if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST
3415             && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST)
3416           {
3417             write_integer_cst (TREE_REALPART (value));
3418             write_char ('_');
3419             write_integer_cst (TREE_IMAGPART (value));
3420           }
3421         else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST
3422                  && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST)
3423           {
3424             write_real_cst (TREE_REALPART (value));
3425             write_char ('_');
3426             write_real_cst (TREE_IMAGPART (value));
3427           }
3428         else
3429           gcc_unreachable ();
3430         break;
3431
3432       case STRING_CST:
3433         sorry ("string literal in function template signature");
3434         break;
3435
3436       default:
3437         gcc_unreachable ();
3438       }
3439
3440   write_char ('E');
3441 }
3442
3443 /* Non-terminal <template-arg>.
3444
3445      <template-arg> ::= <type>                          # type
3446                     ::= L <type> </value/ number> E     # literal
3447                     ::= LZ <name> E                     # external name
3448                     ::= X <expression> E                # expression  */
3449
3450 static void
3451 write_template_arg (tree node)
3452 {
3453   enum tree_code code = TREE_CODE (node);
3454
3455   MANGLE_TRACE_TREE ("template-arg", node);
3456
3457   /* A template template parameter's argument list contains TREE_LIST
3458      nodes of which the value field is the actual argument.  */
3459   if (code == TREE_LIST)
3460     {
3461       node = TREE_VALUE (node);
3462       /* If it's a decl, deal with its type instead.  */
3463       if (DECL_P (node))
3464         {
3465           node = TREE_TYPE (node);
3466           code = TREE_CODE (node);
3467         }
3468     }
3469
3470   /* Strip a conversion added by convert_nontype_argument.  */
3471   if (TREE_CODE (node) == IMPLICIT_CONV_EXPR)
3472     node = TREE_OPERAND (node, 0);
3473   if (REFERENCE_REF_P (node))
3474     node = TREE_OPERAND (node, 0);
3475   if (TREE_CODE (node) == NOP_EXPR
3476       && TYPE_REF_P (TREE_TYPE (node)))
3477     {
3478       /* Template parameters can be of reference type. To maintain
3479          internal consistency, such arguments use a conversion from
3480          address of object to reference type.  */
3481       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
3482       node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
3483     }
3484
3485   if (TREE_CODE (node) == BASELINK
3486       && !type_unknown_p (node))
3487     {
3488       if (abi_version_at_least (6))
3489         node = BASELINK_FUNCTIONS (node);
3490       if (abi_warn_or_compat_version_crosses (6))
3491         /* We wrongly wrapped a class-scope function in X/E.  */
3492         G.need_abi_warning = 1;
3493     }
3494
3495   if (ARGUMENT_PACK_P (node))
3496     {
3497       /* Expand the template argument pack. */
3498       tree args = ARGUMENT_PACK_ARGS (node);
3499       int i, length = TREE_VEC_LENGTH (args);
3500       if (abi_version_at_least (6))
3501         write_char ('J');
3502       else
3503         write_char ('I');
3504       if (abi_warn_or_compat_version_crosses (6))
3505         G.need_abi_warning = 1;
3506       for (i = 0; i < length; ++i)
3507         write_template_arg (TREE_VEC_ELT (args, i));
3508       write_char ('E');
3509     }
3510   else if (TYPE_P (node))
3511     write_type (node);
3512   else if (code == TEMPLATE_DECL)
3513     /* A template appearing as a template arg is a template template arg.  */
3514     write_template_template_arg (node);
3515   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
3516            || code == CONST_DECL
3517            || null_member_pointer_value_p (node))
3518     write_template_arg_literal (node);
3519   else if (DECL_P (node))
3520     {
3521       write_char ('L');
3522       /* Until ABI version 3, the underscore before the mangled name
3523          was incorrectly omitted.  */
3524       if (!abi_version_at_least (3))
3525         write_char ('Z');
3526       else
3527         write_string ("_Z");
3528       if (abi_warn_or_compat_version_crosses (3))
3529         G.need_abi_warning = 1;
3530       write_encoding (node);
3531       write_char ('E');
3532     }
3533   else
3534     {
3535       /* Template arguments may be expressions.  */
3536       write_char ('X');
3537       write_expression (node);
3538       write_char ('E');
3539     }
3540 }
3541
3542 /*  <template-template-arg>
3543                         ::= <name>
3544                         ::= <substitution>  */
3545
3546 static void
3547 write_template_template_arg (const tree decl)
3548 {
3549   MANGLE_TRACE_TREE ("template-template-arg", decl);
3550
3551   if (find_substitution (decl))
3552     return;
3553   write_name (decl, /*ignore_local_scope=*/0);
3554   add_substitution (decl);
3555 }
3556
3557
3558 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
3559
3560      <array-type> ::= A [</dimension/ number>] _ </element/ type>
3561                   ::= A <expression> _ </element/ type>
3562
3563      "Array types encode the dimension (number of elements) and the
3564      element type.  For variable length arrays, the dimension (but not
3565      the '_' separator) is omitted."
3566      Note that for flexible array members, like for other arrays of
3567      unspecified size, the dimension is also omitted.  */
3568
3569 static void
3570 write_array_type (const tree type)
3571 {
3572   write_char ('A');
3573   if (TYPE_DOMAIN (type))
3574     {
3575       tree index_type;
3576
3577       index_type = TYPE_DOMAIN (type);
3578       /* The INDEX_TYPE gives the upper and lower bounds of the array.
3579          It's null for flexible array members which have no upper bound
3580          (this is a change from GCC 5 and prior where such members were
3581          incorrectly mangled as zero-length arrays).  */
3582       if (tree max = TYPE_MAX_VALUE (index_type))
3583         {
3584           if (TREE_CODE (max) == INTEGER_CST)
3585             {
3586               /* The ABI specifies that we should mangle the number of
3587                  elements in the array, not the largest allowed index.  */
3588               offset_int wmax = wi::to_offset (max) + 1;
3589               /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
3590                  number of elements as zero.  */
3591               wmax = wi::zext (wmax, TYPE_PRECISION (TREE_TYPE (max)));
3592               gcc_assert (wi::fits_uhwi_p (wmax));
3593               write_unsigned_number (wmax.to_uhwi ());
3594             }
3595           else
3596             {
3597               max = TREE_OPERAND (max, 0);
3598               write_expression (max);
3599             }
3600         }
3601     }
3602   write_char ('_');
3603   write_type (TREE_TYPE (type));
3604 }
3605
3606 /* Non-terminal <pointer-to-member-type> for pointer-to-member
3607    variables.  TYPE is a pointer-to-member POINTER_TYPE.
3608
3609      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
3610
3611 static void
3612 write_pointer_to_member_type (const tree type)
3613 {
3614   write_char ('M');
3615   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
3616   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
3617 }
3618
3619 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
3620    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3621    TEMPLATE_PARM_INDEX.
3622
3623      <template-param> ::= T </parameter/ number> _  */
3624
3625 static void
3626 write_template_param (const tree parm)
3627 {
3628   int parm_index;
3629
3630   MANGLE_TRACE_TREE ("template-parm", parm);
3631
3632   switch (TREE_CODE (parm))
3633     {
3634     case TEMPLATE_TYPE_PARM:
3635     case TEMPLATE_TEMPLATE_PARM:
3636     case BOUND_TEMPLATE_TEMPLATE_PARM:
3637       parm_index = TEMPLATE_TYPE_IDX (parm);
3638       break;
3639
3640     case TEMPLATE_PARM_INDEX:
3641       parm_index = TEMPLATE_PARM_IDX (parm);
3642       break;
3643
3644     default:
3645       gcc_unreachable ();
3646     }
3647
3648   write_char ('T');
3649   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3650      earliest template param denoted by `_'.  */
3651   write_compact_number (parm_index);
3652 }
3653
3654 /*  <template-template-param>
3655                         ::= <template-param>
3656                         ::= <substitution>  */
3657
3658 static void
3659 write_template_template_param (const tree parm)
3660 {
3661   tree templ = NULL_TREE;
3662
3663   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3664      template template parameter.  The substitution candidate here is
3665      only the template.  */
3666   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
3667     {
3668       templ
3669         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
3670       if (find_substitution (templ))
3671         return;
3672     }
3673
3674   /* <template-param> encodes only the template parameter position,
3675      not its template arguments, which is fine here.  */
3676   write_template_param (parm);
3677   if (templ)
3678     add_substitution (templ);
3679 }
3680
3681 /* Non-terminal <substitution>.
3682
3683       <substitution> ::= S <seq-id> _
3684                      ::= S_  */
3685
3686 static void
3687 write_substitution (const int seq_id)
3688 {
3689   MANGLE_TRACE ("substitution", "");
3690
3691   write_char ('S');
3692   if (seq_id > 0)
3693     write_number (seq_id - 1, /*unsigned=*/1, 36);
3694   write_char ('_');
3695 }
3696
3697 /* Start mangling ENTITY.  */
3698
3699 static inline void
3700 start_mangling (const tree entity)
3701 {
3702   G.entity = entity;
3703   G.need_abi_warning = false;
3704   G.need_cxx17_warning = false;
3705   obstack_free (&name_obstack, name_base);
3706   mangle_obstack = &name_obstack;
3707   name_base = obstack_alloc (&name_obstack, 0);
3708 }
3709
3710 /* Done with mangling. If WARN is true, and the name of G.entity will
3711    be mangled differently in a future version of the ABI, issue a
3712    warning.  */
3713
3714 static void
3715 finish_mangling_internal (void)
3716 {
3717   /* Clear all the substitutions.  */
3718   vec_safe_truncate (G.substitutions, 0);
3719
3720   /* Null-terminate the string.  */
3721   write_char ('\0');
3722 }
3723
3724
3725 /* Like finish_mangling_internal, but return the mangled string.  */
3726
3727 static inline const char *
3728 finish_mangling (void)
3729 {
3730   finish_mangling_internal ();
3731   return (const char *) obstack_finish (mangle_obstack);
3732 }
3733
3734 /* Like finish_mangling_internal, but return an identifier.  */
3735
3736 static tree
3737 finish_mangling_get_identifier (void)
3738 {
3739   finish_mangling_internal ();
3740   /* Don't obstack_finish here, and the next start_mangling will
3741      remove the identifier.  */
3742   return get_identifier ((const char *) obstack_base (mangle_obstack));
3743 }
3744
3745 /* Initialize data structures for mangling.  */
3746
3747 void
3748 init_mangle (void)
3749 {
3750   gcc_obstack_init (&name_obstack);
3751   name_base = obstack_alloc (&name_obstack, 0);
3752   vec_alloc (G.substitutions, 0);
3753
3754   /* Cache these identifiers for quick comparison when checking for
3755      standard substitutions.  */
3756   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
3757   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
3758   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
3759   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
3760   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
3761   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
3762 }
3763
3764 /* Generate the mangled name of DECL.  */
3765
3766 static tree
3767 mangle_decl_string (const tree decl)
3768 {
3769   tree result;
3770   location_t saved_loc = input_location;
3771   tree saved_fn = NULL_TREE;
3772   bool template_p = false;
3773
3774   /* We shouldn't be trying to mangle an uninstantiated template.  */
3775   gcc_assert (!type_dependent_expression_p (decl));
3776
3777   if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3778     {
3779       struct tinst_level *tl = current_instantiation ();
3780       if ((!tl || tl->maybe_get_node () != decl)
3781           && push_tinst_level (decl))
3782         {
3783           template_p = true;
3784           saved_fn = current_function_decl;
3785           current_function_decl = NULL_TREE;
3786         }
3787     }
3788   input_location = DECL_SOURCE_LOCATION (decl);
3789
3790   start_mangling (decl);
3791
3792   if (TREE_CODE (decl) == TYPE_DECL)
3793     write_type (TREE_TYPE (decl));
3794   else
3795     write_mangled_name (decl, true);
3796
3797   result = finish_mangling_get_identifier ();
3798   if (DEBUG_MANGLE)
3799     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
3800              IDENTIFIER_POINTER (result));
3801
3802   if (template_p)
3803     {
3804       pop_tinst_level ();
3805       current_function_decl = saved_fn;
3806     }
3807   input_location = saved_loc;
3808
3809   return result;
3810 }
3811
3812 /* Return an identifier for the external mangled name of DECL.  */
3813
3814 static tree
3815 get_mangled_id (tree decl)
3816 {
3817   tree id = mangle_decl_string (decl);
3818   return targetm.mangle_decl_assembler_name (decl, id);
3819 }
3820
3821 /* Create an identifier for the external mangled name of DECL.  */
3822
3823 void
3824 mangle_decl (const tree decl)
3825 {
3826   tree id;
3827   bool dep;
3828
3829   /* Don't bother mangling uninstantiated templates.  */
3830   ++processing_template_decl;
3831   if (TREE_CODE (decl) == TYPE_DECL)
3832     dep = dependent_type_p (TREE_TYPE (decl));
3833   else
3834     dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
3835            && any_dependent_template_arguments_p (DECL_TI_ARGS (decl)));
3836   --processing_template_decl;
3837   if (dep)
3838     return;
3839
3840   /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
3841      It is not needed to assign names to anonymous namespace, but we use the
3842      "<anon>" marker to be able to tell if type is C++ ODR type or type
3843      produced by other language.  */
3844   if (TREE_CODE (decl) == TYPE_DECL
3845       && TYPE_STUB_DECL (TREE_TYPE (decl))
3846       && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl))))
3847     id = get_identifier ("<anon>");
3848   else
3849     {
3850       gcc_assert (TREE_CODE (decl) != TYPE_DECL
3851                   || !no_linkage_check (TREE_TYPE (decl), true));
3852       if (abi_version_at_least (10))
3853         if (tree fn = decl_function_context (decl))
3854           maybe_check_abi_tags (fn, decl);
3855       id = get_mangled_id (decl);
3856     }
3857   SET_DECL_ASSEMBLER_NAME (decl, id);
3858
3859   if (G.need_cxx17_warning
3860       && (TREE_PUBLIC (decl) || DECL_REALLY_EXTERN (decl)))
3861     warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wnoexcept_type,
3862                 "mangled name for %qD will change in C++17 because the "
3863                 "exception specification is part of a function type",
3864                 decl);
3865
3866   if (id != DECL_NAME (decl)
3867       /* Don't do this for a fake symbol we aren't going to emit anyway.  */
3868       && TREE_CODE (decl) != TYPE_DECL
3869       && !DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
3870     {
3871       int save_ver = flag_abi_version;
3872       tree id2 = NULL_TREE;
3873
3874       if (!DECL_REALLY_EXTERN (decl))
3875         {
3876           record_mangling (decl, G.need_abi_warning);
3877
3878           if (!G.need_abi_warning)
3879             return;
3880
3881           flag_abi_version = flag_abi_compat_version;
3882           id2 = mangle_decl_string (decl);
3883           id2 = targetm.mangle_decl_assembler_name (decl, id2);
3884           flag_abi_version = save_ver;
3885
3886           if (id2 != id)
3887             note_mangling_alias (decl, id2);
3888         }
3889
3890       if (warn_abi)
3891         {
3892           const char fabi_version[] = "-fabi-version";
3893
3894           if (flag_abi_compat_version != warn_abi_version
3895               || id2 == NULL_TREE)
3896             {
3897               flag_abi_version = warn_abi_version;
3898               id2 = mangle_decl_string (decl);
3899               id2 = targetm.mangle_decl_assembler_name (decl, id2);
3900             }
3901           flag_abi_version = save_ver;
3902
3903           if (id2 == id)
3904             /* OK.  */;
3905           else if (warn_abi_version != 0
3906                    && abi_version_at_least (warn_abi_version))
3907             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
3908                         "the mangled name of %qD changed between "
3909                         "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
3910                         G.entity, fabi_version, warn_abi_version, id2,
3911                         fabi_version, save_ver, id);
3912           else
3913             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
3914                         "the mangled name of %qD changes between "
3915                         "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
3916                         G.entity, fabi_version, save_ver, id,
3917                         fabi_version, warn_abi_version, id2);
3918         }
3919
3920       flag_abi_version = save_ver;
3921     }
3922 }
3923
3924 /* Generate the mangled representation of TYPE.  */
3925
3926 const char *
3927 mangle_type_string (const tree type)
3928 {
3929   const char *result;
3930
3931   start_mangling (type);
3932   write_type (type);
3933   result = finish_mangling ();
3934   if (DEBUG_MANGLE)
3935     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
3936   return result;
3937 }
3938
3939 /* Create an identifier for the mangled name of a special component
3940    for belonging to TYPE.  CODE is the ABI-specified code for this
3941    component.  */
3942
3943 static tree
3944 mangle_special_for_type (const tree type, const char *code)
3945 {
3946   tree result;
3947
3948   /* We don't have an actual decl here for the special component, so
3949      we can't just process the <encoded-name>.  Instead, fake it.  */
3950   start_mangling (type);
3951
3952   /* Start the mangling.  */
3953   write_string ("_Z");
3954   write_string (code);
3955
3956   /* Add the type.  */
3957   write_type (type);
3958   result = finish_mangling_get_identifier ();
3959
3960   if (DEBUG_MANGLE)
3961     fprintf (stderr, "mangle_special_for_type = %s\n\n",
3962              IDENTIFIER_POINTER (result));
3963
3964   return result;
3965 }
3966
3967 /* Create an identifier for the mangled representation of the typeinfo
3968    structure for TYPE.  */
3969
3970 tree
3971 mangle_typeinfo_for_type (const tree type)
3972 {
3973   return mangle_special_for_type (type, "TI");
3974 }
3975
3976 /* Create an identifier for the mangled name of the NTBS containing
3977    the mangled name of TYPE.  */
3978
3979 tree
3980 mangle_typeinfo_string_for_type (const tree type)
3981 {
3982   return mangle_special_for_type (type, "TS");
3983 }
3984
3985 /* Create an identifier for the mangled name of the vtable for TYPE.  */
3986
3987 tree
3988 mangle_vtbl_for_type (const tree type)
3989 {
3990   return mangle_special_for_type (type, "TV");
3991 }
3992
3993 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
3994
3995 tree
3996 mangle_vtt_for_type (const tree type)
3997 {
3998   return mangle_special_for_type (type, "TT");
3999 }
4000
4001 /* Returns an identifier for the mangled name of the decomposition
4002    artificial variable DECL.  DECLS is the vector of the VAR_DECLs
4003    for the identifier-list.  */
4004
4005 tree
4006 mangle_decomp (const tree decl, vec<tree> &decls)
4007 {
4008   gcc_assert (!type_dependent_expression_p (decl));
4009
4010   location_t saved_loc = input_location;
4011   input_location = DECL_SOURCE_LOCATION (decl);
4012
4013   start_mangling (decl);
4014   write_string ("_Z");
4015
4016   tree context = decl_mangling_context (decl);
4017   gcc_assert (context != NULL_TREE);
4018
4019   bool nested = false;
4020   if (DECL_NAMESPACE_STD_P (context))
4021     write_string ("St");
4022   else if (context != global_namespace)
4023     {
4024       nested = true;
4025       write_char ('N');
4026       write_prefix (decl_mangling_context (decl));
4027     }
4028
4029   write_string ("DC");
4030   unsigned int i;
4031   tree d;
4032   FOR_EACH_VEC_ELT (decls, i, d)
4033     write_unqualified_name (d);
4034   write_char ('E');
4035
4036   if (nested)
4037     write_char ('E');
4038
4039   tree id = finish_mangling_get_identifier ();
4040   if (DEBUG_MANGLE)
4041     fprintf (stderr, "mangle_decomp = '%s'\n\n",
4042              IDENTIFIER_POINTER (id));
4043
4044   input_location = saved_loc;
4045   return id;
4046 }
4047
4048 /* Return an identifier for a construction vtable group.  TYPE is
4049    the most derived class in the hierarchy; BINFO is the base
4050    subobject for which this construction vtable group will be used.
4051
4052    This mangling isn't part of the ABI specification; in the ABI
4053    specification, the vtable group is dumped in the same COMDAT as the
4054    main vtable, and is referenced only from that vtable, so it doesn't
4055    need an external name.  For binary formats without COMDAT sections,
4056    though, we need external names for the vtable groups.
4057
4058    We use the production
4059
4060     <special-name> ::= CT <type> <offset number> _ <base type>  */
4061
4062 tree
4063 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
4064 {
4065   tree result;
4066
4067   start_mangling (type);
4068
4069   write_string ("_Z");
4070   write_string ("TC");
4071   write_type (type);
4072   write_integer_cst (BINFO_OFFSET (binfo));
4073   write_char ('_');
4074   write_type (BINFO_TYPE (binfo));
4075
4076   result = finish_mangling_get_identifier ();
4077   if (DEBUG_MANGLE)
4078     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
4079              IDENTIFIER_POINTER (result));
4080   return result;
4081 }
4082
4083 /* Mangle a this pointer or result pointer adjustment.
4084
4085    <call-offset> ::= h <fixed offset number> _
4086                  ::= v <fixed offset number> _ <virtual offset number> _ */
4087
4088 static void
4089 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
4090 {
4091   write_char (virtual_offset ? 'v' : 'h');
4092
4093   /* For either flavor, write the fixed offset.  */
4094   write_integer_cst (fixed_offset);
4095   write_char ('_');
4096
4097   /* For a virtual thunk, add the virtual offset.  */
4098   if (virtual_offset)
4099     {
4100       write_integer_cst (virtual_offset);
4101       write_char ('_');
4102     }
4103 }
4104
4105 /* Return an identifier for the mangled name of a this-adjusting or
4106    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
4107    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
4108    is a virtual thunk, and it is the vtbl offset in
4109    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
4110    zero for a covariant thunk. Note, that FN_DECL might be a covariant
4111    thunk itself. A covariant thunk name always includes the adjustment
4112    for the this pointer, even if there is none.
4113
4114    <special-name> ::= T <call-offset> <base encoding>
4115                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
4116                                         <base encoding>  */
4117
4118 tree
4119 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
4120               tree virtual_offset, tree thunk)
4121 {
4122   tree result;
4123
4124   if (abi_version_at_least (11))
4125     maybe_check_abi_tags (fn_decl, thunk, 11);
4126
4127   start_mangling (fn_decl);
4128
4129   write_string ("_Z");
4130   write_char ('T');
4131
4132   if (!this_adjusting)
4133     {
4134       /* Covariant thunk with no this adjustment */
4135       write_char ('c');
4136       mangle_call_offset (integer_zero_node, NULL_TREE);
4137       mangle_call_offset (fixed_offset, virtual_offset);
4138     }
4139   else if (!DECL_THUNK_P (fn_decl))
4140     /* Plain this adjusting thunk.  */
4141     mangle_call_offset (fixed_offset, virtual_offset);
4142   else
4143     {
4144       /* This adjusting thunk to covariant thunk.  */
4145       write_char ('c');
4146       mangle_call_offset (fixed_offset, virtual_offset);
4147       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
4148       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
4149       if (virtual_offset)
4150         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
4151       mangle_call_offset (fixed_offset, virtual_offset);
4152       fn_decl = THUNK_TARGET (fn_decl);
4153     }
4154
4155   /* Scoped name.  */
4156   write_encoding (fn_decl);
4157
4158   result = finish_mangling_get_identifier ();
4159   if (DEBUG_MANGLE)
4160     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
4161   return result;
4162 }
4163
4164 /* Handle ABI backwards compatibility for past bugs where we didn't call
4165    check_abi_tags in places where it's needed: call check_abi_tags and warn if
4166    it makes a difference.  If FOR_DECL is non-null, it's the declaration
4167    that we're actually trying to mangle; if it's null, we're mangling the
4168    guard variable for T.  */
4169
4170 static void
4171 maybe_check_abi_tags (tree t, tree for_decl, int ver)
4172 {
4173   if (DECL_ASSEMBLER_NAME_SET_P (t))
4174     return;
4175
4176   tree oldtags = get_abi_tags (t);
4177
4178   mangle_decl (t);
4179
4180   tree newtags = get_abi_tags (t);
4181   if (newtags && newtags != oldtags
4182       && abi_version_crosses (ver))
4183     {
4184       if (for_decl && DECL_THUNK_P (for_decl))
4185         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
4186                     "the mangled name of a thunk for %qD changes between "
4187                     "-fabi-version=%d and -fabi-version=%d",
4188                     t, flag_abi_version, warn_abi_version);
4189       else if (for_decl)
4190         warning_at (DECL_SOURCE_LOCATION (for_decl), OPT_Wabi,
4191                     "the mangled name of %qD changes between "
4192                     "-fabi-version=%d and -fabi-version=%d",
4193                     for_decl, flag_abi_version, warn_abi_version);
4194       else
4195         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
4196                     "the mangled name of the initialization guard variable "
4197                     "for %qD changes between -fabi-version=%d and "
4198                     "-fabi-version=%d",
4199                     t, flag_abi_version, warn_abi_version);
4200     }
4201 }
4202
4203 /* Write out the appropriate string for this variable when generating
4204    another mangled name based on this one.  */
4205
4206 static void
4207 write_guarded_var_name (const tree variable)
4208 {
4209   if (DECL_NAME (variable)
4210       && strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
4211     /* The name of a guard variable for a reference temporary should refer
4212        to the reference, not the temporary.  */
4213     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
4214   else
4215     write_name (variable, /*ignore_local_scope=*/0);
4216 }
4217
4218 /* Return an identifier for the name of an initialization guard
4219    variable for indicated VARIABLE.  */
4220
4221 tree
4222 mangle_guard_variable (const tree variable)
4223 {
4224   if (abi_version_at_least (10))
4225     maybe_check_abi_tags (variable);
4226   start_mangling (variable);
4227   write_string ("_ZGV");
4228   write_guarded_var_name (variable);
4229   return finish_mangling_get_identifier ();
4230 }
4231
4232 /* Return an identifier for the name of a thread_local initialization
4233    function for VARIABLE.  */
4234
4235 tree
4236 mangle_tls_init_fn (const tree variable)
4237 {
4238   check_abi_tags (variable);
4239   start_mangling (variable);
4240   write_string ("_ZTH");
4241   write_guarded_var_name (variable);
4242   return finish_mangling_get_identifier ();
4243 }
4244
4245 /* Return an identifier for the name of a thread_local wrapper
4246    function for VARIABLE.  */
4247
4248 #define TLS_WRAPPER_PREFIX "_ZTW"
4249
4250 tree
4251 mangle_tls_wrapper_fn (const tree variable)
4252 {
4253   check_abi_tags (variable);
4254   start_mangling (variable);
4255   write_string (TLS_WRAPPER_PREFIX);
4256   write_guarded_var_name (variable);
4257   return finish_mangling_get_identifier ();
4258 }
4259
4260 /* Return true iff FN is a thread_local wrapper function.  */
4261
4262 bool
4263 decl_tls_wrapper_p (const tree fn)
4264 {
4265   if (TREE_CODE (fn) != FUNCTION_DECL)
4266     return false;
4267   tree name = DECL_NAME (fn);
4268   return strncmp (IDENTIFIER_POINTER (name), TLS_WRAPPER_PREFIX,
4269                   strlen (TLS_WRAPPER_PREFIX)) == 0;
4270 }
4271
4272 /* Return an identifier for the name of a temporary variable used to
4273    initialize a static reference.  This isn't part of the ABI, but we might
4274    as well call them something readable.  */
4275
4276 static GTY(()) int temp_count;
4277
4278 tree
4279 mangle_ref_init_variable (const tree variable)
4280 {
4281   start_mangling (variable);
4282   write_string ("_ZGR");
4283   check_abi_tags (variable);
4284   write_name (variable, /*ignore_local_scope=*/0);
4285   /* Avoid name clashes with aggregate initialization of multiple
4286      references at once.  */
4287   write_unsigned_number (temp_count++);
4288   return finish_mangling_get_identifier ();
4289 }
4290 \f
4291 /* Given a CLASS_TYPE, such as a record for std::bad_exception this
4292    function generates a mangled name for the vtable map variable of
4293    the class type.  For example, if the class type is
4294    "std::bad_exception", the mangled name for the class is
4295    "St13bad_exception".  This function would generate the name
4296    "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
4297    "_VTV<std::bad_exception>::__vtable_map".  */
4298
4299
4300 char *
4301 get_mangled_vtable_map_var_name (tree class_type)
4302 {
4303   char *var_name = NULL;
4304   const char *prefix = "_ZN4_VTVI";
4305   const char *postfix = "E12__vtable_mapE";
4306
4307   gcc_assert (TREE_CODE (class_type) == RECORD_TYPE);
4308
4309   tree class_id = DECL_ASSEMBLER_NAME (TYPE_NAME (class_type));
4310
4311   if (strstr (IDENTIFIER_POINTER (class_id), "<anon>") != NULL)
4312     {
4313       class_id = get_mangled_id (TYPE_NAME (class_type));
4314       vtbl_register_mangled_name (TYPE_NAME (class_type), class_id);
4315     }
4316
4317   unsigned int len = strlen (IDENTIFIER_POINTER (class_id)) +
4318                      strlen (prefix) +
4319                      strlen (postfix) + 1;
4320
4321   var_name = (char *) xmalloc (len);
4322
4323   sprintf (var_name, "%s%s%s", prefix, IDENTIFIER_POINTER (class_id), postfix);
4324
4325   return var_name;
4326 }
4327
4328 #include "gt-cp-mangle.h"