gcc/cp/mangle.c

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