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