gcc/cp/mangle.c

   1 /* Name mangling for the 3.0 -*- C++ -*- ABI.
   2    Copyright (C) 2000-2016 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
 119 static GTY (()) globals G;
 120
 121 /* The obstack on which we build mangled names.  */
 122 static struct obstack *mangle_obstack;
 123
 124 /* The obstack on which we build mangled names that are not going to
 125    be IDENTIFIER_NODEs.  */
 126 static struct obstack name_obstack;
 127
 128 /* The first object on the name_obstack; we use this to free memory
 129    allocated on the name_obstack.  */
 130 static void *name_base;
 131
 132 /* Indices into subst_identifiers.  These are identifiers used in
 133    special substitution rules.  */
 134 typedef enum
 135 {
 136   SUBID_ALLOCATOR,
 137   SUBID_BASIC_STRING,
 138   SUBID_CHAR_TRAITS,
 139   SUBID_BASIC_ISTREAM,
 140   SUBID_BASIC_OSTREAM,
 141   SUBID_BASIC_IOSTREAM,
 142   SUBID_MAX
 143 }
 144 substitution_identifier_index_t;
 145
 146 /* For quick substitution checks, look up these common identifiers
 147    once only.  */
 148 static GTY(()) tree subst_identifiers[SUBID_MAX];
 149
 150 /* Single-letter codes for builtin integer types, defined in
 151    <builtin-type>.  These are indexed by integer_type_kind values.  */
 152 static const char
 153 integer_type_codes[itk_none] =
 154 {
 155   'c',  /* itk_char */
 156   'a',  /* itk_signed_char */
 157   'h',  /* itk_unsigned_char */
 158   's',  /* itk_short */
 159   't',  /* itk_unsigned_short */
 160   'i',  /* itk_int */
 161   'j',  /* itk_unsigned_int */
 162   'l',  /* itk_long */
 163   'm',  /* itk_unsigned_long */
 164   'x',  /* itk_long_long */
 165   'y',  /* itk_unsigned_long_long */
 166   /* __intN types are handled separately */
 167   '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
 168 };
 169
 170 static int decl_is_template_id (const tree, tree* const);
 171
 172 /* Functions for handling substitutions.  */
 173
 174 static inline tree canonicalize_for_substitution (tree);
 175 static void add_substitution (tree);
 176 static inline int is_std_substitution (const tree,
 177                                        const substitution_identifier_index_t);
 178 static inline int is_std_substitution_char (const tree,
 179                                             const substitution_identifier_index_t);
 180 static int find_substitution (tree);
 181 static void mangle_call_offset (const tree, const tree);
 182
 183 /* Functions for emitting mangled representations of things.  */
 184
 185 static void write_mangled_name (const tree, bool);
 186 static void write_encoding (const tree);
 187 static void write_name (tree, const int);
 188 static void write_abi_tags (tree);
 189 static void write_unscoped_name (const tree);
 190 static void write_unscoped_template_name (const tree);
 191 static void write_nested_name (const tree);
 192 static void write_prefix (const tree);
 193 static void write_template_prefix (const tree);
 194 static void write_unqualified_name (tree);
 195 static void write_conversion_operator_name (const tree);
 196 static void write_source_name (tree);
 197 static void write_literal_operator_name (tree);
 198 static void write_unnamed_type_name (const tree);
 199 static void write_closure_type_name (const tree);
 200 static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
 201                            const unsigned int);
 202 static void write_number (unsigned HOST_WIDE_INT, const int,
 203                           const unsigned int);
 204 static void write_compact_number (int num);
 205 static void write_integer_cst (const tree);
 206 static void write_real_cst (const tree);
 207 static void write_identifier (const char *);
 208 static void write_special_name_constructor (const tree);
 209 static void write_special_name_destructor (const tree);
 210 static void write_type (tree);
 211 static int write_CV_qualifiers_for_type (const tree);
 212 static void write_builtin_type (tree);
 213 static void write_function_type (const tree);
 214 static void write_bare_function_type (const tree, const int, const tree);
 215 static void write_method_parms (tree, const int, const tree);
 216 static void write_class_enum_type (const tree);
 217 static void write_template_args (tree);
 218 static void write_expression (tree);
 219 static void write_template_arg_literal (const tree);
 220 static void write_template_arg (tree);
 221 static void write_template_template_arg (const tree);
 222 static void write_array_type (const tree);
 223 static void write_pointer_to_member_type (const tree);
 224 static void write_template_param (const tree);
 225 static void write_template_template_param (const tree);
 226 static void write_substitution (const int);
 227 static int discriminator_for_local_entity (tree);
 228 static int discriminator_for_string_literal (tree, tree);
 229 static void write_discriminator (const int);
 230 static void write_local_name (tree, const tree, const tree);
 231 static void dump_substitution_candidates (void);
 232 static tree mangle_decl_string (const tree);
 233 static int local_class_index (tree);
 234 static void maybe_check_abi_tags (tree, tree = NULL_TREE);
 235 static bool equal_abi_tags (tree, tree);
 236
 237 /* Control functions.  */
 238
 239 static inline void start_mangling (const tree);
 240 static tree mangle_special_for_type (const tree, const char *);
 241
 242 /* Foreign language functions.  */
 243
 244 static void write_java_integer_type_codes (const tree);
 245
 246 /* Append a single character to the end of the mangled
 247    representation.  */
 248 #define write_char(CHAR)                                                \
 249   obstack_1grow (mangle_obstack, (CHAR))
 250
 251 /* Append a sized buffer to the end of the mangled representation.  */
 252 #define write_chars(CHAR, LEN)                                          \
 253   obstack_grow (mangle_obstack, (CHAR), (LEN))
 254
 255 /* Append a NUL-terminated string to the end of the mangled
 256    representation.  */
 257 #define write_string(STRING)                                            \
 258   obstack_grow (mangle_obstack, (STRING), strlen (STRING))
 259
 260 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
 261    same purpose (context, which may be a type) and value (template
 262    decl).  See write_template_prefix for more information on what this
 263    is used for.  */
 264 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2)                             \
 265   (TREE_CODE (NODE1) == TREE_LIST                                       \
 266    && TREE_CODE (NODE2) == TREE_LIST                                    \
 267    && ((TYPE_P (TREE_PURPOSE (NODE1))                                   \
 268         && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2)))    \
 269        || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2))                 \
 270    && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
 271
 272 /* Write out an unsigned quantity in base 10.  */
 273 #define write_unsigned_number(NUMBER)                                   \
 274   write_number ((NUMBER), /*unsigned_p=*/1, 10)
 275
 276 /* If DECL is a template instance (including the uninstantiated template
 277    itself), return nonzero and, if TEMPLATE_INFO is non-NULL, set
 278    *TEMPLATE_INFO to its template info.  Otherwise return zero.  */
 279
 280 static int
 281 decl_is_template_id (const tree decl, tree* const template_info)
 282 {
 283   if (TREE_CODE (decl) == TYPE_DECL)
 284     {
 285       /* TYPE_DECLs are handled specially.  Look at its type to decide
 286          if this is a template instantiation.  */
 287       const tree type = TREE_TYPE (decl);
 288
 289       if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
 290         {
 291           if (template_info != NULL)
 292             /* For a templated TYPE_DECL, the template info is hanging
 293                off the type.  */
 294             *template_info = TYPE_TEMPLATE_INFO (type);
 295           return 1;
 296         }
 297     }
 298   else
 299     {
 300       /* Check if this is a primary template.  */
 301       if (DECL_LANG_SPECIFIC (decl) != NULL
 302           && VAR_OR_FUNCTION_DECL_P (decl)
 303           && DECL_TEMPLATE_INFO (decl)
 304           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
 305           && TREE_CODE (decl) != TEMPLATE_DECL)
 306         {
 307           if (template_info != NULL)
 308             /* For most templated decls, the template info is hanging
 309                off the decl.  */
 310             *template_info = DECL_TEMPLATE_INFO (decl);
 311           return 1;
 312         }
 313     }
 314
 315   /* It's not a template id.  */
 316   return 0;
 317 }
 318
 319 /* Produce debugging output of current substitution candidates.  */
 320
 321 static void
 322 dump_substitution_candidates (void)
 323 {
 324   unsigned i;
 325   tree el;
 326
 327   fprintf (stderr, "  ++ substitutions  ");
 328   FOR_EACH_VEC_ELT (*G.substitutions, i, el)
 329     {
 330       const char *name = "???";
 331
 332       if (i > 0)
 333         fprintf (stderr, "                    ");
 334       if (DECL_P (el))
 335         name = IDENTIFIER_POINTER (DECL_NAME (el));
 336       else if (TREE_CODE (el) == TREE_LIST)
 337         name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
 338       else if (TYPE_NAME (el))
 339         name = TYPE_NAME_STRING (el);
 340       fprintf (stderr, " S%d_ = ", i - 1);
 341       if (TYPE_P (el) &&
 342           (CP_TYPE_RESTRICT_P (el)
 343            || CP_TYPE_VOLATILE_P (el)
 344            || CP_TYPE_CONST_P (el)))
 345         fprintf (stderr, "CV-");
 346       fprintf (stderr, "%s (%s at %p)\n",
 347                name, get_tree_code_name (TREE_CODE (el)), (void *) el);
 348     }
 349 }
 350
 351 /* Both decls and types can be substitution candidates, but sometimes
 352    they refer to the same thing.  For instance, a TYPE_DECL and
 353    RECORD_TYPE for the same class refer to the same thing, and should
 354    be treated accordingly in substitutions.  This function returns a
 355    canonicalized tree node representing NODE that is used when adding
 356    and substitution candidates and finding matches.  */
 357
 358 static inline tree
 359 canonicalize_for_substitution (tree node)
 360 {
 361   /* For a TYPE_DECL, use the type instead.  */
 362   if (TREE_CODE (node) == TYPE_DECL)
 363     node = TREE_TYPE (node);
 364   if (TYPE_P (node)
 365       && TYPE_CANONICAL (node) != node
 366       && TYPE_MAIN_VARIANT (node) != node)
 367     {
 368       tree orig = node;
 369       /* Here we want to strip the topmost typedef only.
 370          We need to do that so is_std_substitution can do proper
 371          name matching.  */
 372       if (TREE_CODE (node) == FUNCTION_TYPE)
 373         /* Use build_qualified_type and TYPE_QUALS here to preserve
 374            the old buggy mangling of attribute noreturn with abi<5.  */
 375         node = build_qualified_type (TYPE_MAIN_VARIANT (node),
 376                                      TYPE_QUALS (node));
 377       else
 378         node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node),
 379                                         cp_type_quals (node));
 380       if (TREE_CODE (node) == FUNCTION_TYPE
 381           || TREE_CODE (node) == METHOD_TYPE)
 382         node = build_ref_qualified_type (node, type_memfn_rqual (orig));
 383     }
 384   return node;
 385 }
 386
 387 /* Add NODE as a substitution candidate.  NODE must not already be on
 388    the list of candidates.  */
 389
 390 static void
 391 add_substitution (tree node)
 392 {
 393   tree c;
 394
 395   if (DEBUG_MANGLE)
 396     fprintf (stderr, "  ++ add_substitution (%s at %10p)\n",
 397              get_tree_code_name (TREE_CODE (node)), (void *) node);
 398
 399   /* Get the canonicalized substitution candidate for NODE.  */
 400   c = canonicalize_for_substitution (node);
 401   if (DEBUG_MANGLE && c != node)
 402     fprintf (stderr, "  ++ using candidate (%s at %10p)\n",
 403              get_tree_code_name (TREE_CODE (node)), (void *) node);
 404   node = c;
 405
 406   /* Make sure NODE isn't already a candidate.  */
 407   if (flag_checking)
 408     {
 409       int i;
 410       tree candidate;
 411
 412       FOR_EACH_VEC_SAFE_ELT (G.substitutions, i, candidate)
 413         {
 414           gcc_assert (!(DECL_P (node) && node == candidate));
 415           gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
 416                       && same_type_p (node, candidate)));
 417         }
 418     }
 419
 420   /* Put the decl onto the varray of substitution candidates.  */
 421   vec_safe_push (G.substitutions, node);
 422
 423   if (DEBUG_MANGLE)
 424     dump_substitution_candidates ();
 425 }
 426
 427 /* Helper function for find_substitution.  Returns nonzero if NODE,
 428    which may be a decl or a CLASS_TYPE, is a template-id with template
 429    name of substitution_index[INDEX] in the ::std namespace.  */
 430
 431 static inline int
 432 is_std_substitution (const tree node,
 433                      const substitution_identifier_index_t index)
 434 {
 435   tree type = NULL;
 436   tree decl = NULL;
 437
 438   if (DECL_P (node))
 439     {
 440       type = TREE_TYPE (node);
 441       decl = node;
 442     }
 443   else if (CLASS_TYPE_P (node))
 444     {
 445       type = node;
 446       decl = TYPE_NAME (node);
 447     }
 448   else
 449     /* These are not the droids you're looking for.  */
 450     return 0;
 451
 452   return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
 453           && TYPE_LANG_SPECIFIC (type)
 454           && TYPE_TEMPLATE_INFO (type)
 455           && (DECL_NAME (TYPE_TI_TEMPLATE (type))
 456               == subst_identifiers[index]));
 457 }
 458
 459 /* Return the ABI tags (the TREE_VALUE of the "abi_tag" attribute entry) for T,
 460    which can be a decl or type.  */
 461
 462 static tree
 463 get_abi_tags (tree t)
 464 {
 465   if (!t || TREE_CODE (t) == NAMESPACE_DECL)
 466     return NULL_TREE;
 467
 468   if (DECL_P (t) && DECL_DECLARES_TYPE_P (t))
 469     t = TREE_TYPE (t);
 470
 471   tree attrs;
 472   if (TYPE_P (t))
 473     attrs = TYPE_ATTRIBUTES (t);
 474   else
 475     attrs = DECL_ATTRIBUTES (t);
 476
 477   tree tags = lookup_attribute ("abi_tag", attrs);
 478   if (tags)
 479     tags = TREE_VALUE (tags);
 480   return tags;
 481 }
 482
 483 /* Helper function for find_substitution.  Returns nonzero if NODE,
 484    which may be a decl or a CLASS_TYPE, is the template-id
 485    ::std::identifier<char>, where identifier is
 486    substitution_index[INDEX].  */
 487
 488 static inline int
 489 is_std_substitution_char (const tree node,
 490                           const substitution_identifier_index_t index)
 491 {
 492   tree args;
 493   /* Check NODE's name is ::std::identifier.  */
 494   if (!is_std_substitution (node, index))
 495     return 0;
 496   /* Figure out its template args.  */
 497   if (DECL_P (node))
 498     args = DECL_TI_ARGS (node);
 499   else if (CLASS_TYPE_P (node))
 500     args = CLASSTYPE_TI_ARGS (node);
 501   else
 502     /* Oops, not a template.  */
 503     return 0;
 504   /* NODE's template arg list should be <char>.  */
 505   return
 506     TREE_VEC_LENGTH (args) == 1
 507     && TREE_VEC_ELT (args, 0) == char_type_node;
 508 }
 509
 510 /* Check whether a substitution should be used to represent NODE in
 511    the mangling.
 512
 513    First, check standard special-case substitutions.
 514
 515      <substitution> ::= St
 516          # ::std
 517
 518                     ::= Sa
 519          # ::std::allocator
 520
 521                     ::= Sb
 522          # ::std::basic_string
 523
 524                     ::= Ss
 525          # ::std::basic_string<char,
 526                                ::std::char_traits<char>,
 527                                ::std::allocator<char> >
 528
 529                     ::= Si
 530          # ::std::basic_istream<char, ::std::char_traits<char> >
 531
 532                     ::= So
 533          # ::std::basic_ostream<char, ::std::char_traits<char> >
 534
 535                     ::= Sd
 536          # ::std::basic_iostream<char, ::std::char_traits<char> >
 537
 538    Then examine the stack of currently available substitution
 539    candidates for entities appearing earlier in the same mangling
 540
 541    If a substitution is found, write its mangled representation and
 542    return nonzero.  If none is found, just return zero.  */
 543
 544 static int
 545 find_substitution (tree node)
 546 {
 547   int i;
 548   const int size = vec_safe_length (G.substitutions);
 549   tree decl;
 550   tree type;
 551   const char *abbr = NULL;
 552
 553   if (DEBUG_MANGLE)
 554     fprintf (stderr, "  ++ find_substitution (%s at %p)\n",
 555              get_tree_code_name (TREE_CODE (node)), (void *) node);
 556
 557   /* Obtain the canonicalized substitution representation for NODE.
 558      This is what we'll compare against.  */
 559   node = canonicalize_for_substitution (node);
 560
 561   /* Check for builtin substitutions.  */
 562
 563   decl = TYPE_P (node) ? TYPE_NAME (node) : node;
 564   type = TYPE_P (node) ? node : TREE_TYPE (node);
 565
 566   /* Check for std::allocator.  */
 567   if (decl
 568       && is_std_substitution (decl, SUBID_ALLOCATOR)
 569       && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
 570     abbr = "Sa";
 571
 572   /* Check for std::basic_string.  */
 573   else if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
 574     {
 575       if (TYPE_P (node))
 576         {
 577           /* If this is a type (i.e. a fully-qualified template-id),
 578              check for
 579                  std::basic_string <char,
 580                                     std::char_traits<char>,
 581                                     std::allocator<char> > .  */
 582           if (cp_type_quals (type) == TYPE_UNQUALIFIED
 583               && CLASSTYPE_USE_TEMPLATE (type))
 584             {
 585               tree args = CLASSTYPE_TI_ARGS (type);
 586               if (TREE_VEC_LENGTH (args) == 3
 587                   && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 588                   && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 589                                                SUBID_CHAR_TRAITS)
 590                   && is_std_substitution_char (TREE_VEC_ELT (args, 2),
 591                                                SUBID_ALLOCATOR))
 592                 abbr = "Ss";
 593             }
 594         }
 595       else
 596         /* Substitute for the template name only if this isn't a type.  */
 597         abbr = "Sb";
 598     }
 599
 600   /* Check for basic_{i,o,io}stream.  */
 601   else if (TYPE_P (node)
 602            && cp_type_quals (type) == TYPE_UNQUALIFIED
 603            && CLASS_TYPE_P (type)
 604            && CLASSTYPE_USE_TEMPLATE (type)
 605            && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
 606     {
 607       /* First, check for the template
 608          args <char, std::char_traits<char> > .  */
 609       tree args = CLASSTYPE_TI_ARGS (type);
 610       if (TREE_VEC_LENGTH (args) == 2
 611           && TYPE_P (TREE_VEC_ELT (args, 0))
 612           && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 613           && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 614                                        SUBID_CHAR_TRAITS))
 615         {
 616           /* Got them.  Is this basic_istream?  */
 617           if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
 618             abbr = "Si";
 619           /* Or basic_ostream?  */
 620           else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
 621             abbr = "So";
 622           /* Or basic_iostream?  */
 623           else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
 624             abbr = "Sd";
 625         }
 626     }
 627
 628   /* Check for namespace std.  */
 629   else if (decl && DECL_NAMESPACE_STD_P (decl))
 630     {
 631       write_string ("St");
 632       return 1;
 633     }
 634
 635   tree tags = NULL_TREE;
 636   if (OVERLOAD_TYPE_P (node) || DECL_CLASS_TEMPLATE_P (node))
 637     tags = get_abi_tags (type);
 638   /* Now check the list of available substitutions for this mangling
 639      operation.  */
 640   if (!abbr || tags) for (i = 0; i < size; ++i)
 641     {
 642       tree candidate = (*G.substitutions)[i];
 643       /* NODE is a matched to a candidate if it's the same decl node or
 644          if it's the same type.  */
 645       if (decl == candidate
 646           || (TYPE_P (candidate) && type && TYPE_P (node)
 647               && same_type_p (type, candidate))
 648           || NESTED_TEMPLATE_MATCH (node, candidate))
 649         {
 650           write_substitution (i);
 651           return 1;
 652         }
 653     }
 654
 655   if (!abbr)
 656     /* No substitution found.  */
 657     return 0;
 658
 659   write_string (abbr);
 660   if (tags)
 661     {
 662       /* If there are ABI tags on the abbreviation, it becomes
 663          a substitution candidate.  */
 664       write_abi_tags (tags);
 665       add_substitution (node);
 666     }
 667   return 1;
 668 }
 669
 670 /* Returns whether DECL's symbol name should be the plain unqualified-id
 671    rather than a more complicated mangled name.  */
 672
 673 static bool
 674 unmangled_name_p (const tree decl)
 675 {
 676   if (TREE_CODE (decl) == FUNCTION_DECL)
 677     {
 678       /* The names of `extern "C"' functions are not mangled.  */
 679       return (DECL_EXTERN_C_FUNCTION_P (decl)
 680               /* But overloaded operator names *are* mangled.  */
 681               && !DECL_OVERLOADED_OPERATOR_P (decl));
 682     }
 683   else if (VAR_P (decl))
 684     {
 685       /* static variables are mangled.  */
 686       if (!DECL_EXTERNAL_LINKAGE_P (decl))
 687         return false;
 688
 689       /* extern "C" declarations aren't mangled.  */
 690       if (DECL_EXTERN_C_P (decl))
 691         return true;
 692
 693       /* Other variables at non-global scope are mangled.  */
 694       if (CP_DECL_CONTEXT (decl) != global_namespace)
 695         return false;
 696
 697       /* Variable template instantiations are mangled.  */
 698       if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
 699           && variable_template_p (DECL_TI_TEMPLATE (decl)))
 700         return false;
 701
 702       /* Declarations with ABI tags are mangled.  */
 703       if (get_abi_tags (decl))
 704         return false;
 705
 706       /* The names of non-static global variables aren't mangled.  */
 707       return true;
 708     }
 709
 710   return false;
 711 }
 712
 713 /* TOP_LEVEL is true, if this is being called at outermost level of
 714   mangling. It should be false when mangling a decl appearing in an
 715   expression within some other mangling.
 716
 717   <mangled-name>      ::= _Z <encoding>  */
 718
 719 static void
 720 write_mangled_name (const tree decl, bool top_level)
 721 {
 722   MANGLE_TRACE_TREE ("mangled-name", decl);
 723
 724   check_abi_tags (decl);
 725
 726   if (unmangled_name_p (decl))
 727     {
 728       if (top_level)
 729         write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
 730       else
 731         {
 732           /* The standard notes: "The <encoding> of an extern "C"
 733              function is treated like global-scope data, i.e. as its
 734              <source-name> without a type."  We cannot write
 735              overloaded operators that way though, because it contains
 736              characters invalid in assembler.  */
 737           write_string ("_Z");
 738           write_source_name (DECL_NAME (decl));
 739         }
 740     }
 741   else
 742     {
 743       write_string ("_Z");
 744       write_encoding (decl);
 745     }
 746 }
 747
 748 /* Returns true if the return type of DECL is part of its signature, and
 749    therefore its mangling.  */
 750
 751 bool
 752 mangle_return_type_p (tree decl)
 753 {
 754   return (!DECL_CONSTRUCTOR_P (decl)
 755           && !DECL_DESTRUCTOR_P (decl)
 756           && !DECL_CONV_FN_P (decl)
 757           && decl_is_template_id (decl, NULL));
 758 }
 759
 760 /*   <encoding>         ::= <function name> <bare-function-type>
 761                         ::= <data name>  */
 762
 763 static void
 764 write_encoding (const tree decl)
 765 {
 766   MANGLE_TRACE_TREE ("encoding", decl);
 767
 768   if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
 769     {
 770       /* For overloaded operators write just the mangled name
 771          without arguments.  */
 772       if (DECL_OVERLOADED_OPERATOR_P (decl))
 773         write_name (decl, /*ignore_local_scope=*/0);
 774       else
 775         write_source_name (DECL_NAME (decl));
 776       return;
 777     }
 778
 779   write_name (decl, /*ignore_local_scope=*/0);
 780   if (TREE_CODE (decl) == FUNCTION_DECL)
 781     {
 782       tree fn_type;
 783       tree d;
 784
 785       if (decl_is_template_id (decl, NULL))
 786         {
 787           fn_type = get_mostly_instantiated_function_type (decl);
 788           /* FN_TYPE will not have parameter types for in-charge or
 789              VTT parameters.  Therefore, we pass NULL_TREE to
 790              write_bare_function_type -- otherwise, it will get
 791              confused about which artificial parameters to skip.  */
 792           d = NULL_TREE;
 793         }
 794       else
 795         {
 796           fn_type = TREE_TYPE (decl);
 797           d = decl;
 798         }
 799
 800       write_bare_function_type (fn_type,
 801                                 mangle_return_type_p (decl),
 802                                 d);
 803     }
 804 }
 805
 806 /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
 807    or PARM_DECL context, which doesn't belong in DECL_CONTEXT.  */
 808
 809 static tree
 810 decl_mangling_context (tree decl)
 811 {
 812   tree tcontext = targetm.cxx.decl_mangling_context (decl);
 813
 814   if (tcontext != NULL_TREE)
 815     return tcontext;
 816
 817   if (TREE_CODE (decl) == TEMPLATE_DECL
 818       && DECL_TEMPLATE_RESULT (decl))
 819     decl = DECL_TEMPLATE_RESULT (decl);
 820
 821   if (TREE_CODE (decl) == TYPE_DECL
 822       && LAMBDA_TYPE_P (TREE_TYPE (decl)))
 823     {
 824       tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl));
 825       if (extra)
 826         return extra;
 827     }
 828   else if (template_type_parameter_p (decl))
 829      /* template type parms have no mangling context.  */
 830       return NULL_TREE;
 831   return CP_DECL_CONTEXT (decl);
 832 }
 833
 834 /* <name> ::= <unscoped-name>
 835           ::= <unscoped-template-name> <template-args>
 836           ::= <nested-name>
 837           ::= <local-name>
 838
 839    If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
 840    called from <local-name>, which mangles the enclosing scope
 841    elsewhere and then uses this function to mangle just the part
 842    underneath the function scope.  So don't use the <local-name>
 843    production, to avoid an infinite recursion.  */
 844
 845 static void
 846 write_name (tree decl, const int ignore_local_scope)
 847 {
 848   tree context;
 849
 850   MANGLE_TRACE_TREE ("name", decl);
 851
 852   if (TREE_CODE (decl) == TYPE_DECL)
 853     {
 854       /* In case this is a typedef, fish out the corresponding
 855          TYPE_DECL for the main variant.  */
 856       decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
 857     }
 858
 859   context = decl_mangling_context (decl);
 860
 861   gcc_assert (context != NULL_TREE);
 862
 863   if (abi_warn_or_compat_version_crosses (7)
 864       && ignore_local_scope
 865       && TREE_CODE (context) == PARM_DECL)
 866     G.need_abi_warning = 1;
 867
 868   /* A decl in :: or ::std scope is treated specially.  The former is
 869      mangled using <unscoped-name> or <unscoped-template-name>, the
 870      latter with a special substitution.  Also, a name that is
 871      directly in a local function scope is also mangled with
 872      <unscoped-name> rather than a full <nested-name>.  */
 873   if (context == global_namespace
 874       || DECL_NAMESPACE_STD_P (context)
 875       || (ignore_local_scope
 876           && (TREE_CODE (context) == FUNCTION_DECL
 877               || (abi_version_at_least (7)
 878                   && TREE_CODE (context) == PARM_DECL))))
 879     {
 880       tree template_info;
 881       /* Is this a template instance?  */
 882       if (decl_is_template_id (decl, &template_info))
 883         {
 884           /* Yes: use <unscoped-template-name>.  */
 885           write_unscoped_template_name (TI_TEMPLATE (template_info));
 886           write_template_args (TI_ARGS (template_info));
 887         }
 888       else
 889         /* Everything else gets an <unqualified-name>.  */
 890         write_unscoped_name (decl);
 891     }
 892   else
 893     {
 894       /* Handle local names, unless we asked not to (that is, invoked
 895          under <local-name>, to handle only the part of the name under
 896          the local scope).  */
 897       if (!ignore_local_scope)
 898         {
 899           /* Scan up the list of scope context, looking for a
 900              function.  If we find one, this entity is in local
 901              function scope.  local_entity tracks context one scope
 902              level down, so it will contain the element that's
 903              directly in that function's scope, either decl or one of
 904              its enclosing scopes.  */
 905           tree local_entity = decl;
 906           while (context != global_namespace)
 907             {
 908               /* Make sure we're always dealing with decls.  */
 909               if (TYPE_P (context))
 910                 context = TYPE_NAME (context);
 911               /* Is this a function?  */
 912               if (TREE_CODE (context) == FUNCTION_DECL
 913                   || TREE_CODE (context) == PARM_DECL)
 914                 {
 915                   /* Yes, we have local scope.  Use the <local-name>
 916                      production for the innermost function scope.  */
 917                   write_local_name (context, local_entity, decl);
 918                   return;
 919                 }
 920               /* Up one scope level.  */
 921               local_entity = context;
 922               context = decl_mangling_context (context);
 923             }
 924
 925           /* No local scope found?  Fall through to <nested-name>.  */
 926         }
 927
 928       /* Other decls get a <nested-name> to encode their scope.  */
 929       write_nested_name (decl);
 930     }
 931 }
 932
 933 /* <unscoped-name> ::= <unqualified-name>
 934                    ::= St <unqualified-name>   # ::std::  */
 935
 936 static void
 937 write_unscoped_name (const tree decl)
 938 {
 939   tree context = decl_mangling_context (decl);
 940
 941   MANGLE_TRACE_TREE ("unscoped-name", decl);
 942
 943   /* Is DECL in ::std?  */
 944   if (DECL_NAMESPACE_STD_P (context))
 945     {
 946       write_string ("St");
 947       write_unqualified_name (decl);
 948     }
 949   else
 950     {
 951       /* If not, it should be either in the global namespace, or directly
 952          in a local function scope.  A lambda can also be mangled in the
 953          scope of a default argument.  */
 954       gcc_assert (context == global_namespace
 955                   || TREE_CODE (context) == PARM_DECL
 956                   || TREE_CODE (context) == FUNCTION_DECL);
 957
 958       write_unqualified_name (decl);
 959     }
 960 }
 961
 962 /* <unscoped-template-name> ::= <unscoped-name>
 963                             ::= <substitution>  */
 964
 965 static void
 966 write_unscoped_template_name (const tree decl)
 967 {
 968   MANGLE_TRACE_TREE ("unscoped-template-name", decl);
 969
 970   if (find_substitution (decl))
 971     return;
 972   write_unscoped_name (decl);
 973   add_substitution (decl);
 974 }
 975
 976 /* Write the nested name, including CV-qualifiers, of DECL.
 977
 978    <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
 979                  ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
 980
 981    <ref-qualifier> ::= R # & ref-qualifier
 982                    ::= O # && ref-qualifier
 983    <CV-qualifiers> ::= [r] [V] [K]  */
 984
 985 static void
 986 write_nested_name (const tree decl)
 987 {
 988   tree template_info;
 989
 990   MANGLE_TRACE_TREE ("nested-name", decl);
 991
 992   write_char ('N');
 993
 994   /* Write CV-qualifiers, if this is a member function.  */
 995   if (TREE_CODE (decl) == FUNCTION_DECL
 996       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
 997     {
 998       if (DECL_VOLATILE_MEMFUNC_P (decl))
 999         write_char ('V');
1000       if (DECL_CONST_MEMFUNC_P (decl))
1001         write_char ('K');
1002       if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl)))
1003         {
1004           if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
1005             write_char ('O');
1006           else
1007             write_char ('R');
1008         }
1009     }
1010
1011   /* Is this a template instance?  */
1012   if (decl_is_template_id (decl, &template_info))
1013     {
1014       /* Yes, use <template-prefix>.  */
1015       write_template_prefix (decl);
1016       write_template_args (TI_ARGS (template_info));
1017     }
1018   else if ((!abi_version_at_least (10) || TREE_CODE (decl) == TYPE_DECL)
1019            && TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
1020     {
1021       tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
1022       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1023         {
1024           write_template_prefix (decl);
1025           write_template_args (TREE_OPERAND (name, 1));
1026         }
1027       else
1028         {
1029           write_prefix (decl_mangling_context (decl));
1030           write_unqualified_name (decl);
1031         }
1032     }
1033   else
1034     {
1035       /* No, just use <prefix>  */
1036       write_prefix (decl_mangling_context (decl));
1037       write_unqualified_name (decl);
1038     }
1039   write_char ('E');
1040 }
1041
1042 /* <prefix> ::= <prefix> <unqualified-name>
1043             ::= <template-param>
1044             ::= <template-prefix> <template-args>
1045             ::= <decltype>
1046             ::= # empty
1047             ::= <substitution>  */
1048
1049 static void
1050 write_prefix (const tree node)
1051 {
1052   tree decl;
1053   /* Non-NULL if NODE represents a template-id.  */
1054   tree template_info = NULL;
1055
1056   if (node == NULL
1057       || node == global_namespace)
1058     return;
1059
1060   MANGLE_TRACE_TREE ("prefix", node);
1061
1062   if (TREE_CODE (node) == DECLTYPE_TYPE)
1063     {
1064       write_type (node);
1065       return;
1066     }
1067
1068   if (find_substitution (node))
1069     return;
1070
1071   if (DECL_P (node))
1072     {
1073       /* If this is a function or parm decl, that means we've hit function
1074          scope, so this prefix must be for a local name.  In this
1075          case, we're under the <local-name> production, which encodes
1076          the enclosing function scope elsewhere.  So don't continue
1077          here.  */
1078       if (TREE_CODE (node) == FUNCTION_DECL
1079           || TREE_CODE (node) == PARM_DECL)
1080         return;
1081
1082       decl = node;
1083       decl_is_template_id (decl, &template_info);
1084     }
1085   else
1086     {
1087       /* Node is a type.  */
1088       decl = TYPE_NAME (node);
1089       if (CLASSTYPE_TEMPLATE_ID_P (node))
1090         template_info = TYPE_TEMPLATE_INFO (node);
1091     }
1092
1093   if (TREE_CODE (node) == TEMPLATE_TYPE_PARM)
1094     write_template_param (node);
1095   else if (template_info != NULL)
1096     /* Templated.  */
1097     {
1098       write_template_prefix (decl);
1099       write_template_args (TI_ARGS (template_info));
1100     }
1101   else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
1102     {
1103       tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
1104       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1105         {
1106           write_template_prefix (decl);
1107           write_template_args (TREE_OPERAND (name, 1));
1108         }
1109       else
1110         {
1111           write_prefix (decl_mangling_context (decl));
1112           write_unqualified_name (decl);
1113         }
1114     }
1115   else
1116     /* Not templated.  */
1117     {
1118       write_prefix (decl_mangling_context (decl));
1119       write_unqualified_name (decl);
1120       if (VAR_P (decl)
1121           || TREE_CODE (decl) == FIELD_DECL)
1122         {
1123           /* <data-member-prefix> := <member source-name> M */
1124           write_char ('M');
1125           return;
1126         }
1127     }
1128
1129   add_substitution (node);
1130 }
1131
1132 /* <template-prefix> ::= <prefix> <template component>
1133                      ::= <template-param>
1134                      ::= <substitution>  */
1135
1136 static void
1137 write_template_prefix (const tree node)
1138 {
1139   tree decl = DECL_P (node) ? node : TYPE_NAME (node);
1140   tree type = DECL_P (node) ? TREE_TYPE (node) : node;
1141   tree context = decl_mangling_context (decl);
1142   tree template_info;
1143   tree templ;
1144   tree substitution;
1145
1146   MANGLE_TRACE_TREE ("template-prefix", node);
1147
1148   /* Find the template decl.  */
1149   if (decl_is_template_id (decl, &template_info))
1150     templ = TI_TEMPLATE (template_info);
1151   else if (TREE_CODE (type) == TYPENAME_TYPE)
1152     /* For a typename type, all we have is the name.  */
1153     templ = DECL_NAME (decl);
1154   else
1155     {
1156       gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
1157
1158       templ = TYPE_TI_TEMPLATE (type);
1159     }
1160
1161   /* For a member template, though, the template name for the
1162      innermost name must have all the outer template levels
1163      instantiated.  For instance, consider
1164
1165        template<typename T> struct Outer {
1166          template<typename U> struct Inner {};
1167        };
1168
1169      The template name for `Inner' in `Outer<int>::Inner<float>' is
1170      `Outer<int>::Inner<U>'.  In g++, we don't instantiate the template
1171      levels separately, so there's no TEMPLATE_DECL available for this
1172      (there's only `Outer<T>::Inner<U>').
1173
1174      In order to get the substitutions right, we create a special
1175      TREE_LIST to represent the substitution candidate for a nested
1176      template.  The TREE_PURPOSE is the template's context, fully
1177      instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1178      template.
1179
1180      So, for the example above, `Outer<int>::Inner' is represented as a
1181      substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1182      and whose value is `Outer<T>::Inner<U>'.  */
1183   if (context && TYPE_P (context))
1184     substitution = build_tree_list (context, templ);
1185   else
1186     substitution = templ;
1187
1188   if (find_substitution (substitution))
1189     return;
1190
1191   if (TREE_TYPE (templ)
1192       && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM)
1193     write_template_param (TREE_TYPE (templ));
1194   else
1195     {
1196       write_prefix (context);
1197       write_unqualified_name (decl);
1198     }
1199
1200   add_substitution (substitution);
1201 }
1202
1203 /* We don't need to handle thunks, vtables, or VTTs here.  Those are
1204    mangled through special entry points.
1205
1206     <unqualified-name>  ::= <operator-name>
1207                         ::= <special-name>
1208                         ::= <source-name>
1209                         ::= <unnamed-type-name>
1210                         ::= <local-source-name>
1211
1212     <local-source-name> ::= L <source-name> <discriminator> */
1213
1214 static void
1215 write_unqualified_id (tree identifier)
1216 {
1217   if (IDENTIFIER_TYPENAME_P (identifier))
1218     write_conversion_operator_name (TREE_TYPE (identifier));
1219   else if (IDENTIFIER_OPNAME_P (identifier))
1220     {
1221       int i;
1222       const char *mangled_name = NULL;
1223
1224       /* Unfortunately, there is no easy way to go from the
1225          name of the operator back to the corresponding tree
1226          code.  */
1227       for (i = 0; i < MAX_TREE_CODES; ++i)
1228         if (operator_name_info[i].identifier == identifier)
1229           {
1230             /* The ABI says that we prefer binary operator
1231                names to unary operator names.  */
1232             if (operator_name_info[i].arity == 2)
1233               {
1234                 mangled_name = operator_name_info[i].mangled_name;
1235                 break;
1236               }
1237             else if (!mangled_name)
1238               mangled_name = operator_name_info[i].mangled_name;
1239           }
1240         else if (assignment_operator_name_info[i].identifier
1241                  == identifier)
1242           {
1243             mangled_name
1244               = assignment_operator_name_info[i].mangled_name;
1245             break;
1246           }
1247       write_string (mangled_name);
1248     }
1249   else if (UDLIT_OPER_P (identifier))
1250     write_literal_operator_name (identifier);
1251   else
1252     write_source_name (identifier);
1253 }
1254
1255 static void
1256 write_unqualified_name (tree decl)
1257 {
1258   MANGLE_TRACE_TREE ("unqualified-name", decl);
1259
1260   if (identifier_p (decl))
1261     {
1262       write_unqualified_id (decl);
1263       return;
1264     }
1265
1266   bool found = false;
1267
1268   if (DECL_NAME (decl) == NULL_TREE)
1269     {
1270       found = true;
1271       gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
1272       write_source_name (DECL_ASSEMBLER_NAME (decl));
1273     }
1274   else if (DECL_DECLARES_FUNCTION_P (decl))
1275     {
1276       found = true;
1277       if (DECL_CONSTRUCTOR_P (decl))
1278         write_special_name_constructor (decl);
1279       else if (DECL_DESTRUCTOR_P (decl))
1280         write_special_name_destructor (decl);
1281       else if (DECL_CONV_FN_P (decl))
1282         {
1283           /* Conversion operator. Handle it right here.
1284              <operator> ::= cv <type>  */
1285           tree type;
1286           if (decl_is_template_id (decl, NULL))
1287             {
1288               tree fn_type;
1289               fn_type = get_mostly_instantiated_function_type (decl);
1290               type = TREE_TYPE (fn_type);
1291             }
1292           else if (FNDECL_USED_AUTO (decl))
1293             type = (DECL_STRUCT_FUNCTION (decl)->language
1294                     ->x_auto_return_pattern);
1295           else
1296             type = DECL_CONV_FN_TYPE (decl);
1297           write_conversion_operator_name (type);
1298         }
1299       else if (DECL_OVERLOADED_OPERATOR_P (decl))
1300         {
1301           operator_name_info_t *oni;
1302           if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1303             oni = assignment_operator_name_info;
1304           else
1305             oni = operator_name_info;
1306
1307           write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1308         }
1309       else if (UDLIT_OPER_P (DECL_NAME (decl)))
1310         write_literal_operator_name (DECL_NAME (decl));
1311       else
1312         found = false;
1313     }
1314
1315   if (found)
1316     /* OK */;
1317   else if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
1318            && DECL_NAMESPACE_SCOPE_P (decl)
1319            && decl_linkage (decl) == lk_internal)
1320     {
1321       MANGLE_TRACE_TREE ("local-source-name", decl);
1322       write_char ('L');
1323       write_source_name (DECL_NAME (decl));
1324       /* The default discriminator is 1, and that's all we ever use,
1325          so there's no code to output one here.  */
1326     }
1327   else
1328     {
1329       tree type = TREE_TYPE (decl);
1330
1331       if (TREE_CODE (decl) == TYPE_DECL
1332           && TYPE_UNNAMED_P (type))
1333         write_unnamed_type_name (type);
1334       else if (TREE_CODE (decl) == TYPE_DECL
1335                && LAMBDA_TYPE_P (type))
1336         write_closure_type_name (type);
1337       else
1338         write_source_name (DECL_NAME (decl));
1339     }
1340
1341   /* We use the ABI tags from the primary class template, ignoring tags on any
1342      specializations.  This is necessary because C++ doesn't require a
1343      specialization to be declared before it is used unless the use requires a
1344      complete type, but we need to get the tags right on incomplete types as
1345      well.  */
1346   if (tree tmpl = most_general_template (decl))
1347     {
1348       tree res = DECL_TEMPLATE_RESULT (tmpl);
1349       if (res == NULL_TREE)
1350         /* UNBOUND_CLASS_TEMPLATE.  */;
1351       else if (DECL_DECLARES_TYPE_P (decl))
1352         decl = res;
1353       else if (any_abi_below (11))
1354         {
1355           /* ABI v10 implicit tags on the template.  */
1356           tree mtags = missing_abi_tags (res);
1357           /* Explicit tags on the template.  */
1358           tree ttags = get_abi_tags (res);
1359           /* Tags on the instantiation.  */
1360           tree dtags = get_abi_tags (decl);
1361
1362           if (mtags && abi_warn_or_compat_version_crosses (10))
1363             G.need_abi_warning = 1;
1364
1365           /* Add the v10 tags to the explicit tags now.  */
1366           mtags = chainon (mtags, ttags);
1367
1368           if (!G.need_abi_warning
1369               && abi_warn_or_compat_version_crosses (11)
1370               && !equal_abi_tags (dtags, mtags))
1371             G.need_abi_warning = 1;
1372
1373           if (!abi_version_at_least (10))
1374             /* In abi <10, we only got the explicit tags.  */
1375             decl = res;
1376           else if (flag_abi_version == 10)
1377             {
1378               /* In ABI 10, we want explict and implicit tags.  */
1379               write_abi_tags (mtags);
1380               return;
1381             }
1382         }
1383     }
1384
1385   tree tags = get_abi_tags (decl);
1386   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CONV_FN_P (decl)
1387       && any_abi_below (11))
1388     if (tree mtags = missing_abi_tags (decl))
1389       {
1390         if (abi_warn_or_compat_version_crosses (11))
1391           G.need_abi_warning = true;
1392         if (!abi_version_at_least (11))
1393           tags = chainon (mtags, tags);
1394       }
1395   write_abi_tags (tags);
1396 }
1397
1398 /* Write the unqualified-name for a conversion operator to TYPE.  */
1399
1400 static void
1401 write_conversion_operator_name (const tree type)
1402 {
1403   write_string ("cv");
1404   write_type (type);
1405 }
1406
1407 /* Non-terminal <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
1408
1409      <source-name> ::= </length/ number> <identifier>  */
1410
1411 static void
1412 write_source_name (tree identifier)
1413 {
1414   MANGLE_TRACE_TREE ("source-name", identifier);
1415
1416   /* Never write the whole template-id name including the template
1417      arguments; we only want the template name.  */
1418   if (IDENTIFIER_TEMPLATE (identifier))
1419     identifier = IDENTIFIER_TEMPLATE (identifier);
1420
1421   write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1422   write_identifier (IDENTIFIER_POINTER (identifier));
1423 }
1424
1425 /* Compare two TREE_STRINGs like strcmp.  */
1426
1427 int
1428 tree_string_cmp (const void *p1, const void *p2)
1429 {
1430   if (p1 == p2)
1431     return 0;
1432   tree s1 = *(const tree*)p1;
1433   tree s2 = *(const tree*)p2;
1434   return strcmp (TREE_STRING_POINTER (s1),
1435                  TREE_STRING_POINTER (s2));
1436 }
1437
1438 /* Return the TREE_LIST of TAGS as a sorted VEC.  */
1439
1440 static vec<tree, va_gc> *
1441 sorted_abi_tags (tree tags)
1442 {
1443   vec<tree, va_gc> * vec = make_tree_vector();
1444
1445   for (tree t = tags; t; t = TREE_CHAIN (t))
1446     {
1447       if (ABI_TAG_IMPLICIT (t))
1448         continue;
1449       tree str = TREE_VALUE (t);
1450       vec_safe_push (vec, str);
1451     }
1452
1453   vec->qsort (tree_string_cmp);
1454
1455   return vec;
1456 }
1457
1458 /* ID is the name of a function or type with abi_tags attribute TAGS.
1459    Write out the name, suitably decorated.  */
1460
1461 static void
1462 write_abi_tags (tree tags)
1463 {
1464   if (tags == NULL_TREE)
1465     return;
1466
1467   vec<tree, va_gc> * vec = sorted_abi_tags (tags);
1468
1469   unsigned i; tree str;
1470   FOR_EACH_VEC_ELT (*vec, i, str)
1471     {
1472       write_string ("B");
1473       write_unsigned_number (TREE_STRING_LENGTH (str) - 1);
1474       write_identifier (TREE_STRING_POINTER (str));
1475     }
1476
1477   release_tree_vector (vec);
1478 }
1479
1480 /* Simplified unique_ptr clone to release a tree vec on exit.  */
1481
1482 struct releasing_vec
1483 {
1484   typedef vec<tree, va_gc> vec_t;
1485
1486   releasing_vec (vec_t *v): v(v) { }
1487   releasing_vec (): v(make_tree_vector ()) { }
1488
1489   vec_t &operator* () const { return *v; }
1490   vec_t *operator-> () const { return v; }
1491   vec_t *get () const { return v; }
1492   operator vec_t *() const { return v; }
1493   tree& operator[] (unsigned i) const { return (*v)[i]; }
1494
1495   ~releasing_vec() { release_tree_vector (v); }
1496 private:
1497   vec_t *v;
1498 };
1499
1500 /* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent.  */
1501
1502 static bool
1503 equal_abi_tags (tree t1, tree t2)
1504 {
1505   releasing_vec v1 = sorted_abi_tags (t1);
1506   releasing_vec v2 = sorted_abi_tags (t2);
1507
1508   unsigned len1 = v1->length();
1509   if (len1 != v2->length())
1510     return false;
1511   for (unsigned i = 0; i < len1; ++i)
1512     if (tree_string_cmp (v1[i], v2[i]) != 0)
1513       return false;
1514   return true;
1515 }
1516
1517 /* Write a user-defined literal operator.
1518           ::= li <source-name>    # "" <source-name>
1519    IDENTIFIER is an LITERAL_IDENTIFIER_NODE.  */
1520
1521 static void
1522 write_literal_operator_name (tree identifier)
1523 {
1524   const char* suffix = UDLIT_OP_SUFFIX (identifier);
1525   write_identifier (UDLIT_OP_MANGLED_PREFIX);
1526   write_unsigned_number (strlen (suffix));
1527   write_identifier (suffix);
1528 }
1529
1530 /* Encode 0 as _, and 1+ as n-1_.  */
1531
1532 static void
1533 write_compact_number (int num)
1534 {
1535   if (num > 0)
1536     write_unsigned_number (num - 1);
1537   write_char ('_');
1538 }
1539
1540 /* Return how many unnamed types precede TYPE in its enclosing class.  */
1541
1542 static int
1543 nested_anon_class_index (tree type)
1544 {
1545   int index = 0;
1546   tree member = TYPE_FIELDS (TYPE_CONTEXT (type));
1547   for (; member; member = DECL_CHAIN (member))
1548     if (DECL_IMPLICIT_TYPEDEF_P (member))
1549       {
1550         tree memtype = TREE_TYPE (member);
1551         if (memtype == type)
1552           return index;
1553         else if (TYPE_UNNAMED_P (memtype))
1554           ++index;
1555       }
1556
1557   gcc_unreachable ();
1558 }
1559
1560 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1561
1562 static void
1563 write_unnamed_type_name (const tree type)
1564 {
1565   int discriminator;
1566   MANGLE_TRACE_TREE ("unnamed-type-name", type);
1567
1568   if (TYPE_FUNCTION_SCOPE_P (type))
1569     discriminator = local_class_index (type);
1570   else if (TYPE_CLASS_SCOPE_P (type))
1571     discriminator = nested_anon_class_index (type);
1572   else
1573     {
1574       gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
1575       /* Just use the old mangling at namespace scope.  */
1576       write_source_name (TYPE_IDENTIFIER (type));
1577       return;
1578     }
1579
1580   write_string ("Ut");
1581   write_compact_number (discriminator);
1582 }
1583
1584 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1585    <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters */
1586
1587 static void
1588 write_closure_type_name (const tree type)
1589 {
1590   tree fn = lambda_function (type);
1591   tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
1592   tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
1593
1594   MANGLE_TRACE_TREE ("closure-type-name", type);
1595
1596   write_string ("Ul");
1597   write_method_parms (parms, /*method_p=*/1, fn);
1598   write_char ('E');
1599   write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda));
1600 }
1601
1602 /* Convert NUMBER to ascii using base BASE and generating at least
1603    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1604    into which to store the characters. Returns the number of
1605    characters generated (these will be laid out in advance of where
1606    BUFFER points).  */
1607
1608 static int
1609 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1610                 char *buffer, const unsigned int min_digits)
1611 {
1612   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1613   unsigned digits = 0;
1614
1615   while (number)
1616     {
1617       unsigned HOST_WIDE_INT d = number / base;
1618
1619       *--buffer = base_digits[number - d * base];
1620       digits++;
1621       number = d;
1622     }
1623   while (digits < min_digits)
1624     {
1625       *--buffer = base_digits[0];
1626       digits++;
1627     }
1628   return digits;
1629 }
1630
1631 /* Non-terminal <number>.
1632
1633      <number> ::= [n] </decimal integer/>  */
1634
1635 static void
1636 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1637               const unsigned int base)
1638 {
1639   char buffer[sizeof (HOST_WIDE_INT) * 8];
1640   unsigned count = 0;
1641
1642   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1643     {
1644       write_char ('n');
1645       number = -((HOST_WIDE_INT) number);
1646     }
1647   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1648   write_chars (buffer + sizeof (buffer) - count, count);
1649 }
1650
1651 /* Write out an integral CST in decimal. Most numbers are small, and
1652    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1653    bigger than that, which we must deal with.  */
1654
1655 static inline void
1656 write_integer_cst (const tree cst)
1657 {
1658   int sign = tree_int_cst_sgn (cst);
1659   widest_int abs_value = wi::abs (wi::to_widest (cst));
1660   if (!wi::fits_uhwi_p (abs_value))
1661     {
1662       /* A bignum. We do this in chunks, each of which fits in a
1663          HOST_WIDE_INT.  */
1664       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1665       unsigned HOST_WIDE_INT chunk;
1666       unsigned chunk_digits;
1667       char *ptr = buffer + sizeof (buffer);
1668       unsigned count = 0;
1669       tree n, base, type;
1670       int done;
1671
1672       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1673          representable.  */
1674       chunk = 1000000000;
1675       chunk_digits = 9;
1676
1677       if (sizeof (HOST_WIDE_INT) >= 8)
1678         {
1679           /* It is at least 64 bits, so 10^18 is representable.  */
1680           chunk_digits = 18;
1681           chunk *= chunk;
1682         }
1683
1684       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1685       base = build_int_cstu (type, chunk);
1686       n = wide_int_to_tree (type, cst);
1687
1688       if (sign < 0)
1689         {
1690           write_char ('n');
1691           n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
1692         }
1693       do
1694         {
1695           tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
1696           tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
1697           unsigned c;
1698
1699           done = integer_zerop (d);
1700           tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
1701           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1702                               done ? 1 : chunk_digits);
1703           ptr -= c;
1704           count += c;
1705           n = d;
1706         }
1707       while (!done);
1708       write_chars (ptr, count);
1709     }
1710   else
1711     {
1712       /* A small num.  */
1713       if (sign < 0)
1714         write_char ('n');
1715       write_unsigned_number (abs_value.to_uhwi ());
1716     }
1717 }
1718
1719 /* Write out a floating-point literal.
1720
1721     "Floating-point literals are encoded using the bit pattern of the
1722     target processor's internal representation of that number, as a
1723     fixed-length lowercase hexadecimal string, high-order bytes first
1724     (even if the target processor would store low-order bytes first).
1725     The "n" prefix is not used for floating-point literals; the sign
1726     bit is encoded with the rest of the number.
1727
1728     Here are some examples, assuming the IEEE standard representation
1729     for floating point numbers.  (Spaces are for readability, not
1730     part of the encoding.)
1731
1732         1.0f                    Lf 3f80 0000 E
1733        -1.0f                    Lf bf80 0000 E
1734         1.17549435e-38f         Lf 0080 0000 E
1735         1.40129846e-45f         Lf 0000 0001 E
1736         0.0f                    Lf 0000 0000 E"
1737
1738    Caller is responsible for the Lx and the E.  */
1739 static void
1740 write_real_cst (const tree value)
1741 {
1742   long target_real[4];  /* largest supported float */
1743   char buffer[9];       /* eight hex digits in a 32-bit number */
1744   int i, limit, dir;
1745
1746   tree type = TREE_TYPE (value);
1747   int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1748
1749   real_to_target (target_real, &TREE_REAL_CST (value),
1750                   TYPE_MODE (type));
1751
1752   /* The value in target_real is in the target word order,
1753      so we must write it out backward if that happens to be
1754      little-endian.  write_number cannot be used, it will
1755      produce uppercase.  */
1756   if (FLOAT_WORDS_BIG_ENDIAN)
1757     i = 0, limit = words, dir = 1;
1758   else
1759     i = words - 1, limit = -1, dir = -1;
1760
1761   for (; i != limit; i += dir)
1762     {
1763       sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1764       write_chars (buffer, 8);
1765     }
1766 }
1767
1768 /* Non-terminal <identifier>.
1769
1770      <identifier> ::= </unqualified source code identifier>  */
1771
1772 static void
1773 write_identifier (const char *identifier)
1774 {
1775   MANGLE_TRACE ("identifier", identifier);
1776   write_string (identifier);
1777 }
1778
1779 /* Handle constructor productions of non-terminal <special-name>.
1780    CTOR is a constructor FUNCTION_DECL.
1781
1782      <special-name> ::= C1   # complete object constructor
1783                     ::= C2   # base object constructor
1784                     ::= C3   # complete object allocating constructor
1785
1786    Currently, allocating constructors are never used.  */
1787
1788 static void
1789 write_special_name_constructor (const tree ctor)
1790 {
1791   if (DECL_BASE_CONSTRUCTOR_P (ctor))
1792     write_string ("C2");
1793   /* This is the old-style "[unified]" constructor.
1794      In some cases, we may emit this function and call
1795      it from the clones in order to share code and save space.  */
1796   else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
1797     write_string ("C4");
1798   else
1799     {
1800       gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor));
1801       write_string ("C1");
1802     }
1803 }
1804
1805 /* Handle destructor productions of non-terminal <special-name>.
1806    DTOR is a destructor FUNCTION_DECL.
1807
1808      <special-name> ::= D0 # deleting (in-charge) destructor
1809                     ::= D1 # complete object (in-charge) destructor
1810                     ::= D2 # base object (not-in-charge) destructor  */
1811
1812 static void
1813 write_special_name_destructor (const tree dtor)
1814 {
1815   if (DECL_DELETING_DESTRUCTOR_P (dtor))
1816     write_string ("D0");
1817   else if (DECL_BASE_DESTRUCTOR_P (dtor))
1818     write_string ("D2");
1819   else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
1820     /* This is the old-style "[unified]" destructor.
1821        In some cases, we may emit this function and call
1822        it from the clones in order to share code and save space.  */
1823     write_string ("D4");
1824   else
1825     {
1826       gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor));
1827       write_string ("D1");
1828     }
1829 }
1830
1831 /* Scan the vector of local classes and return how many others with the
1832    same name (or same no name) and context precede ENTITY.  */
1833
1834 static int
1835 local_class_index (tree entity)
1836 {
1837   int ix, discriminator = 0;
1838   tree name = (TYPE_UNNAMED_P (entity) ? NULL_TREE
1839                : TYPE_IDENTIFIER (entity));
1840   tree ctx = TYPE_CONTEXT (entity);
1841   for (ix = 0; ; ix++)
1842     {
1843       tree type = (*local_classes)[ix];
1844       if (type == entity)
1845         return discriminator;
1846       if (TYPE_CONTEXT (type) == ctx
1847           && (name ? TYPE_IDENTIFIER (type) == name
1848               : TYPE_UNNAMED_P (type)))
1849         ++discriminator;
1850     }
1851   gcc_unreachable ();
1852 }
1853
1854 /* Return the discriminator for ENTITY appearing inside
1855    FUNCTION.  The discriminator is the lexical ordinal of VAR among
1856    entities with the same name in the same FUNCTION.  */
1857
1858 static int
1859 discriminator_for_local_entity (tree entity)
1860 {
1861   if (DECL_DISCRIMINATOR_P (entity))
1862     {
1863       if (DECL_DISCRIMINATOR_SET_P (entity))
1864         return DECL_DISCRIMINATOR (entity);
1865       else
1866         /* The first entity with a particular name doesn't get
1867            DECL_DISCRIMINATOR set up.  */
1868         return 0;
1869     }
1870   else if (TREE_CODE (entity) == TYPE_DECL)
1871     {
1872       /* Scan the list of local classes.  */
1873       entity = TREE_TYPE (entity);
1874
1875       /* Lambdas and unnamed types have their own discriminators.  */
1876       if (LAMBDA_TYPE_P (entity) || TYPE_UNNAMED_P (entity))
1877         return 0;
1878
1879       return local_class_index (entity);
1880     }
1881   else
1882     gcc_unreachable ();
1883 }
1884
1885 /* Return the discriminator for STRING, a string literal used inside
1886    FUNCTION.  The discriminator is the lexical ordinal of STRING among
1887    string literals used in FUNCTION.  */
1888
1889 static int
1890 discriminator_for_string_literal (tree /*function*/,
1891                                   tree /*string*/)
1892 {
1893   /* For now, we don't discriminate amongst string literals.  */
1894   return 0;
1895 }
1896
1897 /*   <discriminator> := _ <number>
1898
1899    The discriminator is used only for the second and later occurrences
1900    of the same name within a single function. In this case <number> is
1901    n - 2, if this is the nth occurrence, in lexical order.  */
1902
1903 static void
1904 write_discriminator (const int discriminator)
1905 {
1906   /* If discriminator is zero, don't write anything.  Otherwise...  */
1907   if (discriminator > 0)
1908     {
1909       write_char ('_');
1910       write_unsigned_number (discriminator - 1);
1911     }
1912 }
1913
1914 /* Mangle the name of a function-scope entity.  FUNCTION is the
1915    FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1916    default argument scope.  ENTITY is the decl for the entity itself.
1917    LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1918    either ENTITY itself or an enclosing scope of ENTITY.
1919
1920      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1921                   := Z <function encoding> E s [<discriminator>]
1922                   := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1923
1924 static void
1925 write_local_name (tree function, const tree local_entity,
1926                   const tree entity)
1927 {
1928   tree parm = NULL_TREE;
1929
1930   MANGLE_TRACE_TREE ("local-name", entity);
1931
1932   if (TREE_CODE (function) == PARM_DECL)
1933     {
1934       parm = function;
1935       function = DECL_CONTEXT (parm);
1936     }
1937
1938   write_char ('Z');
1939   write_encoding (function);
1940   write_char ('E');
1941
1942   /* For this purpose, parameters are numbered from right-to-left.  */
1943   if (parm)
1944     {
1945       tree t;
1946       int i = 0;
1947       for (t = DECL_ARGUMENTS (function); t; t = DECL_CHAIN (t))
1948         {
1949           if (t == parm)
1950             i = 1;
1951           else if (i)
1952             ++i;
1953         }
1954       write_char ('d');
1955       write_compact_number (i - 1);
1956     }
1957
1958   if (TREE_CODE (entity) == STRING_CST)
1959     {
1960       write_char ('s');
1961       write_discriminator (discriminator_for_string_literal (function,
1962                                                              entity));
1963     }
1964   else
1965     {
1966       /* Now the <entity name>.  Let write_name know its being called
1967          from <local-name>, so it doesn't try to process the enclosing
1968          function scope again.  */
1969       write_name (entity, /*ignore_local_scope=*/1);
1970       write_discriminator (discriminator_for_local_entity (local_entity));
1971     }
1972 }
1973
1974 /* Non-terminals <type> and <CV-qualifier>.
1975
1976      <type> ::= <builtin-type>
1977             ::= <function-type>
1978             ::= <class-enum-type>
1979             ::= <array-type>
1980             ::= <pointer-to-member-type>
1981             ::= <template-param>
1982             ::= <substitution>
1983             ::= <CV-qualifier>
1984             ::= P <type>    # pointer-to
1985             ::= R <type>    # reference-to
1986             ::= C <type>    # complex pair (C 2000)
1987             ::= G <type>    # imaginary (C 2000)     [not supported]
1988             ::= U <source-name> <type>   # vendor extended type qualifier
1989
1990    C++0x extensions
1991
1992      <type> ::= RR <type>   # rvalue reference-to
1993      <type> ::= Dt <expression> # decltype of an id-expression or
1994                                 # class member access
1995      <type> ::= DT <expression> # decltype of an expression
1996      <type> ::= Dn              # decltype of nullptr
1997
1998    TYPE is a type node.  */
1999
2000 static void
2001 write_type (tree type)
2002 {
2003   /* This gets set to nonzero if TYPE turns out to be a (possibly
2004      CV-qualified) builtin type.  */
2005   int is_builtin_type = 0;
2006
2007   MANGLE_TRACE_TREE ("type", type);
2008
2009   if (type == error_mark_node)
2010     return;
2011
2012   type = canonicalize_for_substitution (type);
2013   if (find_substitution (type))
2014     return;
2015
2016
2017   if (write_CV_qualifiers_for_type (type) > 0)
2018     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
2019        mangle the unqualified type.  The recursive call is needed here
2020        since both the qualified and unqualified types are substitution
2021        candidates.  */
2022     {
2023       tree t = TYPE_MAIN_VARIANT (type);
2024       if (TYPE_ATTRIBUTES (t) && !OVERLOAD_TYPE_P (t))
2025         {
2026           tree attrs = NULL_TREE;
2027           if (tx_safe_fn_type_p (type))
2028             attrs = tree_cons (get_identifier ("transaction_safe"),
2029                                NULL_TREE, attrs);
2030           t = cp_build_type_attribute_variant (t, attrs);
2031         }
2032       gcc_assert (t != type);
2033       if (TREE_CODE (t) == FUNCTION_TYPE
2034           || TREE_CODE (t) == METHOD_TYPE)
2035         {
2036           t = build_ref_qualified_type (t, type_memfn_rqual (type));
2037           if (abi_version_at_least (8)
2038               || type == TYPE_MAIN_VARIANT (type))
2039             /* Avoid adding the unqualified function type as a substitution.  */
2040             write_function_type (t);
2041           else
2042             write_type (t);
2043           if (abi_warn_or_compat_version_crosses (8))
2044             G.need_abi_warning = 1;
2045         }
2046       else
2047         write_type (t);
2048     }
2049   else if (TREE_CODE (type) == ARRAY_TYPE)
2050     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
2051        so that the cv-qualification of the element type is available
2052        in write_array_type.  */
2053     write_array_type (type);
2054   else
2055     {
2056       tree type_orig = type;
2057
2058       /* See through any typedefs.  */
2059       type = TYPE_MAIN_VARIANT (type);
2060       if (TREE_CODE (type) == FUNCTION_TYPE
2061           || TREE_CODE (type) == METHOD_TYPE)
2062         type = build_ref_qualified_type (type, type_memfn_rqual (type_orig));
2063
2064       /* According to the C++ ABI, some library classes are passed the
2065          same as the scalar type of their single member and use the same
2066          mangling.  */
2067       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
2068         type = TREE_TYPE (first_field (type));
2069
2070       if (TYPE_PTRDATAMEM_P (type))
2071         write_pointer_to_member_type (type);
2072       else
2073         {
2074           /* Handle any target-specific fundamental types.  */
2075           const char *target_mangling
2076             = targetm.mangle_type (type_orig);
2077
2078           if (target_mangling)
2079             {
2080               write_string (target_mangling);
2081               /* Add substitutions for types other than fundamental
2082                  types.  */
2083               if (!VOID_TYPE_P (type)
2084                   && TREE_CODE (type) != INTEGER_TYPE
2085                   && TREE_CODE (type) != REAL_TYPE
2086                   && TREE_CODE (type) != BOOLEAN_TYPE)
2087                 add_substitution (type);
2088               return;
2089             }
2090
2091           switch (TREE_CODE (type))
2092             {
2093             case VOID_TYPE:
2094             case BOOLEAN_TYPE:
2095             case INTEGER_TYPE:  /* Includes wchar_t.  */
2096             case REAL_TYPE:
2097             case FIXED_POINT_TYPE:
2098               {
2099                 /* If this is a typedef, TYPE may not be one of
2100                    the standard builtin type nodes, but an alias of one.  Use
2101                    TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
2102                 write_builtin_type (TYPE_MAIN_VARIANT (type));
2103                 ++is_builtin_type;
2104               }
2105               break;
2106
2107             case COMPLEX_TYPE:
2108               write_char ('C');
2109               write_type (TREE_TYPE (type));
2110               break;
2111
2112             case FUNCTION_TYPE:
2113             case METHOD_TYPE:
2114               write_function_type (type);
2115               break;
2116
2117             case UNION_TYPE:
2118             case RECORD_TYPE:
2119             case ENUMERAL_TYPE:
2120               /* A pointer-to-member function is represented as a special
2121                  RECORD_TYPE, so check for this first.  */
2122               if (TYPE_PTRMEMFUNC_P (type))
2123                 write_pointer_to_member_type (type);
2124               else
2125                 write_class_enum_type (type);
2126               break;
2127
2128             case TYPENAME_TYPE:
2129             case UNBOUND_CLASS_TEMPLATE:
2130               /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2131                  ordinary nested names.  */
2132               write_nested_name (TYPE_STUB_DECL (type));
2133               break;
2134
2135             case POINTER_TYPE:
2136             case REFERENCE_TYPE:
2137               if (TYPE_PTR_P (type))
2138                 write_char ('P');
2139               else if (TYPE_REF_IS_RVALUE (type))
2140                 write_char ('O');
2141               else
2142                 write_char ('R');
2143               {
2144                 tree target = TREE_TYPE (type);
2145                 /* Attribute const/noreturn are not reflected in mangling.
2146                    We strip them here rather than at a lower level because
2147                    a typedef or template argument can have function type
2148                    with function-cv-quals (that use the same representation),
2149                    but you can't have a pointer/reference to such a type.  */
2150                 if (TREE_CODE (target) == FUNCTION_TYPE)
2151                   {
2152                     if (abi_warn_or_compat_version_crosses (5)
2153                         && TYPE_QUALS (target) != TYPE_UNQUALIFIED)
2154                       G.need_abi_warning = 1;
2155                     if (abi_version_at_least (5))
2156                       target = build_qualified_type (target, TYPE_UNQUALIFIED);
2157                   }
2158                 write_type (target);
2159               }
2160               break;
2161
2162             case TEMPLATE_TYPE_PARM:
2163               if (is_auto (type))
2164                 {
2165                   if (AUTO_IS_DECLTYPE (type))
2166                     write_identifier ("Dc");
2167                   else
2168                     write_identifier ("Da");
2169                   ++is_builtin_type;
2170                   break;
2171                 }
2172               /* else fall through.  */
2173             case TEMPLATE_PARM_INDEX:
2174               write_template_param (type);
2175               break;
2176
2177             case TEMPLATE_TEMPLATE_PARM:
2178               write_template_template_param (type);
2179               break;
2180
2181             case BOUND_TEMPLATE_TEMPLATE_PARM:
2182               write_template_template_param (type);
2183               write_template_args
2184                 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
2185               break;
2186
2187             case VECTOR_TYPE:
2188               if (abi_version_at_least (4))
2189                 {
2190                   write_string ("Dv");
2191                   /* Non-constant vector size would be encoded with
2192                      _ expression, but we don't support that yet.  */
2193                   write_unsigned_number (TYPE_VECTOR_SUBPARTS (type));
2194                   write_char ('_');
2195                 }
2196               else
2197                 write_string ("U8__vector");
2198               if (abi_warn_or_compat_version_crosses (4))
2199                 G.need_abi_warning = 1;
2200               write_type (TREE_TYPE (type));
2201               break;
2202
2203             case TYPE_PACK_EXPANSION:
2204               write_string ("Dp");
2205               write_type (PACK_EXPANSION_PATTERN (type));
2206               break;
2207
2208             case DECLTYPE_TYPE:
2209               /* These shouldn't make it into mangling.  */
2210               gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
2211                           && !DECLTYPE_FOR_LAMBDA_PROXY (type));
2212
2213               /* In ABI <5, we stripped decltype of a plain decl.  */
2214               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2215                 {
2216                   tree expr = DECLTYPE_TYPE_EXPR (type);
2217                   tree etype = NULL_TREE;
2218                   switch (TREE_CODE (expr))
2219                     {
2220                     case VAR_DECL:
2221                     case PARM_DECL:
2222                     case RESULT_DECL:
2223                     case FUNCTION_DECL:
2224                     case CONST_DECL:
2225                     case TEMPLATE_PARM_INDEX:
2226                       etype = TREE_TYPE (expr);
2227                       break;
2228
2229                     default:
2230                       break;
2231                     }
2232
2233                   if (etype && !type_uses_auto (etype))
2234                     {
2235                       if (abi_warn_or_compat_version_crosses (5))
2236                         G.need_abi_warning = 1;
2237                       if (!abi_version_at_least (5))
2238                         {
2239                           write_type (etype);
2240                           return;
2241                         }
2242                     }
2243                 }
2244
2245               write_char ('D');
2246               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2247                 write_char ('t');
2248               else
2249                 write_char ('T');
2250               ++cp_unevaluated_operand;
2251               write_expression (DECLTYPE_TYPE_EXPR (type));
2252               --cp_unevaluated_operand;
2253               write_char ('E');
2254               break;
2255
2256             case NULLPTR_TYPE:
2257               write_string ("Dn");
2258               if (abi_version_at_least (7))
2259                 ++is_builtin_type;
2260               if (abi_warn_or_compat_version_crosses (7))
2261                 G.need_abi_warning = 1;
2262               break;
2263
2264             case TYPEOF_TYPE:
2265               sorry ("mangling typeof, use decltype instead");
2266               break;
2267
2268             case UNDERLYING_TYPE:
2269               sorry ("mangling __underlying_type");
2270               break;
2271
2272             case LANG_TYPE:
2273               /* fall through.  */
2274
2275             default:
2276               gcc_unreachable ();
2277             }
2278         }
2279     }
2280
2281   /* Types other than builtin types are substitution candidates.  */
2282   if (!is_builtin_type)
2283     add_substitution (type);
2284 }
2285
2286 /* qsort callback for sorting a vector of attribute entries.  */
2287
2288 static int
2289 attr_strcmp (const void *p1, const void *p2)
2290 {
2291   tree a1 = *(const tree*)p1;
2292   tree a2 = *(const tree*)p2;
2293
2294   const attribute_spec *as1 = lookup_attribute_spec (get_attribute_name (a1));
2295   const attribute_spec *as2 = lookup_attribute_spec (get_attribute_name (a2));
2296
2297   return strcmp (as1->name, as2->name);
2298 }
2299
2300 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
2301    CV-qualifiers written for TYPE.
2302
2303      <CV-qualifiers> ::= [r] [V] [K]  */
2304
2305 static int
2306 write_CV_qualifiers_for_type (const tree type)
2307 {
2308   int num_qualifiers = 0;
2309
2310   /* The order is specified by:
2311
2312        "In cases where multiple order-insensitive qualifiers are
2313        present, they should be ordered 'K' (closest to the base type),
2314        'V', 'r', and 'U' (farthest from the base type) ..."  */
2315
2316   /* Mangle attributes that affect type identity as extended qualifiers.
2317
2318      We don't do this with classes and enums because their attributes
2319      are part of their definitions, not something added on.  */
2320
2321   if (!OVERLOAD_TYPE_P (type))
2322     {
2323       auto_vec<tree> vec;
2324       for (tree a = TYPE_ATTRIBUTES (type); a; a = TREE_CHAIN (a))
2325         {
2326           tree name = get_attribute_name (a);
2327           const attribute_spec *as = lookup_attribute_spec (name);
2328           if (as && as->affects_type_identity
2329               && !is_attribute_p ("transaction_safe", name)
2330               && !is_attribute_p ("abi_tag", name))
2331             vec.safe_push (a);
2332         }
2333       if (abi_warn_or_compat_version_crosses (10) && !vec.is_empty ())
2334         G.need_abi_warning = true;
2335       if (abi_version_at_least (10))
2336         {
2337           vec.qsort (attr_strcmp);
2338           while (!vec.is_empty())
2339             {
2340               tree a = vec.pop();
2341               const attribute_spec *as
2342                 = lookup_attribute_spec (get_attribute_name (a));
2343
2344               write_char ('U');
2345               write_unsigned_number (strlen (as->name));
2346               write_string (as->name);
2347               if (TREE_VALUE (a))
2348                 {
2349                   write_char ('I');
2350                   for (tree args = TREE_VALUE (a); args;
2351                        args = TREE_CHAIN (args))
2352                     {
2353                       tree arg = TREE_VALUE (args);
2354                       write_template_arg (arg);
2355                     }
2356                   write_char ('E');
2357                 }
2358
2359               ++num_qualifiers;
2360             }
2361         }
2362     }
2363
2364   /* Note that we do not use cp_type_quals below; given "const
2365      int[3]", the "const" is emitted with the "int", not with the
2366      array.  */
2367   cp_cv_quals quals = TYPE_QUALS (type);
2368
2369   if (quals & TYPE_QUAL_RESTRICT)
2370     {
2371       write_char ('r');
2372       ++num_qualifiers;
2373     }
2374   if (quals & TYPE_QUAL_VOLATILE)
2375     {
2376       write_char ('V');
2377       ++num_qualifiers;
2378     }
2379   if (quals & TYPE_QUAL_CONST)
2380     {
2381       write_char ('K');
2382       ++num_qualifiers;
2383     }
2384
2385   return num_qualifiers;
2386 }
2387
2388 /* Non-terminal <builtin-type>.
2389
2390      <builtin-type> ::= v   # void
2391                     ::= b   # bool
2392                     ::= w   # wchar_t
2393                     ::= c   # char
2394                     ::= a   # signed char
2395                     ::= h   # unsigned char
2396                     ::= s   # short
2397                     ::= t   # unsigned short
2398                     ::= i   # int
2399                     ::= j   # unsigned int
2400                     ::= l   # long
2401                     ::= m   # unsigned long
2402                     ::= x   # long long, __int64
2403                     ::= y   # unsigned long long, __int64
2404                     ::= n   # __int128
2405                     ::= o   # unsigned __int128
2406                     ::= f   # float
2407                     ::= d   # double
2408                     ::= e   # long double, __float80
2409                     ::= g   # __float128          [not supported]
2410                     ::= u <source-name>  # vendor extended type */
2411
2412 static void
2413 write_builtin_type (tree type)
2414 {
2415   if (TYPE_CANONICAL (type))
2416     type = TYPE_CANONICAL (type);
2417
2418   switch (TREE_CODE (type))
2419     {
2420     case VOID_TYPE:
2421       write_char ('v');
2422       break;
2423
2424     case BOOLEAN_TYPE:
2425       write_char ('b');
2426       break;
2427
2428     case INTEGER_TYPE:
2429       /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2430          isn't in integer_type_nodes.  */
2431       if (type == wchar_type_node)
2432         write_char ('w');
2433       else if (type == char16_type_node)
2434         write_string ("Ds");
2435       else if (type == char32_type_node)
2436         write_string ("Di");
2437       else if (TYPE_FOR_JAVA (type))
2438         write_java_integer_type_codes (type);
2439       else
2440         {
2441           size_t itk;
2442           /* Assume TYPE is one of the shared integer type nodes.  Find
2443              it in the array of these nodes.  */
2444         iagain:
2445           for (itk = 0; itk < itk_none; ++itk)
2446             if (integer_types[itk] != NULL_TREE
2447                 && integer_type_codes[itk] != '\0'
2448                 && type == integer_types[itk])
2449               {
2450                 /* Print the corresponding single-letter code.  */
2451                 write_char (integer_type_codes[itk]);
2452                 break;
2453               }
2454
2455           if (itk == itk_none)
2456             {
2457               tree t = c_common_type_for_mode (TYPE_MODE (type),
2458                                                TYPE_UNSIGNED (type));
2459               if (type != t)
2460                 {
2461                   type = t;
2462                   goto iagain;
2463                 }
2464
2465               if (TYPE_PRECISION (type) == 128)
2466                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
2467               else
2468                 {
2469                   /* Allow for cases where TYPE is not one of the shared
2470                      integer type nodes and write a "vendor extended builtin
2471                      type" with a name the form intN or uintN, respectively.
2472                      Situations like this can happen if you have an
2473                      __attribute__((__mode__(__SI__))) type and use exotic
2474                      switches like '-mint8' on AVR.  Of course, this is
2475                      undefined by the C++ ABI (and '-mint8' is not even
2476                      Standard C conforming), but when using such special
2477                      options you're pretty much in nowhere land anyway.  */
2478                   const char *prefix;
2479                   char prec[11];        /* up to ten digits for an unsigned */
2480
2481                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
2482                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
2483                   write_char ('u');     /* "vendor extended builtin type" */
2484                   write_unsigned_number (strlen (prefix) + strlen (prec));
2485                   write_string (prefix);
2486                   write_string (prec);
2487                 }
2488             }
2489         }
2490       break;
2491
2492     case REAL_TYPE:
2493       if (type == float_type_node
2494           || type == java_float_type_node)
2495         write_char ('f');
2496       else if (type == double_type_node
2497                || type == java_double_type_node)
2498         write_char ('d');
2499       else if (type == long_double_type_node)
2500         write_char ('e');
2501       else if (type == dfloat32_type_node)
2502         write_string ("Df");
2503       else if (type == dfloat64_type_node)
2504         write_string ("Dd");
2505       else if (type == dfloat128_type_node)
2506         write_string ("De");
2507       else
2508         gcc_unreachable ();
2509       break;
2510
2511     case FIXED_POINT_TYPE:
2512       write_string ("DF");
2513       if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
2514         write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
2515       if (type == fract_type_node
2516           || type == sat_fract_type_node
2517           || type == accum_type_node
2518           || type == sat_accum_type_node)
2519         write_char ('i');
2520       else if (type == unsigned_fract_type_node
2521                || type == sat_unsigned_fract_type_node
2522                || type == unsigned_accum_type_node
2523                || type == sat_unsigned_accum_type_node)
2524         write_char ('j');
2525       else if (type == short_fract_type_node
2526                || type == sat_short_fract_type_node
2527                || type == short_accum_type_node
2528                || type == sat_short_accum_type_node)
2529         write_char ('s');
2530       else if (type == unsigned_short_fract_type_node
2531                || type == sat_unsigned_short_fract_type_node
2532                || type == unsigned_short_accum_type_node
2533                || type == sat_unsigned_short_accum_type_node)
2534         write_char ('t');
2535       else if (type == long_fract_type_node
2536                || type == sat_long_fract_type_node
2537                || type == long_accum_type_node
2538                || type == sat_long_accum_type_node)
2539         write_char ('l');
2540       else if (type == unsigned_long_fract_type_node
2541                || type == sat_unsigned_long_fract_type_node
2542                || type == unsigned_long_accum_type_node
2543                || type == sat_unsigned_long_accum_type_node)
2544         write_char ('m');
2545       else if (type == long_long_fract_type_node
2546                || type == sat_long_long_fract_type_node
2547                || type == long_long_accum_type_node
2548                || type == sat_long_long_accum_type_node)
2549         write_char ('x');
2550       else if (type == unsigned_long_long_fract_type_node
2551                || type == sat_unsigned_long_long_fract_type_node
2552                || type == unsigned_long_long_accum_type_node
2553                || type == sat_unsigned_long_long_accum_type_node)
2554         write_char ('y');
2555       else
2556         sorry ("mangling unknown fixed point type");
2557       write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
2558       if (TYPE_SATURATING (type))
2559         write_char ('s');
2560       else
2561         write_char ('n');
2562       break;
2563
2564     default:
2565       gcc_unreachable ();
2566     }
2567 }
2568
2569 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
2570    METHOD_TYPE.  The return type is mangled before the parameter
2571    types.
2572
2573      <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E   */
2574
2575 static void
2576 write_function_type (const tree type)
2577 {
2578   MANGLE_TRACE_TREE ("function-type", type);
2579
2580   /* For a pointer to member function, the function type may have
2581      cv-qualifiers, indicating the quals for the artificial 'this'
2582      parameter.  */
2583   if (TREE_CODE (type) == METHOD_TYPE)
2584     {
2585       /* The first parameter must be a POINTER_TYPE pointing to the
2586          `this' parameter.  */
2587       tree this_type = class_of_this_parm (type);
2588       write_CV_qualifiers_for_type (this_type);
2589     }
2590
2591   if (tx_safe_fn_type_p (type))
2592     write_string ("Dx");
2593
2594   write_char ('F');
2595   /* We don't track whether or not a type is `extern "C"'.  Note that
2596      you can have an `extern "C"' function that does not have
2597      `extern "C"' type, and vice versa:
2598
2599        extern "C" typedef void function_t();
2600        function_t f; // f has C++ linkage, but its type is
2601                      // `extern "C"'
2602
2603        typedef void function_t();
2604        extern "C" function_t f; // Vice versa.
2605
2606      See [dcl.link].  */
2607   write_bare_function_type (type, /*include_return_type_p=*/1,
2608                             /*decl=*/NULL);
2609   if (FUNCTION_REF_QUALIFIED (type))
2610     {
2611       if (FUNCTION_RVALUE_QUALIFIED (type))
2612         write_char ('O');
2613       else
2614         write_char ('R');
2615     }
2616   write_char ('E');
2617 }
2618
2619 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
2620    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
2621    is mangled before the parameter types.  If non-NULL, DECL is
2622    FUNCTION_DECL for the function whose type is being emitted.
2623
2624    If DECL is a member of a Java type, then a literal 'J'
2625    is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2626    were nonzero.
2627
2628      <bare-function-type> ::= [J]</signature/ type>+  */
2629
2630 static void
2631 write_bare_function_type (const tree type, const int include_return_type_p,
2632                           const tree decl)
2633 {
2634   int java_method_p;
2635
2636   MANGLE_TRACE_TREE ("bare-function-type", type);
2637
2638   /* Detect Java methods and emit special encoding.  */
2639   if (decl != NULL
2640       && DECL_FUNCTION_MEMBER_P (decl)
2641       && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
2642       && !DECL_CONSTRUCTOR_P (decl)
2643       && !DECL_DESTRUCTOR_P (decl)
2644       && !DECL_CONV_FN_P (decl))
2645     {
2646       java_method_p = 1;
2647       write_char ('J');
2648     }
2649   else
2650     {
2651       java_method_p = 0;
2652     }
2653
2654   /* Mangle the return type, if requested.  */
2655   if (include_return_type_p || java_method_p)
2656     write_type (TREE_TYPE (type));
2657
2658   /* Now mangle the types of the arguments.  */
2659   ++G.parm_depth;
2660   write_method_parms (TYPE_ARG_TYPES (type),
2661                       TREE_CODE (type) == METHOD_TYPE,
2662                       decl);
2663   --G.parm_depth;
2664 }
2665
2666 /* Write the mangled representation of a method parameter list of
2667    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
2668    considered a non-static method, and the this parameter is omitted.
2669    If non-NULL, DECL is the FUNCTION_DECL for the function whose
2670    parameters are being emitted.  */
2671
2672 static void
2673 write_method_parms (tree parm_types, const int method_p, const tree decl)
2674 {
2675   tree first_parm_type;
2676   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2677
2678   /* Assume this parameter type list is variable-length.  If it ends
2679      with a void type, then it's not.  */
2680   int varargs_p = 1;
2681
2682   /* If this is a member function, skip the first arg, which is the
2683      this pointer.
2684        "Member functions do not encode the type of their implicit this
2685        parameter."
2686
2687      Similarly, there's no need to mangle artificial parameters, like
2688      the VTT parameters for constructors and destructors.  */
2689   if (method_p)
2690     {
2691       parm_types = TREE_CHAIN (parm_types);
2692       parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
2693
2694       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2695         {
2696           parm_types = TREE_CHAIN (parm_types);
2697           parm_decl = DECL_CHAIN (parm_decl);
2698         }
2699     }
2700
2701   for (first_parm_type = parm_types;
2702        parm_types;
2703        parm_types = TREE_CHAIN (parm_types))
2704     {
2705       tree parm = TREE_VALUE (parm_types);
2706       if (parm == void_type_node)
2707         {
2708           /* "Empty parameter lists, whether declared as () or
2709              conventionally as (void), are encoded with a void parameter
2710              (v)."  */
2711           if (parm_types == first_parm_type)
2712             write_type (parm);
2713           /* If the parm list is terminated with a void type, it's
2714              fixed-length.  */
2715           varargs_p = 0;
2716           /* A void type better be the last one.  */
2717           gcc_assert (TREE_CHAIN (parm_types) == NULL);
2718         }
2719       else
2720         write_type (parm);
2721     }
2722
2723   if (varargs_p)
2724     /* <builtin-type> ::= z  # ellipsis  */
2725     write_char ('z');
2726 }
2727
2728 /* <class-enum-type> ::= <name>  */
2729
2730 static void
2731 write_class_enum_type (const tree type)
2732 {
2733   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2734 }
2735
2736 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
2737    arguments.
2738
2739      <template-args> ::= I <template-arg>* E  */
2740
2741 static void
2742 write_template_args (tree args)
2743 {
2744   int i;
2745   int length = 0;
2746
2747   MANGLE_TRACE_TREE ("template-args", args);
2748
2749   write_char ('I');
2750
2751   if (args)
2752     length = TREE_VEC_LENGTH (args);
2753
2754   if (args && length && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2755     {
2756       /* We have nested template args.  We want the innermost template
2757          argument list.  */
2758       args = TREE_VEC_ELT (args, length - 1);
2759       length = TREE_VEC_LENGTH (args);
2760     }
2761   for (i = 0; i < length; ++i)
2762     write_template_arg (TREE_VEC_ELT (args, i));
2763
2764   write_char ('E');
2765 }
2766
2767 /* Write out the
2768    <unqualified-name>
2769    <unqualified-name> <template-args>
2770    part of SCOPE_REF or COMPONENT_REF mangling.  */
2771
2772 static void
2773 write_member_name (tree member)
2774 {
2775   if (identifier_p (member))
2776     write_unqualified_id (member);
2777   else if (DECL_P (member))
2778     write_unqualified_name (member);
2779   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2780     {
2781       tree name = TREE_OPERAND (member, 0);
2782       if (TREE_CODE (name) == OVERLOAD)
2783         name = OVL_FUNCTION (name);
2784       write_member_name (name);
2785       write_template_args (TREE_OPERAND (member, 1));
2786     }
2787   else
2788     write_expression (member);
2789 }
2790
2791 /* <expression> ::= <unary operator-name> <expression>
2792                 ::= <binary operator-name> <expression> <expression>
2793                 ::= <expr-primary>
2794
2795    <expr-primary> ::= <template-param>
2796                   ::= L <type> <value number> E         # literal
2797                   ::= L <mangled-name> E                # external name
2798                   ::= st <type>                         # sizeof
2799                   ::= sr <type> <unqualified-name>      # dependent name
2800                   ::= sr <type> <unqualified-name> <template-args> */
2801
2802 static void
2803 write_expression (tree expr)
2804 {
2805   enum tree_code code = TREE_CODE (expr);
2806
2807   /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
2808      is converted (via qualification conversions) to another
2809      type.  */
2810   while (TREE_CODE (expr) == NOP_EXPR
2811          /* Parentheses aren't mangled.  */
2812          || code == PAREN_EXPR
2813          || TREE_CODE (expr) == NON_LVALUE_EXPR)
2814     {
2815       expr = TREE_OPERAND (expr, 0);
2816       code = TREE_CODE (expr);
2817     }
2818
2819   if (code == BASELINK
2820       && (!type_unknown_p (expr)
2821           || !BASELINK_QUALIFIED_P (expr)))
2822     {
2823       expr = BASELINK_FUNCTIONS (expr);
2824       code = TREE_CODE (expr);
2825     }
2826
2827   /* Handle pointers-to-members by making them look like expression
2828      nodes.  */
2829   if (code == PTRMEM_CST)
2830     {
2831       expr = build_nt (ADDR_EXPR,
2832                        build_qualified_name (/*type=*/NULL_TREE,
2833                                              PTRMEM_CST_CLASS (expr),
2834                                              PTRMEM_CST_MEMBER (expr),
2835                                              /*template_p=*/false));
2836       code = TREE_CODE (expr);
2837     }
2838
2839   /* Handle template parameters.  */
2840   if (code == TEMPLATE_TYPE_PARM
2841       || code == TEMPLATE_TEMPLATE_PARM
2842       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2843       || code == TEMPLATE_PARM_INDEX)
2844     write_template_param (expr);
2845   /* Handle literals.  */
2846   else if (TREE_CODE_CLASS (code) == tcc_constant
2847            || code == CONST_DECL)
2848     write_template_arg_literal (expr);
2849   else if (code == PARM_DECL && DECL_ARTIFICIAL (expr))
2850     {
2851       gcc_assert (!strcmp ("this", IDENTIFIER_POINTER (DECL_NAME (expr))));
2852       write_string ("fpT");
2853     }
2854   else if (code == PARM_DECL)
2855     {
2856       /* A function parameter used in a late-specified return type.  */
2857       int index = DECL_PARM_INDEX (expr);
2858       int level = DECL_PARM_LEVEL (expr);
2859       int delta = G.parm_depth - level + 1;
2860       gcc_assert (index >= 1);
2861       write_char ('f');
2862       if (delta != 0)
2863         {
2864           if (abi_version_at_least (5))
2865             {
2866               /* Let L be the number of function prototype scopes from the
2867                  innermost one (in which the parameter reference occurs) up
2868                  to (and including) the one containing the declaration of
2869                  the referenced parameter.  If the parameter declaration
2870                  clause of the innermost function prototype scope has been
2871                  completely seen, it is not counted (in that case -- which
2872                  is perhaps the most common -- L can be zero).  */
2873               write_char ('L');
2874               write_unsigned_number (delta - 1);
2875             }
2876           if (abi_warn_or_compat_version_crosses (5))
2877             G.need_abi_warning = true;
2878         }
2879       write_char ('p');
2880       write_compact_number (index - 1);
2881     }
2882   else if (DECL_P (expr))
2883     {
2884       write_char ('L');
2885       write_mangled_name (expr, false);
2886       write_char ('E');
2887     }
2888   else if (TREE_CODE (expr) == SIZEOF_EXPR)
2889     {
2890       tree op = TREE_OPERAND (expr, 0);
2891
2892       if (PACK_EXPANSION_P (op))
2893         {
2894           if (abi_warn_or_compat_version_crosses (11))
2895             G.need_abi_warning = true;
2896           if (abi_version_at_least (11))
2897             {
2898               /* sZ rather than szDp.  */
2899               write_string ("sZ");
2900               write_expression (PACK_EXPANSION_PATTERN (op));
2901               return;
2902             }
2903         }
2904
2905       if (SIZEOF_EXPR_TYPE_P (expr))
2906         {
2907           write_string ("st");
2908           write_type (TREE_TYPE (op));
2909         }
2910       else if (ARGUMENT_PACK_P (op))
2911         {
2912           tree args = ARGUMENT_PACK_ARGS (op);
2913           int length = TREE_VEC_LENGTH (args);
2914           if (abi_warn_or_compat_version_crosses (10))
2915             G.need_abi_warning = true;
2916           if (abi_version_at_least (10))
2917             {
2918               /* sP <template-arg>* E # sizeof...(T), size of a captured
2919                  template parameter pack from an alias template */
2920               write_string ("sP");
2921               for (int i = 0; i < length; ++i)
2922                 write_template_arg (TREE_VEC_ELT (args, i));
2923               write_char ('E');
2924             }
2925           else
2926             {
2927               /* In GCC 5 we represented this sizeof wrong, with the effect
2928                  that we mangled it as the last element of the pack.  */
2929               tree arg = TREE_VEC_ELT (args, length-1);
2930               if (TYPE_P (op))
2931                 {
2932                   write_string ("st");
2933                   write_type (arg);
2934                 }
2935               else
2936                 {
2937                   write_string ("sz");
2938                   write_expression (arg);
2939                 }
2940             }
2941         }
2942       else if (TYPE_P (TREE_OPERAND (expr, 0)))
2943         {
2944           write_string ("st");
2945           write_type (TREE_OPERAND (expr, 0));
2946         }
2947       else
2948         goto normal_expr;
2949     }
2950   else if (TREE_CODE (expr) == ALIGNOF_EXPR
2951            && TYPE_P (TREE_OPERAND (expr, 0)))
2952     {
2953       write_string ("at");
2954       write_type (TREE_OPERAND (expr, 0));
2955     }
2956   else if (code == SCOPE_REF
2957            || code == BASELINK)
2958     {
2959       tree scope, member;
2960       if (code == SCOPE_REF)
2961         {
2962           scope = TREE_OPERAND (expr, 0);
2963           member = TREE_OPERAND (expr, 1);
2964         }
2965       else
2966         {
2967           scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr));
2968           member = BASELINK_FUNCTIONS (expr);
2969         }
2970
2971       /* If the MEMBER is a real declaration, then the qualifying
2972          scope was not dependent.  Ideally, we would not have a
2973          SCOPE_REF in those cases, but sometimes we do.  If the second
2974          argument is a DECL, then the name must not have been
2975          dependent.  */
2976       if (DECL_P (member))
2977         write_expression (member);
2978       else
2979         {
2980           write_string ("sr");
2981           write_type (scope);
2982           write_member_name (member);
2983         }
2984     }
2985   else if (INDIRECT_REF_P (expr)
2986            && TREE_TYPE (TREE_OPERAND (expr, 0))
2987            && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2988     {
2989       write_expression (TREE_OPERAND (expr, 0));
2990     }
2991   else if (identifier_p (expr))
2992     {
2993       /* An operator name appearing as a dependent name needs to be
2994          specially marked to disambiguate between a use of the operator
2995          name and a use of the operator in an expression.  */
2996       if (IDENTIFIER_OPNAME_P (expr))
2997         write_string ("on");
2998       write_unqualified_id (expr);
2999     }
3000   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
3001     {
3002       tree fn = TREE_OPERAND (expr, 0);
3003       if (is_overloaded_fn (fn))
3004         fn = get_first_fn (fn);
3005       if (DECL_P (fn))
3006         fn = DECL_NAME (fn);
3007       if (IDENTIFIER_OPNAME_P (fn))
3008         write_string ("on");
3009       write_unqualified_id (fn);
3010       write_template_args (TREE_OPERAND (expr, 1));
3011     }
3012   else if (TREE_CODE (expr) == MODOP_EXPR)
3013     {
3014       enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1));
3015       const char *name = (assignment_operator_name_info[(int) subop]
3016                           .mangled_name);
3017       write_string (name);
3018       write_expression (TREE_OPERAND (expr, 0));
3019       write_expression (TREE_OPERAND (expr, 2));
3020     }
3021   else if (code == NEW_EXPR || code == VEC_NEW_EXPR)
3022     {
3023       /* ::= [gs] nw <expression>* _ <type> E
3024          ::= [gs] nw <expression>* _ <type> <initializer>
3025          ::= [gs] na <expression>* _ <type> E
3026          ::= [gs] na <expression>* _ <type> <initializer>
3027          <initializer> ::= pi <expression>* E  */
3028       tree placement = TREE_OPERAND (expr, 0);
3029       tree type = TREE_OPERAND (expr, 1);
3030       tree nelts = TREE_OPERAND (expr, 2);
3031       tree init = TREE_OPERAND (expr, 3);
3032       tree t;
3033
3034       gcc_assert (code == NEW_EXPR);
3035       if (TREE_OPERAND (expr, 2))
3036         code = VEC_NEW_EXPR;
3037
3038       if (NEW_EXPR_USE_GLOBAL (expr))
3039         write_string ("gs");
3040
3041       write_string (operator_name_info[(int) code].mangled_name);
3042
3043       for (t = placement; t; t = TREE_CHAIN (t))
3044         write_expression (TREE_VALUE (t));
3045
3046       write_char ('_');
3047
3048       if (nelts)
3049         {
3050           tree domain;
3051           ++processing_template_decl;
3052           domain = compute_array_index_type (NULL_TREE, nelts,
3053                                              tf_warning_or_error);
3054           type = build_cplus_array_type (type, domain);
3055           --processing_template_decl;
3056         }
3057       write_type (type);
3058
3059       if (init && TREE_CODE (init) == TREE_LIST
3060           && DIRECT_LIST_INIT_P (TREE_VALUE (init)))
3061         write_expression (TREE_VALUE (init));
3062       else
3063         {
3064           if (init)
3065             write_string ("pi");
3066           if (init && init != void_node)
3067             for (t = init; t; t = TREE_CHAIN (t))
3068               write_expression (TREE_VALUE (t));
3069           write_char ('E');
3070         }
3071     }
3072   else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR)
3073     {
3074       gcc_assert (code == DELETE_EXPR);
3075       if (DELETE_EXPR_USE_VEC (expr))
3076         code = VEC_DELETE_EXPR;
3077
3078       if (DELETE_EXPR_USE_GLOBAL (expr))
3079         write_string ("gs");
3080
3081       write_string (operator_name_info[(int) code].mangled_name);
3082
3083       write_expression (TREE_OPERAND (expr, 0));
3084     }
3085   else if (code == THROW_EXPR)
3086     {
3087       tree op = TREE_OPERAND (expr, 0);
3088       if (op)
3089         {
3090           write_string ("tw");
3091           write_expression (op);
3092         }
3093       else
3094         write_string ("tr");
3095     }
3096   else if (code == CONSTRUCTOR)
3097     {
3098       vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (expr);
3099       unsigned i; tree val;
3100
3101       if (BRACE_ENCLOSED_INITIALIZER_P (expr))
3102         write_string ("il");
3103       else
3104         {
3105           write_string ("tl");
3106           write_type (TREE_TYPE (expr));
3107         }
3108       FOR_EACH_CONSTRUCTOR_VALUE (elts, i, val)
3109         write_expression (val);
3110       write_char ('E');
3111     }
3112   else if (dependent_name (expr))
3113     {
3114       write_unqualified_id (dependent_name (expr));
3115     }
3116   else
3117     {
3118     normal_expr:
3119       int i, len;
3120       const char *name;
3121
3122       /* When we bind a variable or function to a non-type template
3123          argument with reference type, we create an ADDR_EXPR to show
3124          the fact that the entity's address has been taken.  But, we
3125          don't actually want to output a mangling code for the `&'.  */
3126       if (TREE_CODE (expr) == ADDR_EXPR
3127           && TREE_TYPE (expr)
3128           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
3129         {
3130           expr = TREE_OPERAND (expr, 0);
3131           if (DECL_P (expr))
3132             {
3133               write_expression (expr);
3134               return;
3135             }
3136
3137           code = TREE_CODE (expr);
3138         }
3139
3140       if (code == COMPONENT_REF)
3141         {
3142           tree ob = TREE_OPERAND (expr, 0);
3143
3144           if (TREE_CODE (ob) == ARROW_EXPR)
3145             {
3146               write_string (operator_name_info[(int)code].mangled_name);
3147               ob = TREE_OPERAND (ob, 0);
3148               write_expression (ob);
3149             }
3150           else if (!is_dummy_object (ob))
3151             {
3152               write_string ("dt");
3153               write_expression (ob);
3154             }
3155           /* else, for a non-static data member with no associated object (in
3156              unevaluated context), use the unresolved-name mangling.  */
3157
3158           write_member_name (TREE_OPERAND (expr, 1));
3159           return;
3160         }
3161
3162       /* If it wasn't any of those, recursively expand the expression.  */
3163       name = operator_name_info[(int) code].mangled_name;
3164
3165       /* We used to mangle const_cast and static_cast like a C cast.  */
3166       if (code == CONST_CAST_EXPR
3167           || code == STATIC_CAST_EXPR)
3168         {
3169           if (abi_warn_or_compat_version_crosses (6))
3170             G.need_abi_warning = 1;
3171           if (!abi_version_at_least (6))
3172             name = operator_name_info[CAST_EXPR].mangled_name;
3173         }
3174
3175       if (name == NULL)
3176         {
3177           switch (code)
3178             {
3179             case TRAIT_EXPR:
3180               error ("use of built-in trait %qE in function signature; "
3181                      "use library traits instead", expr);
3182               break;
3183
3184             default:
3185               sorry ("mangling %C", code);
3186               break;
3187             }
3188           return;
3189         }
3190       else
3191         write_string (name);
3192
3193       switch (code)
3194         {
3195         case CALL_EXPR:
3196           {
3197             tree fn = CALL_EXPR_FN (expr);
3198
3199             if (TREE_CODE (fn) == ADDR_EXPR)
3200               fn = TREE_OPERAND (fn, 0);
3201
3202             /* Mangle a dependent name as the name, not whatever happens to
3203                be the first function in the overload set.  */
3204             if ((TREE_CODE (fn) == FUNCTION_DECL
3205                  || TREE_CODE (fn) == OVERLOAD)
3206                 && type_dependent_expression_p_push (expr))
3207               fn = DECL_NAME (get_first_fn (fn));
3208
3209             write_expression (fn);
3210           }
3211
3212           for (i = 0; i < call_expr_nargs (expr); ++i)
3213             write_expression (CALL_EXPR_ARG (expr, i));
3214           write_char ('E');
3215           break;
3216
3217         case CAST_EXPR:
3218           write_type (TREE_TYPE (expr));
3219           if (list_length (TREE_OPERAND (expr, 0)) == 1)
3220             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
3221           else
3222             {
3223               tree args = TREE_OPERAND (expr, 0);
3224               write_char ('_');
3225               for (; args; args = TREE_CHAIN (args))
3226                 write_expression (TREE_VALUE (args));
3227               write_char ('E');
3228             }
3229           break;
3230
3231         case DYNAMIC_CAST_EXPR:
3232         case REINTERPRET_CAST_EXPR:
3233         case STATIC_CAST_EXPR:
3234         case CONST_CAST_EXPR:
3235           write_type (TREE_TYPE (expr));
3236           write_expression (TREE_OPERAND (expr, 0));
3237           break;
3238
3239         case PREINCREMENT_EXPR:
3240         case PREDECREMENT_EXPR:
3241           if (abi_version_at_least (6))
3242             write_char ('_');
3243           if (abi_warn_or_compat_version_crosses (6))
3244             G.need_abi_warning = 1;
3245           /* Fall through.  */
3246
3247         default:
3248           /* In the middle-end, some expressions have more operands than
3249              they do in templates (and mangling).  */
3250           len = cp_tree_operand_length (expr);
3251
3252           for (i = 0; i < len; ++i)
3253             {
3254               tree operand = TREE_OPERAND (expr, i);
3255               /* As a GNU extension, the middle operand of a
3256                  conditional may be omitted.  Since expression
3257                  manglings are supposed to represent the input token
3258                  stream, there's no good way to mangle such an
3259                  expression without extending the C++ ABI.  */
3260               if (code == COND_EXPR && i == 1 && !operand)
3261                 {
3262                   error ("omitted middle operand to %<?:%> operand "
3263                          "cannot be mangled");
3264                   continue;
3265                 }
3266               else if (FOLD_EXPR_P (expr))
3267                 {
3268                   /* The first 'operand' of a fold-expression is the operator
3269                      that it folds over.  */
3270                   if (i == 0)
3271                     {
3272                       int fcode = TREE_INT_CST_LOW (operand);
3273                       write_string (operator_name_info[fcode].mangled_name);
3274                       continue;
3275                     }
3276                   else if (code == BINARY_LEFT_FOLD_EXPR)
3277                     {
3278                       /* The order of operands of the binary left and right
3279                          folds is the same, but we want to mangle them in
3280                          lexical order, i.e. non-pack first.  */
3281                       if (i == 1)
3282                         operand = FOLD_EXPR_INIT (expr);
3283                       else
3284                         operand = FOLD_EXPR_PACK (expr);
3285                     }
3286                   if (PACK_EXPANSION_P (operand))
3287                     operand = PACK_EXPANSION_PATTERN (operand);
3288                 }
3289               write_expression (operand);
3290             }
3291         }
3292     }
3293 }
3294
3295 /* Literal subcase of non-terminal <template-arg>.
3296
3297      "Literal arguments, e.g. "A<42L>", are encoded with their type
3298      and value. Negative integer values are preceded with "n"; for
3299      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
3300      encoded as 0, true as 1."  */
3301
3302 static void
3303 write_template_arg_literal (const tree value)
3304 {
3305   write_char ('L');
3306   write_type (TREE_TYPE (value));
3307
3308   /* Write a null member pointer value as (type)0, regardless of its
3309      real representation.  */
3310   if (null_member_pointer_value_p (value))
3311     write_integer_cst (integer_zero_node);
3312   else
3313     switch (TREE_CODE (value))
3314       {
3315       case CONST_DECL:
3316         write_integer_cst (DECL_INITIAL (value));
3317         break;
3318
3319       case INTEGER_CST:
3320         gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
3321                     || integer_zerop (value) || integer_onep (value));
3322         write_integer_cst (value);
3323         break;
3324
3325       case REAL_CST:
3326         write_real_cst (value);
3327         break;
3328
3329       case COMPLEX_CST:
3330         if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST
3331             && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST)
3332           {
3333             write_integer_cst (TREE_REALPART (value));
3334             write_char ('_');
3335             write_integer_cst (TREE_IMAGPART (value));
3336           }
3337         else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST
3338                  && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST)
3339           {
3340             write_real_cst (TREE_REALPART (value));
3341             write_char ('_');
3342             write_real_cst (TREE_IMAGPART (value));
3343           }
3344         else
3345           gcc_unreachable ();
3346         break;
3347
3348       case STRING_CST:
3349         sorry ("string literal in function template signature");
3350         break;
3351
3352       default:
3353         gcc_unreachable ();
3354       }
3355
3356   write_char ('E');
3357 }
3358
3359 /* Non-terminal <template-arg>.
3360
3361      <template-arg> ::= <type>                          # type
3362                     ::= L <type> </value/ number> E     # literal
3363                     ::= LZ <name> E                     # external name
3364                     ::= X <expression> E                # expression  */
3365
3366 static void
3367 write_template_arg (tree node)
3368 {
3369   enum tree_code code = TREE_CODE (node);
3370
3371   MANGLE_TRACE_TREE ("template-arg", node);
3372
3373   /* A template template parameter's argument list contains TREE_LIST
3374      nodes of which the value field is the actual argument.  */
3375   if (code == TREE_LIST)
3376     {
3377       node = TREE_VALUE (node);
3378       /* If it's a decl, deal with its type instead.  */
3379       if (DECL_P (node))
3380         {
3381           node = TREE_TYPE (node);
3382           code = TREE_CODE (node);
3383         }
3384     }
3385
3386   if (REFERENCE_REF_P (node))
3387     node = TREE_OPERAND (node, 0);
3388   if (TREE_CODE (node) == NOP_EXPR
3389       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
3390     {
3391       /* Template parameters can be of reference type. To maintain
3392          internal consistency, such arguments use a conversion from
3393          address of object to reference type.  */
3394       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
3395       node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
3396     }
3397
3398   if (TREE_CODE (node) == BASELINK
3399       && !type_unknown_p (node))
3400     {
3401       if (abi_version_at_least (6))
3402         node = BASELINK_FUNCTIONS (node);
3403       if (abi_warn_or_compat_version_crosses (6))
3404         /* We wrongly wrapped a class-scope function in X/E.  */
3405         G.need_abi_warning = 1;
3406     }
3407
3408   if (ARGUMENT_PACK_P (node))
3409     {
3410       /* Expand the template argument pack. */
3411       tree args = ARGUMENT_PACK_ARGS (node);
3412       int i, length = TREE_VEC_LENGTH (args);
3413       if (abi_version_at_least (6))
3414         write_char ('J');
3415       else
3416         write_char ('I');
3417       if (abi_warn_or_compat_version_crosses (6))
3418         G.need_abi_warning = 1;
3419       for (i = 0; i < length; ++i)
3420         write_template_arg (TREE_VEC_ELT (args, i));
3421       write_char ('E');
3422     }
3423   else if (TYPE_P (node))
3424     write_type (node);
3425   else if (code == TEMPLATE_DECL)
3426     /* A template appearing as a template arg is a template template arg.  */
3427     write_template_template_arg (node);
3428   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
3429            || code == CONST_DECL
3430            || null_member_pointer_value_p (node))
3431     write_template_arg_literal (node);
3432   else if (DECL_P (node))
3433     {
3434       write_char ('L');
3435       /* Until ABI version 3, the underscore before the mangled name
3436          was incorrectly omitted.  */
3437       if (!abi_version_at_least (3))
3438         write_char ('Z');
3439       else
3440         write_string ("_Z");
3441       if (abi_warn_or_compat_version_crosses (3))
3442         G.need_abi_warning = 1;
3443       write_encoding (node);
3444       write_char ('E');
3445     }
3446   else
3447     {
3448       /* Template arguments may be expressions.  */
3449       write_char ('X');
3450       write_expression (node);
3451       write_char ('E');
3452     }
3453 }
3454
3455 /*  <template-template-arg>
3456                         ::= <name>
3457                         ::= <substitution>  */
3458
3459 static void
3460 write_template_template_arg (const tree decl)
3461 {
3462   MANGLE_TRACE_TREE ("template-template-arg", decl);
3463
3464   if (find_substitution (decl))
3465     return;
3466   write_name (decl, /*ignore_local_scope=*/0);
3467   add_substitution (decl);
3468 }
3469
3470
3471 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
3472
3473      <array-type> ::= A [</dimension/ number>] _ </element/ type>
3474                   ::= A <expression> _ </element/ type>
3475
3476      "Array types encode the dimension (number of elements) and the
3477      element type.  For variable length arrays, the dimension (but not
3478      the '_' separator) is omitted."
3479      Note that for flexible array members, like for other arrays of
3480      unspecified size, the dimension is also omitted.  */
3481
3482 static void
3483 write_array_type (const tree type)
3484 {
3485   write_char ('A');
3486   if (TYPE_DOMAIN (type))
3487     {
3488       tree index_type;
3489
3490       index_type = TYPE_DOMAIN (type);
3491       /* The INDEX_TYPE gives the upper and lower bounds of the array.
3492          It's null for flexible array members which have no upper bound
3493          (this is a change from GCC 5 and prior where such members were
3494          incorrectly mangled as zero-length arrays).  */
3495       if (tree max = TYPE_MAX_VALUE (index_type))
3496         {
3497           if (TREE_CODE (max) == INTEGER_CST)
3498             {
3499               /* The ABI specifies that we should mangle the number of
3500                  elements in the array, not the largest allowed index.  */
3501               offset_int wmax = wi::to_offset (max) + 1;
3502               /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
3503                  number of elements as zero.  */
3504               wmax = wi::zext (wmax, TYPE_PRECISION (TREE_TYPE (max)));
3505               gcc_assert (wi::fits_uhwi_p (wmax));
3506               write_unsigned_number (wmax.to_uhwi ());
3507             }
3508           else
3509             {
3510               max = TREE_OPERAND (max, 0);
3511               write_expression (max);
3512             }
3513         }
3514     }
3515   write_char ('_');
3516   write_type (TREE_TYPE (type));
3517 }
3518
3519 /* Non-terminal <pointer-to-member-type> for pointer-to-member
3520    variables.  TYPE is a pointer-to-member POINTER_TYPE.
3521
3522      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
3523
3524 static void
3525 write_pointer_to_member_type (const tree type)
3526 {
3527   write_char ('M');
3528   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
3529   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
3530 }
3531
3532 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
3533    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3534    TEMPLATE_PARM_INDEX.
3535
3536      <template-param> ::= T </parameter/ number> _  */
3537
3538 static void
3539 write_template_param (const tree parm)
3540 {
3541   int parm_index;
3542
3543   MANGLE_TRACE_TREE ("template-parm", parm);
3544
3545   switch (TREE_CODE (parm))
3546     {
3547     case TEMPLATE_TYPE_PARM:
3548     case TEMPLATE_TEMPLATE_PARM:
3549     case BOUND_TEMPLATE_TEMPLATE_PARM:
3550       parm_index = TEMPLATE_TYPE_IDX (parm);
3551       break;
3552
3553     case TEMPLATE_PARM_INDEX:
3554       parm_index = TEMPLATE_PARM_IDX (parm);
3555       break;
3556
3557     default:
3558       gcc_unreachable ();
3559     }
3560
3561   write_char ('T');
3562   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3563      earliest template param denoted by `_'.  */
3564   write_compact_number (parm_index);
3565 }
3566
3567 /*  <template-template-param>
3568                         ::= <template-param>
3569                         ::= <substitution>  */
3570
3571 static void
3572 write_template_template_param (const tree parm)
3573 {
3574   tree templ = NULL_TREE;
3575
3576   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3577      template template parameter.  The substitution candidate here is
3578      only the template.  */
3579   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
3580     {
3581       templ
3582         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
3583       if (find_substitution (templ))
3584         return;
3585     }
3586
3587   /* <template-param> encodes only the template parameter position,
3588      not its template arguments, which is fine here.  */
3589   write_template_param (parm);
3590   if (templ)
3591     add_substitution (templ);
3592 }
3593
3594 /* Non-terminal <substitution>.
3595
3596       <substitution> ::= S <seq-id> _
3597                      ::= S_  */
3598
3599 static void
3600 write_substitution (const int seq_id)
3601 {
3602   MANGLE_TRACE ("substitution", "");
3603
3604   write_char ('S');
3605   if (seq_id > 0)
3606     write_number (seq_id - 1, /*unsigned=*/1, 36);
3607   write_char ('_');
3608 }
3609
3610 /* Start mangling ENTITY.  */
3611
3612 static inline void
3613 start_mangling (const tree entity)
3614 {
3615   G.entity = entity;
3616   G.need_abi_warning = false;
3617   obstack_free (&name_obstack, name_base);
3618   mangle_obstack = &name_obstack;
3619   name_base = obstack_alloc (&name_obstack, 0);
3620 }
3621
3622 /* Done with mangling. If WARN is true, and the name of G.entity will
3623    be mangled differently in a future version of the ABI, issue a
3624    warning.  */
3625
3626 static void
3627 finish_mangling_internal (void)
3628 {
3629   /* Clear all the substitutions.  */
3630   vec_safe_truncate (G.substitutions, 0);
3631
3632   /* Null-terminate the string.  */
3633   write_char ('\0');
3634 }
3635
3636
3637 /* Like finish_mangling_internal, but return the mangled string.  */
3638
3639 static inline const char *
3640 finish_mangling (void)
3641 {
3642   finish_mangling_internal ();
3643   return (const char *) obstack_finish (mangle_obstack);
3644 }
3645
3646 /* Like finish_mangling_internal, but return an identifier.  */
3647
3648 static tree
3649 finish_mangling_get_identifier (void)
3650 {
3651   finish_mangling_internal ();
3652   /* Don't obstack_finish here, and the next start_mangling will
3653      remove the identifier.  */
3654   return get_identifier ((const char *) obstack_base (mangle_obstack));
3655 }
3656
3657 /* Initialize data structures for mangling.  */
3658
3659 void
3660 init_mangle (void)
3661 {
3662   gcc_obstack_init (&name_obstack);
3663   name_base = obstack_alloc (&name_obstack, 0);
3664   vec_alloc (G.substitutions, 0);
3665
3666   /* Cache these identifiers for quick comparison when checking for
3667      standard substitutions.  */
3668   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
3669   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
3670   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
3671   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
3672   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
3673   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
3674 }
3675
3676 /* Generate the mangled name of DECL.  */
3677
3678 static tree
3679 mangle_decl_string (const tree decl)
3680 {
3681   tree result;
3682   location_t saved_loc = input_location;
3683   tree saved_fn = NULL_TREE;
3684   bool template_p = false;
3685
3686   /* We shouldn't be trying to mangle an uninstantiated template.  */
3687   gcc_assert (!type_dependent_expression_p (decl));
3688
3689   if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3690     {
3691       struct tinst_level *tl = current_instantiation ();
3692       if ((!tl || tl->decl != decl)
3693           && push_tinst_level (decl))
3694         {
3695           template_p = true;
3696           saved_fn = current_function_decl;
3697           current_function_decl = NULL_TREE;
3698         }
3699     }
3700   input_location = DECL_SOURCE_LOCATION (decl);
3701
3702   start_mangling (decl);
3703
3704   if (TREE_CODE (decl) == TYPE_DECL)
3705     write_type (TREE_TYPE (decl));
3706   else
3707     write_mangled_name (decl, true);
3708
3709   result = finish_mangling_get_identifier ();
3710   if (DEBUG_MANGLE)
3711     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
3712              IDENTIFIER_POINTER (result));
3713
3714   if (template_p)
3715     {
3716       pop_tinst_level ();
3717       current_function_decl = saved_fn;
3718     }
3719   input_location = saved_loc;
3720
3721   return result;
3722 }
3723
3724 /* Return an identifier for the external mangled name of DECL.  */
3725
3726 static tree
3727 get_mangled_id (tree decl)
3728 {
3729   tree id = mangle_decl_string (decl);
3730   return targetm.mangle_decl_assembler_name (decl, id);
3731 }
3732
3733 /* If DECL is an implicit mangling alias, return its symtab node; otherwise
3734    return NULL.  */
3735
3736 static symtab_node *
3737 decl_implicit_alias_p (tree decl)
3738 {
3739   if (DECL_P (decl) && DECL_ARTIFICIAL (decl)
3740       && DECL_IGNORED_P (decl)
3741       && (TREE_CODE (decl) == FUNCTION_DECL
3742           || (VAR_P (decl) && TREE_STATIC (decl))))
3743     {
3744       symtab_node *n = symtab_node::get (decl);
3745       if (n && n->cpp_implicit_alias)
3746         return n;
3747     }
3748   return NULL;
3749 }
3750
3751 /* If DECL is a mangling alias, remove it from the symbol table and return
3752    true; otherwise return false.  */
3753
3754 bool
3755 maybe_remove_implicit_alias (tree decl)
3756 {
3757   if (symtab_node *n = decl_implicit_alias_p (decl))
3758     {
3759       n->remove();
3760       return true;
3761     }
3762   return false;
3763 }
3764
3765 /* Create an identifier for the external mangled name of DECL.  */
3766
3767 void
3768 mangle_decl (const tree decl)
3769 {
3770   tree id;
3771   bool dep;
3772
3773   /* Don't bother mangling uninstantiated templates.  */
3774   ++processing_template_decl;
3775   if (TREE_CODE (decl) == TYPE_DECL)
3776     dep = dependent_type_p (TREE_TYPE (decl));
3777   else
3778     dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
3779            && any_dependent_template_arguments_p (DECL_TI_ARGS (decl)));
3780   --processing_template_decl;
3781   if (dep)
3782     return;
3783
3784   /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
3785      It is not needed to assign names to anonymous namespace, but we use the
3786      "<anon>" marker to be able to tell if type is C++ ODR type or type
3787      produced by other language.  */
3788   if (TREE_CODE (decl) == TYPE_DECL
3789       && TYPE_STUB_DECL (TREE_TYPE (decl))
3790       && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl))))
3791     id = get_identifier ("<anon>");
3792   else
3793     {
3794       gcc_assert (TREE_CODE (decl) != TYPE_DECL
3795                   || !no_linkage_check (TREE_TYPE (decl), true));
3796       if (abi_version_at_least (10))
3797         if (tree fn = decl_function_context (decl))
3798           maybe_check_abi_tags (fn, decl);
3799       id = get_mangled_id (decl);
3800     }
3801   SET_DECL_ASSEMBLER_NAME (decl, id);
3802
3803   if (id != DECL_NAME (decl)
3804       /* Don't do this for a fake symbol we aren't going to emit anyway.  */
3805       && TREE_CODE (decl) != TYPE_DECL
3806       && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
3807       && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3808     {
3809       int save_ver = flag_abi_version;
3810       tree id2 = NULL_TREE;
3811
3812       if (!DECL_REALLY_EXTERN (decl))
3813         {
3814           bool set = false;
3815
3816           /* Check IDENTIFIER_GLOBAL_VALUE before setting to avoid redundant
3817              errors from multiple definitions.  */
3818           tree d = IDENTIFIER_GLOBAL_VALUE (id);
3819           if (!d || decl_implicit_alias_p (d))
3820             {
3821               set = true;
3822               SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3823             }
3824
3825           if (!G.need_abi_warning)
3826             return;
3827
3828           /* If the mangling will change in the future, emit an alias with the
3829              future mangled name for forward-compatibility.  */
3830           if (!set)
3831             {
3832               SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3833               inform (DECL_SOURCE_LOCATION (decl), "a later -fabi-version= (or "
3834                       "=0) avoids this error with a change in mangling");
3835             }
3836
3837           flag_abi_version = flag_abi_compat_version;
3838           id2 = mangle_decl_string (decl);
3839           id2 = targetm.mangle_decl_assembler_name (decl, id2);
3840           flag_abi_version = save_ver;
3841
3842           if (id2 != id)
3843             note_mangling_alias (decl, id2);
3844         }
3845
3846       if (warn_abi)
3847         {
3848           if (flag_abi_compat_version != warn_abi_version
3849               || id2 == NULL_TREE)
3850             {
3851               flag_abi_version = warn_abi_version;
3852               id2 = mangle_decl_string (decl);
3853               id2 = targetm.mangle_decl_assembler_name (decl, id2);
3854             }
3855           flag_abi_version = save_ver;
3856
3857           if (id2 == id)
3858             /* OK.  */;
3859           else if (warn_abi_version != 0
3860                    && abi_version_at_least (warn_abi_version))
3861             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
3862                         "the mangled name of %qD changed between "
3863                         "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3864                         G.entity, warn_abi_version, id2,
3865                         save_ver, id);
3866           else
3867             warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
3868                         "the mangled name of %qD changes between "
3869                         "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3870                         G.entity, save_ver, id,
3871                         warn_abi_version, id2);
3872         }
3873
3874       flag_abi_version = save_ver;
3875     }
3876 }
3877
3878 /* Generate the mangled representation of TYPE.  */
3879
3880 const char *
3881 mangle_type_string (const tree type)
3882 {
3883   const char *result;
3884
3885   start_mangling (type);
3886   write_type (type);
3887   result = finish_mangling ();
3888   if (DEBUG_MANGLE)
3889     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
3890   return result;
3891 }
3892
3893 /* Create an identifier for the mangled name of a special component
3894    for belonging to TYPE.  CODE is the ABI-specified code for this
3895    component.  */
3896
3897 static tree
3898 mangle_special_for_type (const tree type, const char *code)
3899 {
3900   tree result;
3901
3902   /* We don't have an actual decl here for the special component, so
3903      we can't just process the <encoded-name>.  Instead, fake it.  */
3904   start_mangling (type);
3905
3906   /* Start the mangling.  */
3907   write_string ("_Z");
3908   write_string (code);
3909
3910   /* Add the type.  */
3911   write_type (type);
3912   result = finish_mangling_get_identifier ();
3913
3914   if (DEBUG_MANGLE)
3915     fprintf (stderr, "mangle_special_for_type = %s\n\n",
3916              IDENTIFIER_POINTER (result));
3917
3918   return result;
3919 }
3920
3921 /* Create an identifier for the mangled representation of the typeinfo
3922    structure for TYPE.  */
3923
3924 tree
3925 mangle_typeinfo_for_type (const tree type)
3926 {
3927   return mangle_special_for_type (type, "TI");
3928 }
3929
3930 /* Create an identifier for the mangled name of the NTBS containing
3931    the mangled name of TYPE.  */
3932
3933 tree
3934 mangle_typeinfo_string_for_type (const tree type)
3935 {
3936   return mangle_special_for_type (type, "TS");
3937 }
3938
3939 /* Create an identifier for the mangled name of the vtable for TYPE.  */
3940
3941 tree
3942 mangle_vtbl_for_type (const tree type)
3943 {
3944   return mangle_special_for_type (type, "TV");
3945 }
3946
3947 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
3948
3949 tree
3950 mangle_vtt_for_type (const tree type)
3951 {
3952   return mangle_special_for_type (type, "TT");
3953 }
3954
3955 /* Return an identifier for a construction vtable group.  TYPE is
3956    the most derived class in the hierarchy; BINFO is the base
3957    subobject for which this construction vtable group will be used.
3958
3959    This mangling isn't part of the ABI specification; in the ABI
3960    specification, the vtable group is dumped in the same COMDAT as the
3961    main vtable, and is referenced only from that vtable, so it doesn't
3962    need an external name.  For binary formats without COMDAT sections,
3963    though, we need external names for the vtable groups.
3964
3965    We use the production
3966
3967     <special-name> ::= CT <type> <offset number> _ <base type>  */
3968
3969 tree
3970 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
3971 {
3972   tree result;
3973
3974   start_mangling (type);
3975
3976   write_string ("_Z");
3977   write_string ("TC");
3978   write_type (type);
3979   write_integer_cst (BINFO_OFFSET (binfo));
3980   write_char ('_');
3981   write_type (BINFO_TYPE (binfo));
3982
3983   result = finish_mangling_get_identifier ();
3984   if (DEBUG_MANGLE)
3985     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
3986              IDENTIFIER_POINTER (result));
3987   return result;
3988 }
3989
3990 /* Mangle a this pointer or result pointer adjustment.
3991
3992    <call-offset> ::= h <fixed offset number> _
3993                  ::= v <fixed offset number> _ <virtual offset number> _ */
3994
3995 static void
3996 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
3997 {
3998   write_char (virtual_offset ? 'v' : 'h');
3999
4000   /* For either flavor, write the fixed offset.  */
4001   write_integer_cst (fixed_offset);
4002   write_char ('_');
4003
4004   /* For a virtual thunk, add the virtual offset.  */
4005   if (virtual_offset)
4006     {
4007       write_integer_cst (virtual_offset);
4008       write_char ('_');
4009     }
4010 }
4011
4012 /* Return an identifier for the mangled name of a this-adjusting or
4013    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
4014    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
4015    is a virtual thunk, and it is the vtbl offset in
4016    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
4017    zero for a covariant thunk. Note, that FN_DECL might be a covariant
4018    thunk itself. A covariant thunk name always includes the adjustment
4019    for the this pointer, even if there is none.
4020
4021    <special-name> ::= T <call-offset> <base encoding>
4022                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
4023                                         <base encoding>  */
4024
4025 tree
4026 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
4027               tree virtual_offset)
4028 {
4029   tree result;
4030
4031   start_mangling (fn_decl);
4032
4033   write_string ("_Z");
4034   write_char ('T');
4035
4036   if (!this_adjusting)
4037     {
4038       /* Covariant thunk with no this adjustment */
4039       write_char ('c');
4040       mangle_call_offset (integer_zero_node, NULL_TREE);
4041       mangle_call_offset (fixed_offset, virtual_offset);
4042     }
4043   else if (!DECL_THUNK_P (fn_decl))
4044     /* Plain this adjusting thunk.  */
4045     mangle_call_offset (fixed_offset, virtual_offset);
4046   else
4047     {
4048       /* This adjusting thunk to covariant thunk.  */
4049       write_char ('c');
4050       mangle_call_offset (fixed_offset, virtual_offset);
4051       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
4052       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
4053       if (virtual_offset)
4054         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
4055       mangle_call_offset (fixed_offset, virtual_offset);
4056       fn_decl = THUNK_TARGET (fn_decl);
4057     }
4058
4059   /* Scoped name.  */
4060   write_encoding (fn_decl);
4061
4062   result = finish_mangling_get_identifier ();
4063   if (DEBUG_MANGLE)
4064     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
4065   return result;
4066 }
4067
4068 struct conv_type_hasher : ggc_ptr_hash<tree_node>
4069 {
4070   static hashval_t hash (tree);
4071   static bool equal (tree, tree);
4072 };
4073
4074 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
4075    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
4076    TYPE.  */
4077
4078 static GTY (()) hash_table<conv_type_hasher> *conv_type_names;
4079
4080 /* Hash a node (VAL1) in the table.  */
4081
4082 hashval_t
4083 conv_type_hasher::hash (tree val)
4084 {
4085   return (hashval_t) TYPE_UID (TREE_TYPE (val));
4086 }
4087
4088 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
4089
4090 bool
4091 conv_type_hasher::equal (tree val1, tree val2)
4092 {
4093   return TREE_TYPE (val1) == val2;
4094 }
4095
4096 /* Return an identifier for the mangled unqualified name for a
4097    conversion operator to TYPE.  This mangling is not specified by the
4098    ABI spec; it is only used internally.  */
4099
4100 tree
4101 mangle_conv_op_name_for_type (const tree type)
4102 {
4103   tree *slot;
4104   tree identifier;
4105
4106   if (type == error_mark_node)
4107     return error_mark_node;
4108
4109   if (conv_type_names == NULL)
4110     conv_type_names = hash_table<conv_type_hasher>::create_ggc (31);
4111
4112   slot = conv_type_names->find_slot_with_hash (type,
4113                                                (hashval_t) TYPE_UID (type),
4114                                                INSERT);
4115   identifier = *slot;
4116   if (!identifier)
4117     {
4118       char buffer[64];
4119
4120        /* Create a unique name corresponding to TYPE.  */
4121       sprintf (buffer, "operator %lu",
4122                (unsigned long) conv_type_names->elements ());
4123       identifier = get_identifier (buffer);
4124       *slot = identifier;
4125
4126       /* Hang TYPE off the identifier so it can be found easily later
4127          when performing conversions.  */
4128       TREE_TYPE (identifier) = type;
4129
4130       /* Set bits on the identifier so we know later it's a conversion.  */
4131       IDENTIFIER_OPNAME_P (identifier) = 1;
4132       IDENTIFIER_TYPENAME_P (identifier) = 1;
4133     }
4134
4135   return identifier;
4136 }
4137
4138 /* Handle ABI backwards compatibility for past bugs where we didn't call
4139    check_abi_tags in places where it's needed: call check_abi_tags and warn if
4140    it makes a difference.  If FOR_DECL is non-null, it's the declaration
4141    that we're actually trying to mangle; if it's null, we're mangling the
4142    guard variable for T.  */
4143
4144 static void
4145 maybe_check_abi_tags (tree t, tree for_decl)
4146 {
4147   if (DECL_ASSEMBLER_NAME_SET_P (t))
4148     return;
4149
4150   tree oldtags = get_abi_tags (t);
4151
4152   mangle_decl (t);
4153
4154   tree newtags = get_abi_tags (t);
4155   if (newtags && newtags != oldtags
4156       && abi_version_crosses (10))
4157     {
4158       if (for_decl)
4159         warning_at (DECL_SOURCE_LOCATION (for_decl), OPT_Wabi,
4160                     "the mangled name of %qD changes between "
4161                     "-fabi-version=%d and -fabi-version=%d",
4162                     for_decl, flag_abi_version, warn_abi_version);
4163       else
4164         warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
4165                     "the mangled name of the initialization guard variable for"
4166                     "%qD changes between -fabi-version=%d and -fabi-version=%d",
4167                     t, flag_abi_version, warn_abi_version);
4168     }
4169 }
4170
4171 /* Write out the appropriate string for this variable when generating
4172    another mangled name based on this one.  */
4173
4174 static void
4175 write_guarded_var_name (const tree variable)
4176 {
4177   if (DECL_NAME (variable)
4178       && strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
4179     /* The name of a guard variable for a reference temporary should refer
4180        to the reference, not the temporary.  */
4181     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
4182   else
4183     write_name (variable, /*ignore_local_scope=*/0);
4184 }
4185
4186 /* Return an identifier for the name of an initialization guard
4187    variable for indicated VARIABLE.  */
4188
4189 tree
4190 mangle_guard_variable (const tree variable)
4191 {
4192   if (abi_version_at_least (10))
4193     maybe_check_abi_tags (variable);
4194   start_mangling (variable);
4195   write_string ("_ZGV");
4196   write_guarded_var_name (variable);
4197   return finish_mangling_get_identifier ();
4198 }
4199
4200 /* Return an identifier for the name of a thread_local initialization
4201    function for VARIABLE.  */
4202
4203 tree
4204 mangle_tls_init_fn (const tree variable)
4205 {
4206   start_mangling (variable);
4207   write_string ("_ZTH");
4208   write_guarded_var_name (variable);
4209   return finish_mangling_get_identifier ();
4210 }
4211
4212 /* Return an identifier for the name of a thread_local wrapper
4213    function for VARIABLE.  */
4214
4215 #define TLS_WRAPPER_PREFIX "_ZTW"
4216
4217 tree
4218 mangle_tls_wrapper_fn (const tree variable)
4219 {
4220   start_mangling (variable);
4221   write_string (TLS_WRAPPER_PREFIX);
4222   write_guarded_var_name (variable);
4223   return finish_mangling_get_identifier ();
4224 }
4225
4226 /* Return true iff FN is a thread_local wrapper function.  */
4227
4228 bool
4229 decl_tls_wrapper_p (const tree fn)
4230 {
4231   if (TREE_CODE (fn) != FUNCTION_DECL)
4232     return false;
4233   tree name = DECL_NAME (fn);
4234   return strncmp (IDENTIFIER_POINTER (name), TLS_WRAPPER_PREFIX,
4235                   strlen (TLS_WRAPPER_PREFIX)) == 0;
4236 }
4237
4238 /* Return an identifier for the name of a temporary variable used to
4239    initialize a static reference.  This isn't part of the ABI, but we might
4240    as well call them something readable.  */
4241
4242 static GTY(()) int temp_count;
4243
4244 tree
4245 mangle_ref_init_variable (const tree variable)
4246 {
4247   start_mangling (variable);
4248   write_string ("_ZGR");
4249   check_abi_tags (variable);
4250   write_name (variable, /*ignore_local_scope=*/0);
4251   /* Avoid name clashes with aggregate initialization of multiple
4252      references at once.  */
4253   write_unsigned_number (temp_count++);
4254   return finish_mangling_get_identifier ();
4255 }
4256 \f
4257
4258 /* Foreign language type mangling section.  */
4259
4260 /* How to write the type codes for the integer Java type.  */
4261
4262 static void
4263 write_java_integer_type_codes (const tree type)
4264 {
4265   if (type == java_int_type_node)
4266     write_char ('i');
4267   else if (type == java_short_type_node)
4268     write_char ('s');
4269   else if (type == java_byte_type_node)
4270     write_char ('c');
4271   else if (type == java_char_type_node)
4272     write_char ('w');
4273   else if (type == java_long_type_node)
4274     write_char ('x');
4275   else if (type == java_boolean_type_node)
4276     write_char ('b');
4277   else
4278     gcc_unreachable ();
4279 }
4280
4281 /* Given a CLASS_TYPE, such as a record for std::bad_exception this
4282    function generates a mangled name for the vtable map variable of
4283    the class type.  For example, if the class type is
4284    "std::bad_exception", the mangled name for the class is
4285    "St13bad_exception".  This function would generate the name
4286    "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
4287    "_VTV<std::bad_exception>::__vtable_map".  */
4288
4289
4290 char *
4291 get_mangled_vtable_map_var_name (tree class_type)
4292 {
4293   char *var_name = NULL;
4294   const char *prefix = "_ZN4_VTVI";
4295   const char *postfix = "E12__vtable_mapE";
4296
4297   gcc_assert (TREE_CODE (class_type) == RECORD_TYPE);
4298
4299   tree class_id = DECL_ASSEMBLER_NAME (TYPE_NAME (class_type));
4300
4301   if (strstr (IDENTIFIER_POINTER (class_id), "<anon>") != NULL)
4302     {
4303       class_id = get_mangled_id (TYPE_NAME (class_type));
4304       vtbl_register_mangled_name (TYPE_NAME (class_type), class_id);
4305     }
4306
4307   unsigned int len = strlen (IDENTIFIER_POINTER (class_id)) +
4308                      strlen (prefix) +
4309                      strlen (postfix) + 1;
4310
4311   var_name = (char *) xmalloc (len);
4312
4313   sprintf (var_name, "%s%s%s", prefix, IDENTIFIER_POINTER (class_id), postfix);
4314
4315   return var_name;
4316 }
4317
4318 #include "gt-cp-mangle.h"