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_CONV_OP_P (identifier))
1265     write_conversion_operator_name (TREE_TYPE (identifier));
1266   else if (IDENTIFIER_ANY_OP_P (identifier))
1267     {
1268       int i;
1269       const char *mangled_name = NULL;
1270
1271       /* Unfortunately, there is no easy way to go from the
1272          name of the operator back to the corresponding tree
1273          code.  */
1274       for (i = 0; i < MAX_TREE_CODES; ++i)
1275         if (operator_name_info[i].identifier == identifier)
1276           {
1277             /* The ABI says that we prefer binary operator
1278                names to unary operator names.  */
1279             if (operator_name_info[i].arity == 2)
1280               {
1281                 mangled_name = operator_name_info[i].mangled_name;
1282                 break;
1283               }
1284             else if (!mangled_name)
1285               mangled_name = operator_name_info[i].mangled_name;
1286           }
1287         else if (assignment_operator_name_info[i].identifier
1288                  == identifier)
1289           {
1290             mangled_name
1291               = assignment_operator_name_info[i].mangled_name;
1292             break;
1293           }
1294       write_string (mangled_name);
1295     }
1296   else if (UDLIT_OPER_P (identifier))
1297     write_literal_operator_name (identifier);
1298   else
1299     write_source_name (identifier);
1300 }
1301
1302 static void
1303 write_unqualified_name (tree decl)
1304 {
1305   MANGLE_TRACE_TREE ("unqualified-name", decl);
1306
1307   if (identifier_p (decl))
1308     {
1309       write_unqualified_id (decl);
1310       return;
1311     }
1312
1313   bool found = false;
1314
1315   if (DECL_NAME (decl) == NULL_TREE)
1316     {
1317       found = true;
1318       gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
1319       write_source_name (DECL_ASSEMBLER_NAME (decl));
1320     }
1321   else if (DECL_DECLARES_FUNCTION_P (decl))
1322     {
1323       found = true;
1324       if (DECL_CONSTRUCTOR_P (decl))
1325         write_special_name_constructor (decl);
1326       else if (DECL_DESTRUCTOR_P (decl))
1327         write_special_name_destructor (decl);
1328       else if (DECL_CONV_FN_P (decl))
1329         {
1330           /* Conversion operator. Handle it right here.
1331              <operator> ::= cv <type>  */
1332           tree type;
1333           if (decl_is_template_id (decl, NULL))
1334             {
1335               tree fn_type;
1336               fn_type = get_mostly_instantiated_function_type (decl);
1337               type = TREE_TYPE (fn_type);
1338             }
1339           else if (FNDECL_USED_AUTO (decl))
1340             type = (DECL_STRUCT_FUNCTION (decl)->language
1341                     ->x_auto_return_pattern);
1342           else
1343             type = DECL_CONV_FN_TYPE (decl);
1344           write_conversion_operator_name (type);
1345         }
1346       else if (DECL_OVERLOADED_OPERATOR_P (decl))
1347         {
1348           operator_name_info_t *oni;
1349           if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1350             oni = assignment_operator_name_info;
1351           else
1352             oni = operator_name_info;
1353
1354           write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1355         }
1356       else if (UDLIT_OPER_P (DECL_NAME (decl)))
1357         write_literal_operator_name (DECL_NAME (decl));
1358       else
1359         found = false;
1360     }
1361
1362   if (found)
1363     /* OK */;
1364   else if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
1365            && DECL_NAMESPACE_SCOPE_P (decl)
1366            && decl_linkage (decl) == lk_internal)
1367     {
1368       MANGLE_TRACE_TREE ("local-source-name", decl);
1369       write_char ('L');
1370       write_source_name (DECL_NAME (decl));
1371       /* The default discriminator is 1, and that's all we ever use,
1372          so there's no code to output one here.  */
1373     }
1374   else
1375     {
1376       tree type = TREE_TYPE (decl);
1377
1378       if (TREE_CODE (decl) == TYPE_DECL
1379           && TYPE_UNNAMED_P (type))
1380         write_unnamed_type_name (type);
1381       else if (TREE_CODE (decl) == TYPE_DECL
1382                && LAMBDA_TYPE_P (type))
1383         write_closure_type_name (type);
1384       else
1385         write_source_name (DECL_NAME (decl));
1386     }
1387
1388   /* We use the ABI tags from the primary class template, ignoring tags on any
1389      specializations.  This is necessary because C++ doesn't require a
1390      specialization to be declared before it is used unless the use requires a
1391      complete type, but we need to get the tags right on incomplete types as
1392      well.  */
1393   if (tree tmpl = most_general_template (decl))
1394     {
1395       tree res = DECL_TEMPLATE_RESULT (tmpl);
1396       if (res == NULL_TREE)
1397         /* UNBOUND_CLASS_TEMPLATE.  */;
1398       else if (DECL_DECLARES_TYPE_P (decl))
1399         decl = res;
1400       else if (any_abi_below (11))
1401         {
1402           /* ABI v10 implicit tags on the template.  */
1403           tree mtags = missing_abi_tags (res);
1404           /* Explicit tags on the template.  */
1405           tree ttags = get_abi_tags (res);
1406           /* Tags on the instantiation.  */
1407           tree dtags = get_abi_tags (decl);
1408
1409           if (mtags && abi_warn_or_compat_version_crosses (10))
1410             G.need_abi_warning = 1;
1411
1412           /* Add the v10 tags to the explicit tags now.  */
1413           mtags = chainon (mtags, ttags);
1414
1415           if (!G.need_abi_warning
1416               && abi_warn_or_compat_version_crosses (11)
1417               && !equal_abi_tags (dtags, mtags))
1418             G.need_abi_warning = 1;
1419
1420           if (!abi_version_at_least (10))
1421             /* In abi <10, we only got the explicit tags.  */
1422             decl = res;
1423           else if (flag_abi_version == 10)
1424             {
1425               /* In ABI 10, we want explict and implicit tags.  */
1426               write_abi_tags (mtags);
1427               return;
1428             }
1429         }
1430     }
1431
1432   tree tags = get_abi_tags (decl);
1433   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CONV_FN_P (decl)
1434       && any_abi_below (11))
1435     if (tree mtags = missing_abi_tags (decl))
1436       {
1437         if (abi_warn_or_compat_version_crosses (11))
1438           G.need_abi_warning = true;
1439         if (!abi_version_at_least (11))
1440           tags = chainon (mtags, tags);
1441       }
1442   write_abi_tags (tags);
1443 }
1444
1445 /* Write the unqualified-name for a conversion operator to TYPE.  */
1446
1447 static void
1448 write_conversion_operator_name (const tree type)
1449 {
1450   write_string ("cv");
1451   write_type (type);
1452 }
1453
1454 /* Non-terminal <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
1455
1456      <source-name> ::= </length/ number> <identifier>  */
1457
1458 static void
1459 write_source_name (tree identifier)
1460 {
1461   MANGLE_TRACE_TREE ("source-name", identifier);
1462
1463   /* 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 (flag_noexcept_type)
2104             {
2105               tree r = TYPE_RAISES_EXCEPTIONS (type);
2106               t = build_exception_variant (t, r);
2107             }
2108           if (abi_version_at_least (8)
2109               || type == TYPE_MAIN_VARIANT (type))
2110             /* Avoid adding the unqualified function type as a substitution.  */
2111             write_function_type (t);
2112           else
2113             write_type (t);
2114           if (abi_warn_or_compat_version_crosses (8))
2115             G.need_abi_warning = 1;
2116         }
2117       else
2118         write_type (t);
2119     }
2120   else if (TREE_CODE (type) == ARRAY_TYPE)
2121     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
2122        so that the cv-qualification of the element type is available
2123        in write_array_type.  */
2124     write_array_type (type);
2125   else
2126     {
2127       tree type_orig = type;
2128
2129       /* See through any typedefs.  */
2130       type = TYPE_MAIN_VARIANT (type);
2131       if (TREE_CODE (type) == FUNCTION_TYPE
2132           || TREE_CODE (type) == METHOD_TYPE)
2133         {
2134           type = build_ref_qualified_type (type, type_memfn_rqual (type_orig));
2135           type = build_exception_variant (type,
2136                                           TYPE_RAISES_EXCEPTIONS (type_orig));
2137         }
2138
2139       /* According to the C++ ABI, some library classes are passed the
2140          same as the scalar type of their single member and use the same
2141          mangling.  */
2142       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
2143         type = TREE_TYPE (first_field (type));
2144
2145       if (TYPE_PTRDATAMEM_P (type))
2146         write_pointer_to_member_type (type);
2147       else
2148         {
2149           /* Handle any target-specific fundamental types.  */
2150           const char *target_mangling
2151             = targetm.mangle_type (type_orig);
2152
2153           if (target_mangling)
2154             {
2155               write_string (target_mangling);
2156               /* Add substitutions for types other than fundamental
2157                  types.  */
2158               if (!VOID_TYPE_P (type)
2159                   && TREE_CODE (type) != INTEGER_TYPE
2160                   && TREE_CODE (type) != REAL_TYPE
2161                   && TREE_CODE (type) != BOOLEAN_TYPE)
2162                 add_substitution (type);
2163               return;
2164             }
2165
2166           switch (TREE_CODE (type))
2167             {
2168             case VOID_TYPE:
2169             case BOOLEAN_TYPE:
2170             case INTEGER_TYPE:  /* Includes wchar_t.  */
2171             case REAL_TYPE:
2172             case FIXED_POINT_TYPE:
2173               {
2174                 /* If this is a typedef, TYPE may not be one of
2175                    the standard builtin type nodes, but an alias of one.  Use
2176                    TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
2177                 write_builtin_type (TYPE_MAIN_VARIANT (type));
2178                 ++is_builtin_type;
2179               }
2180               break;
2181
2182             case COMPLEX_TYPE:
2183               write_char ('C');
2184               write_type (TREE_TYPE (type));
2185               break;
2186
2187             case FUNCTION_TYPE:
2188             case METHOD_TYPE:
2189               write_function_type (type);
2190               break;
2191
2192             case UNION_TYPE:
2193             case RECORD_TYPE:
2194             case ENUMERAL_TYPE:
2195               /* A pointer-to-member function is represented as a special
2196                  RECORD_TYPE, so check for this first.  */
2197               if (TYPE_PTRMEMFUNC_P (type))
2198                 write_pointer_to_member_type (type);
2199               else
2200                 write_class_enum_type (type);
2201               break;
2202
2203             case TYPENAME_TYPE:
2204             case UNBOUND_CLASS_TEMPLATE:
2205               /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2206                  ordinary nested names.  */
2207               write_nested_name (TYPE_STUB_DECL (type));
2208               break;
2209
2210             case POINTER_TYPE:
2211             case REFERENCE_TYPE:
2212               if (TYPE_PTR_P (type))
2213                 write_char ('P');
2214               else if (TYPE_REF_IS_RVALUE (type))
2215                 write_char ('O');
2216               else
2217                 write_char ('R');
2218               {
2219                 tree target = TREE_TYPE (type);
2220                 /* Attribute const/noreturn are not reflected in mangling.
2221                    We strip them here rather than at a lower level because
2222                    a typedef or template argument can have function type
2223                    with function-cv-quals (that use the same representation),
2224                    but you can't have a pointer/reference to such a type.  */
2225                 if (TREE_CODE (target) == FUNCTION_TYPE)
2226                   {
2227                     if (abi_warn_or_compat_version_crosses (5)
2228                         && TYPE_QUALS (target) != TYPE_UNQUALIFIED)
2229                       G.need_abi_warning = 1;
2230                     if (abi_version_at_least (5))
2231                       target = build_qualified_type (target, TYPE_UNQUALIFIED);
2232                   }
2233                 write_type (target);
2234               }
2235               break;
2236
2237             case TEMPLATE_TYPE_PARM:
2238               if (is_auto (type))
2239                 {
2240                   if (AUTO_IS_DECLTYPE (type))
2241                     write_identifier ("Dc");
2242                   else
2243                     write_identifier ("Da");
2244                   ++is_builtin_type;
2245                   break;
2246                 }
2247               /* fall through.  */
2248             case TEMPLATE_PARM_INDEX:
2249               write_template_param (type);
2250               break;
2251
2252             case TEMPLATE_TEMPLATE_PARM:
2253               write_template_template_param (type);
2254               break;
2255
2256             case BOUND_TEMPLATE_TEMPLATE_PARM:
2257               write_template_template_param (type);
2258               write_template_args
2259                 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
2260               break;
2261
2262             case VECTOR_TYPE:
2263               if (abi_version_at_least (4))
2264                 {
2265                   write_string ("Dv");
2266                   /* Non-constant vector size would be encoded with
2267                      _ expression, but we don't support that yet.  */
2268                   write_unsigned_number (TYPE_VECTOR_SUBPARTS (type));
2269                   write_char ('_');
2270                 }
2271               else
2272                 write_string ("U8__vector");
2273               if (abi_warn_or_compat_version_crosses (4))
2274                 G.need_abi_warning = 1;
2275               write_type (TREE_TYPE (type));
2276               break;
2277
2278             case TYPE_PACK_EXPANSION:
2279               write_string ("Dp");
2280               write_type (PACK_EXPANSION_PATTERN (type));
2281               break;
2282
2283             case DECLTYPE_TYPE:
2284               /* These shouldn't make it into mangling.  */
2285               gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
2286                           && !DECLTYPE_FOR_LAMBDA_PROXY (type));
2287
2288               /* In ABI <5, we stripped decltype of a plain decl.  */
2289               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2290                 {
2291                   tree expr = DECLTYPE_TYPE_EXPR (type);
2292                   tree etype = NULL_TREE;
2293                   switch (TREE_CODE (expr))
2294                     {
2295                     case VAR_DECL:
2296                     case PARM_DECL:
2297                     case RESULT_DECL:
2298                     case FUNCTION_DECL:
2299                     case CONST_DECL:
2300                     case TEMPLATE_PARM_INDEX:
2301                       etype = TREE_TYPE (expr);
2302                       break;
2303
2304                     default:
2305                       break;
2306                     }
2307
2308                   if (etype && !type_uses_auto (etype))
2309                     {
2310                       if (abi_warn_or_compat_version_crosses (5))
2311                         G.need_abi_warning = 1;
2312                       if (!abi_version_at_least (5))
2313                         {
2314                           write_type (etype);
2315                           return;
2316                         }
2317                     }
2318                 }
2319
2320               write_char ('D');
2321               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2322                 write_char ('t');
2323               else
2324                 write_char ('T');
2325               ++cp_unevaluated_operand;
2326               write_expression (DECLTYPE_TYPE_EXPR (type));
2327               --cp_unevaluated_operand;
2328               write_char ('E');
2329               break;
2330
2331             case NULLPTR_TYPE:
2332               write_string ("Dn");
2333               if (abi_version_at_least (7))
2334                 ++is_builtin_type;
2335               if (abi_warn_or_compat_version_crosses (7))
2336                 G.need_abi_warning = 1;
2337               break;
2338
2339             case TYPEOF_TYPE:
2340               sorry ("mangling typeof, use decltype instead");
2341               break;
2342
2343             case UNDERLYING_TYPE:
2344               sorry ("mangling __underlying_type");
2345               break;
2346
2347             case LANG_TYPE:
2348               /* fall through.  */
2349
2350             default:
2351               gcc_unreachable ();
2352             }
2353         }
2354     }
2355
2356   /* Types other than builtin types are substitution candidates.  */
2357   if (!is_builtin_type)
2358     add_substitution (type);
2359 }
2360
2361 /* qsort callback for sorting a vector of attribute entries.  */
2362
2363 static int
2364 attr_strcmp (const void *p1, const void *p2)
2365 {
2366   tree a1 = *(const tree*)p1;
2367   tree a2 = *(const tree*)p2;
2368
2369   const attribute_spec *as1 = lookup_attribute_spec (get_attribute_name (a1));
2370   const attribute_spec *as2 = lookup_attribute_spec (get_attribute_name (a2));
2371
2372   return strcmp (as1->name, as2->name);
2373 }
2374
2375 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
2376    CV-qualifiers written for TYPE.
2377
2378      <CV-qualifiers> ::= [r] [V] [K]  */
2379
2380 static int
2381 write_CV_qualifiers_for_type (const tree type)
2382 {
2383   int num_qualifiers = 0;
2384
2385   /* The order is specified by:
2386
2387        "In cases where multiple order-insensitive qualifiers are
2388        present, they should be ordered 'K' (closest to the base type),
2389        'V', 'r', and 'U' (farthest from the base type) ..."  */
2390
2391   /* Mangle attributes that affect type identity as extended qualifiers.
2392
2393      We don't do this with classes and enums because their attributes
2394      are part of their definitions, not something added on.  */
2395
2396   if (!OVERLOAD_TYPE_P (type))
2397     {
2398       auto_vec<tree> vec;
2399       for (tree a = TYPE_ATTRIBUTES (type); a; a = TREE_CHAIN (a))
2400         {
2401           tree name = get_attribute_name (a);
2402           const attribute_spec *as = lookup_attribute_spec (name);
2403           if (as && as->affects_type_identity
2404               && !is_attribute_p ("transaction_safe", name)
2405               && !is_attribute_p ("abi_tag", name))
2406             vec.safe_push (a);
2407         }
2408       if (abi_warn_or_compat_version_crosses (10) && !vec.is_empty ())
2409         G.need_abi_warning = true;
2410       if (abi_version_at_least (10))
2411         {
2412           vec.qsort (attr_strcmp);
2413           while (!vec.is_empty())
2414             {
2415               tree a = vec.pop();
2416               const attribute_spec *as
2417                 = lookup_attribute_spec (get_attribute_name (a));
2418
2419               write_char ('U');
2420               write_unsigned_number (strlen (as->name));
2421               write_string (as->name);
2422               if (TREE_VALUE (a))
2423                 {
2424                   write_char ('I');
2425                   for (tree args = TREE_VALUE (a); args;
2426                        args = TREE_CHAIN (args))
2427                     {
2428                       tree arg = TREE_VALUE (args);
2429                       write_template_arg (arg);
2430                     }
2431                   write_char ('E');
2432                 }
2433
2434               ++num_qualifiers;
2435             }
2436         }
2437     }
2438
2439   /* Note that we do not use cp_type_quals below; given "const
2440      int[3]", the "const" is emitted with the "int", not with the
2441      array.  */
2442   cp_cv_quals quals = TYPE_QUALS (type);
2443
2444   if (quals & TYPE_QUAL_RESTRICT)
2445     {
2446       write_char ('r');
2447       ++num_qualifiers;
2448     }
2449   if (quals & TYPE_QUAL_VOLATILE)
2450     {
2451       write_char ('V');
2452       ++num_qualifiers;
2453     }
2454   if (quals & TYPE_QUAL_CONST)
2455     {
2456       write_char ('K');
2457       ++num_qualifiers;
2458     }
2459
2460   return num_qualifiers;
2461 }
2462
2463 /* Non-terminal <builtin-type>.
2464
2465      <builtin-type> ::= v   # void
2466                     ::= b   # bool
2467                     ::= w   # wchar_t
2468                     ::= c   # char
2469                     ::= a   # signed char
2470                     ::= h   # unsigned char
2471                     ::= s   # short
2472                     ::= t   # unsigned short
2473                     ::= i   # int
2474                     ::= j   # unsigned int
2475                     ::= l   # long
2476                     ::= m   # unsigned long
2477                     ::= x   # long long, __int64
2478                     ::= y   # unsigned long long, __int64
2479                     ::= n   # __int128
2480                     ::= o   # unsigned __int128
2481                     ::= f   # float
2482                     ::= d   # double
2483                     ::= e   # long double, __float80
2484                     ::= g   # __float128          [not supported]
2485                     ::= u <source-name>  # vendor extended type */
2486
2487 static void
2488 write_builtin_type (tree type)
2489 {
2490   if (TYPE_CANONICAL (type))
2491     type = TYPE_CANONICAL (type);
2492
2493   switch (TREE_CODE (type))
2494     {
2495     case VOID_TYPE:
2496       write_char ('v');
2497       break;
2498
2499     case BOOLEAN_TYPE:
2500       write_char ('b');
2501       break;
2502
2503     case INTEGER_TYPE:
2504       /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2505          isn't in integer_type_nodes.  */
2506       if (type == wchar_type_node)
2507         write_char ('w');
2508       else if (type == char16_type_node)
2509         write_string ("Ds");
2510       else if (type == char32_type_node)
2511         write_string ("Di");
2512       else
2513         {
2514           size_t itk;
2515           /* Assume TYPE is one of the shared integer type nodes.  Find
2516              it in the array of these nodes.  */
2517         iagain:
2518           for (itk = 0; itk < itk_none; ++itk)
2519             if (integer_types[itk] != NULL_TREE
2520                 && integer_type_codes[itk] != '\0'
2521                 && type == integer_types[itk])
2522               {
2523                 /* Print the corresponding single-letter code.  */
2524                 write_char (integer_type_codes[itk]);
2525                 break;
2526               }
2527
2528           if (itk == itk_none)
2529             {
2530               tree t = c_common_type_for_mode (TYPE_MODE (type),
2531                                                TYPE_UNSIGNED (type));
2532               if (type != t)
2533                 {
2534                   type = t;
2535                   goto iagain;
2536                 }
2537
2538               if (TYPE_PRECISION (type) == 128)
2539                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
2540               else
2541                 {
2542                   /* Allow for cases where TYPE is not one of the shared
2543                      integer type nodes and write a "vendor extended builtin
2544                      type" with a name the form intN or uintN, respectively.
2545                      Situations like this can happen if you have an
2546                      __attribute__((__mode__(__SI__))) type and use exotic
2547                      switches like '-mint8' on AVR.  Of course, this is
2548                      undefined by the C++ ABI (and '-mint8' is not even
2549                      Standard C conforming), but when using such special
2550                      options you're pretty much in nowhere land anyway.  */
2551                   const char *prefix;
2552                   char prec[11];        /* up to ten digits for an unsigned */
2553
2554                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
2555                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
2556                   write_char ('u');     /* "vendor extended builtin type" */
2557                   write_unsigned_number (strlen (prefix) + strlen (prec));
2558                   write_string (prefix);
2559                   write_string (prec);
2560                 }
2561             }
2562         }
2563       break;
2564
2565     case REAL_TYPE:
2566       if (type == float_type_node)
2567         write_char ('f');
2568       else if (type == double_type_node)
2569         write_char ('d');
2570       else if (type == long_double_type_node)
2571         write_char ('e');
2572       else if (type == dfloat32_type_node)
2573         write_string ("Df");
2574       else if (type == dfloat64_type_node)
2575         write_string ("Dd");
2576       else if (type == dfloat128_type_node)
2577         write_string ("De");
2578       else
2579         gcc_unreachable ();
2580       break;
2581
2582     case FIXED_POINT_TYPE:
2583       write_string ("DF");
2584       if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
2585         write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
2586       if (type == fract_type_node
2587           || type == sat_fract_type_node
2588           || type == accum_type_node
2589           || type == sat_accum_type_node)
2590         write_char ('i');
2591       else if (type == unsigned_fract_type_node
2592                || type == sat_unsigned_fract_type_node
2593                || type == unsigned_accum_type_node
2594                || type == sat_unsigned_accum_type_node)
2595         write_char ('j');
2596       else if (type == short_fract_type_node
2597                || type == sat_short_fract_type_node
2598                || type == short_accum_type_node
2599                || type == sat_short_accum_type_node)
2600         write_char ('s');
2601       else if (type == unsigned_short_fract_type_node
2602                || type == sat_unsigned_short_fract_type_node
2603                || type == unsigned_short_accum_type_node
2604                || type == sat_unsigned_short_accum_type_node)
2605         write_char ('t');
2606       else if (type == long_fract_type_node
2607                || type == sat_long_fract_type_node
2608                || type == long_accum_type_node
2609                || type == sat_long_accum_type_node)
2610         write_char ('l');
2611       else if (type == unsigned_long_fract_type_node
2612                || type == sat_unsigned_long_fract_type_node
2613                || type == unsigned_long_accum_type_node
2614                || type == sat_unsigned_long_accum_type_node)
2615         write_char ('m');
2616       else if (type == long_long_fract_type_node
2617                || type == sat_long_long_fract_type_node
2618                || type == long_long_accum_type_node
2619                || type == sat_long_long_accum_type_node)
2620         write_char ('x');
2621       else if (type == unsigned_long_long_fract_type_node
2622                || type == sat_unsigned_long_long_fract_type_node
2623                || type == unsigned_long_long_accum_type_node
2624                || type == sat_unsigned_long_long_accum_type_node)
2625         write_char ('y');
2626       else
2627         sorry ("mangling unknown fixed point type");
2628       write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
2629       if (TYPE_SATURATING (type))
2630         write_char ('s');
2631       else
2632         write_char ('n');
2633       break;
2634
2635     default:
2636       gcc_unreachable ();
2637     }
2638 }
2639
2640 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
2641    METHOD_TYPE.  The return type is mangled before the parameter
2642    types.
2643
2644      <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E   */
2645
2646 static void
2647 write_function_type (const tree type)
2648 {
2649   MANGLE_TRACE_TREE ("function-type", type);
2650
2651   /* For a pointer to member function, the function type may have
2652      cv-qualifiers, indicating the quals for the artificial 'this'
2653      parameter.  */
2654   if (TREE_CODE (type) == METHOD_TYPE)
2655     {
2656       /* The first parameter must be a POINTER_TYPE pointing to the
2657          `this' parameter.  */
2658       tree this_type = class_of_this_parm (type);
2659       write_CV_qualifiers_for_type (this_type);
2660     }
2661
2662   write_exception_spec (TYPE_RAISES_EXCEPTIONS (type));
2663
2664   if (tx_safe_fn_type_p (type))
2665     write_string ("Dx");
2666
2667   write_char ('F');
2668   /* We don't track whether or not a type is `extern "C"'.  Note that
2669      you can have an `extern "C"' function that does not have
2670      `extern "C"' type, and vice versa:
2671
2672        extern "C" typedef void function_t();
2673        function_t f; // f has C++ linkage, but its type is
2674                      // `extern "C"'
2675
2676        typedef void function_t();
2677        extern "C" function_t f; // Vice versa.
2678
2679      See [dcl.link].  */
2680   write_bare_function_type (type, /*include_return_type_p=*/1,
2681                             /*decl=*/NULL);
2682   if (FUNCTION_REF_QUALIFIED (type))
2683     {
2684       if (FUNCTION_RVALUE_QUALIFIED (type))
2685         write_char ('O');
2686       else
2687         write_char ('R');
2688     }
2689   write_char ('E');
2690 }
2691
2692 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
2693    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
2694    is mangled before the parameter types.  If non-NULL, DECL is
2695    FUNCTION_DECL for the function whose type is being emitted.  */
2696
2697 static void
2698 write_bare_function_type (const tree type, const int include_return_type_p,
2699                           const tree decl)
2700 {
2701   MANGLE_TRACE_TREE ("bare-function-type", type);
2702
2703   /* Mangle the return type, if requested.  */
2704   if (include_return_type_p)
2705     write_type (TREE_TYPE (type));
2706
2707   /* Now mangle the types of the arguments.  */
2708   ++G.parm_depth;
2709   write_method_parms (TYPE_ARG_TYPES (type),
2710                       TREE_CODE (type) == METHOD_TYPE,
2711                       decl);
2712   --G.parm_depth;
2713 }
2714
2715 /* Write the mangled representation of a method parameter list of
2716    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
2717    considered a non-static method, and the this parameter is omitted.
2718    If non-NULL, DECL is the FUNCTION_DECL for the function whose
2719    parameters are being emitted.  */
2720
2721 static void
2722 write_method_parms (tree parm_types, const int method_p, const tree decl)
2723 {
2724   tree first_parm_type;
2725   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2726
2727   /* Assume this parameter type list is variable-length.  If it ends
2728      with a void type, then it's not.  */
2729   int varargs_p = 1;
2730
2731   /* If this is a member function, skip the first arg, which is the
2732      this pointer.
2733        "Member functions do not encode the type of their implicit this
2734        parameter."
2735
2736      Similarly, there's no need to mangle artificial parameters, like
2737      the VTT parameters for constructors and destructors.  */
2738   if (method_p)
2739     {
2740       parm_types = TREE_CHAIN (parm_types);
2741       parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
2742
2743       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2744         {
2745           parm_types = TREE_CHAIN (parm_types);
2746           parm_decl = DECL_CHAIN (parm_decl);
2747         }
2748
2749       if (decl && ctor_omit_inherited_parms (decl))
2750         /* Bring back parameters omitted from an inherited ctor.  */
2751         parm_types = FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (decl));
2752     }
2753
2754   for (first_parm_type = parm_types;
2755        parm_types;
2756        parm_types = TREE_CHAIN (parm_types))
2757     {
2758       tree parm = TREE_VALUE (parm_types);
2759       if (parm == void_type_node)
2760         {
2761           /* "Empty parameter lists, whether declared as () or
2762              conventionally as (void), are encoded with a void parameter
2763              (v)."  */
2764           if (parm_types == first_parm_type)
2765             write_type (parm);
2766           /* If the parm list is terminated with a void type, it's
2767              fixed-length.  */
2768           varargs_p = 0;
2769           /* A void type better be the last one.  */
2770           gcc_assert (TREE_CHAIN (parm_types) == NULL);
2771         }
2772       else
2773         write_type (parm);
2774     }
2775
2776   if (varargs_p)
2777     /* <builtin-type> ::= z  # ellipsis  */
2778     write_char ('z');
2779 }
2780
2781 /* <class-enum-type> ::= <name>  */
2782
2783 static void
2784 write_class_enum_type (const tree type)
2785 {
2786   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2787 }
2788
2789 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
2790    arguments.
2791
2792      <template-args> ::= I <template-arg>* E  */
2793
2794 static void
2795 write_template_args (tree args)
2796 {
2797   int i;
2798   int length = 0;
2799
2800   MANGLE_TRACE_TREE ("template-args", args);
2801
2802   write_char ('I');
2803
2804   if (args)
2805     length = TREE_VEC_LENGTH (args);
2806
2807   if (args && length && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2808     {
2809       /* We have nested template args.  We want the innermost template
2810          argument list.  */
2811       args = TREE_VEC_ELT (args, length - 1);
2812       length = TREE_VEC_LENGTH (args);
2813     }
2814   for (i = 0; i < length; ++i)
2815     write_template_arg (TREE_VEC_ELT (args, i));
2816
2817   write_char ('E');
2818 }
2819
2820 /* Write out the
2821    <unqualified-name>
2822    <unqualified-name> <template-args>
2823    part of SCOPE_REF or COMPONENT_REF mangling.  */
2824
2825 static void
2826 write_member_name (tree member)
2827 {
2828   if (identifier_p (member))
2829     {
2830       if (abi_version_at_least (11) && IDENTIFIER_ANY_OP_P (member))
2831         {
2832           write_string ("on");
2833           if (abi_warn_or_compat_version_crosses (11))
2834             G.need_abi_warning = 1;
2835         }
2836       write_unqualified_id (member);
2837     }
2838   else if (DECL_P (member))
2839     write_unqualified_name (member);
2840   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2841     {
2842       tree name = TREE_OPERAND (member, 0);
2843       name = OVL_FIRST (name);
2844       write_member_name (name);
2845       write_template_args (TREE_OPERAND (member, 1));
2846     }
2847   else
2848     write_expression (member);
2849 }
2850
2851 /* <expression> ::= <unary operator-name> <expression>
2852                 ::= <binary operator-name> <expression> <expression>
2853                 ::= <expr-primary>
2854
2855    <expr-primary> ::= <template-param>
2856                   ::= L <type> <value number> E         # literal
2857                   ::= L <mangled-name> E                # external name
2858                   ::= st <type>                         # sizeof
2859                   ::= sr <type> <unqualified-name>      # dependent name
2860                   ::= sr <type> <unqualified-name> <template-args> */
2861
2862 static void
2863 write_expression (tree expr)
2864 {
2865   enum tree_code code = TREE_CODE (expr);
2866
2867   /* Skip NOP_EXPR and CONVERT_EXPR.  They can occur when (say) a pointer
2868      argument is converted (via qualification conversions) to another type.  */
2869   while (CONVERT_EXPR_CODE_P (code)
2870          /* Parentheses aren't mangled.  */
2871          || code == PAREN_EXPR
2872          || TREE_CODE (expr) == NON_LVALUE_EXPR)
2873     {
2874       expr = TREE_OPERAND (expr, 0);
2875       code = TREE_CODE (expr);
2876     }
2877
2878   if (code == BASELINK
2879       && (!type_unknown_p (expr)
2880           || !BASELINK_QUALIFIED_P (expr)))
2881     {
2882       expr = BASELINK_FUNCTIONS (expr);
2883       code = TREE_CODE (expr);
2884     }
2885
2886   /* Handle pointers-to-members by making them look like expression
2887      nodes.  */
2888   if (code == PTRMEM_CST)
2889     {
2890       expr = build_nt (ADDR_EXPR,
2891                        build_qualified_name (/*type=*/NULL_TREE,
2892                                              PTRMEM_CST_CLASS (expr),
2893                                              PTRMEM_CST_MEMBER (expr),
2894                                              /*template_p=*/false));
2895       code = TREE_CODE (expr);
2896     }
2897
2898   /* Handle template parameters.  */
2899   if (code == TEMPLATE_TYPE_PARM
2900       || code == TEMPLATE_TEMPLATE_PARM
2901       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2902       || code == TEMPLATE_PARM_INDEX)
2903     write_template_param (expr);
2904   /* Handle literals.  */
2905   else if (TREE_CODE_CLASS (code) == tcc_constant
2906            || code == CONST_DECL)
2907     write_template_arg_literal (expr);
2908   else if (code == PARM_DECL && DECL_ARTIFICIAL (expr))
2909     {
2910       gcc_assert (id_equal (DECL_NAME (expr), "this"));
2911       write_string ("fpT");
2912     }
2913   else if (code == PARM_DECL)
2914     {
2915       /* A function parameter used in a late-specified return type.  */
2916       int index = DECL_PARM_INDEX (expr);
2917       int level = DECL_PARM_LEVEL (expr);
2918       int delta = G.parm_depth - level + 1;
2919       gcc_assert (index >= 1);
2920       write_char ('f');
2921       if (delta != 0)
2922         {
2923           if (abi_version_at_least (5))
2924             {
2925               /* Let L be the number of function prototype scopes from the
2926                  innermost one (in which the parameter reference occurs) up
2927                  to (and including) the one containing the declaration of
2928                  the referenced parameter.  If the parameter declaration
2929                  clause of the innermost function prototype scope has been
2930                  completely seen, it is not counted (in that case -- which
2931                  is perhaps the most common -- L can be zero).  */
2932               write_char ('L');
2933               write_unsigned_number (delta - 1);
2934             }
2935           if (abi_warn_or_compat_version_crosses (5))
2936             G.need_abi_warning = true;
2937         }
2938       write_char ('p');
2939       write_compact_number (index - 1);
2940     }
2941   else if (DECL_P (expr))
2942     {
2943       write_char ('L');
2944       write_mangled_name (expr, false);
2945       write_char ('E');
2946     }
2947   else if (TREE_CODE (expr) == SIZEOF_EXPR)
2948     {
2949       tree op = TREE_OPERAND (expr, 0);
2950
2951       if (PACK_EXPANSION_P (op))
2952         {
2953           if (abi_warn_or_compat_version_crosses (11))
2954             G.need_abi_warning = true;
2955           if (abi_version_at_least (11))
2956             {
2957               /* sZ rather than szDp.  */
2958               write_string ("sZ");
2959               write_expression (PACK_EXPANSION_PATTERN (op));
2960               return;
2961             }
2962         }
2963
2964       if (SIZEOF_EXPR_TYPE_P (expr))
2965         {
2966           write_string ("st");
2967           write_type (TREE_TYPE (op));
2968         }
2969       else if (ARGUMENT_PACK_P (op))
2970         {
2971           tree args = ARGUMENT_PACK_ARGS (op);
2972           int length = TREE_VEC_LENGTH (args);
2973           if (abi_warn_or_compat_version_crosses (10))
2974             G.need_abi_warning = true;
2975           if (abi_version_at_least (10))
2976             {
2977               /* sP <template-arg>* E # sizeof...(T), size of a captured
2978                  template parameter pack from an alias template */
2979               write_string ("sP");
2980               for (int i = 0; i < length; ++i)
2981                 write_template_arg (TREE_VEC_ELT (args, i));
2982               write_char ('E');
2983             }
2984           else
2985             {
2986               /* In GCC 5 we represented this sizeof wrong, with the effect
2987                  that we mangled it as the last element of the pack.  */
2988               tree arg = TREE_VEC_ELT (args, length-1);
2989               if (TYPE_P (op))
2990                 {
2991                   write_string ("st");
2992                   write_type (arg);
2993                 }
2994               else
2995                 {
2996                   write_string ("sz");
2997                   write_expression (arg);
2998                 }
2999             }
3000         }
3001       else if (TYPE_P (TREE_OPERAND (expr, 0)))
3002         {
3003           write_string ("st");
3004           write_type (TREE_OPERAND (expr, 0));
3005         }
3006       else
3007         goto normal_expr;
3008     }
3009   else if (TREE_CODE (expr) == ALIGNOF_EXPR
3010            && TYPE_P (TREE_OPERAND (expr, 0)))
3011     {
3012       write_string ("at");
3013       write_type (TREE_OPERAND (expr, 0));
3014     }
3015   else if (code == SCOPE_REF
3016            || code == BASELINK)
3017     {
3018       tree scope, member;
3019       if (code == SCOPE_REF)
3020         {
3021           scope = TREE_OPERAND (expr, 0);
3022           member = TREE_OPERAND (expr, 1);
3023         }
3024       else
3025         {
3026           scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr));
3027           member = BASELINK_FUNCTIONS (expr);
3028         }
3029
3030       /* If the MEMBER is a real declaration, then the qualifying
3031          scope was not dependent.  Ideally, we would not have a
3032          SCOPE_REF in those cases, but sometimes we do.  If the second
3033          argument is a DECL, then the name must not have been
3034          dependent.  */
3035       if (DECL_P (member))
3036         write_expression (member);
3037       else
3038         {
3039           write_string ("sr");
3040           write_type (scope);
3041           write_member_name (member);
3042         }
3043     }
3044   else if (INDIRECT_REF_P (expr)
3045            && TREE_TYPE (TREE_OPERAND (expr, 0))
3046            && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3047     {
3048       write_expression (TREE_OPERAND (expr, 0));
3049     }
3050   else if (identifier_p (expr))
3051     {
3052       /* An operator name appearing as a dependent name needs to be
3053          specially marked to disambiguate between a use of the operator
3054          name and a use of the operator in an expression.  */
3055       if (IDENTIFIER_ANY_OP_P (expr))
3056         write_string ("on");
3057       write_unqualified_id (expr);
3058     }
3059   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
3060     {
3061       tree fn = TREE_OPERAND (expr, 0);
3062       fn = OVL_NAME (fn);
3063       if (IDENTIFIER_ANY_OP_P (fn))
3064         write_string ("on");
3065       write_unqualified_id (fn);
3066       write_template_args (TREE_OPERAND (expr, 1));
3067     }
3068   else if (TREE_CODE (expr) == MODOP_EXPR)
3069     {
3070       enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1));
3071       const char *name = (assignment_operator_name_info[(int) subop]
3072                           .mangled_name);
3073       write_string (name);
3074       write_expression (TREE_OPERAND (expr, 0));
3075       write_expression (TREE_OPERAND (expr, 2));
3076     }
3077   else if (code == NEW_EXPR || code == VEC_NEW_EXPR)
3078     {
3079       /* ::= [gs] nw <expression>* _ <type> E
3080          ::= [gs] nw <expression>* _ <type> <initializer>
3081          ::= [gs] na <expression>* _ <type> E
3082          ::= [gs] na <expression>* _ <type> <initializer>
3083          <initializer> ::= pi <expression>* E  */
3084       tree placement = TREE_OPERAND (expr, 0);
3085       tree type = TREE_OPERAND (expr, 1);
3086       tree nelts = TREE_OPERAND (expr, 2);
3087       tree init = TREE_OPERAND (expr, 3);
3088       tree t;
3089
3090       gcc_assert (code == NEW_EXPR);
3091       if (TREE_OPERAND (expr, 2))
3092         code = VEC_NEW_EXPR;
3093
3094       if (NEW_EXPR_USE_GLOBAL (expr))
3095         write_string ("gs");
3096
3097       write_string (operator_name_info[(int) code].mangled_name);
3098
3099       for (t = placement; t; t = TREE_CHAIN (t))
3100         write_expression (TREE_VALUE (t));
3101
3102       write_char ('_');
3103
3104       if (nelts)
3105         {
3106           tree domain;
3107           ++processing_template_decl;
3108           domain = compute_array_index_type (NULL_TREE, nelts,
3109                                              tf_warning_or_error);
3110           type = build_cplus_array_type (type, domain);
3111           --processing_template_decl;
3112         }
3113       write_type (type);
3114
3115       if (init && TREE_CODE (init) == TREE_LIST
3116           && DIRECT_LIST_INIT_P (TREE_VALUE (init)))
3117         write_expression (TREE_VALUE (init));
3118       else
3119         {
3120           if (init)
3121             write_string ("pi");
3122           if (init && init != void_node)
3123             for (t = init; t; t = TREE_CHAIN (t))
3124               write_expression (TREE_VALUE (t));
3125           write_char ('E');
3126         }
3127     }
3128   else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR)
3129     {
3130       gcc_assert (code == DELETE_EXPR);
3131       if (DELETE_EXPR_USE_VEC (expr))
3132         code = VEC_DELETE_EXPR;
3133
3134       if (DELETE_EXPR_USE_GLOBAL (expr))
3135         write_string ("gs");
3136
3137       write_string (operator_name_info[(int) code].mangled_name);
3138
3139       write_expression (TREE_OPERAND (expr, 0));
3140     }
3141   else if (code == THROW_EXPR)
3142     {
3143       tree op = TREE_OPERAND (expr, 0);
3144       if (op)
3145         {
3146           write_string ("tw");
3147           write_expression (op);
3148         }
3149       else
3150         write_string ("tr");
3151     }
3152   else if (code == CONSTRUCTOR)
3153     {
3154       vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (expr);
3155       unsigned i; tree val;
3156
3157       if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3158         write_string ("il");
3159       else
3160         {
3161           write_string ("tl");
3162           write_type (TREE_TYPE (expr));
3163         }
3164       FOR_EACH_CONSTRUCTOR_VALUE (elts, i, val)
3165         write_expression (val);
3166       write_char ('E');
3167     }
3168   else if (dependent_name (expr))
3169     {
3170       write_unqualified_id (dependent_name (expr));
3171     }
3172   else
3173     {
3174     normal_expr:
3175       int i, len;
3176       const char *name;
3177
3178       /* When we bind a variable or function to a non-type template
3179          argument with reference type, we create an ADDR_EXPR to show
3180          the fact that the entity's address has been taken.  But, we
3181          don't actually want to output a mangling code for the `&'.  */
3182       if (TREE_CODE (expr) == ADDR_EXPR
3183           && TREE_TYPE (expr)
3184           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
3185         {
3186           expr = TREE_OPERAND (expr, 0);
3187           if (DECL_P (expr))
3188             {
3189               write_expression (expr);
3190               return;
3191             }
3192
3193           code = TREE_CODE (expr);
3194         }
3195
3196       if (code == COMPONENT_REF)
3197         {
3198           tree ob = TREE_OPERAND (expr, 0);
3199
3200           if (TREE_CODE (ob) == ARROW_EXPR)
3201             {
3202               write_string (operator_name_info[(int)code].mangled_name);
3203               ob = TREE_OPERAND (ob, 0);
3204               write_expression (ob);
3205             }
3206           else if (!is_dummy_object (ob))
3207             {
3208               write_string ("dt");
3209               write_expression (ob);
3210             }
3211           /* else, for a non-static data member with no associated object (in
3212              unevaluated context), use the unresolved-name mangling.  */
3213
3214           write_member_name (TREE_OPERAND (expr, 1));
3215           return;
3216         }
3217
3218       /* If it wasn't any of those, recursively expand the expression.  */
3219       name = operator_name_info[(int) code].mangled_name;
3220
3221       /* We used to mangle const_cast and static_cast like a C cast.  */
3222       if (code == CONST_CAST_EXPR
3223           || code == STATIC_CAST_EXPR)
3224         {
3225           if (abi_warn_or_compat_version_crosses (6))
3226             G.need_abi_warning = 1;
3227           if (!abi_version_at_least (6))
3228             name = operator_name_info[CAST_EXPR].mangled_name;
3229         }
3230
3231       if (name == NULL)
3232         {
3233           switch (code)
3234             {
3235             case TRAIT_EXPR:
3236               error ("use of built-in trait %qE in function signature; "
3237                      "use library traits instead", expr);
3238               break;
3239
3240             default:
3241               sorry ("mangling %C", code);
3242               break;
3243             }
3244           return;
3245         }
3246       else
3247         write_string (name);
3248
3249       switch (code)
3250         {
3251         case CALL_EXPR:
3252           {
3253             tree fn = CALL_EXPR_FN (expr);
3254
3255             if (TREE_CODE (fn) == ADDR_EXPR)
3256               fn = TREE_OPERAND (fn, 0);
3257
3258             /* Mangle a dependent name as the name, not whatever happens to
3259                be the first function in the overload set.  */
3260             if ((TREE_CODE (fn) == FUNCTION_DECL
3261                  || TREE_CODE (fn) == OVERLOAD)
3262                 && type_dependent_expression_p_push (expr))
3263               fn = OVL_NAME (fn);
3264
3265             write_expression (fn);
3266           }
3267
3268           for (i = 0; i < call_expr_nargs (expr); ++i)
3269             write_expression (CALL_EXPR_ARG (expr, i));
3270           write_char ('E');
3271           break;
3272
3273         case CAST_EXPR:
3274           write_type (TREE_TYPE (expr));
3275           if (list_length (TREE_OPERAND (expr, 0)) == 1)
3276             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
3277           else
3278             {
3279               tree args = TREE_OPERAND (expr, 0);
3280               write_char ('_');
3281               for (; args; args = TREE_CHAIN (args))
3282                 write_expression (TREE_VALUE (args));
3283               write_char ('E');
3284             }
3285           break;
3286
3287         case DYNAMIC_CAST_EXPR:
3288         case REINTERPRET_CAST_EXPR:
3289         case STATIC_CAST_EXPR:
3290         case CONST_CAST_EXPR:
3291           write_type (TREE_TYPE (expr));
3292           write_expression (TREE_OPERAND (expr, 0));
3293           break;
3294
3295         case PREINCREMENT_EXPR:
3296         case PREDECREMENT_EXPR:
3297           if (abi_version_at_least (6))
3298             write_char ('_');
3299           if (abi_warn_or_compat_version_crosses (6))
3300             G.need_abi_warning = 1;
3301           /* Fall through.  */
3302
3303         default:
3304           /* In the middle-end, some expressions have more operands than
3305              they do in templates (and mangling).  */
3306           len = cp_tree_operand_length (expr);
3307
3308           for (i = 0; i < len; ++i)
3309             {
3310               tree operand = TREE_OPERAND (expr, i);
3311               /* As a GNU extension, the middle operand of a
3312                  conditional may be omitted.  Since expression
3313                  manglings are supposed to represent the input token
3314                  stream, there's no good way to mangle such an
3315                  expression without extending the C++ ABI.  */
3316               if (code == COND_EXPR && i == 1 && !operand)
3317                 {
3318                   error ("omitted middle operand to %<?:%> operand "
3319                          "cannot be mangled");
3320                   continue;
3321                 }
3322               else if (FOLD_EXPR_P (expr))
3323                 {
3324                   /* The first 'operand' of a fold-expression is the operator
3325                      that it folds over.  */
3326                   if (i == 0)
3327                     {
3328                       int fcode = TREE_INT_CST_LOW (operand);
3329                       write_string (operator_name_info[fcode].mangled_name);
3330                       continue;
3331                     }
3332                   else if (code == BINARY_LEFT_FOLD_EXPR)
3333                     {
3334                       /* The order of operands of the binary left and right
3335                          folds is the same, but we want to mangle them in
3336                          lexical order, i.e. non-pack first.  */
3337                       if (i == 1)
3338                         operand = FOLD_EXPR_INIT (expr);
3339                       else
3340                         operand = FOLD_EXPR_PACK (expr);
3341                     }
3342                   if (PACK_EXPANSION_P (operand))
3343                     operand = PACK_EXPANSION_PATTERN (operand);
3344                 }
3345               write_expression (operand);
3346             }
3347         }
3348     }
3349 }
3350
3351 /* Literal subcase of non-terminal <template-arg>.
3352
3353      "Literal arguments, e.g. "A<42L>", are encoded with their type
3354      and value. Negative integer values are preceded with "n"; for
3355      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
3356      encoded as 0, true as 1."  */
3357
3358 static void
3359 write_template_arg_literal (const tree value)
3360 {
3361   write_char ('L');
3362   write_type (TREE_TYPE (value));
3363
3364   /* Write a null member pointer value as (type)0, regardless of its
3365      real representation.  */
3366   if (null_member_pointer_value_p (value))
3367     write_integer_cst (integer_zero_node);
3368   else
3369     switch (TREE_CODE (value))
3370       {
3371       case CONST_DECL:
3372         write_integer_cst (DECL_INITIAL (value));
3373         break;
3374
3375       case INTEGER_CST:
3376         gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
3377                     || integer_zerop (value) || integer_onep (value));
3378         write_integer_cst (value);
3379         break;
3380
3381       case REAL_CST:
3382         write_real_cst (value);
3383         break;
3384
3385       case COMPLEX_CST:
3386         if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST
3387             && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST)
3388           {
3389             write_integer_cst (TREE_REALPART (value));
3390             write_char ('_');
3391             write_integer_cst (TREE_IMAGPART (value));
3392           }
3393         else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST
3394                  && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST)
3395           {
3396             write_real_cst (TREE_REALPART (value));
3397             write_char ('_');
3398             write_real_cst (TREE_IMAGPART (value));
3399           }
3400         else
3401           gcc_unreachable ();
3402         break;
3403
3404       case STRING_CST:
3405         sorry ("string literal in function template signature");
3406         break;
3407
3408       default:
3409         gcc_unreachable ();
3410       }
3411
3412   write_char ('E');
3413 }
3414
3415 /* Non-terminal <template-arg>.
3416
3417      <template-arg> ::= <type>                          # type
3418                     ::= L <type> </value/ number> E     # literal
3419                     ::= LZ <name> E                     # external name
3420                     ::= X <expression> E                # expression  */
3421
3422 static void
3423 write_template_arg (tree node)
3424 {
3425   enum tree_code code = TREE_CODE (node);
3426
3427   MANGLE_TRACE_TREE ("template-arg", node);
3428
3429   /* A template template parameter's argument list contains TREE_LIST
3430      nodes of which the value field is the actual argument.  */
3431   if (code == TREE_LIST)
3432     {
3433       node = TREE_VALUE (node);
3434       /* If it's a decl, deal with its type instead.  */
3435       if (DECL_P (node))
3436         {
3437           node = TREE_TYPE (node);
3438           code = TREE_CODE (node);
3439         }
3440     }
3441
3442   if (REFERENCE_REF_P (node))
3443     node = TREE_OPERAND (node, 0);
3444   if (TREE_CODE (node) == NOP_EXPR
3445       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
3446     {
3447       /* Template parameters can be of reference type. To maintain
3448          internal consistency, such arguments use a conversion from
3449          address of object to reference type.  */
3450       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
3451       node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
3452     }
3453
3454   if (TREE_CODE (node) == BASELINK
3455       && !type_unknown_p (node))
3456     {
3457       if (abi_version_at_least (6))
3458         node = BASELINK_FUNCTIONS (node);
3459       if (abi_warn_or_compat_version_crosses (6))
3460         /* We wrongly wrapped a class-scope function in X/E.  */
3461         G.need_abi_warning = 1;
3462     }
3463
3464   if (ARGUMENT_PACK_P (node))
3465     {
3466       /* Expand the template argument pack. */
3467       tree args = ARGUMENT_PACK_ARGS (node);
3468       int i, length = TREE_VEC_LENGTH (args);
3469       if (abi_version_at_least (6))
3470         write_char ('J');
3471       else
3472         write_char ('I');
3473       if (abi_warn_or_compat_version_crosses (6))
3474         G.need_abi_warning = 1;
3475       for (i = 0; i < length; ++i)
3476         write_template_arg (TREE_VEC_ELT (args, i));
3477       write_char ('E');
3478     }
3479   else if (TYPE_P (node))
3480     write_type (node);
3481   else if (code == TEMPLATE_DECL)
3482     /* A template appearing as a template arg is a template template arg.  */
3483     write_template_template_arg (node);
3484   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
3485            || code == CONST_DECL
3486            || null_member_pointer_value_p (node))
3487     write_template_arg_literal (node);
3488   else if (DECL_P (node))
3489     {
3490       write_char ('L');
3491       /* Until ABI version 3, the underscore before the mangled name
3492          was incorrectly omitted.  */
3493       if (!abi_version_at_least (3))
3494         write_char ('Z');
3495       else
3496         write_string ("_Z");
3497       if (abi_warn_or_compat_version_crosses (3))
3498         G.need_abi_warning = 1;
3499       write_encoding (node);
3500       write_char ('E');
3501     }
3502   else
3503     {
3504       /* Template arguments may be expressions.  */
3505       write_char ('X');
3506       write_expression (node);
3507       write_char ('E');
3508     }
3509 }
3510
3511 /*  <template-template-arg>
3512                         ::= <name>
3513                         ::= <substitution>  */
3514
3515 static void
3516 write_template_template_arg (const tree decl)
3517 {
3518   MANGLE_TRACE_TREE ("template-template-arg", decl);
3519
3520   if (find_substitution (decl))
3521     return;
3522   write_name (decl, /*ignore_local_scope=*/0);
3523   add_substitution (decl);
3524 }
3525
3526
3527 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
3528
3529      <array-type> ::= A [</dimension/ number>] _ </element/ type>
3530                   ::= A <expression> _ </element/ type>
3531
3532      "Array types encode the dimension (number of elements) and the
3533      element type.  For variable length arrays, the dimension (but not
3534      the '_' separator) is omitted."
3535      Note that for flexible array members, like for other arrays of
3536      unspecified size, the dimension is also omitted.  */
3537
3538 static void
3539 write_array_type (const tree type)
3540 {
3541   write_char ('A');
3542   if (TYPE_DOMAIN (type))
3543     {
3544       tree index_type;
3545
3546       index_type = TYPE_DOMAIN (type);
3547       /* The INDEX_TYPE gives the upper and lower bounds of the array.
3548          It's null for flexible array members which have no upper bound
3549          (this is a change from GCC 5 and prior where such members were
3550          incorrectly mangled as zero-length arrays).  */
3551       if (tree max = TYPE_MAX_VALUE (index_type))
3552         {
3553           if (TREE_CODE (max) == INTEGER_CST)
3554             {
3555               /* The ABI specifies that we should mangle the number of
3556                  elements in the array, not the largest allowed index.  */
3557               offset_int wmax = wi::to_offset (max) + 1;
3558               /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
3559                  number of elements as zero.  */
3560               wmax = wi::zext (wmax, TYPE_PRECISION (TREE_TYPE (max)));
3561               gcc_assert (wi::fits_uhwi_p (wmax));
3562               write_unsigned_number (wmax.to_uhwi ());
3563             }
3564           else
3565             {
3566               max = TREE_OPERAND (max, 0);
3567               write_expression (max);
3568             }
3569         }
3570     }
3571   write_char ('_');
3572   write_type (TREE_TYPE (type));
3573 }
3574
3575 /* Non-terminal <pointer-to-member-type> for pointer-to-member
3576    variables.  TYPE is a pointer-to-member POINTER_TYPE.
3577
3578      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
3579
3580 static void
3581 write_pointer_to_member_type (const tree type)
3582 {
3583   write_char ('M');
3584   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
3585   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
3586 }
3587
3588 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
3589    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3590    TEMPLATE_PARM_INDEX.
3591
3592      <template-param> ::= T </parameter/ number> _  */
3593
3594 static void
3595 write_template_param (const tree parm)
3596 {
3597   int parm_index;
3598
3599   MANGLE_TRACE_TREE ("template-parm", parm);
3600
3601   switch (TREE_CODE (parm))
3602     {
3603     case TEMPLATE_TYPE_PARM:
3604     case TEMPLATE_TEMPLATE_PARM:
3605     case BOUND_TEMPLATE_TEMPLATE_PARM:
3606       parm_index = TEMPLATE_TYPE_IDX (parm);
3607       break;
3608
3609     case TEMPLATE_PARM_INDEX:
3610       parm_index = TEMPLATE_PARM_IDX (parm);
3611       break;
3612
3613     default:
3614       gcc_unreachable ();
3615     }
3616
3617   write_char ('T');
3618   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3619      earliest template param denoted by `_'.  */
3620   write_compact_number (parm_index);
3621 }
3622
3623 /*  <template-template-param>
3624                         ::= <template-param>
3625                         ::= <substitution>  */
3626
3627 static void
3628 write_template_template_param (const tree parm)
3629 {
3630   tree templ = NULL_TREE;
3631
3632   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3633      template template parameter.  The substitution candidate here is
3634      only the template.  */
3635   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
3636     {
3637       templ
3638         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
3639       if (find_substitution (templ))
3640         return;
3641     }
3642
3643   /* <template-param> encodes only the template parameter position,
3644      not its template arguments, which is fine here.  */
3645   write_template_param (parm);
3646   if (templ)
3647     add_substitution (templ);
3648 }
3649
3650 /* Non-terminal <substitution>.
3651
3652       <substitution> ::= S <seq-id> _
3653                      ::= S_  */
3654
3655 static void
3656 write_substitution (const int seq_id)
3657 {
3658   MANGLE_TRACE ("substitution", "");
3659
3660   write_char ('S');
3661   if (seq_id > 0)
3662     write_number (seq_id - 1, /*unsigned=*/1, 36);
3663   write_char ('_');
3664 }
3665
3666 /* Start mangling ENTITY.  */
3667
3668 static inline void
3669 start_mangling (const tree entity)
3670 {
3671   G.entity = entity;
3672   G.need_abi_warning = false;
3673   G.need_cxx1z_warning = false;
3674   obstack_free (&name_obstack, name_base);
3675   mangle_obstack = &name_obstack;
3676   name_base = obstack_alloc (&name_obstack, 0);
3677 }
3678
3679 /* Done with mangling. If WARN is true, and the name of G.entity will
3680    be mangled differently in a future version of the ABI, issue a
3681    warning.  */
3682
3683 static void
3684 finish_mangling_internal (void)
3685 {
3686   /* Clear all the substitutions.  */
3687   vec_safe_truncate (G.substitutions, 0);
3688
3689   /* Null-terminate the string.  */
3690   write_char ('\0');
3691 }
3692
3693
3694 /* Like finish_mangling_internal, but return the mangled string.  */
3695
3696 static inline const char *
3697 finish_mangling (void)
3698 {
3699   finish_mangling_internal ();
3700   return (const char *) obstack_finish (mangle_obstack);
3701 }
3702
3703 /* Like finish_mangling_internal, but return an identifier.  */
3704
3705 static tree
3706 finish_mangling_get_identifier (void)
3707 {
3708   finish_mangling_internal ();
3709   /* Don't obstack_finish here, and the next start_mangling will
3710      remove the identifier.  */
3711   return get_identifier ((const char *) obstack_base (mangle_obstack));
3712 }
3713
3714 /* Initialize data structures for mangling.  */
3715
3716 void
3717 init_mangle (void)
3718 {
3719   gcc_obstack_init (&name_obstack);
3720   name_base = obstack_alloc (&name_obstack, 0);
3721   vec_alloc (G.substitutions, 0);
3722
3723   /* Cache these identifiers for quick comparison when checking for
3724      standard substitutions.  */
3725   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
3726   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
3727   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
3728   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
3729   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
3730   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
3731 }
3732
3733 /* Generate the mangled name of DECL.  */
3734
3735 static tree
3736 mangle_decl_string (const tree decl)
3737 {
3738   tree result;
3739   location_t saved_loc = input_location;
3740   tree saved_fn = NULL_TREE;
3741   bool template_p = false;
3742
3743   /* We shouldn't be trying to mangle an uninstantiated template.  */
3744   gcc_assert (!type_dependent_expression_p (decl));
3745
3746   if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3747     {
3748       struct tinst_level *tl = current_instantiation ();
3749       if ((!tl || tl->decl != decl)
3750           && push_tinst_level (decl))
3751         {
3752           template_p = true;
3753           saved_fn = current_function_decl;
3754           current_function_decl = NULL_TREE;
3755         }
3756     }
3757   input_location = DECL_SOURCE_LOCATION (decl);
3758
3759   start_mangling (decl);
3760
3761   if (TREE_CODE (decl) == TYPE_DECL)
3762     write_type (TREE_TYPE (decl));
3763   else
3764     write_mangled_name (decl, true);
3765
3766   result = finish_mangling_get_identifier ();
3767   if (DEBUG_MANGLE)
3768     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
3769              IDENTIFIER_POINTER (result));
3770
3771   if (template_p)
3772     {
3773       pop_tinst_level ();
3774       current_function_decl = saved_fn;
3775     }
3776   input_location = saved_loc;
3777
3778   return result;
3779 }
3780
3781 /* Return an identifier for the external mangled name of DECL.  */
3782
3783 static tree
3784 get_mangled_id (tree decl)
3785 {
3786   tree id = mangle_decl_string (decl);
3787   return targetm.mangle_decl_assembler_name (decl, id);
3788 }
3789
3790 /* If DECL is an implicit mangling alias, return its symtab node; otherwise
3791    return NULL.  */
3792
3793 static symtab_node *
3794 decl_implicit_alias_p (tree decl)
3795 {
3796   if (DECL_P (decl) && DECL_ARTIFICIAL (decl)
3797       && DECL_IGNORED_P (decl)
3798       && (TREE_CODE (decl) == FUNCTION_DECL
3799           || (VAR_P (decl) && TREE_STATIC (decl))))
3800     {
3801       symtab_node *n = symtab_node::get (decl);
3802       if (n && n->cpp_implicit_alias)
3803         return n;
3804     }
3805   return NULL;
3806 }
3807
3808 /* If DECL is a mangling alias, remove it from the symbol table and return
3809    true; otherwise return false.  */
3810
3811 bool
3812 maybe_remove_implicit_alias (tree decl)
3813 {
3814   if (symtab_node *n = decl_implicit_alias_p (decl))
3815     {
3816       n->remove();
3817       return true;
3818     }
3819   return false;
3820 }
3821
3822 /* Create an identifier for the external mangled name of DECL.  */
3823
3824 void
3825 mangle_decl (const tree decl)
3826 {
3827   tree id;
3828   bool dep;
3829
3830   /* Don't bother mangling uninstantiated templates.  */
3831   ++processing_template_decl;
3832   if (TREE_CODE (decl) == TYPE_DECL)
3833     dep = dependent_type_p (TREE_TYPE (decl));
3834   else
3835     dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
3836            && any_dependent_template_arguments_p (DECL_TI_ARGS (decl)));
3837   --processing_template_decl;
3838   if (dep)
3839     return;
3840
3841   /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
3842      It is not needed to assign names to anonymous namespace, but we use the
3843      "<anon>" marker to be able to tell if type is C++ ODR type or type
3844      produced by other language.  */
3845   if (TREE_CODE (decl) == TYPE_DECL
3846       && TYPE_STUB_DECL (TREE_TYPE (decl))
3847       && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl))))
3848     id = get_identifier ("<anon>");
3849   else
3850     {
3851       gcc_assert (TREE_CODE (decl) != TYPE_DECL
3852                   || !no_linkage_check (TREE_TYPE (decl), true));
3853       if (abi_version_at_least (10))
3854         if (tree fn = decl_function_context (decl))
3855           maybe_check_abi_tags (fn, decl);
3856       id = get_mangled_id (decl);
3857     }
3858   SET_DECL_ASSEMBLER_NAME (decl, id);
3859
3860   if (G.need_cxx1z_warning
3861       && (TREE_PUBLIC (decl) || DECL_REALLY_EXTERN (decl)))
3862     warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wnoexcept_type,
3863                 "mangled name for %qD will change in C++17 because the "
3864                 "exception specification is part of a function type",
3865                 decl);
3866
3867   if (id != DECL_NAME (decl)
3868       /* Don't do this for a fake symbol we aren't going to emit anyway.  */
3869       && TREE_CODE (decl) != TYPE_DECL
3870       && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
3871       && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3872     {
3873       int save_ver = flag_abi_version;
3874       tree id2 = NULL_TREE;
3875
3876       if (!DECL_REALLY_EXTERN (decl))
3877         {
3878           bool set = false;
3879
3880           /* Check IDENTIFIER_GLOBAL_VALUE before setting to avoid redundant
3881              errors from multiple definitions.  */
3882           tree d = IDENTIFIER_GLOBAL_VALUE (id);
3883           if (!d || decl_implicit_alias_p (d))
3884             {
3885               set = true;
3886               SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3887             }
3888
3889           if (!G.need_abi_warning)
3890             return;
3891
3892           /* If the mangling will change in the future, emit an alias with the
3893              future mangled name for forward-compatibility.  */
3894           if (!set)
3895             {
3896               SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3897               inform (DECL_SOURCE_LOCATION (decl), "a later -fabi-version= (or "
3898                       "=0) avoids this error with a change in mangling");
3899             }
3900
3901           flag_abi_version = flag_abi_compat_version;
3902           id2 = mangle_decl_string (decl);
3903           id2 = targetm.mangle_decl_assembler_name (decl, id2);
3904           flag_abi_version = save_ver;
3905
3906           if (id2 != id)
3907             note_mangling_alias (decl, id2);
3908         }
3909
3910       if (warn_abi)
3911         {
3912           const char fabi_version[] = "-fabi-version";
3913
3914           if (flag_abi_compat_version != warn_abi_version
3915               || id2 == NULL_TREE)
3916             {
3917               flag_abi_version = warn_abi_version;
3918               id2 = mangle_decl_string (decl);
3919               id2 = targetm.mangle_decl_assembler_name (decl, id2);
3920             }
3921           flag_abi_version = save_ver;
3922
3923           if (id2 == id)
3924             /* OK.  */;
3925           else if (warn_abi_version != 0
3926                    && abi_version_at_least (warn_abi_version))
3927             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
3928                         "the mangled name of %qD changed between "
3929                         "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
3930                         G.entity, fabi_version, warn_abi_version, id2,
3931                         fabi_version, save_ver, id);
3932           else
3933             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
3934                         "the mangled name of %qD changes between "
3935                         "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
3936                         G.entity, fabi_version, save_ver, id,
3937                         fabi_version, warn_abi_version, id2);
3938         }
3939
3940       flag_abi_version = save_ver;
3941     }
3942 }
3943
3944 /* Generate the mangled representation of TYPE.  */
3945
3946 const char *
3947 mangle_type_string (const tree type)
3948 {
3949   const char *result;
3950
3951   start_mangling (type);
3952   write_type (type);
3953   result = finish_mangling ();
3954   if (DEBUG_MANGLE)
3955     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
3956   return result;
3957 }
3958
3959 /* Create an identifier for the mangled name of a special component
3960    for belonging to TYPE.  CODE is the ABI-specified code for this
3961    component.  */
3962
3963 static tree
3964 mangle_special_for_type (const tree type, const char *code)
3965 {
3966   tree result;
3967
3968   /* We don't have an actual decl here for the special component, so
3969      we can't just process the <encoded-name>.  Instead, fake it.  */
3970   start_mangling (type);
3971
3972   /* Start the mangling.  */
3973   write_string ("_Z");
3974   write_string (code);
3975
3976   /* Add the type.  */
3977   write_type (type);
3978   result = finish_mangling_get_identifier ();
3979
3980   if (DEBUG_MANGLE)
3981     fprintf (stderr, "mangle_special_for_type = %s\n\n",
3982              IDENTIFIER_POINTER (result));
3983
3984   return result;
3985 }
3986
3987 /* Create an identifier for the mangled representation of the typeinfo
3988    structure for TYPE.  */
3989
3990 tree
3991 mangle_typeinfo_for_type (const tree type)
3992 {
3993   return mangle_special_for_type (type, "TI");
3994 }
3995
3996 /* Create an identifier for the mangled name of the NTBS containing
3997    the mangled name of TYPE.  */
3998
3999 tree
4000 mangle_typeinfo_string_for_type (const tree type)
4001 {
4002   return mangle_special_for_type (type, "TS");
4003 }
4004
4005 /* Create an identifier for the mangled name of the vtable for TYPE.  */
4006
4007 tree
4008 mangle_vtbl_for_type (const tree type)
4009 {
4010   return mangle_special_for_type (type, "TV");
4011 }
4012
4013 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
4014
4015 tree
4016 mangle_vtt_for_type (const tree type)
4017 {
4018   return mangle_special_for_type (type, "TT");
4019 }
4020
4021 /* Returns an identifier for the mangled name of the decomposition
4022    artificial variable DECL.  DECLS is the vector of the VAR_DECLs
4023    for the identifier-list.  */
4024
4025 tree
4026 mangle_decomp (const tree decl, vec<tree> &decls)
4027 {
4028   gcc_assert (!type_dependent_expression_p (decl));
4029
4030   location_t saved_loc = input_location;
4031   input_location = DECL_SOURCE_LOCATION (decl);
4032
4033   start_mangling (decl);
4034   write_string ("_Z");
4035
4036   tree context = decl_mangling_context (decl);
4037   gcc_assert (context != NULL_TREE);
4038
4039   bool nested = false;
4040   if (DECL_NAMESPACE_STD_P (context))
4041     write_string ("St");
4042   else if (context != global_namespace)
4043     {
4044       nested = true;
4045       write_char ('N');
4046       write_prefix (decl_mangling_context (decl));
4047     }
4048
4049   write_string ("DC");
4050   unsigned int i;
4051   tree d;
4052   FOR_EACH_VEC_ELT (decls, i, d)
4053     write_unqualified_name (d);
4054   write_char ('E');
4055
4056   if (nested)
4057     write_char ('E');
4058
4059   tree id = finish_mangling_get_identifier ();
4060   if (DEBUG_MANGLE)
4061     fprintf (stderr, "mangle_decomp = '%s'\n\n",
4062              IDENTIFIER_POINTER (id));
4063
4064   input_location = saved_loc;
4065   return id;
4066 }
4067
4068 /* Return an identifier for a construction vtable group.  TYPE is
4069    the most derived class in the hierarchy; BINFO is the base
4070    subobject for which this construction vtable group will be used.
4071
4072    This mangling isn't part of the ABI specification; in the ABI
4073    specification, the vtable group is dumped in the same COMDAT as the
4074    main vtable, and is referenced only from that vtable, so it doesn't
4075    need an external name.  For binary formats without COMDAT sections,
4076    though, we need external names for the vtable groups.
4077
4078    We use the production
4079
4080     <special-name> ::= CT <type> <offset number> _ <base type>  */
4081
4082 tree
4083 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
4084 {
4085   tree result;
4086
4087   start_mangling (type);
4088
4089   write_string ("_Z");
4090   write_string ("TC");
4091   write_type (type);
4092   write_integer_cst (BINFO_OFFSET (binfo));
4093   write_char ('_');
4094   write_type (BINFO_TYPE (binfo));
4095
4096   result = finish_mangling_get_identifier ();
4097   if (DEBUG_MANGLE)
4098     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
4099              IDENTIFIER_POINTER (result));
4100   return result;
4101 }
4102
4103 /* Mangle a this pointer or result pointer adjustment.
4104
4105    <call-offset> ::= h <fixed offset number> _
4106                  ::= v <fixed offset number> _ <virtual offset number> _ */
4107
4108 static void
4109 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
4110 {
4111   write_char (virtual_offset ? 'v' : 'h');
4112
4113   /* For either flavor, write the fixed offset.  */
4114   write_integer_cst (fixed_offset);
4115   write_char ('_');
4116
4117   /* For a virtual thunk, add the virtual offset.  */
4118   if (virtual_offset)
4119     {
4120       write_integer_cst (virtual_offset);
4121       write_char ('_');
4122     }
4123 }
4124
4125 /* Return an identifier for the mangled name of a this-adjusting or
4126    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
4127    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
4128    is a virtual thunk, and it is the vtbl offset in
4129    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
4130    zero for a covariant thunk. Note, that FN_DECL might be a covariant
4131    thunk itself. A covariant thunk name always includes the adjustment
4132    for the this pointer, even if there is none.
4133
4134    <special-name> ::= T <call-offset> <base encoding>
4135                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
4136                                         <base encoding>  */
4137
4138 tree
4139 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
4140               tree virtual_offset, tree thunk)
4141 {
4142   tree result;
4143
4144   if (abi_version_at_least (11))
4145     maybe_check_abi_tags (fn_decl, thunk, 11);
4146
4147   start_mangling (fn_decl);
4148
4149   write_string ("_Z");
4150   write_char ('T');
4151
4152   if (!this_adjusting)
4153     {
4154       /* Covariant thunk with no this adjustment */
4155       write_char ('c');
4156       mangle_call_offset (integer_zero_node, NULL_TREE);
4157       mangle_call_offset (fixed_offset, virtual_offset);
4158     }
4159   else if (!DECL_THUNK_P (fn_decl))
4160     /* Plain this adjusting thunk.  */
4161     mangle_call_offset (fixed_offset, virtual_offset);
4162   else
4163     {
4164       /* This adjusting thunk to covariant thunk.  */
4165       write_char ('c');
4166       mangle_call_offset (fixed_offset, virtual_offset);
4167       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
4168       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
4169       if (virtual_offset)
4170         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
4171       mangle_call_offset (fixed_offset, virtual_offset);
4172       fn_decl = THUNK_TARGET (fn_decl);
4173     }
4174
4175   /* Scoped name.  */
4176   write_encoding (fn_decl);
4177
4178   result = finish_mangling_get_identifier ();
4179   if (DEBUG_MANGLE)
4180     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
4181   return result;
4182 }
4183
4184 struct conv_type_hasher : ggc_ptr_hash<tree_node>
4185 {
4186   static hashval_t hash (tree);
4187   static bool equal (tree, tree);
4188 };
4189
4190 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
4191    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
4192    TYPE.  */
4193
4194 static GTY (()) hash_table<conv_type_hasher> *conv_type_names;
4195
4196 /* Hash a node (VAL1) in the table.  */
4197
4198 hashval_t
4199 conv_type_hasher::hash (tree val)
4200 {
4201   return (hashval_t) TYPE_UID (TREE_TYPE (val));
4202 }
4203
4204 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
4205
4206 bool
4207 conv_type_hasher::equal (tree val1, tree val2)
4208 {
4209   return TREE_TYPE (val1) == val2;
4210 }
4211
4212 /* Return an identifier for the mangled unqualified name for a
4213    conversion operator to TYPE.  This mangling is not specified by the
4214    ABI spec; it is only used internally.  */
4215
4216 tree
4217 mangle_conv_op_name_for_type (const tree type)
4218 {
4219   tree *slot;
4220   tree identifier;
4221
4222   if (type == error_mark_node)
4223     return error_mark_node;
4224
4225   if (conv_type_names == NULL)
4226     conv_type_names = hash_table<conv_type_hasher>::create_ggc (31);
4227
4228   slot = conv_type_names->find_slot_with_hash (type,
4229                                                (hashval_t) TYPE_UID (type),
4230                                                INSERT);
4231   identifier = *slot;
4232   if (!identifier)
4233     {
4234       char buffer[64];
4235
4236        /* Create a unique name corresponding to TYPE.  */
4237       sprintf (buffer, "operator %lu",
4238                (unsigned long) conv_type_names->elements ());
4239       identifier = get_identifier (buffer);
4240       *slot = identifier;
4241
4242       /* Hang TYPE off the identifier so it can be found easily later
4243          when performing conversions.  */
4244       TREE_TYPE (identifier) = type;
4245
4246       /* Set the identifier kind so we know later it's a conversion.  */
4247       set_identifier_kind (identifier, cik_conv_op);
4248     }
4249
4250   return identifier;
4251 }
4252
4253 /* Handle ABI backwards compatibility for past bugs where we didn't call
4254    check_abi_tags in places where it's needed: call check_abi_tags and warn if
4255    it makes a difference.  If FOR_DECL is non-null, it's the declaration
4256    that we're actually trying to mangle; if it's null, we're mangling the
4257    guard variable for T.  */
4258
4259 static void
4260 maybe_check_abi_tags (tree t, tree for_decl, int ver)
4261 {
4262   if (DECL_ASSEMBLER_NAME_SET_P (t))
4263     return;
4264
4265   tree oldtags = get_abi_tags (t);
4266
4267   mangle_decl (t);
4268
4269   tree newtags = get_abi_tags (t);
4270   if (newtags && newtags != oldtags
4271       && abi_version_crosses (ver))
4272     {
4273       if (for_decl && DECL_THUNK_P (for_decl))
4274         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
4275                     "the mangled name of a thunk for %qD changes between "
4276                     "-fabi-version=%d and -fabi-version=%d",
4277                     t, flag_abi_version, warn_abi_version);
4278       else if (for_decl)
4279         warning_at (DECL_SOURCE_LOCATION (for_decl), OPT_Wabi,
4280                     "the mangled name of %qD changes between "
4281                     "-fabi-version=%d and -fabi-version=%d",
4282                     for_decl, flag_abi_version, warn_abi_version);
4283       else
4284         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
4285                     "the mangled name of the initialization guard variable "
4286                     "for %qD changes between -fabi-version=%d and "
4287                     "-fabi-version=%d",
4288                     t, flag_abi_version, warn_abi_version);
4289     }
4290 }
4291
4292 /* Write out the appropriate string for this variable when generating
4293    another mangled name based on this one.  */
4294
4295 static void
4296 write_guarded_var_name (const tree variable)
4297 {
4298   if (DECL_NAME (variable)
4299       && strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
4300     /* The name of a guard variable for a reference temporary should refer
4301        to the reference, not the temporary.  */
4302     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
4303   else
4304     write_name (variable, /*ignore_local_scope=*/0);
4305 }
4306
4307 /* Return an identifier for the name of an initialization guard
4308    variable for indicated VARIABLE.  */
4309
4310 tree
4311 mangle_guard_variable (const tree variable)
4312 {
4313   if (abi_version_at_least (10))
4314     maybe_check_abi_tags (variable);
4315   start_mangling (variable);
4316   write_string ("_ZGV");
4317   write_guarded_var_name (variable);
4318   return finish_mangling_get_identifier ();
4319 }
4320
4321 /* Return an identifier for the name of a thread_local initialization
4322    function for VARIABLE.  */
4323
4324 tree
4325 mangle_tls_init_fn (const tree variable)
4326 {
4327   check_abi_tags (variable);
4328   start_mangling (variable);
4329   write_string ("_ZTH");
4330   write_guarded_var_name (variable);
4331   return finish_mangling_get_identifier ();
4332 }
4333
4334 /* Return an identifier for the name of a thread_local wrapper
4335    function for VARIABLE.  */
4336
4337 #define TLS_WRAPPER_PREFIX "_ZTW"
4338
4339 tree
4340 mangle_tls_wrapper_fn (const tree variable)
4341 {
4342   check_abi_tags (variable);
4343   start_mangling (variable);
4344   write_string (TLS_WRAPPER_PREFIX);
4345   write_guarded_var_name (variable);
4346   return finish_mangling_get_identifier ();
4347 }
4348
4349 /* Return true iff FN is a thread_local wrapper function.  */
4350
4351 bool
4352 decl_tls_wrapper_p (const tree fn)
4353 {
4354   if (TREE_CODE (fn) != FUNCTION_DECL)
4355     return false;
4356   tree name = DECL_NAME (fn);
4357   return strncmp (IDENTIFIER_POINTER (name), TLS_WRAPPER_PREFIX,
4358                   strlen (TLS_WRAPPER_PREFIX)) == 0;
4359 }
4360
4361 /* Return an identifier for the name of a temporary variable used to
4362    initialize a static reference.  This isn't part of the ABI, but we might
4363    as well call them something readable.  */
4364
4365 static GTY(()) int temp_count;
4366
4367 tree
4368 mangle_ref_init_variable (const tree variable)
4369 {
4370   start_mangling (variable);
4371   write_string ("_ZGR");
4372   check_abi_tags (variable);
4373   write_name (variable, /*ignore_local_scope=*/0);
4374   /* Avoid name clashes with aggregate initialization of multiple
4375      references at once.  */
4376   write_unsigned_number (temp_count++);
4377   return finish_mangling_get_identifier ();
4378 }
4379 \f
4380 /* Given a CLASS_TYPE, such as a record for std::bad_exception this
4381    function generates a mangled name for the vtable map variable of
4382    the class type.  For example, if the class type is
4383    "std::bad_exception", the mangled name for the class is
4384    "St13bad_exception".  This function would generate the name
4385    "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
4386    "_VTV<std::bad_exception>::__vtable_map".  */
4387
4388
4389 char *
4390 get_mangled_vtable_map_var_name (tree class_type)
4391 {
4392   char *var_name = NULL;
4393   const char *prefix = "_ZN4_VTVI";
4394   const char *postfix = "E12__vtable_mapE";
4395
4396   gcc_assert (TREE_CODE (class_type) == RECORD_TYPE);
4397
4398   tree class_id = DECL_ASSEMBLER_NAME (TYPE_NAME (class_type));
4399
4400   if (strstr (IDENTIFIER_POINTER (class_id), "<anon>") != NULL)
4401     {
4402       class_id = get_mangled_id (TYPE_NAME (class_type));
4403       vtbl_register_mangled_name (TYPE_NAME (class_type), class_id);
4404     }
4405
4406   unsigned int len = strlen (IDENTIFIER_POINTER (class_id)) +
4407                      strlen (prefix) +
4408                      strlen (postfix) + 1;
4409
4410   var_name = (char *) xmalloc (len);
4411
4412   sprintf (var_name, "%s%s%s", prefix, IDENTIFIER_POINTER (class_id), postfix);
4413
4414   return var_name;
4415 }
4416
4417 #include "gt-cp-mangle.h"