gcc/cp/mangle.c

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