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   (TYPE_LANG_SPECIFIC (NODE) != NULL                                    \
  85    && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM                 \
  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_cxx1z_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_cxx1z_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_TYPENAME_P (identifier))
1265     write_conversion_operator_name (TREE_TYPE (identifier));
1266   else if (IDENTIFIER_OPNAME_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   /* Never write the whole template-id name including the template
1464      arguments; we only want the template name.  */
1465   if (IDENTIFIER_TEMPLATE (identifier))
1466     identifier = IDENTIFIER_TEMPLATE (identifier);
1467
1468   write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1469   write_identifier (IDENTIFIER_POINTER (identifier));
1470 }
1471
1472 /* Compare two TREE_STRINGs like strcmp.  */
1473
1474 int
1475 tree_string_cmp (const void *p1, const void *p2)
1476 {
1477   if (p1 == p2)
1478     return 0;
1479   tree s1 = *(const tree*)p1;
1480   tree s2 = *(const tree*)p2;
1481   return strcmp (TREE_STRING_POINTER (s1),
1482                  TREE_STRING_POINTER (s2));
1483 }
1484
1485 /* Return the TREE_LIST of TAGS as a sorted VEC.  */
1486
1487 static vec<tree, va_gc> *
1488 sorted_abi_tags (tree tags)
1489 {
1490   vec<tree, va_gc> * vec = make_tree_vector();
1491
1492   for (tree t = tags; t; t = TREE_CHAIN (t))
1493     {
1494       if (ABI_TAG_IMPLICIT (t))
1495         continue;
1496       tree str = TREE_VALUE (t);
1497       vec_safe_push (vec, str);
1498     }
1499
1500   vec->qsort (tree_string_cmp);
1501
1502   return vec;
1503 }
1504
1505 /* ID is the name of a function or type with abi_tags attribute TAGS.
1506    Write out the name, suitably decorated.  */
1507
1508 static void
1509 write_abi_tags (tree tags)
1510 {
1511   if (tags == NULL_TREE)
1512     return;
1513
1514   vec<tree, va_gc> * vec = sorted_abi_tags (tags);
1515
1516   unsigned i; tree str;
1517   FOR_EACH_VEC_ELT (*vec, i, str)
1518     {
1519       write_string ("B");
1520       write_unsigned_number (TREE_STRING_LENGTH (str) - 1);
1521       write_identifier (TREE_STRING_POINTER (str));
1522     }
1523
1524   release_tree_vector (vec);
1525 }
1526
1527 /* Simplified unique_ptr clone to release a tree vec on exit.  */
1528
1529 struct releasing_vec
1530 {
1531   typedef vec<tree, va_gc> vec_t;
1532
1533   releasing_vec (vec_t *v): v(v) { }
1534   releasing_vec (): v(make_tree_vector ()) { }
1535
1536   vec_t &operator* () const { return *v; }
1537   vec_t *operator-> () const { return v; }
1538   vec_t *get () const { return v; }
1539   operator vec_t *() const { return v; }
1540   tree& operator[] (unsigned i) const { return (*v)[i]; }
1541
1542   ~releasing_vec() { release_tree_vector (v); }
1543 private:
1544   vec_t *v;
1545 };
1546
1547 /* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent.  */
1548
1549 static bool
1550 equal_abi_tags (tree t1, tree t2)
1551 {
1552   releasing_vec v1 = sorted_abi_tags (t1);
1553   releasing_vec v2 = sorted_abi_tags (t2);
1554
1555   unsigned len1 = v1->length();
1556   if (len1 != v2->length())
1557     return false;
1558   for (unsigned i = 0; i < len1; ++i)
1559     if (tree_string_cmp (v1[i], v2[i]) != 0)
1560       return false;
1561   return true;
1562 }
1563
1564 /* Write a user-defined literal operator.
1565           ::= li <source-name>    # "" <source-name>
1566    IDENTIFIER is an LITERAL_IDENTIFIER_NODE.  */
1567
1568 static void
1569 write_literal_operator_name (tree identifier)
1570 {
1571   const char* suffix = UDLIT_OP_SUFFIX (identifier);
1572   write_identifier (UDLIT_OP_MANGLED_PREFIX);
1573   write_unsigned_number (strlen (suffix));
1574   write_identifier (suffix);
1575 }
1576
1577 /* Encode 0 as _, and 1+ as n-1_.  */
1578
1579 static void
1580 write_compact_number (int num)
1581 {
1582   if (num > 0)
1583     write_unsigned_number (num - 1);
1584   write_char ('_');
1585 }
1586
1587 /* Return how many unnamed types precede TYPE in its enclosing class.  */
1588
1589 static int
1590 nested_anon_class_index (tree type)
1591 {
1592   int index = 0;
1593   tree member = TYPE_FIELDS (TYPE_CONTEXT (type));
1594   for (; member; member = DECL_CHAIN (member))
1595     if (DECL_IMPLICIT_TYPEDEF_P (member))
1596       {
1597         tree memtype = TREE_TYPE (member);
1598         if (memtype == type)
1599           return index;
1600         else if (TYPE_UNNAMED_P (memtype))
1601           ++index;
1602       }
1603
1604   gcc_unreachable ();
1605 }
1606
1607 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1608
1609 static void
1610 write_unnamed_type_name (const tree type)
1611 {
1612   int discriminator;
1613   MANGLE_TRACE_TREE ("unnamed-type-name", type);
1614
1615   if (TYPE_FUNCTION_SCOPE_P (type))
1616     discriminator = local_class_index (type);
1617   else if (TYPE_CLASS_SCOPE_P (type))
1618     discriminator = nested_anon_class_index (type);
1619   else
1620     {
1621       gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
1622       /* Just use the old mangling at namespace scope.  */
1623       write_source_name (TYPE_IDENTIFIER (type));
1624       return;
1625     }
1626
1627   write_string ("Ut");
1628   write_compact_number (discriminator);
1629 }
1630
1631 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1632    <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters */
1633
1634 static void
1635 write_closure_type_name (const tree type)
1636 {
1637   tree fn = lambda_function (type);
1638   tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
1639   tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
1640
1641   MANGLE_TRACE_TREE ("closure-type-name", type);
1642
1643   write_string ("Ul");
1644   write_method_parms (parms, /*method_p=*/1, fn);
1645   write_char ('E');
1646   write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda));
1647 }
1648
1649 /* Convert NUMBER to ascii using base BASE and generating at least
1650    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1651    into which to store the characters. Returns the number of
1652    characters generated (these will be laid out in advance of where
1653    BUFFER points).  */
1654
1655 static int
1656 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1657                 char *buffer, const unsigned int min_digits)
1658 {
1659   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1660   unsigned digits = 0;
1661
1662   while (number)
1663     {
1664       unsigned HOST_WIDE_INT d = number / base;
1665
1666       *--buffer = base_digits[number - d * base];
1667       digits++;
1668       number = d;
1669     }
1670   while (digits < min_digits)
1671     {
1672       *--buffer = base_digits[0];
1673       digits++;
1674     }
1675   return digits;
1676 }
1677
1678 /* Non-terminal <number>.
1679
1680      <number> ::= [n] </decimal integer/>  */
1681
1682 static void
1683 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1684               const unsigned int base)
1685 {
1686   char buffer[sizeof (HOST_WIDE_INT) * 8];
1687   unsigned count = 0;
1688
1689   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1690     {
1691       write_char ('n');
1692       number = -((HOST_WIDE_INT) number);
1693     }
1694   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1695   write_chars (buffer + sizeof (buffer) - count, count);
1696 }
1697
1698 /* Write out an integral CST in decimal. Most numbers are small, and
1699    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1700    bigger than that, which we must deal with.  */
1701
1702 static inline void
1703 write_integer_cst (const tree cst)
1704 {
1705   int sign = tree_int_cst_sgn (cst);
1706   widest_int abs_value = wi::abs (wi::to_widest (cst));
1707   if (!wi::fits_uhwi_p (abs_value))
1708     {
1709       /* A bignum. We do this in chunks, each of which fits in a
1710          HOST_WIDE_INT.  */
1711       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1712       unsigned HOST_WIDE_INT chunk;
1713       unsigned chunk_digits;
1714       char *ptr = buffer + sizeof (buffer);
1715       unsigned count = 0;
1716       tree n, base, type;
1717       int done;
1718
1719       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1720          representable.  */
1721       chunk = 1000000000;
1722       chunk_digits = 9;
1723
1724       if (sizeof (HOST_WIDE_INT) >= 8)
1725         {
1726           /* It is at least 64 bits, so 10^18 is representable.  */
1727           chunk_digits = 18;
1728           chunk *= chunk;
1729         }
1730
1731       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1732       base = build_int_cstu (type, chunk);
1733       n = wide_int_to_tree (type, cst);
1734
1735       if (sign < 0)
1736         {
1737           write_char ('n');
1738           n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
1739         }
1740       do
1741         {
1742           tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
1743           tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
1744           unsigned c;
1745
1746           done = integer_zerop (d);
1747           tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
1748           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1749                               done ? 1 : chunk_digits);
1750           ptr -= c;
1751           count += c;
1752           n = d;
1753         }
1754       while (!done);
1755       write_chars (ptr, count);
1756     }
1757   else
1758     {
1759       /* A small num.  */
1760       if (sign < 0)
1761         write_char ('n');
1762       write_unsigned_number (abs_value.to_uhwi ());
1763     }
1764 }
1765
1766 /* Write out a floating-point literal.
1767
1768     "Floating-point literals are encoded using the bit pattern of the
1769     target processor's internal representation of that number, as a
1770     fixed-length lowercase hexadecimal string, high-order bytes first
1771     (even if the target processor would store low-order bytes first).
1772     The "n" prefix is not used for floating-point literals; the sign
1773     bit is encoded with the rest of the number.
1774
1775     Here are some examples, assuming the IEEE standard representation
1776     for floating point numbers.  (Spaces are for readability, not
1777     part of the encoding.)
1778
1779         1.0f                    Lf 3f80 0000 E
1780        -1.0f                    Lf bf80 0000 E
1781         1.17549435e-38f         Lf 0080 0000 E
1782         1.40129846e-45f         Lf 0000 0001 E
1783         0.0f                    Lf 0000 0000 E"
1784
1785    Caller is responsible for the Lx and the E.  */
1786 static void
1787 write_real_cst (const tree value)
1788 {
1789   long target_real[4];  /* largest supported float */
1790   /* Buffer for eight hex digits in a 32-bit number but big enough
1791      even for 64-bit long to avoid warnings.  */
1792   char buffer[17];
1793   int i, limit, dir;
1794
1795   tree type = TREE_TYPE (value);
1796   int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1797
1798   real_to_target (target_real, &TREE_REAL_CST (value),
1799                   TYPE_MODE (type));
1800
1801   /* The value in target_real is in the target word order,
1802      so we must write it out backward if that happens to be
1803      little-endian.  write_number cannot be used, it will
1804      produce uppercase.  */
1805   if (FLOAT_WORDS_BIG_ENDIAN)
1806     i = 0, limit = words, dir = 1;
1807   else
1808     i = words - 1, limit = -1, dir = -1;
1809
1810   for (; i != limit; i += dir)
1811     {
1812       sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1813       write_chars (buffer, 8);
1814     }
1815 }
1816
1817 /* Non-terminal <identifier>.
1818
1819      <identifier> ::= </unqualified source code identifier>  */
1820
1821 static void
1822 write_identifier (const char *identifier)
1823 {
1824   MANGLE_TRACE ("identifier", identifier);
1825   write_string (identifier);
1826 }
1827
1828 /* Handle constructor productions of non-terminal <special-name>.
1829    CTOR is a constructor FUNCTION_DECL.
1830
1831      <special-name> ::= C1   # complete object constructor
1832                     ::= C2   # base object constructor
1833                     ::= C3   # complete object allocating constructor
1834
1835    Currently, allocating constructors are never used.  */
1836
1837 static void
1838 write_special_name_constructor (const tree ctor)
1839 {
1840   write_char ('C');
1841   bool new_inh = (flag_new_inheriting_ctors
1842                   && DECL_INHERITED_CTOR (ctor));
1843   if (new_inh)
1844     write_char ('I');
1845   if (DECL_BASE_CONSTRUCTOR_P (ctor))
1846     write_char ('2');
1847   /* This is the old-style "[unified]" constructor.
1848      In some cases, we may emit this function and call
1849      it from the clones in order to share code and save space.  */
1850   else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
1851     write_char ('4');
1852   else
1853     {
1854       gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor));
1855       write_char ('1');
1856     }
1857   if (new_inh)
1858     write_type (DECL_INHERITED_CTOR_BASE (ctor));
1859 }
1860
1861 /* Handle destructor productions of non-terminal <special-name>.
1862    DTOR is a destructor FUNCTION_DECL.
1863
1864      <special-name> ::= D0 # deleting (in-charge) destructor
1865                     ::= D1 # complete object (in-charge) destructor
1866                     ::= D2 # base object (not-in-charge) destructor  */
1867
1868 static void
1869 write_special_name_destructor (const tree dtor)
1870 {
1871   if (DECL_DELETING_DESTRUCTOR_P (dtor))
1872     write_string ("D0");
1873   else if (DECL_BASE_DESTRUCTOR_P (dtor))
1874     write_string ("D2");
1875   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
1876     /* This is the old-style "[unified]" destructor.
1877        In some cases, we may emit this function and call
1878        it from the clones in order to share code and save space.  */
1879     write_string ("D4");
1880   else
1881     {
1882       gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor));
1883       write_string ("D1");
1884     }
1885 }
1886
1887 /* Scan the vector of local classes and return how many others with the
1888    same name (or same no name) and context precede ENTITY.  */
1889
1890 static int
1891 local_class_index (tree entity)
1892 {
1893   int ix, discriminator = 0;
1894   tree name = (TYPE_UNNAMED_P (entity) ? NULL_TREE
1895                : TYPE_IDENTIFIER (entity));
1896   tree ctx = TYPE_CONTEXT (entity);
1897   for (ix = 0; ; ix++)
1898     {
1899       tree type = (*local_classes)[ix];
1900       if (type == entity)
1901         return discriminator;
1902       if (TYPE_CONTEXT (type) == ctx
1903           && (name ? TYPE_IDENTIFIER (type) == name
1904               : TYPE_UNNAMED_P (type)))
1905         ++discriminator;
1906     }
1907   gcc_unreachable ();
1908 }
1909
1910 /* Return the discriminator for ENTITY appearing inside
1911    FUNCTION.  The discriminator is the lexical ordinal of VAR among
1912    entities with the same name in the same FUNCTION.  */
1913
1914 static int
1915 discriminator_for_local_entity (tree entity)
1916 {
1917   if (DECL_DISCRIMINATOR_P (entity))
1918     {
1919       if (DECL_DISCRIMINATOR_SET_P (entity))
1920         return DECL_DISCRIMINATOR (entity);
1921       else
1922         /* The first entity with a particular name doesn't get
1923            DECL_DISCRIMINATOR set up.  */
1924         return 0;
1925     }
1926   else if (TREE_CODE (entity) == TYPE_DECL)
1927     {
1928       /* Scan the list of local classes.  */
1929       entity = TREE_TYPE (entity);
1930
1931       /* Lambdas and unnamed types have their own discriminators.  */
1932       if (LAMBDA_TYPE_P (entity) || TYPE_UNNAMED_P (entity))
1933         return 0;
1934
1935       return local_class_index (entity);
1936     }
1937   else
1938     gcc_unreachable ();
1939 }
1940
1941 /* Return the discriminator for STRING, a string literal used inside
1942    FUNCTION.  The discriminator is the lexical ordinal of STRING among
1943    string literals used in FUNCTION.  */
1944
1945 static int
1946 discriminator_for_string_literal (tree /*function*/,
1947                                   tree /*string*/)
1948 {
1949   /* For now, we don't discriminate amongst string literals.  */
1950   return 0;
1951 }
1952
1953 /*   <discriminator> := _ <number>    # when number < 10
1954                      := __ <number> _ # when number >= 10
1955
1956    The discriminator is used only for the second and later occurrences
1957    of the same name within a single function. In this case <number> is
1958    n - 2, if this is the nth occurrence, in lexical order.  */
1959
1960 static void
1961 write_discriminator (const int discriminator)
1962 {
1963   /* If discriminator is zero, don't write anything.  Otherwise...  */
1964   if (discriminator > 0)
1965     {
1966       write_char ('_');
1967       if (discriminator - 1 >= 10)
1968         {
1969           if (abi_warn_or_compat_version_crosses (11))
1970             G.need_abi_warning = 1;
1971           if (abi_version_at_least (11))
1972             write_char ('_');
1973         }
1974       write_unsigned_number (discriminator - 1);
1975       if (abi_version_at_least (11) && discriminator - 1 >= 10)
1976         write_char ('_');
1977     }
1978 }
1979
1980 /* Mangle the name of a function-scope entity.  FUNCTION is the
1981    FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1982    default argument scope.  ENTITY is the decl for the entity itself.
1983    LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1984    either ENTITY itself or an enclosing scope of ENTITY.
1985
1986      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1987                   := Z <function encoding> E s [<discriminator>]
1988                   := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1989
1990 static void
1991 write_local_name (tree function, const tree local_entity,
1992                   const tree entity)
1993 {
1994   tree parm = NULL_TREE;
1995
1996   MANGLE_TRACE_TREE ("local-name", entity);
1997
1998   if (TREE_CODE (function) == PARM_DECL)
1999     {
2000       parm = function;
2001       function = DECL_CONTEXT (parm);
2002     }
2003
2004   write_char ('Z');
2005   write_encoding (function);
2006   write_char ('E');
2007
2008   /* For this purpose, parameters are numbered from right-to-left.  */
2009   if (parm)
2010     {
2011       tree t;
2012       int i = 0;
2013       for (t = DECL_ARGUMENTS (function); t; t = DECL_CHAIN (t))
2014         {
2015           if (t == parm)
2016             i = 1;
2017           else if (i)
2018             ++i;
2019         }
2020       write_char ('d');
2021       write_compact_number (i - 1);
2022     }
2023
2024   if (TREE_CODE (entity) == STRING_CST)
2025     {
2026       write_char ('s');
2027       write_discriminator (discriminator_for_string_literal (function,
2028                                                              entity));
2029     }
2030   else
2031     {
2032       /* Now the <entity name>.  Let write_name know its being called
2033          from <local-name>, so it doesn't try to process the enclosing
2034          function scope again.  */
2035       write_name (entity, /*ignore_local_scope=*/1);
2036       write_discriminator (discriminator_for_local_entity (local_entity));
2037     }
2038 }
2039
2040 /* Non-terminals <type> and <CV-qualifier>.
2041
2042      <type> ::= <builtin-type>
2043             ::= <function-type>
2044             ::= <class-enum-type>
2045             ::= <array-type>
2046             ::= <pointer-to-member-type>
2047             ::= <template-param>
2048             ::= <substitution>
2049             ::= <CV-qualifier>
2050             ::= P <type>    # pointer-to
2051             ::= R <type>    # reference-to
2052             ::= C <type>    # complex pair (C 2000)
2053             ::= G <type>    # imaginary (C 2000)     [not supported]
2054             ::= U <source-name> <type>   # vendor extended type qualifier
2055
2056    C++0x extensions
2057
2058      <type> ::= RR <type>   # rvalue reference-to
2059      <type> ::= Dt <expression> # decltype of an id-expression or
2060                                 # class member access
2061      <type> ::= DT <expression> # decltype of an expression
2062      <type> ::= Dn              # decltype of nullptr
2063
2064    TYPE is a type node.  */
2065
2066 static void
2067 write_type (tree type)
2068 {
2069   /* This gets set to nonzero if TYPE turns out to be a (possibly
2070      CV-qualified) builtin type.  */
2071   int is_builtin_type = 0;
2072
2073   MANGLE_TRACE_TREE ("type", type);
2074
2075   if (type == error_mark_node)
2076     return;
2077
2078   type = canonicalize_for_substitution (type);
2079   if (find_substitution (type))
2080     return;
2081
2082
2083   if (write_CV_qualifiers_for_type (type) > 0)
2084     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
2085        mangle the unqualified type.  The recursive call is needed here
2086        since both the qualified and unqualified types are substitution
2087        candidates.  */
2088     {
2089       tree t = TYPE_MAIN_VARIANT (type);
2090       if (TYPE_ATTRIBUTES (t) && !OVERLOAD_TYPE_P (t))
2091         {
2092           tree attrs = NULL_TREE;
2093           if (tx_safe_fn_type_p (type))
2094             attrs = tree_cons (get_identifier ("transaction_safe"),
2095                                NULL_TREE, attrs);
2096           t = cp_build_type_attribute_variant (t, attrs);
2097         }
2098       gcc_assert (t != type);
2099       if (TREE_CODE (t) == FUNCTION_TYPE
2100           || TREE_CODE (t) == METHOD_TYPE)
2101         {
2102           t = build_ref_qualified_type (t, type_memfn_rqual (type));
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 (abi_version_at_least (11) && IDENTIFIER_OPNAME_P (member))
2824     {
2825       write_string ("on");
2826       if (abi_warn_or_compat_version_crosses (11))
2827         G.need_abi_warning = 1;
2828     }
2829   if (identifier_p (member))
2830     write_unqualified_id (member);
2831   else if (DECL_P (member))
2832     write_unqualified_name (member);
2833   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2834     {
2835       tree name = TREE_OPERAND (member, 0);
2836       if (TREE_CODE (name) == OVERLOAD)
2837         name = OVL_FUNCTION (name);
2838       write_member_name (name);
2839       write_template_args (TREE_OPERAND (member, 1));
2840     }
2841   else
2842     write_expression (member);
2843 }
2844
2845 /* <expression> ::= <unary operator-name> <expression>
2846                 ::= <binary operator-name> <expression> <expression>
2847                 ::= <expr-primary>
2848
2849    <expr-primary> ::= <template-param>
2850                   ::= L <type> <value number> E         # literal
2851                   ::= L <mangled-name> E                # external name
2852                   ::= st <type>                         # sizeof
2853                   ::= sr <type> <unqualified-name>      # dependent name
2854                   ::= sr <type> <unqualified-name> <template-args> */
2855
2856 static void
2857 write_expression (tree expr)
2858 {
2859   enum tree_code code = TREE_CODE (expr);
2860
2861   /* Skip NOP_EXPR and CONVERT_EXPR.  They can occur when (say) a pointer
2862      argument is converted (via qualification conversions) to another type.  */
2863   while (CONVERT_EXPR_CODE_P (code)
2864          /* Parentheses aren't mangled.  */
2865          || code == PAREN_EXPR
2866          || TREE_CODE (expr) == NON_LVALUE_EXPR)
2867     {
2868       expr = TREE_OPERAND (expr, 0);
2869       code = TREE_CODE (expr);
2870     }
2871
2872   if (code == BASELINK
2873       && (!type_unknown_p (expr)
2874           || !BASELINK_QUALIFIED_P (expr)))
2875     {
2876       expr = BASELINK_FUNCTIONS (expr);
2877       code = TREE_CODE (expr);
2878     }
2879
2880   /* Handle pointers-to-members by making them look like expression
2881      nodes.  */
2882   if (code == PTRMEM_CST)
2883     {
2884       expr = build_nt (ADDR_EXPR,
2885                        build_qualified_name (/*type=*/NULL_TREE,
2886                                              PTRMEM_CST_CLASS (expr),
2887                                              PTRMEM_CST_MEMBER (expr),
2888                                              /*template_p=*/false));
2889       code = TREE_CODE (expr);
2890     }
2891
2892   /* Handle template parameters.  */
2893   if (code == TEMPLATE_TYPE_PARM
2894       || code == TEMPLATE_TEMPLATE_PARM
2895       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2896       || code == TEMPLATE_PARM_INDEX)
2897     write_template_param (expr);
2898   /* Handle literals.  */
2899   else if (TREE_CODE_CLASS (code) == tcc_constant
2900            || code == CONST_DECL)
2901     write_template_arg_literal (expr);
2902   else if (code == PARM_DECL && DECL_ARTIFICIAL (expr))
2903     {
2904       gcc_assert (!strcmp ("this", IDENTIFIER_POINTER (DECL_NAME (expr))));
2905       write_string ("fpT");
2906     }
2907   else if (code == PARM_DECL)
2908     {
2909       /* A function parameter used in a late-specified return type.  */
2910       int index = DECL_PARM_INDEX (expr);
2911       int level = DECL_PARM_LEVEL (expr);
2912       int delta = G.parm_depth - level + 1;
2913       gcc_assert (index >= 1);
2914       write_char ('f');
2915       if (delta != 0)
2916         {
2917           if (abi_version_at_least (5))
2918             {
2919               /* Let L be the number of function prototype scopes from the
2920                  innermost one (in which the parameter reference occurs) up
2921                  to (and including) the one containing the declaration of
2922                  the referenced parameter.  If the parameter declaration
2923                  clause of the innermost function prototype scope has been
2924                  completely seen, it is not counted (in that case -- which
2925                  is perhaps the most common -- L can be zero).  */
2926               write_char ('L');
2927               write_unsigned_number (delta - 1);
2928             }
2929           if (abi_warn_or_compat_version_crosses (5))
2930             G.need_abi_warning = true;
2931         }
2932       write_char ('p');
2933       write_compact_number (index - 1);
2934     }
2935   else if (DECL_P (expr))
2936     {
2937       write_char ('L');
2938       write_mangled_name (expr, false);
2939       write_char ('E');
2940     }
2941   else if (TREE_CODE (expr) == SIZEOF_EXPR)
2942     {
2943       tree op = TREE_OPERAND (expr, 0);
2944
2945       if (PACK_EXPANSION_P (op))
2946         {
2947           if (abi_warn_or_compat_version_crosses (11))
2948             G.need_abi_warning = true;
2949           if (abi_version_at_least (11))
2950             {
2951               /* sZ rather than szDp.  */
2952               write_string ("sZ");
2953               write_expression (PACK_EXPANSION_PATTERN (op));
2954               return;
2955             }
2956         }
2957
2958       if (SIZEOF_EXPR_TYPE_P (expr))
2959         {
2960           write_string ("st");
2961           write_type (TREE_TYPE (op));
2962         }
2963       else if (ARGUMENT_PACK_P (op))
2964         {
2965           tree args = ARGUMENT_PACK_ARGS (op);
2966           int length = TREE_VEC_LENGTH (args);
2967           if (abi_warn_or_compat_version_crosses (10))
2968             G.need_abi_warning = true;
2969           if (abi_version_at_least (10))
2970             {
2971               /* sP <template-arg>* E # sizeof...(T), size of a captured
2972                  template parameter pack from an alias template */
2973               write_string ("sP");
2974               for (int i = 0; i < length; ++i)
2975                 write_template_arg (TREE_VEC_ELT (args, i));
2976               write_char ('E');
2977             }
2978           else
2979             {
2980               /* In GCC 5 we represented this sizeof wrong, with the effect
2981                  that we mangled it as the last element of the pack.  */
2982               tree arg = TREE_VEC_ELT (args, length-1);
2983               if (TYPE_P (op))
2984                 {
2985                   write_string ("st");
2986                   write_type (arg);
2987                 }
2988               else
2989                 {
2990                   write_string ("sz");
2991                   write_expression (arg);
2992                 }
2993             }
2994         }
2995       else if (TYPE_P (TREE_OPERAND (expr, 0)))
2996         {
2997           write_string ("st");
2998           write_type (TREE_OPERAND (expr, 0));
2999         }
3000       else
3001         goto normal_expr;
3002     }
3003   else if (TREE_CODE (expr) == ALIGNOF_EXPR
3004            && TYPE_P (TREE_OPERAND (expr, 0)))
3005     {
3006       write_string ("at");
3007       write_type (TREE_OPERAND (expr, 0));
3008     }
3009   else if (code == SCOPE_REF
3010            || code == BASELINK)
3011     {
3012       tree scope, member;
3013       if (code == SCOPE_REF)
3014         {
3015           scope = TREE_OPERAND (expr, 0);
3016           member = TREE_OPERAND (expr, 1);
3017         }
3018       else
3019         {
3020           scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr));
3021           member = BASELINK_FUNCTIONS (expr);
3022         }
3023
3024       /* If the MEMBER is a real declaration, then the qualifying
3025          scope was not dependent.  Ideally, we would not have a
3026          SCOPE_REF in those cases, but sometimes we do.  If the second
3027          argument is a DECL, then the name must not have been
3028          dependent.  */
3029       if (DECL_P (member))
3030         write_expression (member);
3031       else
3032         {
3033           write_string ("sr");
3034           write_type (scope);
3035           write_member_name (member);
3036         }
3037     }
3038   else if (INDIRECT_REF_P (expr)
3039            && TREE_TYPE (TREE_OPERAND (expr, 0))
3040            && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3041     {
3042       write_expression (TREE_OPERAND (expr, 0));
3043     }
3044   else if (identifier_p (expr))
3045     {
3046       /* An operator name appearing as a dependent name needs to be
3047          specially marked to disambiguate between a use of the operator
3048          name and a use of the operator in an expression.  */
3049       if (IDENTIFIER_OPNAME_P (expr))
3050         write_string ("on");
3051       write_unqualified_id (expr);
3052     }
3053   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
3054     {
3055       tree fn = TREE_OPERAND (expr, 0);
3056       if (is_overloaded_fn (fn))
3057         fn = get_first_fn (fn);
3058       if (DECL_P (fn))
3059         fn = DECL_NAME (fn);
3060       if (IDENTIFIER_OPNAME_P (fn))
3061         write_string ("on");
3062       write_unqualified_id (fn);
3063       write_template_args (TREE_OPERAND (expr, 1));
3064     }
3065   else if (TREE_CODE (expr) == MODOP_EXPR)
3066     {
3067       enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1));
3068       const char *name = (assignment_operator_name_info[(int) subop]
3069                           .mangled_name);
3070       write_string (name);
3071       write_expression (TREE_OPERAND (expr, 0));
3072       write_expression (TREE_OPERAND (expr, 2));
3073     }
3074   else if (code == NEW_EXPR || code == VEC_NEW_EXPR)
3075     {
3076       /* ::= [gs] nw <expression>* _ <type> E
3077          ::= [gs] nw <expression>* _ <type> <initializer>
3078          ::= [gs] na <expression>* _ <type> E
3079          ::= [gs] na <expression>* _ <type> <initializer>
3080          <initializer> ::= pi <expression>* E  */
3081       tree placement = TREE_OPERAND (expr, 0);
3082       tree type = TREE_OPERAND (expr, 1);
3083       tree nelts = TREE_OPERAND (expr, 2);
3084       tree init = TREE_OPERAND (expr, 3);
3085       tree t;
3086
3087       gcc_assert (code == NEW_EXPR);
3088       if (TREE_OPERAND (expr, 2))
3089         code = VEC_NEW_EXPR;
3090
3091       if (NEW_EXPR_USE_GLOBAL (expr))
3092         write_string ("gs");
3093
3094       write_string (operator_name_info[(int) code].mangled_name);
3095
3096       for (t = placement; t; t = TREE_CHAIN (t))
3097         write_expression (TREE_VALUE (t));
3098
3099       write_char ('_');
3100
3101       if (nelts)
3102         {
3103           tree domain;
3104           ++processing_template_decl;
3105           domain = compute_array_index_type (NULL_TREE, nelts,
3106                                              tf_warning_or_error);
3107           type = build_cplus_array_type (type, domain);
3108           --processing_template_decl;
3109         }
3110       write_type (type);
3111
3112       if (init && TREE_CODE (init) == TREE_LIST
3113           && DIRECT_LIST_INIT_P (TREE_VALUE (init)))
3114         write_expression (TREE_VALUE (init));
3115       else
3116         {
3117           if (init)
3118             write_string ("pi");
3119           if (init && init != void_node)
3120             for (t = init; t; t = TREE_CHAIN (t))
3121               write_expression (TREE_VALUE (t));
3122           write_char ('E');
3123         }
3124     }
3125   else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR)
3126     {
3127       gcc_assert (code == DELETE_EXPR);
3128       if (DELETE_EXPR_USE_VEC (expr))
3129         code = VEC_DELETE_EXPR;
3130
3131       if (DELETE_EXPR_USE_GLOBAL (expr))
3132         write_string ("gs");
3133
3134       write_string (operator_name_info[(int) code].mangled_name);
3135
3136       write_expression (TREE_OPERAND (expr, 0));
3137     }
3138   else if (code == THROW_EXPR)
3139     {
3140       tree op = TREE_OPERAND (expr, 0);
3141       if (op)
3142         {
3143           write_string ("tw");
3144           write_expression (op);
3145         }
3146       else
3147         write_string ("tr");
3148     }
3149   else if (code == CONSTRUCTOR)
3150     {
3151       vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (expr);
3152       unsigned i; tree val;
3153
3154       if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3155         write_string ("il");
3156       else
3157         {
3158           write_string ("tl");
3159           write_type (TREE_TYPE (expr));
3160         }
3161       FOR_EACH_CONSTRUCTOR_VALUE (elts, i, val)
3162         write_expression (val);
3163       write_char ('E');
3164     }
3165   else if (dependent_name (expr))
3166     {
3167       write_unqualified_id (dependent_name (expr));
3168     }
3169   else
3170     {
3171     normal_expr:
3172       int i, len;
3173       const char *name;
3174
3175       /* When we bind a variable or function to a non-type template
3176          argument with reference type, we create an ADDR_EXPR to show
3177          the fact that the entity's address has been taken.  But, we
3178          don't actually want to output a mangling code for the `&'.  */
3179       if (TREE_CODE (expr) == ADDR_EXPR
3180           && TREE_TYPE (expr)
3181           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
3182         {
3183           expr = TREE_OPERAND (expr, 0);
3184           if (DECL_P (expr))
3185             {
3186               write_expression (expr);
3187               return;
3188             }
3189
3190           code = TREE_CODE (expr);
3191         }
3192
3193       if (code == COMPONENT_REF)
3194         {
3195           tree ob = TREE_OPERAND (expr, 0);
3196
3197           if (TREE_CODE (ob) == ARROW_EXPR)
3198             {
3199               write_string (operator_name_info[(int)code].mangled_name);
3200               ob = TREE_OPERAND (ob, 0);
3201               write_expression (ob);
3202             }
3203           else if (!is_dummy_object (ob))
3204             {
3205               write_string ("dt");
3206               write_expression (ob);
3207             }
3208           /* else, for a non-static data member with no associated object (in
3209              unevaluated context), use the unresolved-name mangling.  */
3210
3211           write_member_name (TREE_OPERAND (expr, 1));
3212           return;
3213         }
3214
3215       /* If it wasn't any of those, recursively expand the expression.  */
3216       name = operator_name_info[(int) code].mangled_name;
3217
3218       /* We used to mangle const_cast and static_cast like a C cast.  */
3219       if (code == CONST_CAST_EXPR
3220           || code == STATIC_CAST_EXPR)
3221         {
3222           if (abi_warn_or_compat_version_crosses (6))
3223             G.need_abi_warning = 1;
3224           if (!abi_version_at_least (6))
3225             name = operator_name_info[CAST_EXPR].mangled_name;
3226         }
3227
3228       if (name == NULL)
3229         {
3230           switch (code)
3231             {
3232             case TRAIT_EXPR:
3233               error ("use of built-in trait %qE in function signature; "
3234                      "use library traits instead", expr);
3235               break;
3236
3237             default:
3238               sorry ("mangling %C", code);
3239               break;
3240             }
3241           return;
3242         }
3243       else
3244         write_string (name);
3245
3246       switch (code)
3247         {
3248         case CALL_EXPR:
3249           {
3250             tree fn = CALL_EXPR_FN (expr);
3251
3252             if (TREE_CODE (fn) == ADDR_EXPR)
3253               fn = TREE_OPERAND (fn, 0);
3254
3255             /* Mangle a dependent name as the name, not whatever happens to
3256                be the first function in the overload set.  */
3257             if ((TREE_CODE (fn) == FUNCTION_DECL
3258                  || TREE_CODE (fn) == OVERLOAD)
3259                 && type_dependent_expression_p_push (expr))
3260               fn = DECL_NAME (get_first_fn (fn));
3261
3262             write_expression (fn);
3263           }
3264
3265           for (i = 0; i < call_expr_nargs (expr); ++i)
3266             write_expression (CALL_EXPR_ARG (expr, i));
3267           write_char ('E');
3268           break;
3269
3270         case CAST_EXPR:
3271           write_type (TREE_TYPE (expr));
3272           if (list_length (TREE_OPERAND (expr, 0)) == 1)
3273             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
3274           else
3275             {
3276               tree args = TREE_OPERAND (expr, 0);
3277               write_char ('_');
3278               for (; args; args = TREE_CHAIN (args))
3279                 write_expression (TREE_VALUE (args));
3280               write_char ('E');
3281             }
3282           break;
3283
3284         case DYNAMIC_CAST_EXPR:
3285         case REINTERPRET_CAST_EXPR:
3286         case STATIC_CAST_EXPR:
3287         case CONST_CAST_EXPR:
3288           write_type (TREE_TYPE (expr));
3289           write_expression (TREE_OPERAND (expr, 0));
3290           break;
3291
3292         case PREINCREMENT_EXPR:
3293         case PREDECREMENT_EXPR:
3294           if (abi_version_at_least (6))
3295             write_char ('_');
3296           if (abi_warn_or_compat_version_crosses (6))
3297             G.need_abi_warning = 1;
3298           /* Fall through.  */
3299
3300         default:
3301           /* In the middle-end, some expressions have more operands than
3302              they do in templates (and mangling).  */
3303           len = cp_tree_operand_length (expr);
3304
3305           for (i = 0; i < len; ++i)
3306             {
3307               tree operand = TREE_OPERAND (expr, i);
3308               /* As a GNU extension, the middle operand of a
3309                  conditional may be omitted.  Since expression
3310                  manglings are supposed to represent the input token
3311                  stream, there's no good way to mangle such an
3312                  expression without extending the C++ ABI.  */
3313               if (code == COND_EXPR && i == 1 && !operand)
3314                 {
3315                   error ("omitted middle operand to %<?:%> operand "
3316                          "cannot be mangled");
3317                   continue;
3318                 }
3319               else if (FOLD_EXPR_P (expr))
3320                 {
3321                   /* The first 'operand' of a fold-expression is the operator
3322                      that it folds over.  */
3323                   if (i == 0)
3324                     {
3325                       int fcode = TREE_INT_CST_LOW (operand);
3326                       write_string (operator_name_info[fcode].mangled_name);
3327                       continue;
3328                     }
3329                   else if (code == BINARY_LEFT_FOLD_EXPR)
3330                     {
3331                       /* The order of operands of the binary left and right
3332                          folds is the same, but we want to mangle them in
3333                          lexical order, i.e. non-pack first.  */
3334                       if (i == 1)
3335                         operand = FOLD_EXPR_INIT (expr);
3336                       else
3337                         operand = FOLD_EXPR_PACK (expr);
3338                     }
3339                   if (PACK_EXPANSION_P (operand))
3340                     operand = PACK_EXPANSION_PATTERN (operand);
3341                 }
3342               write_expression (operand);
3343             }
3344         }
3345     }
3346 }
3347
3348 /* Literal subcase of non-terminal <template-arg>.
3349
3350      "Literal arguments, e.g. "A<42L>", are encoded with their type
3351      and value. Negative integer values are preceded with "n"; for
3352      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
3353      encoded as 0, true as 1."  */
3354
3355 static void
3356 write_template_arg_literal (const tree value)
3357 {
3358   write_char ('L');
3359   write_type (TREE_TYPE (value));
3360
3361   /* Write a null member pointer value as (type)0, regardless of its
3362      real representation.  */
3363   if (null_member_pointer_value_p (value))
3364     write_integer_cst (integer_zero_node);
3365   else
3366     switch (TREE_CODE (value))
3367       {
3368       case CONST_DECL:
3369         write_integer_cst (DECL_INITIAL (value));
3370         break;
3371
3372       case INTEGER_CST:
3373         gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
3374                     || integer_zerop (value) || integer_onep (value));
3375         write_integer_cst (value);
3376         break;
3377
3378       case REAL_CST:
3379         write_real_cst (value);
3380         break;
3381
3382       case COMPLEX_CST:
3383         if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST
3384             && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST)
3385           {
3386             write_integer_cst (TREE_REALPART (value));
3387             write_char ('_');
3388             write_integer_cst (TREE_IMAGPART (value));
3389           }
3390         else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST
3391                  && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST)
3392           {
3393             write_real_cst (TREE_REALPART (value));
3394             write_char ('_');
3395             write_real_cst (TREE_IMAGPART (value));
3396           }
3397         else
3398           gcc_unreachable ();
3399         break;
3400
3401       case STRING_CST:
3402         sorry ("string literal in function template signature");
3403         break;
3404
3405       default:
3406         gcc_unreachable ();
3407       }
3408
3409   write_char ('E');
3410 }
3411
3412 /* Non-terminal <template-arg>.
3413
3414      <template-arg> ::= <type>                          # type
3415                     ::= L <type> </value/ number> E     # literal
3416                     ::= LZ <name> E                     # external name
3417                     ::= X <expression> E                # expression  */
3418
3419 static void
3420 write_template_arg (tree node)
3421 {
3422   enum tree_code code = TREE_CODE (node);
3423
3424   MANGLE_TRACE_TREE ("template-arg", node);
3425
3426   /* A template template parameter's argument list contains TREE_LIST
3427      nodes of which the value field is the actual argument.  */
3428   if (code == TREE_LIST)
3429     {
3430       node = TREE_VALUE (node);
3431       /* If it's a decl, deal with its type instead.  */
3432       if (DECL_P (node))
3433         {
3434           node = TREE_TYPE (node);
3435           code = TREE_CODE (node);
3436         }
3437     }
3438
3439   if (REFERENCE_REF_P (node))
3440     node = TREE_OPERAND (node, 0);
3441   if (TREE_CODE (node) == NOP_EXPR
3442       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
3443     {
3444       /* Template parameters can be of reference type. To maintain
3445          internal consistency, such arguments use a conversion from
3446          address of object to reference type.  */
3447       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
3448       node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
3449     }
3450
3451   if (TREE_CODE (node) == BASELINK
3452       && !type_unknown_p (node))
3453     {
3454       if (abi_version_at_least (6))
3455         node = BASELINK_FUNCTIONS (node);
3456       if (abi_warn_or_compat_version_crosses (6))
3457         /* We wrongly wrapped a class-scope function in X/E.  */
3458         G.need_abi_warning = 1;
3459     }
3460
3461   if (ARGUMENT_PACK_P (node))
3462     {
3463       /* Expand the template argument pack. */
3464       tree args = ARGUMENT_PACK_ARGS (node);
3465       int i, length = TREE_VEC_LENGTH (args);
3466       if (abi_version_at_least (6))
3467         write_char ('J');
3468       else
3469         write_char ('I');
3470       if (abi_warn_or_compat_version_crosses (6))
3471         G.need_abi_warning = 1;
3472       for (i = 0; i < length; ++i)
3473         write_template_arg (TREE_VEC_ELT (args, i));
3474       write_char ('E');
3475     }
3476   else if (TYPE_P (node))
3477     write_type (node);
3478   else if (code == TEMPLATE_DECL)
3479     /* A template appearing as a template arg is a template template arg.  */
3480     write_template_template_arg (node);
3481   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
3482            || code == CONST_DECL
3483            || null_member_pointer_value_p (node))
3484     write_template_arg_literal (node);
3485   else if (DECL_P (node))
3486     {
3487       write_char ('L');
3488       /* Until ABI version 3, the underscore before the mangled name
3489          was incorrectly omitted.  */
3490       if (!abi_version_at_least (3))
3491         write_char ('Z');
3492       else
3493         write_string ("_Z");
3494       if (abi_warn_or_compat_version_crosses (3))
3495         G.need_abi_warning = 1;
3496       write_encoding (node);
3497       write_char ('E');
3498     }
3499   else
3500     {
3501       /* Template arguments may be expressions.  */
3502       write_char ('X');
3503       write_expression (node);
3504       write_char ('E');
3505     }
3506 }
3507
3508 /*  <template-template-arg>
3509                         ::= <name>
3510                         ::= <substitution>  */
3511
3512 static void
3513 write_template_template_arg (const tree decl)
3514 {
3515   MANGLE_TRACE_TREE ("template-template-arg", decl);
3516
3517   if (find_substitution (decl))
3518     return;
3519   write_name (decl, /*ignore_local_scope=*/0);
3520   add_substitution (decl);
3521 }
3522
3523
3524 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
3525
3526      <array-type> ::= A [</dimension/ number>] _ </element/ type>
3527                   ::= A <expression> _ </element/ type>
3528
3529      "Array types encode the dimension (number of elements) and the
3530      element type.  For variable length arrays, the dimension (but not
3531      the '_' separator) is omitted."
3532      Note that for flexible array members, like for other arrays of
3533      unspecified size, the dimension is also omitted.  */
3534
3535 static void
3536 write_array_type (const tree type)
3537 {
3538   write_char ('A');
3539   if (TYPE_DOMAIN (type))
3540     {
3541       tree index_type;
3542
3543       index_type = TYPE_DOMAIN (type);
3544       /* The INDEX_TYPE gives the upper and lower bounds of the array.
3545          It's null for flexible array members which have no upper bound
3546          (this is a change from GCC 5 and prior where such members were
3547          incorrectly mangled as zero-length arrays).  */
3548       if (tree max = TYPE_MAX_VALUE (index_type))
3549         {
3550           if (TREE_CODE (max) == INTEGER_CST)
3551             {
3552               /* The ABI specifies that we should mangle the number of
3553                  elements in the array, not the largest allowed index.  */
3554               offset_int wmax = wi::to_offset (max) + 1;
3555               /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
3556                  number of elements as zero.  */
3557               wmax = wi::zext (wmax, TYPE_PRECISION (TREE_TYPE (max)));
3558               gcc_assert (wi::fits_uhwi_p (wmax));
3559               write_unsigned_number (wmax.to_uhwi ());
3560             }
3561           else
3562             {
3563               max = TREE_OPERAND (max, 0);
3564               write_expression (max);
3565             }
3566         }
3567     }
3568   write_char ('_');
3569   write_type (TREE_TYPE (type));
3570 }
3571
3572 /* Non-terminal <pointer-to-member-type> for pointer-to-member
3573    variables.  TYPE is a pointer-to-member POINTER_TYPE.
3574
3575      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
3576
3577 static void
3578 write_pointer_to_member_type (const tree type)
3579 {
3580   write_char ('M');
3581   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
3582   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
3583 }
3584
3585 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
3586    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3587    TEMPLATE_PARM_INDEX.
3588
3589      <template-param> ::= T </parameter/ number> _  */
3590
3591 static void
3592 write_template_param (const tree parm)
3593 {
3594   int parm_index;
3595
3596   MANGLE_TRACE_TREE ("template-parm", parm);
3597
3598   switch (TREE_CODE (parm))
3599     {
3600     case TEMPLATE_TYPE_PARM:
3601     case TEMPLATE_TEMPLATE_PARM:
3602     case BOUND_TEMPLATE_TEMPLATE_PARM:
3603       parm_index = TEMPLATE_TYPE_IDX (parm);
3604       break;
3605
3606     case TEMPLATE_PARM_INDEX:
3607       parm_index = TEMPLATE_PARM_IDX (parm);
3608       break;
3609
3610     default:
3611       gcc_unreachable ();
3612     }
3613
3614   write_char ('T');
3615   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3616      earliest template param denoted by `_'.  */
3617   write_compact_number (parm_index);
3618 }
3619
3620 /*  <template-template-param>
3621                         ::= <template-param>
3622                         ::= <substitution>  */
3623
3624 static void
3625 write_template_template_param (const tree parm)
3626 {
3627   tree templ = NULL_TREE;
3628
3629   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3630      template template parameter.  The substitution candidate here is
3631      only the template.  */
3632   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
3633     {
3634       templ
3635         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
3636       if (find_substitution (templ))
3637         return;
3638     }
3639
3640   /* <template-param> encodes only the template parameter position,
3641      not its template arguments, which is fine here.  */
3642   write_template_param (parm);
3643   if (templ)
3644     add_substitution (templ);
3645 }
3646
3647 /* Non-terminal <substitution>.
3648
3649       <substitution> ::= S <seq-id> _
3650                      ::= S_  */
3651
3652 static void
3653 write_substitution (const int seq_id)
3654 {
3655   MANGLE_TRACE ("substitution", "");
3656
3657   write_char ('S');
3658   if (seq_id > 0)
3659     write_number (seq_id - 1, /*unsigned=*/1, 36);
3660   write_char ('_');
3661 }
3662
3663 /* Start mangling ENTITY.  */
3664
3665 static inline void
3666 start_mangling (const tree entity)
3667 {
3668   G.entity = entity;
3669   G.need_abi_warning = false;
3670   G.need_cxx1z_warning = false;
3671   obstack_free (&name_obstack, name_base);
3672   mangle_obstack = &name_obstack;
3673   name_base = obstack_alloc (&name_obstack, 0);
3674 }
3675
3676 /* Done with mangling. If WARN is true, and the name of G.entity will
3677    be mangled differently in a future version of the ABI, issue a
3678    warning.  */
3679
3680 static void
3681 finish_mangling_internal (void)
3682 {
3683   /* Clear all the substitutions.  */
3684   vec_safe_truncate (G.substitutions, 0);
3685
3686   /* Null-terminate the string.  */
3687   write_char ('\0');
3688 }
3689
3690
3691 /* Like finish_mangling_internal, but return the mangled string.  */
3692
3693 static inline const char *
3694 finish_mangling (void)
3695 {
3696   finish_mangling_internal ();
3697   return (const char *) obstack_finish (mangle_obstack);
3698 }
3699
3700 /* Like finish_mangling_internal, but return an identifier.  */
3701
3702 static tree
3703 finish_mangling_get_identifier (void)
3704 {
3705   finish_mangling_internal ();
3706   /* Don't obstack_finish here, and the next start_mangling will
3707      remove the identifier.  */
3708   return get_identifier ((const char *) obstack_base (mangle_obstack));
3709 }
3710
3711 /* Initialize data structures for mangling.  */
3712
3713 void
3714 init_mangle (void)
3715 {
3716   gcc_obstack_init (&name_obstack);
3717   name_base = obstack_alloc (&name_obstack, 0);
3718   vec_alloc (G.substitutions, 0);
3719
3720   /* Cache these identifiers for quick comparison when checking for
3721      standard substitutions.  */
3722   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
3723   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
3724   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
3725   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
3726   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
3727   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
3728 }
3729
3730 /* Generate the mangled name of DECL.  */
3731
3732 static tree
3733 mangle_decl_string (const tree decl)
3734 {
3735   tree result;
3736   location_t saved_loc = input_location;
3737   tree saved_fn = NULL_TREE;
3738   bool template_p = false;
3739
3740   /* We shouldn't be trying to mangle an uninstantiated template.  */
3741   gcc_assert (!type_dependent_expression_p (decl));
3742
3743   if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3744     {
3745       struct tinst_level *tl = current_instantiation ();
3746       if ((!tl || tl->decl != decl)
3747           && push_tinst_level (decl))
3748         {
3749           template_p = true;
3750           saved_fn = current_function_decl;
3751           current_function_decl = NULL_TREE;
3752         }
3753     }
3754   input_location = DECL_SOURCE_LOCATION (decl);
3755
3756   start_mangling (decl);
3757
3758   if (TREE_CODE (decl) == TYPE_DECL)
3759     write_type (TREE_TYPE (decl));
3760   else
3761     write_mangled_name (decl, true);
3762
3763   result = finish_mangling_get_identifier ();
3764   if (DEBUG_MANGLE)
3765     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
3766              IDENTIFIER_POINTER (result));
3767
3768   if (template_p)
3769     {
3770       pop_tinst_level ();
3771       current_function_decl = saved_fn;
3772     }
3773   input_location = saved_loc;
3774
3775   return result;
3776 }
3777
3778 /* Return an identifier for the external mangled name of DECL.  */
3779
3780 static tree
3781 get_mangled_id (tree decl)
3782 {
3783   tree id = mangle_decl_string (decl);
3784   return targetm.mangle_decl_assembler_name (decl, id);
3785 }
3786
3787 /* If DECL is an implicit mangling alias, return its symtab node; otherwise
3788    return NULL.  */
3789
3790 static symtab_node *
3791 decl_implicit_alias_p (tree decl)
3792 {
3793   if (DECL_P (decl) && DECL_ARTIFICIAL (decl)
3794       && DECL_IGNORED_P (decl)
3795       && (TREE_CODE (decl) == FUNCTION_DECL
3796           || (VAR_P (decl) && TREE_STATIC (decl))))
3797     {
3798       symtab_node *n = symtab_node::get (decl);
3799       if (n && n->cpp_implicit_alias)
3800         return n;
3801     }
3802   return NULL;
3803 }
3804
3805 /* If DECL is a mangling alias, remove it from the symbol table and return
3806    true; otherwise return false.  */
3807
3808 bool
3809 maybe_remove_implicit_alias (tree decl)
3810 {
3811   if (symtab_node *n = decl_implicit_alias_p (decl))
3812     {
3813       n->remove();
3814       return true;
3815     }
3816   return false;
3817 }
3818
3819 /* Create an identifier for the external mangled name of DECL.  */
3820
3821 void
3822 mangle_decl (const tree decl)
3823 {
3824   tree id;
3825   bool dep;
3826
3827   /* Don't bother mangling uninstantiated templates.  */
3828   ++processing_template_decl;
3829   if (TREE_CODE (decl) == TYPE_DECL)
3830     dep = dependent_type_p (TREE_TYPE (decl));
3831   else
3832     dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
3833            && any_dependent_template_arguments_p (DECL_TI_ARGS (decl)));
3834   --processing_template_decl;
3835   if (dep)
3836     return;
3837
3838   /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
3839      It is not needed to assign names to anonymous namespace, but we use the
3840      "<anon>" marker to be able to tell if type is C++ ODR type or type
3841      produced by other language.  */
3842   if (TREE_CODE (decl) == TYPE_DECL
3843       && TYPE_STUB_DECL (TREE_TYPE (decl))
3844       && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl))))
3845     id = get_identifier ("<anon>");
3846   else
3847     {
3848       gcc_assert (TREE_CODE (decl) != TYPE_DECL
3849                   || !no_linkage_check (TREE_TYPE (decl), true));
3850       if (abi_version_at_least (10))
3851         if (tree fn = decl_function_context (decl))
3852           maybe_check_abi_tags (fn, decl);
3853       id = get_mangled_id (decl);
3854     }
3855   SET_DECL_ASSEMBLER_NAME (decl, id);
3856
3857   if (G.need_cxx1z_warning
3858       && (TREE_PUBLIC (decl) || DECL_REALLY_EXTERN (decl)))
3859     warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wnoexcept_type,
3860                 "mangled name for %qD will change in C++17 because the "
3861                 "exception specification is part of a function type",
3862                 decl);
3863
3864   if (id != DECL_NAME (decl)
3865       /* Don't do this for a fake symbol we aren't going to emit anyway.  */
3866       && TREE_CODE (decl) != TYPE_DECL
3867       && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
3868       && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3869     {
3870       int save_ver = flag_abi_version;
3871       tree id2 = NULL_TREE;
3872
3873       if (!DECL_REALLY_EXTERN (decl))
3874         {
3875           bool set = false;
3876
3877           /* Check IDENTIFIER_GLOBAL_VALUE before setting to avoid redundant
3878              errors from multiple definitions.  */
3879           tree d = IDENTIFIER_GLOBAL_VALUE (id);
3880           if (!d || decl_implicit_alias_p (d))
3881             {
3882               set = true;
3883               SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3884             }
3885
3886           if (!G.need_abi_warning)
3887             return;
3888
3889           /* If the mangling will change in the future, emit an alias with the
3890              future mangled name for forward-compatibility.  */
3891           if (!set)
3892             {
3893               SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3894               inform (DECL_SOURCE_LOCATION (decl), "a later -fabi-version= (or "
3895                       "=0) avoids this error with a change in mangling");
3896             }
3897
3898           flag_abi_version = flag_abi_compat_version;
3899           id2 = mangle_decl_string (decl);
3900           id2 = targetm.mangle_decl_assembler_name (decl, id2);
3901           flag_abi_version = save_ver;
3902
3903           if (id2 != id)
3904             note_mangling_alias (decl, id2);
3905         }
3906
3907       if (warn_abi)
3908         {
3909           if (flag_abi_compat_version != warn_abi_version
3910               || id2 == NULL_TREE)
3911             {
3912               flag_abi_version = warn_abi_version;
3913               id2 = mangle_decl_string (decl);
3914               id2 = targetm.mangle_decl_assembler_name (decl, id2);
3915             }
3916           flag_abi_version = save_ver;
3917
3918           if (id2 == id)
3919             /* OK.  */;
3920           else if (warn_abi_version != 0
3921                    && abi_version_at_least (warn_abi_version))
3922             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
3923                         "the mangled name of %qD changed between "
3924                         "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3925                         G.entity, warn_abi_version, id2,
3926                         save_ver, id);
3927           else
3928             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
3929                         "the mangled name of %qD changes between "
3930                         "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3931                         G.entity, save_ver, id,
3932                         warn_abi_version, id2);
3933         }
3934
3935       flag_abi_version = save_ver;
3936     }
3937 }
3938
3939 /* Generate the mangled representation of TYPE.  */
3940
3941 const char *
3942 mangle_type_string (const tree type)
3943 {
3944   const char *result;
3945
3946   start_mangling (type);
3947   write_type (type);
3948   result = finish_mangling ();
3949   if (DEBUG_MANGLE)
3950     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
3951   return result;
3952 }
3953
3954 /* Create an identifier for the mangled name of a special component
3955    for belonging to TYPE.  CODE is the ABI-specified code for this
3956    component.  */
3957
3958 static tree
3959 mangle_special_for_type (const tree type, const char *code)
3960 {
3961   tree result;
3962
3963   /* We don't have an actual decl here for the special component, so
3964      we can't just process the <encoded-name>.  Instead, fake it.  */
3965   start_mangling (type);
3966
3967   /* Start the mangling.  */
3968   write_string ("_Z");
3969   write_string (code);
3970
3971   /* Add the type.  */
3972   write_type (type);
3973   result = finish_mangling_get_identifier ();
3974
3975   if (DEBUG_MANGLE)
3976     fprintf (stderr, "mangle_special_for_type = %s\n\n",
3977              IDENTIFIER_POINTER (result));
3978
3979   return result;
3980 }
3981
3982 /* Create an identifier for the mangled representation of the typeinfo
3983    structure for TYPE.  */
3984
3985 tree
3986 mangle_typeinfo_for_type (const tree type)
3987 {
3988   return mangle_special_for_type (type, "TI");
3989 }
3990
3991 /* Create an identifier for the mangled name of the NTBS containing
3992    the mangled name of TYPE.  */
3993
3994 tree
3995 mangle_typeinfo_string_for_type (const tree type)
3996 {
3997   return mangle_special_for_type (type, "TS");
3998 }
3999
4000 /* Create an identifier for the mangled name of the vtable for TYPE.  */
4001
4002 tree
4003 mangle_vtbl_for_type (const tree type)
4004 {
4005   return mangle_special_for_type (type, "TV");
4006 }
4007
4008 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
4009
4010 tree
4011 mangle_vtt_for_type (const tree type)
4012 {
4013   return mangle_special_for_type (type, "TT");
4014 }
4015
4016 /* Returns an identifier for the mangled name of the decomposition
4017    artificial variable DECL.  DECLS is the vector of the VAR_DECLs
4018    for the identifier-list.  */
4019
4020 tree
4021 mangle_decomp (const tree decl, vec<tree> &decls)
4022 {
4023   gcc_assert (!type_dependent_expression_p (decl));
4024
4025   location_t saved_loc = input_location;
4026   input_location = DECL_SOURCE_LOCATION (decl);
4027
4028   start_mangling (decl);
4029   write_string ("_Z");
4030
4031   tree context = decl_mangling_context (decl);
4032   gcc_assert (context != NULL_TREE);
4033
4034   bool nested = false;
4035   if (DECL_NAMESPACE_STD_P (context))
4036     write_string ("St");
4037   else if (context != global_namespace)
4038     {
4039       nested = true;
4040       write_char ('N');
4041       write_prefix (decl_mangling_context (decl));
4042     }
4043
4044   write_string ("DC");
4045   unsigned int i;
4046   tree d;
4047   FOR_EACH_VEC_ELT (decls, i, d)
4048     write_unqualified_name (d);
4049   write_char ('E');
4050
4051   if (nested)
4052     write_char ('E');
4053
4054   tree id = finish_mangling_get_identifier ();
4055   if (DEBUG_MANGLE)
4056     fprintf (stderr, "mangle_decomp = '%s'\n\n",
4057              IDENTIFIER_POINTER (id));
4058
4059   input_location = saved_loc;
4060   return id;
4061 }
4062
4063 /* Return an identifier for a construction vtable group.  TYPE is
4064    the most derived class in the hierarchy; BINFO is the base
4065    subobject for which this construction vtable group will be used.
4066
4067    This mangling isn't part of the ABI specification; in the ABI
4068    specification, the vtable group is dumped in the same COMDAT as the
4069    main vtable, and is referenced only from that vtable, so it doesn't
4070    need an external name.  For binary formats without COMDAT sections,
4071    though, we need external names for the vtable groups.
4072
4073    We use the production
4074
4075     <special-name> ::= CT <type> <offset number> _ <base type>  */
4076
4077 tree
4078 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
4079 {
4080   tree result;
4081
4082   start_mangling (type);
4083
4084   write_string ("_Z");
4085   write_string ("TC");
4086   write_type (type);
4087   write_integer_cst (BINFO_OFFSET (binfo));
4088   write_char ('_');
4089   write_type (BINFO_TYPE (binfo));
4090
4091   result = finish_mangling_get_identifier ();
4092   if (DEBUG_MANGLE)
4093     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
4094              IDENTIFIER_POINTER (result));
4095   return result;
4096 }
4097
4098 /* Mangle a this pointer or result pointer adjustment.
4099
4100    <call-offset> ::= h <fixed offset number> _
4101                  ::= v <fixed offset number> _ <virtual offset number> _ */
4102
4103 static void
4104 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
4105 {
4106   write_char (virtual_offset ? 'v' : 'h');
4107
4108   /* For either flavor, write the fixed offset.  */
4109   write_integer_cst (fixed_offset);
4110   write_char ('_');
4111
4112   /* For a virtual thunk, add the virtual offset.  */
4113   if (virtual_offset)
4114     {
4115       write_integer_cst (virtual_offset);
4116       write_char ('_');
4117     }
4118 }
4119
4120 /* Return an identifier for the mangled name of a this-adjusting or
4121    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
4122    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
4123    is a virtual thunk, and it is the vtbl offset in
4124    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
4125    zero for a covariant thunk. Note, that FN_DECL might be a covariant
4126    thunk itself. A covariant thunk name always includes the adjustment
4127    for the this pointer, even if there is none.
4128
4129    <special-name> ::= T <call-offset> <base encoding>
4130                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
4131                                         <base encoding>  */
4132
4133 tree
4134 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
4135               tree virtual_offset, tree thunk)
4136 {
4137   tree result;
4138
4139   if (abi_version_at_least (11))
4140     maybe_check_abi_tags (fn_decl, thunk, 11);
4141
4142   start_mangling (fn_decl);
4143
4144   write_string ("_Z");
4145   write_char ('T');
4146
4147   if (!this_adjusting)
4148     {
4149       /* Covariant thunk with no this adjustment */
4150       write_char ('c');
4151       mangle_call_offset (integer_zero_node, NULL_TREE);
4152       mangle_call_offset (fixed_offset, virtual_offset);
4153     }
4154   else if (!DECL_THUNK_P (fn_decl))
4155     /* Plain this adjusting thunk.  */
4156     mangle_call_offset (fixed_offset, virtual_offset);
4157   else
4158     {
4159       /* This adjusting thunk to covariant thunk.  */
4160       write_char ('c');
4161       mangle_call_offset (fixed_offset, virtual_offset);
4162       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
4163       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
4164       if (virtual_offset)
4165         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
4166       mangle_call_offset (fixed_offset, virtual_offset);
4167       fn_decl = THUNK_TARGET (fn_decl);
4168     }
4169
4170   /* Scoped name.  */
4171   write_encoding (fn_decl);
4172
4173   result = finish_mangling_get_identifier ();
4174   if (DEBUG_MANGLE)
4175     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
4176   return result;
4177 }
4178
4179 struct conv_type_hasher : ggc_ptr_hash<tree_node>
4180 {
4181   static hashval_t hash (tree);
4182   static bool equal (tree, tree);
4183 };
4184
4185 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
4186    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
4187    TYPE.  */
4188
4189 static GTY (()) hash_table<conv_type_hasher> *conv_type_names;
4190
4191 /* Hash a node (VAL1) in the table.  */
4192
4193 hashval_t
4194 conv_type_hasher::hash (tree val)
4195 {
4196   return (hashval_t) TYPE_UID (TREE_TYPE (val));
4197 }
4198
4199 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
4200
4201 bool
4202 conv_type_hasher::equal (tree val1, tree val2)
4203 {
4204   return TREE_TYPE (val1) == val2;
4205 }
4206
4207 /* Return an identifier for the mangled unqualified name for a
4208    conversion operator to TYPE.  This mangling is not specified by the
4209    ABI spec; it is only used internally.  */
4210
4211 tree
4212 mangle_conv_op_name_for_type (const tree type)
4213 {
4214   tree *slot;
4215   tree identifier;
4216
4217   if (type == error_mark_node)
4218     return error_mark_node;
4219
4220   if (conv_type_names == NULL)
4221     conv_type_names = hash_table<conv_type_hasher>::create_ggc (31);
4222
4223   slot = conv_type_names->find_slot_with_hash (type,
4224                                                (hashval_t) TYPE_UID (type),
4225                                                INSERT);
4226   identifier = *slot;
4227   if (!identifier)
4228     {
4229       char buffer[64];
4230
4231        /* Create a unique name corresponding to TYPE.  */
4232       sprintf (buffer, "operator %lu",
4233                (unsigned long) conv_type_names->elements ());
4234       identifier = get_identifier (buffer);
4235       *slot = identifier;
4236
4237       /* Hang TYPE off the identifier so it can be found easily later
4238          when performing conversions.  */
4239       TREE_TYPE (identifier) = type;
4240
4241       /* Set bits on the identifier so we know later it's a conversion.  */
4242       IDENTIFIER_OPNAME_P (identifier) = 1;
4243       IDENTIFIER_TYPENAME_P (identifier) = 1;
4244     }
4245
4246   return identifier;
4247 }
4248
4249 /* Handle ABI backwards compatibility for past bugs where we didn't call
4250    check_abi_tags in places where it's needed: call check_abi_tags and warn if
4251    it makes a difference.  If FOR_DECL is non-null, it's the declaration
4252    that we're actually trying to mangle; if it's null, we're mangling the
4253    guard variable for T.  */
4254
4255 static void
4256 maybe_check_abi_tags (tree t, tree for_decl, int ver)
4257 {
4258   if (DECL_ASSEMBLER_NAME_SET_P (t))
4259     return;
4260
4261   tree oldtags = get_abi_tags (t);
4262
4263   mangle_decl (t);
4264
4265   tree newtags = get_abi_tags (t);
4266   if (newtags && newtags != oldtags
4267       && abi_version_crosses (ver))
4268     {
4269       if (for_decl && DECL_THUNK_P (for_decl))
4270         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
4271                     "the mangled name of a thunk for %qD changes between "
4272                     "-fabi-version=%d and -fabi-version=%d",
4273                     t, flag_abi_version, warn_abi_version);
4274       else if (for_decl)
4275         warning_at (DECL_SOURCE_LOCATION (for_decl), OPT_Wabi,
4276                     "the mangled name of %qD changes between "
4277                     "-fabi-version=%d and -fabi-version=%d",
4278                     for_decl, flag_abi_version, warn_abi_version);
4279       else
4280         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
4281                     "the mangled name of the initialization guard variable "
4282                     "for %qD changes between -fabi-version=%d and "
4283                     "-fabi-version=%d",
4284                     t, flag_abi_version, warn_abi_version);
4285     }
4286 }
4287
4288 /* Write out the appropriate string for this variable when generating
4289    another mangled name based on this one.  */
4290
4291 static void
4292 write_guarded_var_name (const tree variable)
4293 {
4294   if (DECL_NAME (variable)
4295       && strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
4296     /* The name of a guard variable for a reference temporary should refer
4297        to the reference, not the temporary.  */
4298     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
4299   else
4300     write_name (variable, /*ignore_local_scope=*/0);
4301 }
4302
4303 /* Return an identifier for the name of an initialization guard
4304    variable for indicated VARIABLE.  */
4305
4306 tree
4307 mangle_guard_variable (const tree variable)
4308 {
4309   if (abi_version_at_least (10))
4310     maybe_check_abi_tags (variable);
4311   start_mangling (variable);
4312   write_string ("_ZGV");
4313   write_guarded_var_name (variable);
4314   return finish_mangling_get_identifier ();
4315 }
4316
4317 /* Return an identifier for the name of a thread_local initialization
4318    function for VARIABLE.  */
4319
4320 tree
4321 mangle_tls_init_fn (const tree variable)
4322 {
4323   check_abi_tags (variable);
4324   start_mangling (variable);
4325   write_string ("_ZTH");
4326   write_guarded_var_name (variable);
4327   return finish_mangling_get_identifier ();
4328 }
4329
4330 /* Return an identifier for the name of a thread_local wrapper
4331    function for VARIABLE.  */
4332
4333 #define TLS_WRAPPER_PREFIX "_ZTW"
4334
4335 tree
4336 mangle_tls_wrapper_fn (const tree variable)
4337 {
4338   check_abi_tags (variable);
4339   start_mangling (variable);
4340   write_string (TLS_WRAPPER_PREFIX);
4341   write_guarded_var_name (variable);
4342   return finish_mangling_get_identifier ();
4343 }
4344
4345 /* Return true iff FN is a thread_local wrapper function.  */
4346
4347 bool
4348 decl_tls_wrapper_p (const tree fn)
4349 {
4350   if (TREE_CODE (fn) != FUNCTION_DECL)
4351     return false;
4352   tree name = DECL_NAME (fn);
4353   return strncmp (IDENTIFIER_POINTER (name), TLS_WRAPPER_PREFIX,
4354                   strlen (TLS_WRAPPER_PREFIX)) == 0;
4355 }
4356
4357 /* Return an identifier for the name of a temporary variable used to
4358    initialize a static reference.  This isn't part of the ABI, but we might
4359    as well call them something readable.  */
4360
4361 static GTY(()) int temp_count;
4362
4363 tree
4364 mangle_ref_init_variable (const tree variable)
4365 {
4366   start_mangling (variable);
4367   write_string ("_ZGR");
4368   check_abi_tags (variable);
4369   write_name (variable, /*ignore_local_scope=*/0);
4370   /* Avoid name clashes with aggregate initialization of multiple
4371      references at once.  */
4372   write_unsigned_number (temp_count++);
4373   return finish_mangling_get_identifier ();
4374 }
4375 \f
4376 /* Given a CLASS_TYPE, such as a record for std::bad_exception this
4377    function generates a mangled name for the vtable map variable of
4378    the class type.  For example, if the class type is
4379    "std::bad_exception", the mangled name for the class is
4380    "St13bad_exception".  This function would generate the name
4381    "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
4382    "_VTV<std::bad_exception>::__vtable_map".  */
4383
4384
4385 char *
4386 get_mangled_vtable_map_var_name (tree class_type)
4387 {
4388   char *var_name = NULL;
4389   const char *prefix = "_ZN4_VTVI";
4390   const char *postfix = "E12__vtable_mapE";
4391
4392   gcc_assert (TREE_CODE (class_type) == RECORD_TYPE);
4393
4394   tree class_id = DECL_ASSEMBLER_NAME (TYPE_NAME (class_type));
4395
4396   if (strstr (IDENTIFIER_POINTER (class_id), "<anon>") != NULL)
4397     {
4398       class_id = get_mangled_id (TYPE_NAME (class_type));
4399       vtbl_register_mangled_name (TYPE_NAME (class_type), class_id);
4400     }
4401
4402   unsigned int len = strlen (IDENTIFIER_POINTER (class_id)) +
4403                      strlen (prefix) +
4404                      strlen (postfix) + 1;
4405
4406   var_name = (char *) xmalloc (len);
4407
4408   sprintf (var_name, "%s%s%s", prefix, IDENTIFIER_POINTER (class_id), postfix);
4409
4410   return var_name;
4411 }
4412
4413 #include "gt-cp-mangle.h"