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   if (seen_error ())
1627     return -1;
1628
1629   gcc_unreachable ();
1630 }
1631
1632 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1633
1634 static void
1635 write_unnamed_type_name (const tree type)
1636 {
1637   int discriminator;
1638   MANGLE_TRACE_TREE ("unnamed-type-name", type);
1639
1640   if (TYPE_FUNCTION_SCOPE_P (type))
1641     discriminator = local_class_index (type);
1642   else if (TYPE_CLASS_SCOPE_P (type))
1643     discriminator = nested_anon_class_index (type);
1644   else
1645     {
1646       gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
1647       /* Just use the old mangling at namespace scope.  */
1648       write_source_name (TYPE_IDENTIFIER (type));
1649       return;
1650     }
1651
1652   write_string ("Ut");
1653   write_compact_number (discriminator);
1654 }
1655
1656 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1657    <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters */
1658
1659 static void
1660 write_closure_type_name (const tree type)
1661 {
1662   tree fn = lambda_function (type);
1663   tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
1664   tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
1665
1666   MANGLE_TRACE_TREE ("closure-type-name", type);
1667
1668   write_string ("Ul");
1669   write_method_parms (parms, /*method_p=*/1, fn);
1670   write_char ('E');
1671   write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda));
1672 }
1673
1674 /* Convert NUMBER to ascii using base BASE and generating at least
1675    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1676    into which to store the characters. Returns the number of
1677    characters generated (these will be laid out in advance of where
1678    BUFFER points).  */
1679
1680 static int
1681 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1682                 char *buffer, const unsigned int min_digits)
1683 {
1684   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1685   unsigned digits = 0;
1686
1687   while (number)
1688     {
1689       unsigned HOST_WIDE_INT d = number / base;
1690
1691       *--buffer = base_digits[number - d * base];
1692       digits++;
1693       number = d;
1694     }
1695   while (digits < min_digits)
1696     {
1697       *--buffer = base_digits[0];
1698       digits++;
1699     }
1700   return digits;
1701 }
1702
1703 /* Non-terminal <number>.
1704
1705      <number> ::= [n] </decimal integer/>  */
1706
1707 static void
1708 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1709               const unsigned int base)
1710 {
1711   char buffer[sizeof (HOST_WIDE_INT) * 8];
1712   unsigned count = 0;
1713
1714   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1715     {
1716       write_char ('n');
1717       number = -((HOST_WIDE_INT) number);
1718     }
1719   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1720   write_chars (buffer + sizeof (buffer) - count, count);
1721 }
1722
1723 /* Write out an integral CST in decimal. Most numbers are small, and
1724    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1725    bigger than that, which we must deal with.  */
1726
1727 static inline void
1728 write_integer_cst (const tree cst)
1729 {
1730   int sign = tree_int_cst_sgn (cst);
1731   widest_int abs_value = wi::abs (wi::to_widest (cst));
1732   if (!wi::fits_uhwi_p (abs_value))
1733     {
1734       /* A bignum. We do this in chunks, each of which fits in a
1735          HOST_WIDE_INT.  */
1736       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1737       unsigned HOST_WIDE_INT chunk;
1738       unsigned chunk_digits;
1739       char *ptr = buffer + sizeof (buffer);
1740       unsigned count = 0;
1741       tree n, base, type;
1742       int done;
1743
1744       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1745          representable.  */
1746       chunk = 1000000000;
1747       chunk_digits = 9;
1748
1749       if (sizeof (HOST_WIDE_INT) >= 8)
1750         {
1751           /* It is at least 64 bits, so 10^18 is representable.  */
1752           chunk_digits = 18;
1753           chunk *= chunk;
1754         }
1755
1756       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1757       base = build_int_cstu (type, chunk);
1758       n = wide_int_to_tree (type, wi::to_wide (cst));
1759
1760       if (sign < 0)
1761         {
1762           write_char ('n');
1763           n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
1764         }
1765       do
1766         {
1767           tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
1768           tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
1769           unsigned c;
1770
1771           done = integer_zerop (d);
1772           tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
1773           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1774                               done ? 1 : chunk_digits);
1775           ptr -= c;
1776           count += c;
1777           n = d;
1778         }
1779       while (!done);
1780       write_chars (ptr, count);
1781     }
1782   else
1783     {
1784       /* A small num.  */
1785       if (sign < 0)
1786         write_char ('n');
1787       write_unsigned_number (abs_value.to_uhwi ());
1788     }
1789 }
1790
1791 /* Write out a floating-point literal.
1792
1793     "Floating-point literals are encoded using the bit pattern of the
1794     target processor's internal representation of that number, as a
1795     fixed-length lowercase hexadecimal string, high-order bytes first
1796     (even if the target processor would store low-order bytes first).
1797     The "n" prefix is not used for floating-point literals; the sign
1798     bit is encoded with the rest of the number.
1799
1800     Here are some examples, assuming the IEEE standard representation
1801     for floating point numbers.  (Spaces are for readability, not
1802     part of the encoding.)
1803
1804         1.0f                    Lf 3f80 0000 E
1805        -1.0f                    Lf bf80 0000 E
1806         1.17549435e-38f         Lf 0080 0000 E
1807         1.40129846e-45f         Lf 0000 0001 E
1808         0.0f                    Lf 0000 0000 E"
1809
1810    Caller is responsible for the Lx and the E.  */
1811 static void
1812 write_real_cst (const tree value)
1813 {
1814   long target_real[4];  /* largest supported float */
1815   /* Buffer for eight hex digits in a 32-bit number but big enough
1816      even for 64-bit long to avoid warnings.  */
1817   char buffer[17];
1818   int i, limit, dir;
1819
1820   tree type = TREE_TYPE (value);
1821   int words = GET_MODE_BITSIZE (SCALAR_FLOAT_TYPE_MODE (type)) / 32;
1822
1823   real_to_target (target_real, &TREE_REAL_CST (value),
1824                   TYPE_MODE (type));
1825
1826   /* The value in target_real is in the target word order,
1827      so we must write it out backward if that happens to be
1828      little-endian.  write_number cannot be used, it will
1829      produce uppercase.  */
1830   if (FLOAT_WORDS_BIG_ENDIAN)
1831     i = 0, limit = words, dir = 1;
1832   else
1833     i = words - 1, limit = -1, dir = -1;
1834
1835   for (; i != limit; i += dir)
1836     {
1837       sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1838       write_chars (buffer, 8);
1839     }
1840 }
1841
1842 /* Non-terminal <identifier>.
1843
1844      <identifier> ::= </unqualified source code identifier>  */
1845
1846 static void
1847 write_identifier (const char *identifier)
1848 {
1849   MANGLE_TRACE ("identifier", identifier);
1850   write_string (identifier);
1851 }
1852
1853 /* Handle constructor productions of non-terminal <special-name>.
1854    CTOR is a constructor FUNCTION_DECL.
1855
1856      <special-name> ::= C1   # complete object constructor
1857                     ::= C2   # base object constructor
1858                     ::= C3   # complete object allocating constructor
1859
1860    Currently, allocating constructors are never used.  */
1861
1862 static void
1863 write_special_name_constructor (const tree ctor)
1864 {
1865   write_char ('C');
1866   bool new_inh = (flag_new_inheriting_ctors
1867                   && DECL_INHERITED_CTOR (ctor));
1868   if (new_inh)
1869     write_char ('I');
1870   if (DECL_BASE_CONSTRUCTOR_P (ctor))
1871     write_char ('2');
1872   /* This is the old-style "[unified]" constructor.
1873      In some cases, we may emit this function and call
1874      it from the clones in order to share code and save space.  */
1875   else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
1876     write_char ('4');
1877   else
1878     {
1879       gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor));
1880       write_char ('1');
1881     }
1882   if (new_inh)
1883     write_type (DECL_INHERITED_CTOR_BASE (ctor));
1884 }
1885
1886 /* Handle destructor productions of non-terminal <special-name>.
1887    DTOR is a destructor FUNCTION_DECL.
1888
1889      <special-name> ::= D0 # deleting (in-charge) destructor
1890                     ::= D1 # complete object (in-charge) destructor
1891                     ::= D2 # base object (not-in-charge) destructor  */
1892
1893 static void
1894 write_special_name_destructor (const tree dtor)
1895 {
1896   if (DECL_DELETING_DESTRUCTOR_P (dtor))
1897     write_string ("D0");
1898   else if (DECL_BASE_DESTRUCTOR_P (dtor))
1899     write_string ("D2");
1900   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
1901     /* This is the old-style "[unified]" destructor.
1902        In some cases, we may emit this function and call
1903        it from the clones in order to share code and save space.  */
1904     write_string ("D4");
1905   else
1906     {
1907       gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor));
1908       write_string ("D1");
1909     }
1910 }
1911
1912 /* Scan the vector of local classes and return how many others with the
1913    same name (or same no name) and context precede ENTITY.  */
1914
1915 static int
1916 local_class_index (tree entity)
1917 {
1918   int ix, discriminator = 0;
1919   tree name = (TYPE_UNNAMED_P (entity) ? NULL_TREE
1920                : TYPE_IDENTIFIER (entity));
1921   tree ctx = TYPE_CONTEXT (entity);
1922   for (ix = 0; ; ix++)
1923     {
1924       tree type = (*local_classes)[ix];
1925       if (type == entity)
1926         return discriminator;
1927       if (TYPE_CONTEXT (type) == ctx
1928           && (name ? TYPE_IDENTIFIER (type) == name
1929               : TYPE_UNNAMED_P (type)))
1930         ++discriminator;
1931     }
1932   gcc_unreachable ();
1933 }
1934
1935 /* Return the discriminator for ENTITY appearing inside
1936    FUNCTION.  The discriminator is the lexical ordinal of VAR among
1937    entities with the same name in the same FUNCTION.  */
1938
1939 static int
1940 discriminator_for_local_entity (tree entity)
1941 {
1942   if (DECL_DISCRIMINATOR_P (entity))
1943     {
1944       if (DECL_DISCRIMINATOR_SET_P (entity))
1945         return DECL_DISCRIMINATOR (entity);
1946       else
1947         /* The first entity with a particular name doesn't get
1948            DECL_DISCRIMINATOR set up.  */
1949         return 0;
1950     }
1951   else if (TREE_CODE (entity) == TYPE_DECL)
1952     {
1953       /* Scan the list of local classes.  */
1954       entity = TREE_TYPE (entity);
1955
1956       /* Lambdas and unnamed types have their own discriminators.  */
1957       if (LAMBDA_TYPE_P (entity) || TYPE_UNNAMED_P (entity))
1958         return 0;
1959
1960       return local_class_index (entity);
1961     }
1962   else
1963     gcc_unreachable ();
1964 }
1965
1966 /* Return the discriminator for STRING, a string literal used inside
1967    FUNCTION.  The discriminator is the lexical ordinal of STRING among
1968    string literals used in FUNCTION.  */
1969
1970 static int
1971 discriminator_for_string_literal (tree /*function*/,
1972                                   tree /*string*/)
1973 {
1974   /* For now, we don't discriminate amongst string literals.  */
1975   return 0;
1976 }
1977
1978 /*   <discriminator> := _ <number>    # when number < 10
1979                      := __ <number> _ # when number >= 10
1980
1981    The discriminator is used only for the second and later occurrences
1982    of the same name within a single function. In this case <number> is
1983    n - 2, if this is the nth occurrence, in lexical order.  */
1984
1985 static void
1986 write_discriminator (const int discriminator)
1987 {
1988   /* If discriminator is zero, don't write anything.  Otherwise...  */
1989   if (discriminator > 0)
1990     {
1991       write_char ('_');
1992       if (discriminator - 1 >= 10)
1993         {
1994           if (abi_warn_or_compat_version_crosses (11))
1995             G.need_abi_warning = 1;
1996           if (abi_version_at_least (11))
1997             write_char ('_');
1998         }
1999       write_unsigned_number (discriminator - 1);
2000       if (abi_version_at_least (11) && discriminator - 1 >= 10)
2001         write_char ('_');
2002     }
2003 }
2004
2005 /* Mangle the name of a function-scope entity.  FUNCTION is the
2006    FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
2007    default argument scope.  ENTITY is the decl for the entity itself.
2008    LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
2009    either ENTITY itself or an enclosing scope of ENTITY.
2010
2011      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
2012                   := Z <function encoding> E s [<discriminator>]
2013                   := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
2014
2015 static void
2016 write_local_name (tree function, const tree local_entity,
2017                   const tree entity)
2018 {
2019   tree parm = NULL_TREE;
2020
2021   MANGLE_TRACE_TREE ("local-name", entity);
2022
2023   if (TREE_CODE (function) == PARM_DECL)
2024     {
2025       parm = function;
2026       function = DECL_CONTEXT (parm);
2027     }
2028
2029   write_char ('Z');
2030   write_encoding (function);
2031   write_char ('E');
2032
2033   /* For this purpose, parameters are numbered from right-to-left.  */
2034   if (parm)
2035     {
2036       tree t;
2037       int i = 0;
2038       for (t = DECL_ARGUMENTS (function); t; t = DECL_CHAIN (t))
2039         {
2040           if (t == parm)
2041             i = 1;
2042           else if (i)
2043             ++i;
2044         }
2045       write_char ('d');
2046       write_compact_number (i - 1);
2047     }
2048
2049   if (TREE_CODE (entity) == STRING_CST)
2050     {
2051       write_char ('s');
2052       write_discriminator (discriminator_for_string_literal (function,
2053                                                              entity));
2054     }
2055   else
2056     {
2057       /* Now the <entity name>.  Let write_name know its being called
2058          from <local-name>, so it doesn't try to process the enclosing
2059          function scope again.  */
2060       write_name (entity, /*ignore_local_scope=*/1);
2061       write_discriminator (discriminator_for_local_entity (local_entity));
2062     }
2063 }
2064
2065 /* Non-terminals <type> and <CV-qualifier>.
2066
2067      <type> ::= <builtin-type>
2068             ::= <function-type>
2069             ::= <class-enum-type>
2070             ::= <array-type>
2071             ::= <pointer-to-member-type>
2072             ::= <template-param>
2073             ::= <substitution>
2074             ::= <CV-qualifier>
2075             ::= P <type>    # pointer-to
2076             ::= R <type>    # reference-to
2077             ::= C <type>    # complex pair (C 2000)
2078             ::= G <type>    # imaginary (C 2000)     [not supported]
2079             ::= U <source-name> <type>   # vendor extended type qualifier
2080
2081    C++0x extensions
2082
2083      <type> ::= RR <type>   # rvalue reference-to
2084      <type> ::= Dt <expression> # decltype of an id-expression or
2085                                 # class member access
2086      <type> ::= DT <expression> # decltype of an expression
2087      <type> ::= Dn              # decltype of nullptr
2088
2089    TYPE is a type node.  */
2090
2091 static void
2092 write_type (tree type)
2093 {
2094   /* This gets set to nonzero if TYPE turns out to be a (possibly
2095      CV-qualified) builtin type.  */
2096   int is_builtin_type = 0;
2097
2098   MANGLE_TRACE_TREE ("type", type);
2099
2100   if (type == error_mark_node)
2101     return;
2102
2103   type = canonicalize_for_substitution (type);
2104   if (find_substitution (type))
2105     return;
2106
2107
2108   if (write_CV_qualifiers_for_type (type) > 0)
2109     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
2110        mangle the unqualified type.  The recursive call is needed here
2111        since both the qualified and unqualified types are substitution
2112        candidates.  */
2113     {
2114       tree t = TYPE_MAIN_VARIANT (type);
2115       if (TYPE_ATTRIBUTES (t) && !OVERLOAD_TYPE_P (t))
2116         {
2117           tree attrs = NULL_TREE;
2118           if (tx_safe_fn_type_p (type))
2119             attrs = tree_cons (get_identifier ("transaction_safe"),
2120                                NULL_TREE, attrs);
2121           t = cp_build_type_attribute_variant (t, attrs);
2122         }
2123       gcc_assert (t != type);
2124       if (TREE_CODE (t) == FUNCTION_TYPE
2125           || TREE_CODE (t) == METHOD_TYPE)
2126         {
2127           t = build_ref_qualified_type (t, type_memfn_rqual (type));
2128           if (flag_noexcept_type)
2129             {
2130               tree r = TYPE_RAISES_EXCEPTIONS (type);
2131               t = build_exception_variant (t, r);
2132             }
2133           if (abi_version_at_least (8)
2134               || type == TYPE_MAIN_VARIANT (type))
2135             /* Avoid adding the unqualified function type as a substitution.  */
2136             write_function_type (t);
2137           else
2138             write_type (t);
2139           if (abi_warn_or_compat_version_crosses (8))
2140             G.need_abi_warning = 1;
2141         }
2142       else
2143         write_type (t);
2144     }
2145   else if (TREE_CODE (type) == ARRAY_TYPE)
2146     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
2147        so that the cv-qualification of the element type is available
2148        in write_array_type.  */
2149     write_array_type (type);
2150   else
2151     {
2152       tree type_orig = type;
2153
2154       /* See through any typedefs.  */
2155       type = TYPE_MAIN_VARIANT (type);
2156       if (TREE_CODE (type) == FUNCTION_TYPE
2157           || TREE_CODE (type) == METHOD_TYPE)
2158         type = cxx_copy_lang_qualifiers (type, type_orig);
2159
2160       /* According to the C++ ABI, some library classes are passed the
2161          same as the scalar type of their single member and use the same
2162          mangling.  */
2163       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
2164         type = TREE_TYPE (first_field (type));
2165
2166       if (TYPE_PTRDATAMEM_P (type))
2167         write_pointer_to_member_type (type);
2168       else
2169         {
2170           /* Handle any target-specific fundamental types.  */
2171           const char *target_mangling
2172             = targetm.mangle_type (type_orig);
2173
2174           if (target_mangling)
2175             {
2176               write_string (target_mangling);
2177               /* Add substitutions for types other than fundamental
2178                  types.  */
2179               if (!VOID_TYPE_P (type)
2180                   && TREE_CODE (type) != INTEGER_TYPE
2181                   && TREE_CODE (type) != REAL_TYPE
2182                   && TREE_CODE (type) != BOOLEAN_TYPE)
2183                 add_substitution (type);
2184               return;
2185             }
2186
2187           switch (TREE_CODE (type))
2188             {
2189             case VOID_TYPE:
2190             case BOOLEAN_TYPE:
2191             case INTEGER_TYPE:  /* Includes wchar_t.  */
2192             case REAL_TYPE:
2193             case FIXED_POINT_TYPE:
2194               {
2195                 /* If this is a typedef, TYPE may not be one of
2196                    the standard builtin type nodes, but an alias of one.  Use
2197                    TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
2198                 write_builtin_type (TYPE_MAIN_VARIANT (type));
2199                 ++is_builtin_type;
2200               }
2201               break;
2202
2203             case COMPLEX_TYPE:
2204               write_char ('C');
2205               write_type (TREE_TYPE (type));
2206               break;
2207
2208             case FUNCTION_TYPE:
2209             case METHOD_TYPE:
2210               write_function_type (type);
2211               break;
2212
2213             case UNION_TYPE:
2214             case RECORD_TYPE:
2215             case ENUMERAL_TYPE:
2216               /* A pointer-to-member function is represented as a special
2217                  RECORD_TYPE, so check for this first.  */
2218               if (TYPE_PTRMEMFUNC_P (type))
2219                 write_pointer_to_member_type (type);
2220               else
2221                 write_class_enum_type (type);
2222               break;
2223
2224             case TYPENAME_TYPE:
2225             case UNBOUND_CLASS_TEMPLATE:
2226               /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2227                  ordinary nested names.  */
2228               write_nested_name (TYPE_STUB_DECL (type));
2229               break;
2230
2231             case POINTER_TYPE:
2232             case REFERENCE_TYPE:
2233               if (TYPE_PTR_P (type))
2234                 write_char ('P');
2235               else if (TYPE_REF_IS_RVALUE (type))
2236                 write_char ('O');
2237               else
2238                 write_char ('R');
2239               {
2240                 tree target = TREE_TYPE (type);
2241                 /* Attribute const/noreturn are not reflected in mangling.
2242                    We strip them here rather than at a lower level because
2243                    a typedef or template argument can have function type
2244                    with function-cv-quals (that use the same representation),
2245                    but you can't have a pointer/reference to such a type.  */
2246                 if (TREE_CODE (target) == FUNCTION_TYPE)
2247                   {
2248                     if (abi_warn_or_compat_version_crosses (5)
2249                         && TYPE_QUALS (target) != TYPE_UNQUALIFIED)
2250                       G.need_abi_warning = 1;
2251                     if (abi_version_at_least (5))
2252                       target = build_qualified_type (target, TYPE_UNQUALIFIED);
2253                   }
2254                 write_type (target);
2255               }
2256               break;
2257
2258             case TEMPLATE_TYPE_PARM:
2259               if (is_auto (type))
2260                 {
2261                   if (AUTO_IS_DECLTYPE (type))
2262                     write_identifier ("Dc");
2263                   else
2264                     write_identifier ("Da");
2265                   ++is_builtin_type;
2266                   break;
2267                 }
2268               /* fall through.  */
2269             case TEMPLATE_PARM_INDEX:
2270               write_template_param (type);
2271               break;
2272
2273             case TEMPLATE_TEMPLATE_PARM:
2274               write_template_template_param (type);
2275               break;
2276
2277             case BOUND_TEMPLATE_TEMPLATE_PARM:
2278               write_template_template_param (type);
2279               write_template_args
2280                 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
2281               break;
2282
2283             case VECTOR_TYPE:
2284               if (abi_version_at_least (4))
2285                 {
2286                   write_string ("Dv");
2287                   /* Non-constant vector size would be encoded with
2288                      _ expression, but we don't support that yet.  */
2289                   write_unsigned_number (TYPE_VECTOR_SUBPARTS (type)
2290                                          .to_constant ());
2291                   write_char ('_');
2292                 }
2293               else
2294                 write_string ("U8__vector");
2295               if (abi_warn_or_compat_version_crosses (4))
2296                 G.need_abi_warning = 1;
2297               write_type (TREE_TYPE (type));
2298               break;
2299
2300             case TYPE_PACK_EXPANSION:
2301               write_string ("Dp");
2302               write_type (PACK_EXPANSION_PATTERN (type));
2303               break;
2304
2305             case DECLTYPE_TYPE:
2306               /* These shouldn't make it into mangling.  */
2307               gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
2308                           && !DECLTYPE_FOR_LAMBDA_PROXY (type));
2309
2310               /* In ABI <5, we stripped decltype of a plain decl.  */
2311               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2312                 {
2313                   tree expr = DECLTYPE_TYPE_EXPR (type);
2314                   tree etype = NULL_TREE;
2315                   switch (TREE_CODE (expr))
2316                     {
2317                     case VAR_DECL:
2318                     case PARM_DECL:
2319                     case RESULT_DECL:
2320                     case FUNCTION_DECL:
2321                     case CONST_DECL:
2322                     case TEMPLATE_PARM_INDEX:
2323                       etype = TREE_TYPE (expr);
2324                       break;
2325
2326                     default:
2327                       break;
2328                     }
2329
2330                   if (etype && !type_uses_auto (etype))
2331                     {
2332                       if (abi_warn_or_compat_version_crosses (5))
2333                         G.need_abi_warning = 1;
2334                       if (!abi_version_at_least (5))
2335                         {
2336                           write_type (etype);
2337                           return;
2338                         }
2339                     }
2340                 }
2341
2342               write_char ('D');
2343               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2344                 write_char ('t');
2345               else
2346                 write_char ('T');
2347               ++cp_unevaluated_operand;
2348               write_expression (DECLTYPE_TYPE_EXPR (type));
2349               --cp_unevaluated_operand;
2350               write_char ('E');
2351               break;
2352
2353             case NULLPTR_TYPE:
2354               write_string ("Dn");
2355               if (abi_version_at_least (7))
2356                 ++is_builtin_type;
2357               if (abi_warn_or_compat_version_crosses (7))
2358                 G.need_abi_warning = 1;
2359               break;
2360
2361             case TYPEOF_TYPE:
2362               sorry ("mangling typeof, use decltype instead");
2363               break;
2364
2365             case UNDERLYING_TYPE:
2366               sorry ("mangling __underlying_type");
2367               break;
2368
2369             case LANG_TYPE:
2370               /* fall through.  */
2371
2372             default:
2373               gcc_unreachable ();
2374             }
2375         }
2376     }
2377
2378   /* Types other than builtin types are substitution candidates.  */
2379   if (!is_builtin_type)
2380     add_substitution (type);
2381 }
2382
2383 /* qsort callback for sorting a vector of attribute entries.  */
2384
2385 static int
2386 attr_strcmp (const void *p1, const void *p2)
2387 {
2388   tree a1 = *(const tree*)p1;
2389   tree a2 = *(const tree*)p2;
2390
2391   const attribute_spec *as1 = lookup_attribute_spec (get_attribute_name (a1));
2392   const attribute_spec *as2 = lookup_attribute_spec (get_attribute_name (a2));
2393
2394   return strcmp (as1->name, as2->name);
2395 }
2396
2397 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
2398    CV-qualifiers written for TYPE.
2399
2400      <CV-qualifiers> ::= [r] [V] [K]  */
2401
2402 static int
2403 write_CV_qualifiers_for_type (const tree type)
2404 {
2405   int num_qualifiers = 0;
2406
2407   /* The order is specified by:
2408
2409        "In cases where multiple order-insensitive qualifiers are
2410        present, they should be ordered 'K' (closest to the base type),
2411        'V', 'r', and 'U' (farthest from the base type) ..."  */
2412
2413   /* Mangle attributes that affect type identity as extended qualifiers.
2414
2415      We don't do this with classes and enums because their attributes
2416      are part of their definitions, not something added on.  */
2417
2418   if (!OVERLOAD_TYPE_P (type))
2419     {
2420       auto_vec<tree> vec;
2421       for (tree a = TYPE_ATTRIBUTES (type); a; a = TREE_CHAIN (a))
2422         {
2423           tree name = get_attribute_name (a);
2424           const attribute_spec *as = lookup_attribute_spec (name);
2425           if (as && as->affects_type_identity
2426               && !is_attribute_p ("transaction_safe", name)
2427               && !is_attribute_p ("abi_tag", name))
2428             vec.safe_push (a);
2429         }
2430       if (abi_warn_or_compat_version_crosses (10) && !vec.is_empty ())
2431         G.need_abi_warning = true;
2432       if (abi_version_at_least (10))
2433         {
2434           vec.qsort (attr_strcmp);
2435           while (!vec.is_empty())
2436             {
2437               tree a = vec.pop();
2438               const attribute_spec *as
2439                 = lookup_attribute_spec (get_attribute_name (a));
2440
2441               write_char ('U');
2442               write_unsigned_number (strlen (as->name));
2443               write_string (as->name);
2444               if (TREE_VALUE (a))
2445                 {
2446                   write_char ('I');
2447                   for (tree args = TREE_VALUE (a); args;
2448                        args = TREE_CHAIN (args))
2449                     {
2450                       tree arg = TREE_VALUE (args);
2451                       write_template_arg (arg);
2452                     }
2453                   write_char ('E');
2454                 }
2455
2456               ++num_qualifiers;
2457             }
2458         }
2459     }
2460
2461   /* Note that we do not use cp_type_quals below; given "const
2462      int[3]", the "const" is emitted with the "int", not with the
2463      array.  */
2464   cp_cv_quals quals = TYPE_QUALS (type);
2465
2466   if (quals & TYPE_QUAL_RESTRICT)
2467     {
2468       write_char ('r');
2469       ++num_qualifiers;
2470     }
2471   if (quals & TYPE_QUAL_VOLATILE)
2472     {
2473       write_char ('V');
2474       ++num_qualifiers;
2475     }
2476   if (quals & TYPE_QUAL_CONST)
2477     {
2478       write_char ('K');
2479       ++num_qualifiers;
2480     }
2481
2482   return num_qualifiers;
2483 }
2484
2485 /* Non-terminal <builtin-type>.
2486
2487      <builtin-type> ::= v   # void
2488                     ::= b   # bool
2489                     ::= w   # wchar_t
2490                     ::= c   # char
2491                     ::= a   # signed char
2492                     ::= h   # unsigned char
2493                     ::= s   # short
2494                     ::= t   # unsigned short
2495                     ::= i   # int
2496                     ::= j   # unsigned int
2497                     ::= l   # long
2498                     ::= m   # unsigned long
2499                     ::= x   # long long, __int64
2500                     ::= y   # unsigned long long, __int64
2501                     ::= n   # __int128
2502                     ::= o   # unsigned __int128
2503                     ::= f   # float
2504                     ::= d   # double
2505                     ::= e   # long double, __float80
2506                     ::= g   # __float128          [not supported]
2507                     ::= u <source-name>  # vendor extended type */
2508
2509 static void
2510 write_builtin_type (tree type)
2511 {
2512   if (TYPE_CANONICAL (type))
2513     type = TYPE_CANONICAL (type);
2514
2515   switch (TREE_CODE (type))
2516     {
2517     case VOID_TYPE:
2518       write_char ('v');
2519       break;
2520
2521     case BOOLEAN_TYPE:
2522       write_char ('b');
2523       break;
2524
2525     case INTEGER_TYPE:
2526       /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2527          isn't in integer_type_nodes.  */
2528       if (type == wchar_type_node)
2529         write_char ('w');
2530       else if (type == char16_type_node)
2531         write_string ("Ds");
2532       else if (type == char32_type_node)
2533         write_string ("Di");
2534       else
2535         {
2536           size_t itk;
2537           /* Assume TYPE is one of the shared integer type nodes.  Find
2538              it in the array of these nodes.  */
2539         iagain:
2540           for (itk = 0; itk < itk_none; ++itk)
2541             if (integer_types[itk] != NULL_TREE
2542                 && integer_type_codes[itk] != '\0'
2543                 && type == integer_types[itk])
2544               {
2545                 /* Print the corresponding single-letter code.  */
2546                 write_char (integer_type_codes[itk]);
2547                 break;
2548               }
2549
2550           if (itk == itk_none)
2551             {
2552               tree t = c_common_type_for_mode (TYPE_MODE (type),
2553                                                TYPE_UNSIGNED (type));
2554               if (type != t)
2555                 {
2556                   type = t;
2557                   goto iagain;
2558                 }
2559
2560               if (TYPE_PRECISION (type) == 128)
2561                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
2562               else
2563                 {
2564                   /* Allow for cases where TYPE is not one of the shared
2565                      integer type nodes and write a "vendor extended builtin
2566                      type" with a name the form intN or uintN, respectively.
2567                      Situations like this can happen if you have an
2568                      __attribute__((__mode__(__SI__))) type and use exotic
2569                      switches like '-mint8' on AVR.  Of course, this is
2570                      undefined by the C++ ABI (and '-mint8' is not even
2571                      Standard C conforming), but when using such special
2572                      options you're pretty much in nowhere land anyway.  */
2573                   const char *prefix;
2574                   char prec[11];        /* up to ten digits for an unsigned */
2575
2576                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
2577                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
2578                   write_char ('u');     /* "vendor extended builtin type" */
2579                   write_unsigned_number (strlen (prefix) + strlen (prec));
2580                   write_string (prefix);
2581                   write_string (prec);
2582                 }
2583             }
2584         }
2585       break;
2586
2587     case REAL_TYPE:
2588       if (type == float_type_node)
2589         write_char ('f');
2590       else if (type == double_type_node)
2591         write_char ('d');
2592       else if (type == long_double_type_node)
2593         write_char ('e');
2594       else if (type == dfloat32_type_node)
2595         write_string ("Df");
2596       else if (type == dfloat64_type_node)
2597         write_string ("Dd");
2598       else if (type == dfloat128_type_node)
2599         write_string ("De");
2600       else
2601         gcc_unreachable ();
2602       break;
2603
2604     case FIXED_POINT_TYPE:
2605       write_string ("DF");
2606       if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
2607         write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
2608       if (type == fract_type_node
2609           || type == sat_fract_type_node
2610           || type == accum_type_node
2611           || type == sat_accum_type_node)
2612         write_char ('i');
2613       else if (type == unsigned_fract_type_node
2614                || type == sat_unsigned_fract_type_node
2615                || type == unsigned_accum_type_node
2616                || type == sat_unsigned_accum_type_node)
2617         write_char ('j');
2618       else if (type == short_fract_type_node
2619                || type == sat_short_fract_type_node
2620                || type == short_accum_type_node
2621                || type == sat_short_accum_type_node)
2622         write_char ('s');
2623       else if (type == unsigned_short_fract_type_node
2624                || type == sat_unsigned_short_fract_type_node
2625                || type == unsigned_short_accum_type_node
2626                || type == sat_unsigned_short_accum_type_node)
2627         write_char ('t');
2628       else if (type == long_fract_type_node
2629                || type == sat_long_fract_type_node
2630                || type == long_accum_type_node
2631                || type == sat_long_accum_type_node)
2632         write_char ('l');
2633       else if (type == unsigned_long_fract_type_node
2634                || type == sat_unsigned_long_fract_type_node
2635                || type == unsigned_long_accum_type_node
2636                || type == sat_unsigned_long_accum_type_node)
2637         write_char ('m');
2638       else if (type == long_long_fract_type_node
2639                || type == sat_long_long_fract_type_node
2640                || type == long_long_accum_type_node
2641                || type == sat_long_long_accum_type_node)
2642         write_char ('x');
2643       else if (type == unsigned_long_long_fract_type_node
2644                || type == sat_unsigned_long_long_fract_type_node
2645                || type == unsigned_long_long_accum_type_node
2646                || type == sat_unsigned_long_long_accum_type_node)
2647         write_char ('y');
2648       else
2649         sorry ("mangling unknown fixed point type");
2650       write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
2651       if (TYPE_SATURATING (type))
2652         write_char ('s');
2653       else
2654         write_char ('n');
2655       break;
2656
2657     default:
2658       gcc_unreachable ();
2659     }
2660 }
2661
2662 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
2663    METHOD_TYPE.  The return type is mangled before the parameter
2664    types.
2665
2666      <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E   */
2667
2668 static void
2669 write_function_type (const tree type)
2670 {
2671   MANGLE_TRACE_TREE ("function-type", type);
2672
2673   /* For a pointer to member function, the function type may have
2674      cv-qualifiers, indicating the quals for the artificial 'this'
2675      parameter.  */
2676   if (TREE_CODE (type) == METHOD_TYPE)
2677     {
2678       /* The first parameter must be a POINTER_TYPE pointing to the
2679          `this' parameter.  */
2680       tree this_type = class_of_this_parm (type);
2681       write_CV_qualifiers_for_type (this_type);
2682     }
2683
2684   write_exception_spec (TYPE_RAISES_EXCEPTIONS (type));
2685
2686   if (tx_safe_fn_type_p (type))
2687     write_string ("Dx");
2688
2689   write_char ('F');
2690   /* We don't track whether or not a type is `extern "C"'.  Note that
2691      you can have an `extern "C"' function that does not have
2692      `extern "C"' type, and vice versa:
2693
2694        extern "C" typedef void function_t();
2695        function_t f; // f has C++ linkage, but its type is
2696                      // `extern "C"'
2697
2698        typedef void function_t();
2699        extern "C" function_t f; // Vice versa.
2700
2701      See [dcl.link].  */
2702   write_bare_function_type (type, /*include_return_type_p=*/1,
2703                             /*decl=*/NULL);
2704   if (FUNCTION_REF_QUALIFIED (type))
2705     {
2706       if (FUNCTION_RVALUE_QUALIFIED (type))
2707         write_char ('O');
2708       else
2709         write_char ('R');
2710     }
2711   write_char ('E');
2712 }
2713
2714 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
2715    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
2716    is mangled before the parameter types.  If non-NULL, DECL is
2717    FUNCTION_DECL for the function whose type is being emitted.  */
2718
2719 static void
2720 write_bare_function_type (const tree type, const int include_return_type_p,
2721                           const tree decl)
2722 {
2723   MANGLE_TRACE_TREE ("bare-function-type", type);
2724
2725   /* Mangle the return type, if requested.  */
2726   if (include_return_type_p)
2727     write_type (TREE_TYPE (type));
2728
2729   /* Now mangle the types of the arguments.  */
2730   ++G.parm_depth;
2731   write_method_parms (TYPE_ARG_TYPES (type),
2732                       TREE_CODE (type) == METHOD_TYPE,
2733                       decl);
2734   --G.parm_depth;
2735 }
2736
2737 /* Write the mangled representation of a method parameter list of
2738    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
2739    considered a non-static method, and the this parameter is omitted.
2740    If non-NULL, DECL is the FUNCTION_DECL for the function whose
2741    parameters are being emitted.  */
2742
2743 static void
2744 write_method_parms (tree parm_types, const int method_p, const tree decl)
2745 {
2746   tree first_parm_type;
2747   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2748
2749   /* Assume this parameter type list is variable-length.  If it ends
2750      with a void type, then it's not.  */
2751   int varargs_p = 1;
2752
2753   /* If this is a member function, skip the first arg, which is the
2754      this pointer.
2755        "Member functions do not encode the type of their implicit this
2756        parameter."
2757
2758      Similarly, there's no need to mangle artificial parameters, like
2759      the VTT parameters for constructors and destructors.  */
2760   if (method_p)
2761     {
2762       parm_types = TREE_CHAIN (parm_types);
2763       parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
2764
2765       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2766         {
2767           parm_types = TREE_CHAIN (parm_types);
2768           parm_decl = DECL_CHAIN (parm_decl);
2769         }
2770
2771       if (decl && ctor_omit_inherited_parms (decl))
2772         /* Bring back parameters omitted from an inherited ctor.  */
2773         parm_types = FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (decl));
2774     }
2775
2776   for (first_parm_type = parm_types;
2777        parm_types;
2778        parm_types = TREE_CHAIN (parm_types))
2779     {
2780       tree parm = TREE_VALUE (parm_types);
2781       if (parm == void_type_node)
2782         {
2783           /* "Empty parameter lists, whether declared as () or
2784              conventionally as (void), are encoded with a void parameter
2785              (v)."  */
2786           if (parm_types == first_parm_type)
2787             write_type (parm);
2788           /* If the parm list is terminated with a void type, it's
2789              fixed-length.  */
2790           varargs_p = 0;
2791           /* A void type better be the last one.  */
2792           gcc_assert (TREE_CHAIN (parm_types) == NULL);
2793         }
2794       else
2795         write_type (parm);
2796     }
2797
2798   if (varargs_p)
2799     /* <builtin-type> ::= z  # ellipsis  */
2800     write_char ('z');
2801 }
2802
2803 /* <class-enum-type> ::= <name>  */
2804
2805 static void
2806 write_class_enum_type (const tree type)
2807 {
2808   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2809 }
2810
2811 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
2812    arguments.
2813
2814      <template-args> ::= I <template-arg>* E  */
2815
2816 static void
2817 write_template_args (tree args)
2818 {
2819   int i;
2820   int length = 0;
2821
2822   MANGLE_TRACE_TREE ("template-args", args);
2823
2824   write_char ('I');
2825
2826   if (args)
2827     length = TREE_VEC_LENGTH (args);
2828
2829   if (args && length && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2830     {
2831       /* We have nested template args.  We want the innermost template
2832          argument list.  */
2833       args = TREE_VEC_ELT (args, length - 1);
2834       length = TREE_VEC_LENGTH (args);
2835     }
2836   for (i = 0; i < length; ++i)
2837     write_template_arg (TREE_VEC_ELT (args, i));
2838
2839   write_char ('E');
2840 }
2841
2842 /* Write out the
2843    <unqualified-name>
2844    <unqualified-name> <template-args>
2845    part of SCOPE_REF or COMPONENT_REF mangling.  */
2846
2847 static void
2848 write_member_name (tree member)
2849 {
2850   if (identifier_p (member))
2851     {
2852       if (abi_version_at_least (11) && IDENTIFIER_ANY_OP_P (member))
2853         {
2854           write_string ("on");
2855           if (abi_warn_or_compat_version_crosses (11))
2856             G.need_abi_warning = 1;
2857         }
2858       write_unqualified_id (member);
2859     }
2860   else if (DECL_P (member))
2861     write_unqualified_name (member);
2862   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2863     {
2864       tree name = TREE_OPERAND (member, 0);
2865       name = OVL_FIRST (name);
2866       write_member_name (name);
2867       write_template_args (TREE_OPERAND (member, 1));
2868     }
2869   else
2870     write_expression (member);
2871 }
2872
2873 /* <expression> ::= <unary operator-name> <expression>
2874                 ::= <binary operator-name> <expression> <expression>
2875                 ::= <expr-primary>
2876
2877    <expr-primary> ::= <template-param>
2878                   ::= L <type> <value number> E         # literal
2879                   ::= L <mangled-name> E                # external name
2880                   ::= st <type>                         # sizeof
2881                   ::= sr <type> <unqualified-name>      # dependent name
2882                   ::= sr <type> <unqualified-name> <template-args> */
2883
2884 static void
2885 write_expression (tree expr)
2886 {
2887   enum tree_code code = TREE_CODE (expr);
2888
2889   /* Skip NOP_EXPR and CONVERT_EXPR.  They can occur when (say) a pointer
2890      argument is converted (via qualification conversions) to another type.  */
2891   while (CONVERT_EXPR_CODE_P (code)
2892          || location_wrapper_p (expr)
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            && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
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           && TYPE_REF_P (TREE_TYPE (expr)))
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       && TYPE_REF_P (TREE_TYPE (node)))
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->maybe_get_node () != 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"