gcc/cp/mangle.c

   1 /* Name mangling for the 3.0 C++ ABI.
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4    Written by Alex Samuel <samuel@codesourcery.com>
   5
   6    This file is part of GCC.
   7
   8    GCC is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    GCC is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 /* This file implements mangling of C++ names according to the IA64
  23    C++ ABI specification.  A mangled name encodes a function or
  24    variable's name, scope, type, and/or template arguments into a text
  25    identifier.  This identifier is used as the function's or
  26    variable's linkage name, to preserve compatibility between C++'s
  27    language features (templates, scoping, and overloading) and C
  28    linkers.
  29
  30    Additionally, g++ uses mangled names internally.  To support this,
  31    mangling of types is allowed, even though the mangled name of a
  32    type should not appear by itself as an exported name.  Ditto for
  33    uninstantiated templates.
  34
  35    The primary entry point for this module is mangle_decl, which
  36    returns an identifier containing the mangled name for a decl.
  37    Additional entry points are provided to build mangled names of
  38    particular constructs when the appropriate decl for that construct
  39    is not available.  These are:
  40
  41      mangle_typeinfo_for_type:          typeinfo data
  42      mangle_typeinfo_string_for_type:   typeinfo type name
  43      mangle_vtbl_for_type:              virtual table data
  44      mangle_vtt_for_type:               VTT data
  45      mangle_ctor_vtbl_for_type:         `C-in-B' constructor virtual table data
  46      mangle_thunk:                      thunk function or entry  */
  47
  48 #include "config.h"
  49 #include "system.h"
  50 #include "coretypes.h"
  51 #include "tm.h"
  52 #include "tree.h"
  53 #include "tm_p.h"
  54 #include "cp-tree.h"
  55 #include "obstack.h"
  56 #include "flags.h"
  57 #include "target.h"
  58 #include "cgraph.h"
  59
  60 /* Debugging support.  */
  61
  62 /* Define DEBUG_MANGLE to enable very verbose trace messages.  */
  63 #ifndef DEBUG_MANGLE
  64 #define DEBUG_MANGLE 0
  65 #endif
  66
  67 /* Macros for tracing the write_* functions.  */
  68 #if DEBUG_MANGLE
  69 # define MANGLE_TRACE(FN, INPUT) \
  70   fprintf (stderr, "  %-24s: %-24s\n", (FN), (INPUT))
  71 # define MANGLE_TRACE_TREE(FN, NODE) \
  72   fprintf (stderr, "  %-24s: %-24s (%p)\n", \
  73            (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE))
  74 #else
  75 # define MANGLE_TRACE(FN, INPUT)
  76 # define MANGLE_TRACE_TREE(FN, NODE)
  77 #endif
  78
  79 /* Nonzero if NODE is a class template-id.  We can't rely on
  80    CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
  81    that hard to distinguish A<T> from A, where A<T> is the type as
  82    instantiated outside of the template, and A is the type used
  83    without parameters inside the template.  */
  84 #define CLASSTYPE_TEMPLATE_ID_P(NODE)                                   \
  85   (TYPE_LANG_SPECIFIC (NODE) != NULL                                    \
  86    && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM                 \
  87        || (CLASSTYPE_TEMPLATE_INFO (NODE) != NULL                       \
  88            && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))))
  89
  90 /* Things we only need one of.  This module is not reentrant.  */
  91 typedef struct GTY(()) globals {
  92   /* An array of the current substitution candidates, in the order
  93      we've seen them.  */
  94   VEC(tree,gc) *substitutions;
  95
  96   /* The entity that is being mangled.  */
  97   tree GTY ((skip)) entity;
  98
  99   /* How many parameter scopes we are inside.  */
 100   int parm_depth;
 101
 102   /* True if the mangling will be different in a future version of the
 103      ABI.  */
 104   bool need_abi_warning;
 105 } globals;
 106
 107 static GTY (()) globals G;
 108
 109 /* The obstack on which we build mangled names.  */
 110 static struct obstack *mangle_obstack;
 111
 112 /* The obstack on which we build mangled names that are not going to
 113    be IDENTIFIER_NODEs.  */
 114 static struct obstack name_obstack;
 115
 116 /* The first object on the name_obstack; we use this to free memory
 117    allocated on the name_obstack.  */
 118 static void *name_base;
 119
 120 /* Indices into subst_identifiers.  These are identifiers used in
 121    special substitution rules.  */
 122 typedef enum
 123 {
 124   SUBID_ALLOCATOR,
 125   SUBID_BASIC_STRING,
 126   SUBID_CHAR_TRAITS,
 127   SUBID_BASIC_ISTREAM,
 128   SUBID_BASIC_OSTREAM,
 129   SUBID_BASIC_IOSTREAM,
 130   SUBID_MAX
 131 }
 132 substitution_identifier_index_t;
 133
 134 /* For quick substitution checks, look up these common identifiers
 135    once only.  */
 136 static GTY(()) tree subst_identifiers[SUBID_MAX];
 137
 138 /* Single-letter codes for builtin integer types, defined in
 139    <builtin-type>.  These are indexed by integer_type_kind values.  */
 140 static const char
 141 integer_type_codes[itk_none] =
 142 {
 143   'c',  /* itk_char */
 144   'a',  /* itk_signed_char */
 145   'h',  /* itk_unsigned_char */
 146   's',  /* itk_short */
 147   't',  /* itk_unsigned_short */
 148   'i',  /* itk_int */
 149   'j',  /* itk_unsigned_int */
 150   'l',  /* itk_long */
 151   'm',  /* itk_unsigned_long */
 152   'x',  /* itk_long_long */
 153   'y',  /* itk_unsigned_long_long */
 154   'n',  /* itk_int128 */
 155   'o',  /* itk_unsigned_int128  */
 156 };
 157
 158 static int decl_is_template_id (const tree, tree* const);
 159
 160 /* Functions for handling substitutions.  */
 161
 162 static inline tree canonicalize_for_substitution (tree);
 163 static void add_substitution (tree);
 164 static inline int is_std_substitution (const tree,
 165                                        const substitution_identifier_index_t);
 166 static inline int is_std_substitution_char (const tree,
 167                                             const substitution_identifier_index_t);
 168 static int find_substitution (tree);
 169 static void mangle_call_offset (const tree, const tree);
 170
 171 /* Functions for emitting mangled representations of things.  */
 172
 173 static void write_mangled_name (const tree, bool);
 174 static void write_encoding (const tree);
 175 static void write_name (tree, const int);
 176 static void write_unscoped_name (const tree);
 177 static void write_unscoped_template_name (const tree);
 178 static void write_nested_name (const tree);
 179 static void write_prefix (const tree);
 180 static void write_template_prefix (const tree);
 181 static void write_unqualified_name (const tree);
 182 static void write_conversion_operator_name (const tree);
 183 static void write_source_name (tree);
 184 static void write_unnamed_type_name (const tree);
 185 static void write_closure_type_name (const tree);
 186 static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
 187                            const unsigned int);
 188 static void write_number (unsigned HOST_WIDE_INT, const int,
 189                           const unsigned int);
 190 static void write_compact_number (int num);
 191 static void write_integer_cst (const tree);
 192 static void write_real_cst (const tree);
 193 static void write_identifier (const char *);
 194 static void write_special_name_constructor (const tree);
 195 static void write_special_name_destructor (const tree);
 196 static void write_type (tree);
 197 static int write_CV_qualifiers_for_type (const tree);
 198 static void write_builtin_type (tree);
 199 static void write_function_type (const tree);
 200 static void write_bare_function_type (const tree, const int, const tree);
 201 static void write_method_parms (tree, const int, const tree);
 202 static void write_class_enum_type (const tree);
 203 static void write_template_args (tree);
 204 static void write_expression (tree);
 205 static void write_template_arg_literal (const tree);
 206 static void write_template_arg (tree);
 207 static void write_template_template_arg (const tree);
 208 static void write_array_type (const tree);
 209 static void write_pointer_to_member_type (const tree);
 210 static void write_template_param (const tree);
 211 static void write_template_template_param (const tree);
 212 static void write_substitution (const int);
 213 static int discriminator_for_local_entity (tree);
 214 static int discriminator_for_string_literal (tree, tree);
 215 static void write_discriminator (const int);
 216 static void write_local_name (tree, const tree, const tree);
 217 static void dump_substitution_candidates (void);
 218 static tree mangle_decl_string (const tree);
 219 static int local_class_index (tree);
 220
 221 /* Control functions.  */
 222
 223 static inline void start_mangling (const tree);
 224 static inline const char *finish_mangling (const bool);
 225 static tree mangle_special_for_type (const tree, const char *);
 226
 227 /* Foreign language functions.  */
 228
 229 static void write_java_integer_type_codes (const tree);
 230
 231 /* Append a single character to the end of the mangled
 232    representation.  */
 233 #define write_char(CHAR)                                                \
 234   obstack_1grow (mangle_obstack, (CHAR))
 235
 236 /* Append a sized buffer to the end of the mangled representation.  */
 237 #define write_chars(CHAR, LEN)                                          \
 238   obstack_grow (mangle_obstack, (CHAR), (LEN))
 239
 240 /* Append a NUL-terminated string to the end of the mangled
 241    representation.  */
 242 #define write_string(STRING)                                            \
 243   obstack_grow (mangle_obstack, (STRING), strlen (STRING))
 244
 245 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
 246    same purpose (context, which may be a type) and value (template
 247    decl).  See write_template_prefix for more information on what this
 248    is used for.  */
 249 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2)                             \
 250   (TREE_CODE (NODE1) == TREE_LIST                                       \
 251    && TREE_CODE (NODE2) == TREE_LIST                                    \
 252    && ((TYPE_P (TREE_PURPOSE (NODE1))                                   \
 253         && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2)))    \
 254        || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2))                 \
 255    && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
 256
 257 /* Write out an unsigned quantity in base 10.  */
 258 #define write_unsigned_number(NUMBER)                                   \
 259   write_number ((NUMBER), /*unsigned_p=*/1, 10)
 260
 261 /* If DECL is a template instance, return nonzero and, if
 262    TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
 263    Otherwise return zero.  */
 264
 265 static int
 266 decl_is_template_id (const tree decl, tree* const template_info)
 267 {
 268   if (TREE_CODE (decl) == TYPE_DECL)
 269     {
 270       /* TYPE_DECLs are handled specially.  Look at its type to decide
 271          if this is a template instantiation.  */
 272       const tree type = TREE_TYPE (decl);
 273
 274       if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
 275         {
 276           if (template_info != NULL)
 277             /* For a templated TYPE_DECL, the template info is hanging
 278                off the type.  */
 279             *template_info = TYPE_TEMPLATE_INFO (type);
 280           return 1;
 281         }
 282     }
 283   else
 284     {
 285       /* Check if this is a primary template.  */
 286       if (DECL_LANG_SPECIFIC (decl) != NULL
 287           && DECL_USE_TEMPLATE (decl)
 288           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
 289           && TREE_CODE (decl) != TEMPLATE_DECL)
 290         {
 291           if (template_info != NULL)
 292             /* For most templated decls, the template info is hanging
 293                off the decl.  */
 294             *template_info = DECL_TEMPLATE_INFO (decl);
 295           return 1;
 296         }
 297     }
 298
 299   /* It's not a template id.  */
 300   return 0;
 301 }
 302
 303 /* Produce debugging output of current substitution candidates.  */
 304
 305 static void
 306 dump_substitution_candidates (void)
 307 {
 308   unsigned i;
 309   tree el;
 310
 311   fprintf (stderr, "  ++ substitutions  ");
 312   FOR_EACH_VEC_ELT (tree, G.substitutions, i, el)
 313     {
 314       const char *name = "???";
 315
 316       if (i > 0)
 317         fprintf (stderr, "                    ");
 318       if (DECL_P (el))
 319         name = IDENTIFIER_POINTER (DECL_NAME (el));
 320       else if (TREE_CODE (el) == TREE_LIST)
 321         name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
 322       else if (TYPE_NAME (el))
 323         name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el)));
 324       fprintf (stderr, " S%d_ = ", i - 1);
 325       if (TYPE_P (el) &&
 326           (CP_TYPE_RESTRICT_P (el)
 327            || CP_TYPE_VOLATILE_P (el)
 328            || CP_TYPE_CONST_P (el)))
 329         fprintf (stderr, "CV-");
 330       fprintf (stderr, "%s (%s at %p)\n",
 331                name, tree_code_name[TREE_CODE (el)], (void *) el);
 332     }
 333 }
 334
 335 /* Both decls and types can be substitution candidates, but sometimes
 336    they refer to the same thing.  For instance, a TYPE_DECL and
 337    RECORD_TYPE for the same class refer to the same thing, and should
 338    be treated accordingly in substitutions.  This function returns a
 339    canonicalized tree node representing NODE that is used when adding
 340    and substitution candidates and finding matches.  */
 341
 342 static inline tree
 343 canonicalize_for_substitution (tree node)
 344 {
 345   /* For a TYPE_DECL, use the type instead.  */
 346   if (TREE_CODE (node) == TYPE_DECL)
 347     node = TREE_TYPE (node);
 348   if (TYPE_P (node)
 349       && TYPE_CANONICAL (node) != node
 350       && TYPE_MAIN_VARIANT (node) != node)
 351     {
 352       /* Here we want to strip the topmost typedef only.
 353          We need to do that so is_std_substitution can do proper
 354          name matching.  */
 355       if (TREE_CODE (node) == FUNCTION_TYPE)
 356         /* Use build_qualified_type and TYPE_QUALS here to preserve
 357            the old buggy mangling of attribute noreturn with abi<5.  */
 358         node = build_qualified_type (TYPE_MAIN_VARIANT (node),
 359                                      TYPE_QUALS (node));
 360       else
 361         node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node),
 362                                         cp_type_quals (node));
 363     }
 364   return node;
 365 }
 366
 367 /* Add NODE as a substitution candidate.  NODE must not already be on
 368    the list of candidates.  */
 369
 370 static void
 371 add_substitution (tree node)
 372 {
 373   tree c;
 374
 375   if (DEBUG_MANGLE)
 376     fprintf (stderr, "  ++ add_substitution (%s at %10p)\n",
 377              tree_code_name[TREE_CODE (node)], (void *) node);
 378
 379   /* Get the canonicalized substitution candidate for NODE.  */
 380   c = canonicalize_for_substitution (node);
 381   if (DEBUG_MANGLE && c != node)
 382     fprintf (stderr, "  ++ using candidate (%s at %10p)\n",
 383              tree_code_name[TREE_CODE (node)], (void *) node);
 384   node = c;
 385
 386 #if ENABLE_CHECKING
 387   /* Make sure NODE isn't already a candidate.  */
 388   {
 389     int i;
 390     tree candidate;
 391
 392     FOR_EACH_VEC_ELT (tree, G.substitutions, i, candidate)
 393       {
 394         gcc_assert (!(DECL_P (node) && node == candidate));
 395         gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
 396                       && same_type_p (node, candidate)));
 397       }
 398   }
 399 #endif /* ENABLE_CHECKING */
 400
 401   /* Put the decl onto the varray of substitution candidates.  */
 402   VEC_safe_push (tree, gc, G.substitutions, node);
 403
 404   if (DEBUG_MANGLE)
 405     dump_substitution_candidates ();
 406 }
 407
 408 /* Helper function for find_substitution.  Returns nonzero if NODE,
 409    which may be a decl or a CLASS_TYPE, is a template-id with template
 410    name of substitution_index[INDEX] in the ::std namespace.  */
 411
 412 static inline int
 413 is_std_substitution (const tree node,
 414                      const substitution_identifier_index_t index)
 415 {
 416   tree type = NULL;
 417   tree decl = NULL;
 418
 419   if (DECL_P (node))
 420     {
 421       type = TREE_TYPE (node);
 422       decl = node;
 423     }
 424   else if (CLASS_TYPE_P (node))
 425     {
 426       type = node;
 427       decl = TYPE_NAME (node);
 428     }
 429   else
 430     /* These are not the droids you're looking for.  */
 431     return 0;
 432
 433   return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
 434           && TYPE_LANG_SPECIFIC (type)
 435           && TYPE_TEMPLATE_INFO (type)
 436           && (DECL_NAME (TYPE_TI_TEMPLATE (type))
 437               == subst_identifiers[index]));
 438 }
 439
 440 /* Helper function for find_substitution.  Returns nonzero if NODE,
 441    which may be a decl or a CLASS_TYPE, is the template-id
 442    ::std::identifier<char>, where identifier is
 443    substitution_index[INDEX].  */
 444
 445 static inline int
 446 is_std_substitution_char (const tree node,
 447                           const substitution_identifier_index_t index)
 448 {
 449   tree args;
 450   /* Check NODE's name is ::std::identifier.  */
 451   if (!is_std_substitution (node, index))
 452     return 0;
 453   /* Figure out its template args.  */
 454   if (DECL_P (node))
 455     args = DECL_TI_ARGS (node);
 456   else if (CLASS_TYPE_P (node))
 457     args = CLASSTYPE_TI_ARGS (node);
 458   else
 459     /* Oops, not a template.  */
 460     return 0;
 461   /* NODE's template arg list should be <char>.  */
 462   return
 463     TREE_VEC_LENGTH (args) == 1
 464     && TREE_VEC_ELT (args, 0) == char_type_node;
 465 }
 466
 467 /* Check whether a substitution should be used to represent NODE in
 468    the mangling.
 469
 470    First, check standard special-case substitutions.
 471
 472      <substitution> ::= St
 473          # ::std
 474
 475                     ::= Sa
 476          # ::std::allocator
 477
 478                     ::= Sb
 479          # ::std::basic_string
 480
 481                     ::= Ss
 482          # ::std::basic_string<char,
 483                                ::std::char_traits<char>,
 484                                ::std::allocator<char> >
 485
 486                     ::= Si
 487          # ::std::basic_istream<char, ::std::char_traits<char> >
 488
 489                     ::= So
 490          # ::std::basic_ostream<char, ::std::char_traits<char> >
 491
 492                     ::= Sd
 493          # ::std::basic_iostream<char, ::std::char_traits<char> >
 494
 495    Then examine the stack of currently available substitution
 496    candidates for entities appearing earlier in the same mangling
 497
 498    If a substitution is found, write its mangled representation and
 499    return nonzero.  If none is found, just return zero.  */
 500
 501 static int
 502 find_substitution (tree node)
 503 {
 504   int i;
 505   const int size = VEC_length (tree, G.substitutions);
 506   tree decl;
 507   tree type;
 508
 509   if (DEBUG_MANGLE)
 510     fprintf (stderr, "  ++ find_substitution (%s at %p)\n",
 511              tree_code_name[TREE_CODE (node)], (void *) node);
 512
 513   /* Obtain the canonicalized substitution representation for NODE.
 514      This is what we'll compare against.  */
 515   node = canonicalize_for_substitution (node);
 516
 517   /* Check for builtin substitutions.  */
 518
 519   decl = TYPE_P (node) ? TYPE_NAME (node) : node;
 520   type = TYPE_P (node) ? node : TREE_TYPE (node);
 521
 522   /* Check for std::allocator.  */
 523   if (decl
 524       && is_std_substitution (decl, SUBID_ALLOCATOR)
 525       && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
 526     {
 527       write_string ("Sa");
 528       return 1;
 529     }
 530
 531   /* Check for std::basic_string.  */
 532   if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
 533     {
 534       if (TYPE_P (node))
 535         {
 536           /* If this is a type (i.e. a fully-qualified template-id),
 537              check for
 538                  std::basic_string <char,
 539                                     std::char_traits<char>,
 540                                     std::allocator<char> > .  */
 541           if (cp_type_quals (type) == TYPE_UNQUALIFIED
 542               && CLASSTYPE_USE_TEMPLATE (type))
 543             {
 544               tree args = CLASSTYPE_TI_ARGS (type);
 545               if (TREE_VEC_LENGTH (args) == 3
 546                   && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 547                   && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 548                                                SUBID_CHAR_TRAITS)
 549                   && is_std_substitution_char (TREE_VEC_ELT (args, 2),
 550                                                SUBID_ALLOCATOR))
 551                 {
 552                   write_string ("Ss");
 553                   return 1;
 554                 }
 555             }
 556         }
 557       else
 558         /* Substitute for the template name only if this isn't a type.  */
 559         {
 560           write_string ("Sb");
 561           return 1;
 562         }
 563     }
 564
 565   /* Check for basic_{i,o,io}stream.  */
 566   if (TYPE_P (node)
 567       && cp_type_quals (type) == TYPE_UNQUALIFIED
 568       && CLASS_TYPE_P (type)
 569       && CLASSTYPE_USE_TEMPLATE (type)
 570       && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
 571     {
 572       /* First, check for the template
 573          args <char, std::char_traits<char> > .  */
 574       tree args = CLASSTYPE_TI_ARGS (type);
 575       if (TREE_VEC_LENGTH (args) == 2
 576           && TYPE_P (TREE_VEC_ELT (args, 0))
 577           && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 578           && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 579                                        SUBID_CHAR_TRAITS))
 580         {
 581           /* Got them.  Is this basic_istream?  */
 582           if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
 583             {
 584               write_string ("Si");
 585               return 1;
 586             }
 587           /* Or basic_ostream?  */
 588           else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
 589             {
 590               write_string ("So");
 591               return 1;
 592             }
 593           /* Or basic_iostream?  */
 594           else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
 595             {
 596               write_string ("Sd");
 597               return 1;
 598             }
 599         }
 600     }
 601
 602   /* Check for namespace std.  */
 603   if (decl && DECL_NAMESPACE_STD_P (decl))
 604     {
 605       write_string ("St");
 606       return 1;
 607     }
 608
 609   /* Now check the list of available substitutions for this mangling
 610      operation.  */
 611   for (i = 0; i < size; ++i)
 612     {
 613       tree candidate = VEC_index (tree, G.substitutions, i);
 614       /* NODE is a matched to a candidate if it's the same decl node or
 615          if it's the same type.  */
 616       if (decl == candidate
 617           || (TYPE_P (candidate) && type && TYPE_P (type)
 618               && same_type_p (type, candidate))
 619           || NESTED_TEMPLATE_MATCH (node, candidate))
 620         {
 621           write_substitution (i);
 622           return 1;
 623         }
 624     }
 625
 626   /* No substitution found.  */
 627   return 0;
 628 }
 629
 630
 631 /* TOP_LEVEL is true, if this is being called at outermost level of
 632   mangling. It should be false when mangling a decl appearing in an
 633   expression within some other mangling.
 634
 635   <mangled-name>      ::= _Z <encoding>  */
 636
 637 static void
 638 write_mangled_name (const tree decl, bool top_level)
 639 {
 640   MANGLE_TRACE_TREE ("mangled-name", decl);
 641
 642   if (/* The names of `extern "C"' functions are not mangled.  */
 643       DECL_EXTERN_C_FUNCTION_P (decl)
 644       /* But overloaded operator names *are* mangled.  */
 645       && !DECL_OVERLOADED_OPERATOR_P (decl))
 646     {
 647     unmangled_name:;
 648
 649       if (top_level)
 650         write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
 651       else
 652         {
 653           /* The standard notes: "The <encoding> of an extern "C"
 654              function is treated like global-scope data, i.e. as its
 655              <source-name> without a type."  We cannot write
 656              overloaded operators that way though, because it contains
 657              characters invalid in assembler.  */
 658           if (abi_version_at_least (2))
 659             write_string ("_Z");
 660           else
 661             G.need_abi_warning = true;
 662           write_source_name (DECL_NAME (decl));
 663         }
 664     }
 665   else if (TREE_CODE (decl) == VAR_DECL
 666            /* The names of non-static global variables aren't mangled.  */
 667            && DECL_EXTERNAL_LINKAGE_P (decl)
 668            && (CP_DECL_CONTEXT (decl) == global_namespace
 669                /* And neither are `extern "C"' variables.  */
 670                || DECL_EXTERN_C_P (decl)))
 671     {
 672       if (top_level || abi_version_at_least (2))
 673         goto unmangled_name;
 674       else
 675         {
 676           G.need_abi_warning = true;
 677           goto mangled_name;
 678         }
 679     }
 680   else
 681     {
 682     mangled_name:;
 683       write_string ("_Z");
 684       write_encoding (decl);
 685       if (DECL_LANG_SPECIFIC (decl)
 686           && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
 687               || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
 688         /* We need a distinct mangled name for these entities, but
 689            we should never actually output it.  So, we append some
 690            characters the assembler won't like.  */
 691         write_string (" *INTERNAL* ");
 692     }
 693 }
 694
 695 /*   <encoding>         ::= <function name> <bare-function-type>
 696                         ::= <data name>  */
 697
 698 static void
 699 write_encoding (const tree decl)
 700 {
 701   MANGLE_TRACE_TREE ("encoding", decl);
 702
 703   if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
 704     {
 705       /* For overloaded operators write just the mangled name
 706          without arguments.  */
 707       if (DECL_OVERLOADED_OPERATOR_P (decl))
 708         write_name (decl, /*ignore_local_scope=*/0);
 709       else
 710         write_source_name (DECL_NAME (decl));
 711       return;
 712     }
 713
 714   write_name (decl, /*ignore_local_scope=*/0);
 715   if (TREE_CODE (decl) == FUNCTION_DECL)
 716     {
 717       tree fn_type;
 718       tree d;
 719
 720       if (decl_is_template_id (decl, NULL))
 721         {
 722           fn_type = get_mostly_instantiated_function_type (decl);
 723           /* FN_TYPE will not have parameter types for in-charge or
 724              VTT parameters.  Therefore, we pass NULL_TREE to
 725              write_bare_function_type -- otherwise, it will get
 726              confused about which artificial parameters to skip.  */
 727           d = NULL_TREE;
 728         }
 729       else
 730         {
 731           fn_type = TREE_TYPE (decl);
 732           d = decl;
 733         }
 734
 735       write_bare_function_type (fn_type,
 736                                 (!DECL_CONSTRUCTOR_P (decl)
 737                                  && !DECL_DESTRUCTOR_P (decl)
 738                                  && !DECL_CONV_FN_P (decl)
 739                                  && decl_is_template_id (decl, NULL)),
 740                                 d);
 741     }
 742 }
 743
 744 /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
 745    or PARM_DECL context, which doesn't belong in DECL_CONTEXT.  */
 746
 747 static tree
 748 decl_mangling_context (tree decl)
 749 {
 750   if (TREE_CODE (decl) == TYPE_DECL
 751       && LAMBDA_TYPE_P (TREE_TYPE (decl)))
 752     {
 753       tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl));
 754       if (extra)
 755         return extra;
 756     }
 757     else if (TREE_CODE (decl) == TYPE_DECL
 758              && TREE_CODE (TREE_TYPE (decl)) == TEMPLATE_TYPE_PARM)
 759      /* template type parms have no mangling context.  */
 760       return NULL_TREE;
 761   return CP_DECL_CONTEXT (decl);
 762 }
 763
 764 /* <name> ::= <unscoped-name>
 765           ::= <unscoped-template-name> <template-args>
 766           ::= <nested-name>
 767           ::= <local-name>
 768
 769    If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
 770    called from <local-name>, which mangles the enclosing scope
 771    elsewhere and then uses this function to mangle just the part
 772    underneath the function scope.  So don't use the <local-name>
 773    production, to avoid an infinite recursion.  */
 774
 775 static void
 776 write_name (tree decl, const int ignore_local_scope)
 777 {
 778   tree context;
 779
 780   MANGLE_TRACE_TREE ("name", decl);
 781
 782   if (TREE_CODE (decl) == TYPE_DECL)
 783     {
 784       /* In case this is a typedef, fish out the corresponding
 785          TYPE_DECL for the main variant.  */
 786       decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
 787     }
 788
 789   context = decl_mangling_context (decl);
 790
 791   /* A decl in :: or ::std scope is treated specially.  The former is
 792      mangled using <unscoped-name> or <unscoped-template-name>, the
 793      latter with a special substitution.  Also, a name that is
 794      directly in a local function scope is also mangled with
 795      <unscoped-name> rather than a full <nested-name>.  */
 796   if (context == NULL
 797       || context == global_namespace
 798       || DECL_NAMESPACE_STD_P (context)
 799       || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL))
 800     {
 801       tree template_info;
 802       /* Is this a template instance?  */
 803       if (decl_is_template_id (decl, &template_info))
 804         {
 805           /* Yes: use <unscoped-template-name>.  */
 806           write_unscoped_template_name (TI_TEMPLATE (template_info));
 807           write_template_args (TI_ARGS (template_info));
 808         }
 809       else
 810         /* Everything else gets an <unqualified-name>.  */
 811         write_unscoped_name (decl);
 812     }
 813   else
 814     {
 815       /* Handle local names, unless we asked not to (that is, invoked
 816          under <local-name>, to handle only the part of the name under
 817          the local scope).  */
 818       if (!ignore_local_scope)
 819         {
 820           /* Scan up the list of scope context, looking for a
 821              function.  If we find one, this entity is in local
 822              function scope.  local_entity tracks context one scope
 823              level down, so it will contain the element that's
 824              directly in that function's scope, either decl or one of
 825              its enclosing scopes.  */
 826           tree local_entity = decl;
 827           while (context != NULL && context != global_namespace)
 828             {
 829               /* Make sure we're always dealing with decls.  */
 830               if (context != NULL && TYPE_P (context))
 831                 context = TYPE_NAME (context);
 832               /* Is this a function?  */
 833               if (TREE_CODE (context) == FUNCTION_DECL
 834                   || TREE_CODE (context) == PARM_DECL)
 835                 {
 836                   /* Yes, we have local scope.  Use the <local-name>
 837                      production for the innermost function scope.  */
 838                   write_local_name (context, local_entity, decl);
 839                   return;
 840                 }
 841               /* Up one scope level.  */
 842               local_entity = context;
 843               context = decl_mangling_context (context);
 844             }
 845
 846           /* No local scope found?  Fall through to <nested-name>.  */
 847         }
 848
 849       /* Other decls get a <nested-name> to encode their scope.  */
 850       write_nested_name (decl);
 851     }
 852 }
 853
 854 /* <unscoped-name> ::= <unqualified-name>
 855                    ::= St <unqualified-name>   # ::std::  */
 856
 857 static void
 858 write_unscoped_name (const tree decl)
 859 {
 860   tree context = CP_DECL_CONTEXT (decl);
 861
 862   MANGLE_TRACE_TREE ("unscoped-name", decl);
 863
 864   /* Is DECL in ::std?  */
 865   if (DECL_NAMESPACE_STD_P (context))
 866     {
 867       write_string ("St");
 868       write_unqualified_name (decl);
 869     }
 870   else
 871     {
 872       /* If not, it should be either in the global namespace, or directly
 873          in a local function scope.  */
 874       gcc_assert (context == global_namespace
 875                   || context != NULL
 876                   || TREE_CODE (context) == FUNCTION_DECL);
 877
 878       write_unqualified_name (decl);
 879     }
 880 }
 881
 882 /* <unscoped-template-name> ::= <unscoped-name>
 883                             ::= <substitution>  */
 884
 885 static void
 886 write_unscoped_template_name (const tree decl)
 887 {
 888   MANGLE_TRACE_TREE ("unscoped-template-name", decl);
 889
 890   if (find_substitution (decl))
 891     return;
 892   write_unscoped_name (decl);
 893   add_substitution (decl);
 894 }
 895
 896 /* Write the nested name, including CV-qualifiers, of DECL.
 897
 898    <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
 899                  ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
 900
 901    <CV-qualifiers> ::= [r] [V] [K]  */
 902
 903 static void
 904 write_nested_name (const tree decl)
 905 {
 906   tree template_info;
 907
 908   MANGLE_TRACE_TREE ("nested-name", decl);
 909
 910   write_char ('N');
 911
 912   /* Write CV-qualifiers, if this is a member function.  */
 913   if (TREE_CODE (decl) == FUNCTION_DECL
 914       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
 915     {
 916       if (DECL_VOLATILE_MEMFUNC_P (decl))
 917         write_char ('V');
 918       if (DECL_CONST_MEMFUNC_P (decl))
 919         write_char ('K');
 920     }
 921
 922   /* Is this a template instance?  */
 923   if (decl_is_template_id (decl, &template_info))
 924     {
 925       /* Yes, use <template-prefix>.  */
 926       write_template_prefix (decl);
 927       write_template_args (TI_ARGS (template_info));
 928     }
 929   else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
 930     {
 931       tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
 932       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
 933         {
 934           write_template_prefix (decl);
 935           write_template_args (TREE_OPERAND (name, 1));
 936         }
 937       else
 938         {
 939           write_prefix (CP_DECL_CONTEXT (decl));
 940           write_unqualified_name (decl);
 941         }
 942     }
 943   else
 944     {
 945       /* No, just use <prefix>  */
 946       write_prefix (DECL_CONTEXT (decl));
 947       write_unqualified_name (decl);
 948     }
 949   write_char ('E');
 950 }
 951
 952 /* <prefix> ::= <prefix> <unqualified-name>
 953             ::= <template-param>
 954             ::= <template-prefix> <template-args>
 955             ::= # empty
 956             ::= <substitution>  */
 957
 958 static void
 959 write_prefix (const tree node)
 960 {
 961   tree decl;
 962   /* Non-NULL if NODE represents a template-id.  */
 963   tree template_info = NULL;
 964
 965   if (node == NULL
 966       || node == global_namespace)
 967     return;
 968
 969   MANGLE_TRACE_TREE ("prefix", node);
 970
 971   if (find_substitution (node))
 972     return;
 973
 974   if (DECL_P (node))
 975     {
 976       /* If this is a function or parm decl, that means we've hit function
 977          scope, so this prefix must be for a local name.  In this
 978          case, we're under the <local-name> production, which encodes
 979          the enclosing function scope elsewhere.  So don't continue
 980          here.  */
 981       if (TREE_CODE (node) == FUNCTION_DECL
 982           || TREE_CODE (node) == PARM_DECL)
 983         return;
 984
 985       decl = node;
 986       decl_is_template_id (decl, &template_info);
 987     }
 988   else
 989     {
 990       /* Node is a type.  */
 991       decl = TYPE_NAME (node);
 992       if (CLASSTYPE_TEMPLATE_ID_P (node))
 993         template_info = TYPE_TEMPLATE_INFO (node);
 994     }
 995
 996   /* In G++ 3.2, the name of the template parameter was used.  */
 997   if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
 998       && !abi_version_at_least (2))
 999     G.need_abi_warning = true;
1000
1001   if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
1002       && abi_version_at_least (2))
1003     write_template_param (node);
1004   else if (template_info != NULL)
1005     /* Templated.  */
1006     {
1007       write_template_prefix (decl);
1008       write_template_args (TI_ARGS (template_info));
1009     }
1010   else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
1011     {
1012       tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
1013       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1014         {
1015           write_template_prefix (decl);
1016           write_template_args (TREE_OPERAND (name, 1));
1017         }
1018       else
1019         {
1020           write_prefix (CP_DECL_CONTEXT (decl));
1021           write_unqualified_name (decl);
1022         }
1023     }
1024   else
1025     /* Not templated.  */
1026     {
1027       write_prefix (decl_mangling_context (decl));
1028       write_unqualified_name (decl);
1029       if (TREE_CODE (decl) == VAR_DECL
1030           || TREE_CODE (decl) == FIELD_DECL)
1031         {
1032           /* <data-member-prefix> := <member source-name> M */
1033           write_char ('M');
1034           return;
1035         }
1036     }
1037
1038   add_substitution (node);
1039 }
1040
1041 /* <template-prefix> ::= <prefix> <template component>
1042                      ::= <template-param>
1043                      ::= <substitution>  */
1044
1045 static void
1046 write_template_prefix (const tree node)
1047 {
1048   tree decl = DECL_P (node) ? node : TYPE_NAME (node);
1049   tree type = DECL_P (node) ? TREE_TYPE (node) : node;
1050   tree context = CP_DECL_CONTEXT (decl);
1051   tree template_info;
1052   tree templ;
1053   tree substitution;
1054
1055   MANGLE_TRACE_TREE ("template-prefix", node);
1056
1057   /* Find the template decl.  */
1058   if (decl_is_template_id (decl, &template_info))
1059     templ = TI_TEMPLATE (template_info);
1060   else if (TREE_CODE (type) == TYPENAME_TYPE)
1061     /* For a typename type, all we have is the name.  */
1062     templ = DECL_NAME (decl);
1063   else
1064     {
1065       gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
1066
1067       templ = TYPE_TI_TEMPLATE (type);
1068     }
1069
1070   /* For a member template, though, the template name for the
1071      innermost name must have all the outer template levels
1072      instantiated.  For instance, consider
1073
1074        template<typename T> struct Outer {
1075          template<typename U> struct Inner {};
1076        };
1077
1078      The template name for `Inner' in `Outer<int>::Inner<float>' is
1079      `Outer<int>::Inner<U>'.  In g++, we don't instantiate the template
1080      levels separately, so there's no TEMPLATE_DECL available for this
1081      (there's only `Outer<T>::Inner<U>').
1082
1083      In order to get the substitutions right, we create a special
1084      TREE_LIST to represent the substitution candidate for a nested
1085      template.  The TREE_PURPOSE is the template's context, fully
1086      instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1087      template.
1088
1089      So, for the example above, `Outer<int>::Inner' is represented as a
1090      substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1091      and whose value is `Outer<T>::Inner<U>'.  */
1092   if (TYPE_P (context))
1093     substitution = build_tree_list (context, templ);
1094   else
1095     substitution = templ;
1096
1097   if (find_substitution (substitution))
1098     return;
1099
1100   /* In G++ 3.2, the name of the template template parameter was used.  */
1101   if (TREE_TYPE (templ)
1102       && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
1103       && !abi_version_at_least (2))
1104     G.need_abi_warning = true;
1105
1106   if (TREE_TYPE (templ)
1107       && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
1108       && abi_version_at_least (2))
1109     write_template_param (TREE_TYPE (templ));
1110   else
1111     {
1112       write_prefix (context);
1113       write_unqualified_name (decl);
1114     }
1115
1116   add_substitution (substitution);
1117 }
1118
1119 /* We don't need to handle thunks, vtables, or VTTs here.  Those are
1120    mangled through special entry points.
1121
1122     <unqualified-name>  ::= <operator-name>
1123                         ::= <special-name>
1124                         ::= <source-name>
1125                         ::= <unnamed-type-name>
1126                         ::= <local-source-name>
1127
1128     <local-source-name> ::= L <source-name> <discriminator> */
1129
1130 static void
1131 write_unqualified_id (tree identifier)
1132 {
1133   if (IDENTIFIER_TYPENAME_P (identifier))
1134     write_conversion_operator_name (TREE_TYPE (identifier));
1135   else if (IDENTIFIER_OPNAME_P (identifier))
1136     {
1137       int i;
1138       const char *mangled_name = NULL;
1139
1140       /* Unfortunately, there is no easy way to go from the
1141          name of the operator back to the corresponding tree
1142          code.  */
1143       for (i = 0; i < MAX_TREE_CODES; ++i)
1144         if (operator_name_info[i].identifier == identifier)
1145           {
1146             /* The ABI says that we prefer binary operator
1147                names to unary operator names.  */
1148             if (operator_name_info[i].arity == 2)
1149               {
1150                 mangled_name = operator_name_info[i].mangled_name;
1151                 break;
1152               }
1153             else if (!mangled_name)
1154               mangled_name = operator_name_info[i].mangled_name;
1155           }
1156         else if (assignment_operator_name_info[i].identifier
1157                  == identifier)
1158           {
1159             mangled_name
1160               = assignment_operator_name_info[i].mangled_name;
1161             break;
1162           }
1163       write_string (mangled_name);
1164     }
1165   else
1166     write_source_name (identifier);
1167 }
1168
1169 static void
1170 write_unqualified_name (const tree decl)
1171 {
1172   MANGLE_TRACE_TREE ("unqualified-name", decl);
1173
1174   if (TREE_CODE (decl) == IDENTIFIER_NODE)
1175     {
1176       write_unqualified_id (decl);
1177       return;
1178     }
1179
1180   if (DECL_NAME (decl) == NULL_TREE)
1181     {
1182       gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
1183       write_source_name (DECL_ASSEMBLER_NAME (decl));
1184       return;
1185     }
1186   else if (DECL_DECLARES_FUNCTION_P (decl))
1187     {
1188       bool found = true;
1189       if (DECL_CONSTRUCTOR_P (decl))
1190         write_special_name_constructor (decl);
1191       else if (DECL_DESTRUCTOR_P (decl))
1192         write_special_name_destructor (decl);
1193       else if (DECL_CONV_FN_P (decl))
1194         {
1195           /* Conversion operator. Handle it right here.
1196              <operator> ::= cv <type>  */
1197           tree type;
1198           if (decl_is_template_id (decl, NULL))
1199             {
1200               tree fn_type;
1201               fn_type = get_mostly_instantiated_function_type (decl);
1202               type = TREE_TYPE (fn_type);
1203             }
1204           else
1205             type = DECL_CONV_FN_TYPE (decl);
1206           write_conversion_operator_name (type);
1207         }
1208       else if (DECL_OVERLOADED_OPERATOR_P (decl))
1209         {
1210           operator_name_info_t *oni;
1211           if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1212             oni = assignment_operator_name_info;
1213           else
1214             oni = operator_name_info;
1215
1216           write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1217         }
1218       else
1219         found = false;
1220
1221       if (found)
1222         return;
1223     }
1224
1225   if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
1226       && DECL_NAMESPACE_SCOPE_P (decl)
1227       && decl_linkage (decl) == lk_internal)
1228     {
1229       MANGLE_TRACE_TREE ("local-source-name", decl);
1230       write_char ('L');
1231       write_source_name (DECL_NAME (decl));
1232       /* The default discriminator is 1, and that's all we ever use,
1233          so there's no code to output one here.  */
1234     }
1235   else
1236     {
1237       tree type = TREE_TYPE (decl);
1238
1239       if (TREE_CODE (decl) == TYPE_DECL
1240           && TYPE_ANONYMOUS_P (type))
1241         write_unnamed_type_name (type);
1242       else if (TREE_CODE (decl) == TYPE_DECL
1243                && LAMBDA_TYPE_P (type))
1244         write_closure_type_name (type);
1245       else
1246         write_source_name (DECL_NAME (decl));
1247     }
1248 }
1249
1250 /* Write the unqualified-name for a conversion operator to TYPE.  */
1251
1252 static void
1253 write_conversion_operator_name (const tree type)
1254 {
1255   write_string ("cv");
1256   write_type (type);
1257 }
1258
1259 /* Non-terminal <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
1260
1261      <source-name> ::= </length/ number> <identifier>  */
1262
1263 static void
1264 write_source_name (tree identifier)
1265 {
1266   MANGLE_TRACE_TREE ("source-name", identifier);
1267
1268   /* Never write the whole template-id name including the template
1269      arguments; we only want the template name.  */
1270   if (IDENTIFIER_TEMPLATE (identifier))
1271     identifier = IDENTIFIER_TEMPLATE (identifier);
1272
1273   write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1274   write_identifier (IDENTIFIER_POINTER (identifier));
1275 }
1276
1277 /* Encode 0 as _, and 1+ as n-1_.  */
1278
1279 static void
1280 write_compact_number (int num)
1281 {
1282   if (num > 0)
1283     write_unsigned_number (num - 1);
1284   write_char ('_');
1285 }
1286
1287 /* Return how many unnamed types precede TYPE in its enclosing class.  */
1288
1289 static int
1290 nested_anon_class_index (tree type)
1291 {
1292   int index = 0;
1293   tree member = TYPE_FIELDS (TYPE_CONTEXT (type));
1294   for (; member; member = DECL_CHAIN (member))
1295     if (DECL_IMPLICIT_TYPEDEF_P (member))
1296       {
1297         tree memtype = TREE_TYPE (member);
1298         if (memtype == type)
1299           return index;
1300         else if (TYPE_ANONYMOUS_P (memtype))
1301           ++index;
1302       }
1303
1304   gcc_unreachable ();
1305 }
1306
1307 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1308
1309 static void
1310 write_unnamed_type_name (const tree type __attribute__ ((__unused__)))
1311 {
1312   int discriminator;
1313   MANGLE_TRACE_TREE ("unnamed-type-name", type);
1314
1315   if (TYPE_FUNCTION_SCOPE_P (type))
1316     discriminator = local_class_index (type);
1317   else if (TYPE_CLASS_SCOPE_P (type))
1318     discriminator = nested_anon_class_index (type);
1319   else
1320     {
1321       gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
1322       /* Just use the old mangling at namespace scope.  */
1323       write_source_name (TYPE_IDENTIFIER (type));
1324       return;
1325     }
1326
1327   write_string ("Ut");
1328   write_compact_number (discriminator);
1329 }
1330
1331 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1332    <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters */
1333
1334 static void
1335 write_closure_type_name (const tree type)
1336 {
1337   tree fn = lambda_function (type);
1338   tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
1339   tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
1340
1341   MANGLE_TRACE_TREE ("closure-type-name", type);
1342
1343   write_string ("Ul");
1344   write_method_parms (parms, /*method_p=*/1, fn);
1345   write_char ('E');
1346   write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda));
1347 }
1348
1349 /* Convert NUMBER to ascii using base BASE and generating at least
1350    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1351    into which to store the characters. Returns the number of
1352    characters generated (these will be layed out in advance of where
1353    BUFFER points).  */
1354
1355 static int
1356 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1357                 char *buffer, const unsigned int min_digits)
1358 {
1359   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1360   unsigned digits = 0;
1361
1362   while (number)
1363     {
1364       unsigned HOST_WIDE_INT d = number / base;
1365
1366       *--buffer = base_digits[number - d * base];
1367       digits++;
1368       number = d;
1369     }
1370   while (digits < min_digits)
1371     {
1372       *--buffer = base_digits[0];
1373       digits++;
1374     }
1375   return digits;
1376 }
1377
1378 /* Non-terminal <number>.
1379
1380      <number> ::= [n] </decimal integer/>  */
1381
1382 static void
1383 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1384               const unsigned int base)
1385 {
1386   char buffer[sizeof (HOST_WIDE_INT) * 8];
1387   unsigned count = 0;
1388
1389   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1390     {
1391       write_char ('n');
1392       number = -((HOST_WIDE_INT) number);
1393     }
1394   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1395   write_chars (buffer + sizeof (buffer) - count, count);
1396 }
1397
1398 /* Write out an integral CST in decimal. Most numbers are small, and
1399    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1400    bigger than that, which we must deal with.  */
1401
1402 static inline void
1403 write_integer_cst (const tree cst)
1404 {
1405   int sign = tree_int_cst_sgn (cst);
1406
1407   if (TREE_INT_CST_HIGH (cst) + (sign < 0))
1408     {
1409       /* A bignum. We do this in chunks, each of which fits in a
1410          HOST_WIDE_INT.  */
1411       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1412       unsigned HOST_WIDE_INT chunk;
1413       unsigned chunk_digits;
1414       char *ptr = buffer + sizeof (buffer);
1415       unsigned count = 0;
1416       tree n, base, type;
1417       int done;
1418
1419       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1420          representable.  */
1421       chunk = 1000000000;
1422       chunk_digits = 9;
1423
1424       if (sizeof (HOST_WIDE_INT) >= 8)
1425         {
1426           /* It is at least 64 bits, so 10^18 is representable.  */
1427           chunk_digits = 18;
1428           chunk *= chunk;
1429         }
1430
1431       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1432       base = build_int_cstu (type, chunk);
1433       n = build_int_cst_wide (type,
1434                               TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
1435
1436       if (sign < 0)
1437         {
1438           write_char ('n');
1439           n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
1440         }
1441       do
1442         {
1443           tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
1444           tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
1445           unsigned c;
1446
1447           done = integer_zerop (d);
1448           tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
1449           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1450                               done ? 1 : chunk_digits);
1451           ptr -= c;
1452           count += c;
1453           n = d;
1454         }
1455       while (!done);
1456       write_chars (ptr, count);
1457     }
1458   else
1459     {
1460       /* A small num.  */
1461       unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
1462
1463       if (sign < 0)
1464         {
1465           write_char ('n');
1466           low = -low;
1467         }
1468       write_unsigned_number (low);
1469     }
1470 }
1471
1472 /* Write out a floating-point literal.
1473
1474     "Floating-point literals are encoded using the bit pattern of the
1475     target processor's internal representation of that number, as a
1476     fixed-length lowercase hexadecimal string, high-order bytes first
1477     (even if the target processor would store low-order bytes first).
1478     The "n" prefix is not used for floating-point literals; the sign
1479     bit is encoded with the rest of the number.
1480
1481     Here are some examples, assuming the IEEE standard representation
1482     for floating point numbers.  (Spaces are for readability, not
1483     part of the encoding.)
1484
1485         1.0f                    Lf 3f80 0000 E
1486        -1.0f                    Lf bf80 0000 E
1487         1.17549435e-38f         Lf 0080 0000 E
1488         1.40129846e-45f         Lf 0000 0001 E
1489         0.0f                    Lf 0000 0000 E"
1490
1491    Caller is responsible for the Lx and the E.  */
1492 static void
1493 write_real_cst (const tree value)
1494 {
1495   if (abi_version_at_least (2))
1496     {
1497       long target_real[4];  /* largest supported float */
1498       char buffer[9];       /* eight hex digits in a 32-bit number */
1499       int i, limit, dir;
1500
1501       tree type = TREE_TYPE (value);
1502       int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1503
1504       real_to_target (target_real, &TREE_REAL_CST (value),
1505                       TYPE_MODE (type));
1506
1507       /* The value in target_real is in the target word order,
1508          so we must write it out backward if that happens to be
1509          little-endian.  write_number cannot be used, it will
1510          produce uppercase.  */
1511       if (FLOAT_WORDS_BIG_ENDIAN)
1512         i = 0, limit = words, dir = 1;
1513       else
1514         i = words - 1, limit = -1, dir = -1;
1515
1516       for (; i != limit; i += dir)
1517         {
1518           sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1519           write_chars (buffer, 8);
1520         }
1521     }
1522   else
1523     {
1524       /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out
1525          literally.  Note that compatibility with 3.2 is impossible,
1526          because the old floating-point emulator used a different
1527          format for REAL_VALUE_TYPE.  */
1528       size_t i;
1529       for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1530         write_number (((unsigned char *) &TREE_REAL_CST (value))[i],
1531                       /*unsigned_p*/ 1,
1532                       /*base*/ 16);
1533       G.need_abi_warning = 1;
1534     }
1535 }
1536
1537 /* Non-terminal <identifier>.
1538
1539      <identifier> ::= </unqualified source code identifier>  */
1540
1541 static void
1542 write_identifier (const char *identifier)
1543 {
1544   MANGLE_TRACE ("identifier", identifier);
1545   write_string (identifier);
1546 }
1547
1548 /* Handle constructor productions of non-terminal <special-name>.
1549    CTOR is a constructor FUNCTION_DECL.
1550
1551      <special-name> ::= C1   # complete object constructor
1552                     ::= C2   # base object constructor
1553                     ::= C3   # complete object allocating constructor
1554
1555    Currently, allocating constructors are never used.
1556
1557    We also need to provide mangled names for the maybe-in-charge
1558    constructor, so we treat it here too.  mangle_decl_string will
1559    append *INTERNAL* to that, to make sure we never emit it.  */
1560
1561 static void
1562 write_special_name_constructor (const tree ctor)
1563 {
1564   if (DECL_BASE_CONSTRUCTOR_P (ctor))
1565     write_string ("C2");
1566   else
1567     {
1568       gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1569                   /* Even though we don't ever emit a definition of
1570                      the old-style destructor, we still have to
1571                      consider entities (like static variables) nested
1572                      inside it.  */
1573                   || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor));
1574       write_string ("C1");
1575     }
1576 }
1577
1578 /* Handle destructor productions of non-terminal <special-name>.
1579    DTOR is a destructor FUNCTION_DECL.
1580
1581      <special-name> ::= D0 # deleting (in-charge) destructor
1582                     ::= D1 # complete object (in-charge) destructor
1583                     ::= D2 # base object (not-in-charge) destructor
1584
1585    We also need to provide mangled names for the maybe-incharge
1586    destructor, so we treat it here too.  mangle_decl_string will
1587    append *INTERNAL* to that, to make sure we never emit it.  */
1588
1589 static void
1590 write_special_name_destructor (const tree dtor)
1591 {
1592   if (DECL_DELETING_DESTRUCTOR_P (dtor))
1593     write_string ("D0");
1594   else if (DECL_BASE_DESTRUCTOR_P (dtor))
1595     write_string ("D2");
1596   else
1597     {
1598       gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1599                   /* Even though we don't ever emit a definition of
1600                      the old-style destructor, we still have to
1601                      consider entities (like static variables) nested
1602                      inside it.  */
1603                   || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor));
1604       write_string ("D1");
1605     }
1606 }
1607
1608 /* Scan the vector of local classes and return how many others with the
1609    same name (or same no name) and context precede ENTITY.  */
1610
1611 static int
1612 local_class_index (tree entity)
1613 {
1614   int ix, discriminator = 0;
1615   tree name = (TYPE_ANONYMOUS_P (entity) ? NULL_TREE
1616                : TYPE_IDENTIFIER (entity));
1617   tree ctx = TYPE_CONTEXT (entity);
1618   for (ix = 0; ; ix++)
1619     {
1620       tree type = VEC_index (tree, local_classes, ix);
1621       if (type == entity)
1622         return discriminator;
1623       if (TYPE_CONTEXT (type) == ctx
1624           && (name ? TYPE_IDENTIFIER (type) == name
1625               : TYPE_ANONYMOUS_P (type)))
1626         ++discriminator;
1627     }
1628   gcc_unreachable ();
1629 }
1630
1631 /* Return the discriminator for ENTITY appearing inside
1632    FUNCTION.  The discriminator is the lexical ordinal of VAR among
1633    entities with the same name in the same FUNCTION.  */
1634
1635 static int
1636 discriminator_for_local_entity (tree entity)
1637 {
1638   if (DECL_DISCRIMINATOR_P (entity))
1639     {
1640       if (DECL_DISCRIMINATOR_SET_P (entity))
1641         return DECL_DISCRIMINATOR (entity);
1642       else
1643         /* The first entity with a particular name doesn't get
1644            DECL_DISCRIMINATOR set up.  */
1645         return 0;
1646     }
1647   else if (TREE_CODE (entity) == TYPE_DECL)
1648     {
1649       /* Scan the list of local classes.  */
1650       entity = TREE_TYPE (entity);
1651
1652       /* Lambdas and unnamed types have their own discriminators.  */
1653       if (LAMBDA_TYPE_P (entity) || TYPE_ANONYMOUS_P (entity))
1654         return 0;
1655
1656       return local_class_index (entity);
1657     }
1658   else
1659     gcc_unreachable ();
1660 }
1661
1662 /* Return the discriminator for STRING, a string literal used inside
1663    FUNCTION.  The discriminator is the lexical ordinal of STRING among
1664    string literals used in FUNCTION.  */
1665
1666 static int
1667 discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED,
1668                                   tree string ATTRIBUTE_UNUSED)
1669 {
1670   /* For now, we don't discriminate amongst string literals.  */
1671   return 0;
1672 }
1673
1674 /*   <discriminator> := _ <number>
1675
1676    The discriminator is used only for the second and later occurrences
1677    of the same name within a single function. In this case <number> is
1678    n - 2, if this is the nth occurrence, in lexical order.  */
1679
1680 static void
1681 write_discriminator (const int discriminator)
1682 {
1683   /* If discriminator is zero, don't write anything.  Otherwise...  */
1684   if (discriminator > 0)
1685     {
1686       write_char ('_');
1687       write_unsigned_number (discriminator - 1);
1688     }
1689 }
1690
1691 /* Mangle the name of a function-scope entity.  FUNCTION is the
1692    FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1693    default argument scope.  ENTITY is the decl for the entity itself.
1694    LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1695    either ENTITY itself or an enclosing scope of ENTITY.
1696
1697      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1698                   := Z <function encoding> E s [<discriminator>]
1699                   := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1700
1701 static void
1702 write_local_name (tree function, const tree local_entity,
1703                   const tree entity)
1704 {
1705   tree parm = NULL_TREE;
1706
1707   MANGLE_TRACE_TREE ("local-name", entity);
1708
1709   if (TREE_CODE (function) == PARM_DECL)
1710     {
1711       parm = function;
1712       function = DECL_CONTEXT (parm);
1713     }
1714
1715   write_char ('Z');
1716   write_encoding (function);
1717   write_char ('E');
1718
1719   /* For this purpose, parameters are numbered from right-to-left.  */
1720   if (parm)
1721     {
1722       tree t;
1723       int i = 0;
1724       for (t = DECL_ARGUMENTS (function); t; t = DECL_CHAIN (t))
1725         {
1726           if (t == parm)
1727             i = 1;
1728           else if (i)
1729             ++i;
1730         }
1731       write_char ('d');
1732       write_compact_number (i - 1);
1733     }
1734
1735   if (TREE_CODE (entity) == STRING_CST)
1736     {
1737       write_char ('s');
1738       write_discriminator (discriminator_for_string_literal (function,
1739                                                              entity));
1740     }
1741   else
1742     {
1743       /* Now the <entity name>.  Let write_name know its being called
1744          from <local-name>, so it doesn't try to process the enclosing
1745          function scope again.  */
1746       write_name (entity, /*ignore_local_scope=*/1);
1747       write_discriminator (discriminator_for_local_entity (local_entity));
1748     }
1749 }
1750
1751 /* Non-terminals <type> and <CV-qualifier>.
1752
1753      <type> ::= <builtin-type>
1754             ::= <function-type>
1755             ::= <class-enum-type>
1756             ::= <array-type>
1757             ::= <pointer-to-member-type>
1758             ::= <template-param>
1759             ::= <substitution>
1760             ::= <CV-qualifier>
1761             ::= P <type>    # pointer-to
1762             ::= R <type>    # reference-to
1763             ::= C <type>    # complex pair (C 2000)
1764             ::= G <type>    # imaginary (C 2000)     [not supported]
1765             ::= U <source-name> <type>   # vendor extended type qualifier
1766
1767    C++0x extensions
1768
1769      <type> ::= RR <type>   # rvalue reference-to
1770      <type> ::= Dt <expression> # decltype of an id-expression or
1771                                 # class member access
1772      <type> ::= DT <expression> # decltype of an expression
1773      <type> ::= Dn              # decltype of nullptr
1774
1775    TYPE is a type node.  */
1776
1777 static void
1778 write_type (tree type)
1779 {
1780   /* This gets set to nonzero if TYPE turns out to be a (possibly
1781      CV-qualified) builtin type.  */
1782   int is_builtin_type = 0;
1783
1784   MANGLE_TRACE_TREE ("type", type);
1785
1786   if (type == error_mark_node)
1787     return;
1788
1789   type = canonicalize_for_substitution (type);
1790   if (find_substitution (type))
1791     return;
1792
1793   /* According to the C++ ABI, some library classes are passed the
1794      same as the scalar type of their single member and use the same
1795      mangling.  */
1796   if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
1797     type = TREE_TYPE (first_field (type));
1798
1799   if (write_CV_qualifiers_for_type (type) > 0)
1800     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1801        mangle the unqualified type.  The recursive call is needed here
1802        since both the qualified and unqualified types are substitution
1803        candidates.  */
1804     write_type (TYPE_MAIN_VARIANT (type));
1805   else if (TREE_CODE (type) == ARRAY_TYPE)
1806     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1807        so that the cv-qualification of the element type is available
1808        in write_array_type.  */
1809     write_array_type (type);
1810   else
1811     {
1812       tree type_orig = type;
1813
1814       /* See through any typedefs.  */
1815       type = TYPE_MAIN_VARIANT (type);
1816
1817       if (TYPE_PTRMEM_P (type))
1818         write_pointer_to_member_type (type);
1819       else
1820         {
1821           /* Handle any target-specific fundamental types.  */
1822           const char *target_mangling
1823             = targetm.mangle_type (type_orig);
1824
1825           if (target_mangling)
1826             {
1827               write_string (target_mangling);
1828               /* Add substitutions for types other than fundamental
1829                  types.  */
1830               if (TREE_CODE (type) != VOID_TYPE
1831                   && TREE_CODE (type) != INTEGER_TYPE
1832                   && TREE_CODE (type) != REAL_TYPE
1833                   && TREE_CODE (type) != BOOLEAN_TYPE)
1834                 add_substitution (type);
1835               return;
1836             }
1837
1838           switch (TREE_CODE (type))
1839             {
1840             case VOID_TYPE:
1841             case BOOLEAN_TYPE:
1842             case INTEGER_TYPE:  /* Includes wchar_t.  */
1843             case REAL_TYPE:
1844             case FIXED_POINT_TYPE:
1845               {
1846                 /* If this is a typedef, TYPE may not be one of
1847                    the standard builtin type nodes, but an alias of one.  Use
1848                    TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
1849                 write_builtin_type (TYPE_MAIN_VARIANT (type));
1850                 ++is_builtin_type;
1851               }
1852               break;
1853
1854             case COMPLEX_TYPE:
1855               write_char ('C');
1856               write_type (TREE_TYPE (type));
1857               break;
1858
1859             case FUNCTION_TYPE:
1860             case METHOD_TYPE:
1861               write_function_type (type);
1862               break;
1863
1864             case UNION_TYPE:
1865             case RECORD_TYPE:
1866             case ENUMERAL_TYPE:
1867               /* A pointer-to-member function is represented as a special
1868                  RECORD_TYPE, so check for this first.  */
1869               if (TYPE_PTRMEMFUNC_P (type))
1870                 write_pointer_to_member_type (type);
1871               else
1872                 write_class_enum_type (type);
1873               break;
1874
1875             case TYPENAME_TYPE:
1876             case UNBOUND_CLASS_TEMPLATE:
1877               /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1878                  ordinary nested names.  */
1879               write_nested_name (TYPE_STUB_DECL (type));
1880               break;
1881
1882             case POINTER_TYPE:
1883             case REFERENCE_TYPE:
1884               if (TREE_CODE (type) == POINTER_TYPE)
1885                 write_char ('P');
1886               else if (TYPE_REF_IS_RVALUE (type))
1887                 write_char ('O');
1888               else
1889                 write_char ('R');
1890               {
1891                 tree target = TREE_TYPE (type);
1892                 /* Attribute const/noreturn are not reflected in mangling.
1893                    We strip them here rather than at a lower level because
1894                    a typedef or template argument can have function type
1895                    with function-cv-quals (that use the same representation),
1896                    but you can't have a pointer/reference to such a type.  */
1897                 if (abi_version_at_least (5)
1898                     && TREE_CODE (target) == FUNCTION_TYPE)
1899                   target = build_qualified_type (target, TYPE_UNQUALIFIED);
1900                 write_type (target);
1901               }
1902               break;
1903
1904             case TEMPLATE_TYPE_PARM:
1905             case TEMPLATE_PARM_INDEX:
1906               write_template_param (type);
1907               break;
1908
1909             case TEMPLATE_TEMPLATE_PARM:
1910               write_template_template_param (type);
1911               break;
1912
1913             case BOUND_TEMPLATE_TEMPLATE_PARM:
1914               write_template_template_param (type);
1915               write_template_args
1916                 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1917               break;
1918
1919             case VECTOR_TYPE:
1920               if (abi_version_at_least (4))
1921                 {
1922                   write_string ("Dv");
1923                   /* Non-constant vector size would be encoded with
1924                      _ expression, but we don't support that yet.  */
1925                   write_unsigned_number (TYPE_VECTOR_SUBPARTS (type));
1926                   write_char ('_');
1927                 }
1928               else
1929                 {
1930                   G.need_abi_warning = 1;
1931                   write_string ("U8__vector");
1932                 }
1933               write_type (TREE_TYPE (type));
1934               break;
1935
1936             case TYPE_PACK_EXPANSION:
1937               write_string ("Dp");
1938               write_type (PACK_EXPANSION_PATTERN (type));
1939               break;
1940
1941             case DECLTYPE_TYPE:
1942               /* These shouldn't make it into mangling.  */
1943               gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
1944                           && !DECLTYPE_FOR_LAMBDA_RETURN (type));
1945
1946               /* In ABI <5, we stripped decltype of a plain decl.  */
1947               if (!abi_version_at_least (5)
1948                   && DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
1949                 {
1950                   tree expr = DECLTYPE_TYPE_EXPR (type);
1951                   tree etype = NULL_TREE;
1952                   switch (TREE_CODE (expr))
1953                     {
1954                     case VAR_DECL:
1955                     case PARM_DECL:
1956                     case RESULT_DECL:
1957                     case FUNCTION_DECL:
1958                     case CONST_DECL:
1959                     case TEMPLATE_PARM_INDEX:
1960                       etype = TREE_TYPE (expr);
1961                       break;
1962
1963                     default:
1964                       break;
1965                     }
1966
1967                   if (etype && !type_uses_auto (etype))
1968                     {
1969                       G.need_abi_warning = 1;
1970                       write_type (etype);
1971                       return;
1972                     }
1973                 }
1974
1975               write_char ('D');
1976               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
1977                 write_char ('t');
1978               else
1979                 write_char ('T');
1980               ++cp_unevaluated_operand;
1981               write_expression (DECLTYPE_TYPE_EXPR (type));
1982               --cp_unevaluated_operand;
1983               write_char ('E');
1984               break;
1985
1986             case NULLPTR_TYPE:
1987               write_string ("Dn");
1988               break;
1989
1990             case TYPEOF_TYPE:
1991               sorry ("mangling typeof, use decltype instead");
1992               break;
1993
1994             case UNDERLYING_TYPE:
1995               sorry ("mangling __underlying_type");
1996               break;
1997
1998             case LANG_TYPE:
1999               /* fall through.  */
2000
2001             default:
2002               gcc_unreachable ();
2003             }
2004         }
2005     }
2006
2007   /* Types other than builtin types are substitution candidates.  */
2008   if (!is_builtin_type)
2009     add_substitution (type);
2010 }
2011
2012 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
2013    CV-qualifiers written for TYPE.
2014
2015      <CV-qualifiers> ::= [r] [V] [K]  */
2016
2017 static int
2018 write_CV_qualifiers_for_type (const tree type)
2019 {
2020   int num_qualifiers = 0;
2021
2022   /* The order is specified by:
2023
2024        "In cases where multiple order-insensitive qualifiers are
2025        present, they should be ordered 'K' (closest to the base type),
2026        'V', 'r', and 'U' (farthest from the base type) ..."
2027
2028      Note that we do not use cp_type_quals below; given "const
2029      int[3]", the "const" is emitted with the "int", not with the
2030      array.  */
2031   cp_cv_quals quals = TYPE_QUALS (type);
2032
2033   if (quals & TYPE_QUAL_RESTRICT)
2034     {
2035       write_char ('r');
2036       ++num_qualifiers;
2037     }
2038   if (quals & TYPE_QUAL_VOLATILE)
2039     {
2040       write_char ('V');
2041       ++num_qualifiers;
2042     }
2043   if (quals & TYPE_QUAL_CONST)
2044     {
2045       write_char ('K');
2046       ++num_qualifiers;
2047     }
2048
2049   return num_qualifiers;
2050 }
2051
2052 /* Non-terminal <builtin-type>.
2053
2054      <builtin-type> ::= v   # void
2055                     ::= b   # bool
2056                     ::= w   # wchar_t
2057                     ::= c   # char
2058                     ::= a   # signed char
2059                     ::= h   # unsigned char
2060                     ::= s   # short
2061                     ::= t   # unsigned short
2062                     ::= i   # int
2063                     ::= j   # unsigned int
2064                     ::= l   # long
2065                     ::= m   # unsigned long
2066                     ::= x   # long long, __int64
2067                     ::= y   # unsigned long long, __int64
2068                     ::= n   # __int128
2069                     ::= o   # unsigned __int128
2070                     ::= f   # float
2071                     ::= d   # double
2072                     ::= e   # long double, __float80
2073                     ::= g   # __float128          [not supported]
2074                     ::= u <source-name>  # vendor extended type */
2075
2076 static void
2077 write_builtin_type (tree type)
2078 {
2079   if (TYPE_CANONICAL (type))
2080     type = TYPE_CANONICAL (type);
2081
2082   switch (TREE_CODE (type))
2083     {
2084     case VOID_TYPE:
2085       write_char ('v');
2086       break;
2087
2088     case BOOLEAN_TYPE:
2089       write_char ('b');
2090       break;
2091
2092     case INTEGER_TYPE:
2093       /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2094          isn't in integer_type_nodes.  */
2095       if (type == wchar_type_node)
2096         write_char ('w');
2097       else if (type == char16_type_node)
2098         write_string ("Ds");
2099       else if (type == char32_type_node)
2100         write_string ("Di");
2101       else if (TYPE_FOR_JAVA (type))
2102         write_java_integer_type_codes (type);
2103       else
2104         {
2105           size_t itk;
2106           /* Assume TYPE is one of the shared integer type nodes.  Find
2107              it in the array of these nodes.  */
2108         iagain:
2109           for (itk = 0; itk < itk_none; ++itk)
2110             if (integer_types[itk] != NULL_TREE
2111                 && type == integer_types[itk])
2112               {
2113                 /* Print the corresponding single-letter code.  */
2114                 write_char (integer_type_codes[itk]);
2115                 break;
2116               }
2117
2118           if (itk == itk_none)
2119             {
2120               tree t = c_common_type_for_mode (TYPE_MODE (type),
2121                                                TYPE_UNSIGNED (type));
2122               if (type != t)
2123                 {
2124                   type = t;
2125                   goto iagain;
2126                 }
2127
2128               if (TYPE_PRECISION (type) == 128)
2129                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
2130               else
2131                 {
2132                   /* Allow for cases where TYPE is not one of the shared
2133                      integer type nodes and write a "vendor extended builtin
2134                      type" with a name the form intN or uintN, respectively.
2135                      Situations like this can happen if you have an
2136                      __attribute__((__mode__(__SI__))) type and use exotic
2137                      switches like '-mint8' on AVR.  Of course, this is
2138                      undefined by the C++ ABI (and '-mint8' is not even
2139                      Standard C conforming), but when using such special
2140                      options you're pretty much in nowhere land anyway.  */
2141                   const char *prefix;
2142                   char prec[11];        /* up to ten digits for an unsigned */
2143
2144                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
2145                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
2146                   write_char ('u');     /* "vendor extended builtin type" */
2147                   write_unsigned_number (strlen (prefix) + strlen (prec));
2148                   write_string (prefix);
2149                   write_string (prec);
2150                 }
2151             }
2152         }
2153       break;
2154
2155     case REAL_TYPE:
2156       if (type == float_type_node
2157           || type == java_float_type_node)
2158         write_char ('f');
2159       else if (type == double_type_node
2160                || type == java_double_type_node)
2161         write_char ('d');
2162       else if (type == long_double_type_node)
2163         write_char ('e');
2164       else if (type == dfloat32_type_node)
2165         write_string ("Df");
2166       else if (type == dfloat64_type_node)
2167         write_string ("Dd");
2168       else if (type == dfloat128_type_node)
2169         write_string ("De");
2170       else
2171         gcc_unreachable ();
2172       break;
2173
2174     case FIXED_POINT_TYPE:
2175       write_string ("DF");
2176       if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
2177         write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
2178       if (type == fract_type_node
2179           || type == sat_fract_type_node
2180           || type == accum_type_node
2181           || type == sat_accum_type_node)
2182         write_char ('i');
2183       else if (type == unsigned_fract_type_node
2184                || type == sat_unsigned_fract_type_node
2185                || type == unsigned_accum_type_node
2186                || type == sat_unsigned_accum_type_node)
2187         write_char ('j');
2188       else if (type == short_fract_type_node
2189                || type == sat_short_fract_type_node
2190                || type == short_accum_type_node
2191                || type == sat_short_accum_type_node)
2192         write_char ('s');
2193       else if (type == unsigned_short_fract_type_node
2194                || type == sat_unsigned_short_fract_type_node
2195                || type == unsigned_short_accum_type_node
2196                || type == sat_unsigned_short_accum_type_node)
2197         write_char ('t');
2198       else if (type == long_fract_type_node
2199                || type == sat_long_fract_type_node
2200                || type == long_accum_type_node
2201                || type == sat_long_accum_type_node)
2202         write_char ('l');
2203       else if (type == unsigned_long_fract_type_node
2204                || type == sat_unsigned_long_fract_type_node
2205                || type == unsigned_long_accum_type_node
2206                || type == sat_unsigned_long_accum_type_node)
2207         write_char ('m');
2208       else if (type == long_long_fract_type_node
2209                || type == sat_long_long_fract_type_node
2210                || type == long_long_accum_type_node
2211                || type == sat_long_long_accum_type_node)
2212         write_char ('x');
2213       else if (type == unsigned_long_long_fract_type_node
2214                || type == sat_unsigned_long_long_fract_type_node
2215                || type == unsigned_long_long_accum_type_node
2216                || type == sat_unsigned_long_long_accum_type_node)
2217         write_char ('y');
2218       else
2219         sorry ("mangling unknown fixed point type");
2220       write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
2221       if (TYPE_SATURATING (type))
2222         write_char ('s');
2223       else
2224         write_char ('n');
2225       break;
2226
2227     default:
2228       gcc_unreachable ();
2229     }
2230 }
2231
2232 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
2233    METHOD_TYPE.  The return type is mangled before the parameter
2234    types.
2235
2236      <function-type> ::= F [Y] <bare-function-type> E   */
2237
2238 static void
2239 write_function_type (const tree type)
2240 {
2241   MANGLE_TRACE_TREE ("function-type", type);
2242
2243   /* For a pointer to member function, the function type may have
2244      cv-qualifiers, indicating the quals for the artificial 'this'
2245      parameter.  */
2246   if (TREE_CODE (type) == METHOD_TYPE)
2247     {
2248       /* The first parameter must be a POINTER_TYPE pointing to the
2249          `this' parameter.  */
2250       tree this_type = class_of_this_parm (type);
2251       write_CV_qualifiers_for_type (this_type);
2252     }
2253
2254   write_char ('F');
2255   /* We don't track whether or not a type is `extern "C"'.  Note that
2256      you can have an `extern "C"' function that does not have
2257      `extern "C"' type, and vice versa:
2258
2259        extern "C" typedef void function_t();
2260        function_t f; // f has C++ linkage, but its type is
2261                      // `extern "C"'
2262
2263        typedef void function_t();
2264        extern "C" function_t f; // Vice versa.
2265
2266      See [dcl.link].  */
2267   write_bare_function_type (type, /*include_return_type_p=*/1,
2268                             /*decl=*/NULL);
2269   write_char ('E');
2270 }
2271
2272 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
2273    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
2274    is mangled before the parameter types.  If non-NULL, DECL is
2275    FUNCTION_DECL for the function whose type is being emitted.
2276
2277    If DECL is a member of a Java type, then a literal 'J'
2278    is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2279    were nonzero.
2280
2281      <bare-function-type> ::= [J]</signature/ type>+  */
2282
2283 static void
2284 write_bare_function_type (const tree type, const int include_return_type_p,
2285                           const tree decl)
2286 {
2287   int java_method_p;
2288
2289   MANGLE_TRACE_TREE ("bare-function-type", type);
2290
2291   /* Detect Java methods and emit special encoding.  */
2292   if (decl != NULL
2293       && DECL_FUNCTION_MEMBER_P (decl)
2294       && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
2295       && !DECL_CONSTRUCTOR_P (decl)
2296       && !DECL_DESTRUCTOR_P (decl)
2297       && !DECL_CONV_FN_P (decl))
2298     {
2299       java_method_p = 1;
2300       write_char ('J');
2301     }
2302   else
2303     {
2304       java_method_p = 0;
2305     }
2306
2307   /* Mangle the return type, if requested.  */
2308   if (include_return_type_p || java_method_p)
2309     write_type (TREE_TYPE (type));
2310
2311   /* Now mangle the types of the arguments.  */
2312   ++G.parm_depth;
2313   write_method_parms (TYPE_ARG_TYPES (type),
2314                       TREE_CODE (type) == METHOD_TYPE,
2315                       decl);
2316   --G.parm_depth;
2317 }
2318
2319 /* Write the mangled representation of a method parameter list of
2320    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
2321    considered a non-static method, and the this parameter is omitted.
2322    If non-NULL, DECL is the FUNCTION_DECL for the function whose
2323    parameters are being emitted.  */
2324
2325 static void
2326 write_method_parms (tree parm_types, const int method_p, const tree decl)
2327 {
2328   tree first_parm_type;
2329   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2330
2331   /* Assume this parameter type list is variable-length.  If it ends
2332      with a void type, then it's not.  */
2333   int varargs_p = 1;
2334
2335   /* If this is a member function, skip the first arg, which is the
2336      this pointer.
2337        "Member functions do not encode the type of their implicit this
2338        parameter."
2339
2340      Similarly, there's no need to mangle artificial parameters, like
2341      the VTT parameters for constructors and destructors.  */
2342   if (method_p)
2343     {
2344       parm_types = TREE_CHAIN (parm_types);
2345       parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
2346
2347       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2348         {
2349           parm_types = TREE_CHAIN (parm_types);
2350           parm_decl = DECL_CHAIN (parm_decl);
2351         }
2352     }
2353
2354   for (first_parm_type = parm_types;
2355        parm_types;
2356        parm_types = TREE_CHAIN (parm_types))
2357     {
2358       tree parm = TREE_VALUE (parm_types);
2359       if (parm == void_type_node)
2360         {
2361           /* "Empty parameter lists, whether declared as () or
2362              conventionally as (void), are encoded with a void parameter
2363              (v)."  */
2364           if (parm_types == first_parm_type)
2365             write_type (parm);
2366           /* If the parm list is terminated with a void type, it's
2367              fixed-length.  */
2368           varargs_p = 0;
2369           /* A void type better be the last one.  */
2370           gcc_assert (TREE_CHAIN (parm_types) == NULL);
2371         }
2372       else
2373         write_type (parm);
2374     }
2375
2376   if (varargs_p)
2377     /* <builtin-type> ::= z  # ellipsis  */
2378     write_char ('z');
2379 }
2380
2381 /* <class-enum-type> ::= <name>  */
2382
2383 static void
2384 write_class_enum_type (const tree type)
2385 {
2386   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2387 }
2388
2389 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
2390    arguments.
2391
2392      <template-args> ::= I <template-arg>* E  */
2393
2394 static void
2395 write_template_args (tree args)
2396 {
2397   int i;
2398   int length = 0;
2399
2400   MANGLE_TRACE_TREE ("template-args", args);
2401
2402   write_char ('I');
2403
2404   if (args)
2405     length = TREE_VEC_LENGTH (args);
2406
2407   if (args && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2408     {
2409       /* We have nested template args.  We want the innermost template
2410          argument list.  */
2411       args = TREE_VEC_ELT (args, length - 1);
2412       length = TREE_VEC_LENGTH (args);
2413     }
2414   for (i = 0; i < length; ++i)
2415     write_template_arg (TREE_VEC_ELT (args, i));
2416
2417   write_char ('E');
2418 }
2419
2420 /* Write out the
2421    <unqualified-name>
2422    <unqualified-name> <template-args>
2423    part of SCOPE_REF or COMPONENT_REF mangling.  */
2424
2425 static void
2426 write_member_name (tree member)
2427 {
2428   if (TREE_CODE (member) == IDENTIFIER_NODE)
2429     write_unqualified_id (member);
2430   else if (DECL_P (member))
2431     write_unqualified_name (member);
2432   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2433     {
2434       tree name = TREE_OPERAND (member, 0);
2435       if (TREE_CODE (name) == OVERLOAD)
2436         name = OVL_FUNCTION (name);
2437       write_member_name (name);
2438       write_template_args (TREE_OPERAND (member, 1));
2439     }
2440   else
2441     write_expression (member);
2442 }
2443
2444 /* <expression> ::= <unary operator-name> <expression>
2445                 ::= <binary operator-name> <expression> <expression>
2446                 ::= <expr-primary>
2447
2448    <expr-primary> ::= <template-param>
2449                   ::= L <type> <value number> E         # literal
2450                   ::= L <mangled-name> E                # external name
2451                   ::= st <type>                         # sizeof
2452                   ::= sr <type> <unqualified-name>      # dependent name
2453                   ::= sr <type> <unqualified-name> <template-args> */
2454
2455 static void
2456 write_expression (tree expr)
2457 {
2458   enum tree_code code = TREE_CODE (expr);
2459
2460   /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
2461      is converted (via qualification conversions) to another
2462      type.  */
2463   while (TREE_CODE (expr) == NOP_EXPR
2464          || TREE_CODE (expr) == NON_LVALUE_EXPR)
2465     {
2466       expr = TREE_OPERAND (expr, 0);
2467       code = TREE_CODE (expr);
2468     }
2469
2470   if (code == BASELINK)
2471     {
2472       expr = BASELINK_FUNCTIONS (expr);
2473       code = TREE_CODE (expr);
2474     }
2475
2476   /* Handle pointers-to-members by making them look like expression
2477      nodes.  */
2478   if (code == PTRMEM_CST)
2479     {
2480       expr = build_nt (ADDR_EXPR,
2481                        build_qualified_name (/*type=*/NULL_TREE,
2482                                              PTRMEM_CST_CLASS (expr),
2483                                              PTRMEM_CST_MEMBER (expr),
2484                                              /*template_p=*/false));
2485       code = TREE_CODE (expr);
2486     }
2487
2488   /* Handle template parameters.  */
2489   if (code == TEMPLATE_TYPE_PARM
2490       || code == TEMPLATE_TEMPLATE_PARM
2491       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2492       || code == TEMPLATE_PARM_INDEX)
2493     write_template_param (expr);
2494   /* Handle literals.  */
2495   else if (TREE_CODE_CLASS (code) == tcc_constant
2496            || (abi_version_at_least (2) && code == CONST_DECL))
2497     write_template_arg_literal (expr);
2498   else if (code == PARM_DECL)
2499     {
2500       /* A function parameter used in a late-specified return type.  */
2501       int index = DECL_PARM_INDEX (expr);
2502       int level = DECL_PARM_LEVEL (expr);
2503       int delta = G.parm_depth - level + 1;
2504       gcc_assert (index >= 1);
2505       write_char ('f');
2506       if (delta != 0)
2507         {
2508           if (abi_version_at_least (5))
2509             {
2510               /* Let L be the number of function prototype scopes from the
2511                  innermost one (in which the parameter reference occurs) up
2512                  to (and including) the one containing the declaration of
2513                  the referenced parameter.  If the parameter declaration
2514                  clause of the innermost function prototype scope has been
2515                  completely seen, it is not counted (in that case -- which
2516                  is perhaps the most common -- L can be zero).  */
2517               write_char ('L');
2518               write_unsigned_number (delta - 1);
2519             }
2520           else
2521             G.need_abi_warning = true;
2522         }
2523       write_char ('p');
2524       write_compact_number (index - 1);
2525     }
2526   else if (DECL_P (expr))
2527     {
2528       /* G++ 3.2 incorrectly mangled non-type template arguments of
2529          enumeration type using their names.  */
2530       if (code == CONST_DECL)
2531         G.need_abi_warning = 1;
2532       write_char ('L');
2533       write_mangled_name (expr, false);
2534       write_char ('E');
2535     }
2536   else if (TREE_CODE (expr) == SIZEOF_EXPR
2537            && TYPE_P (TREE_OPERAND (expr, 0)))
2538     {
2539       write_string ("st");
2540       write_type (TREE_OPERAND (expr, 0));
2541     }
2542   else if (TREE_CODE (expr) == ALIGNOF_EXPR
2543            && TYPE_P (TREE_OPERAND (expr, 0)))
2544     {
2545       write_string ("at");
2546       write_type (TREE_OPERAND (expr, 0));
2547     }
2548   else if (TREE_CODE (expr) == SCOPE_REF)
2549     {
2550       tree scope = TREE_OPERAND (expr, 0);
2551       tree member = TREE_OPERAND (expr, 1);
2552
2553       if (!abi_version_at_least (2) && DECL_P (member))
2554         {
2555           write_string ("sr");
2556           write_type (scope);
2557           /* G++ 3.2 incorrectly put out both the "sr" code and
2558              the nested name of the qualified name.  */
2559           G.need_abi_warning = 1;
2560           write_encoding (member);
2561         }
2562
2563       /* If the MEMBER is a real declaration, then the qualifying
2564          scope was not dependent.  Ideally, we would not have a
2565          SCOPE_REF in those cases, but sometimes we do.  If the second
2566          argument is a DECL, then the name must not have been
2567          dependent.  */
2568       else if (DECL_P (member))
2569         write_expression (member);
2570       else
2571         {
2572           write_string ("sr");
2573           write_type (scope);
2574           write_member_name (member);
2575         }
2576     }
2577   else if (TREE_CODE (expr) == INDIRECT_REF
2578            && TREE_TYPE (TREE_OPERAND (expr, 0))
2579            && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2580     {
2581       write_expression (TREE_OPERAND (expr, 0));
2582     }
2583   else if (TREE_CODE (expr) == IDENTIFIER_NODE)
2584     {
2585       /* An operator name appearing as a dependent name needs to be
2586          specially marked to disambiguate between a use of the operator
2587          name and a use of the operator in an expression.  */
2588       if (IDENTIFIER_OPNAME_P (expr))
2589         write_string ("on");
2590       write_unqualified_id (expr);
2591     }
2592   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
2593     {
2594       tree fn = TREE_OPERAND (expr, 0);
2595       if (is_overloaded_fn (fn))
2596         fn = DECL_NAME (get_first_fn (fn));
2597       if (IDENTIFIER_OPNAME_P (fn))
2598         write_string ("on");
2599       write_unqualified_id (fn);
2600       write_template_args (TREE_OPERAND (expr, 1));
2601     }
2602   else
2603     {
2604       int i, len;
2605       const char *name;
2606
2607       /* When we bind a variable or function to a non-type template
2608          argument with reference type, we create an ADDR_EXPR to show
2609          the fact that the entity's address has been taken.  But, we
2610          don't actually want to output a mangling code for the `&'.  */
2611       if (TREE_CODE (expr) == ADDR_EXPR
2612           && TREE_TYPE (expr)
2613           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2614         {
2615           expr = TREE_OPERAND (expr, 0);
2616           if (DECL_P (expr))
2617             {
2618               write_expression (expr);
2619               return;
2620             }
2621
2622           code = TREE_CODE (expr);
2623         }
2624
2625       if (code == COMPONENT_REF)
2626         {
2627           tree ob = TREE_OPERAND (expr, 0);
2628
2629           if (TREE_CODE (ob) == ARROW_EXPR)
2630             {
2631               write_string (operator_name_info[(int)code].mangled_name);
2632               ob = TREE_OPERAND (ob, 0);
2633             }
2634           else
2635             write_string ("dt");
2636
2637           write_expression (ob);
2638           write_member_name (TREE_OPERAND (expr, 1));
2639           return;
2640         }
2641
2642       /* If it wasn't any of those, recursively expand the expression.  */
2643       name = operator_name_info[(int) code].mangled_name;
2644       if (name == NULL)
2645         {
2646           sorry ("mangling %C", code);
2647           return;
2648         }
2649       else
2650         write_string (name);
2651
2652       switch (code)
2653         {
2654         case CALL_EXPR:
2655           {
2656             tree fn = CALL_EXPR_FN (expr);
2657
2658             if (TREE_CODE (fn) == ADDR_EXPR)
2659               fn = TREE_OPERAND (fn, 0);
2660
2661             /* Mangle a dependent name as the name, not whatever happens to
2662                be the first function in the overload set.  */
2663             if ((TREE_CODE (fn) == FUNCTION_DECL
2664                  || TREE_CODE (fn) == OVERLOAD)
2665                 && type_dependent_expression_p_push (expr))
2666               fn = DECL_NAME (get_first_fn (fn));
2667
2668             write_expression (fn);
2669           }
2670
2671           for (i = 0; i < call_expr_nargs (expr); ++i)
2672             write_expression (CALL_EXPR_ARG (expr, i));
2673           write_char ('E');
2674           break;
2675
2676         case CAST_EXPR:
2677           write_type (TREE_TYPE (expr));
2678           if (list_length (TREE_OPERAND (expr, 0)) == 1)
2679             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2680           else
2681             {
2682               tree args = TREE_OPERAND (expr, 0);
2683               write_char ('_');
2684               for (; args; args = TREE_CHAIN (args))
2685                 write_expression (TREE_VALUE (args));
2686               write_char ('E');
2687             }
2688           break;
2689
2690           /* FIXME these should have a distinct mangling.  */
2691         case STATIC_CAST_EXPR:
2692         case CONST_CAST_EXPR:
2693           write_type (TREE_TYPE (expr));
2694           write_expression (TREE_OPERAND (expr, 0));
2695           break;
2696
2697         case NEW_EXPR:
2698           sorry ("mangling new-expression");
2699           break;
2700
2701         default:
2702           /* In the middle-end, some expressions have more operands than
2703              they do in templates (and mangling).  */
2704           len = cp_tree_operand_length (expr);
2705
2706           for (i = 0; i < len; ++i)
2707             {
2708               tree operand = TREE_OPERAND (expr, i);
2709               /* As a GNU extension, the middle operand of a
2710                  conditional may be omitted.  Since expression
2711                  manglings are supposed to represent the input token
2712                  stream, there's no good way to mangle such an
2713                  expression without extending the C++ ABI.  */
2714               if (code == COND_EXPR && i == 1 && !operand)
2715                 {
2716                   error ("omitted middle operand to %<?:%> operand "
2717                          "cannot be mangled");
2718                   continue;
2719                 }
2720               write_expression (operand);
2721             }
2722         }
2723     }
2724 }
2725
2726 /* Literal subcase of non-terminal <template-arg>.
2727
2728      "Literal arguments, e.g. "A<42L>", are encoded with their type
2729      and value. Negative integer values are preceded with "n"; for
2730      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2731      encoded as 0, true as 1."  */
2732
2733 static void
2734 write_template_arg_literal (const tree value)
2735 {
2736   write_char ('L');
2737   write_type (TREE_TYPE (value));
2738
2739   switch (TREE_CODE (value))
2740     {
2741     case CONST_DECL:
2742       write_integer_cst (DECL_INITIAL (value));
2743       break;
2744
2745     case INTEGER_CST:
2746       gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2747                   || integer_zerop (value) || integer_onep (value));
2748       write_integer_cst (value);
2749       break;
2750
2751     case REAL_CST:
2752       write_real_cst (value);
2753       break;
2754
2755     case STRING_CST:
2756       sorry ("string literal in function template signature");
2757       break;
2758
2759     default:
2760       gcc_unreachable ();
2761     }
2762
2763   write_char ('E');
2764 }
2765
2766 /* Non-terminal <template-arg>.
2767
2768      <template-arg> ::= <type>                          # type
2769                     ::= L <type> </value/ number> E     # literal
2770                     ::= LZ <name> E                     # external name
2771                     ::= X <expression> E                # expression  */
2772
2773 static void
2774 write_template_arg (tree node)
2775 {
2776   enum tree_code code = TREE_CODE (node);
2777
2778   MANGLE_TRACE_TREE ("template-arg", node);
2779
2780   /* A template template parameter's argument list contains TREE_LIST
2781      nodes of which the value field is the actual argument.  */
2782   if (code == TREE_LIST)
2783     {
2784       node = TREE_VALUE (node);
2785       /* If it's a decl, deal with its type instead.  */
2786       if (DECL_P (node))
2787         {
2788           node = TREE_TYPE (node);
2789           code = TREE_CODE (node);
2790         }
2791     }
2792
2793   if (TREE_CODE (node) == NOP_EXPR
2794       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2795     {
2796       /* Template parameters can be of reference type. To maintain
2797          internal consistency, such arguments use a conversion from
2798          address of object to reference type.  */
2799       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2800       if (abi_version_at_least (2))
2801         node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2802       else
2803         G.need_abi_warning = 1;
2804     }
2805
2806   if (ARGUMENT_PACK_P (node))
2807     {
2808       /* Expand the template argument pack. */
2809       tree args = ARGUMENT_PACK_ARGS (node);
2810       int i, length = TREE_VEC_LENGTH (args);
2811       write_char ('I');
2812       for (i = 0; i < length; ++i)
2813         write_template_arg (TREE_VEC_ELT (args, i));
2814       write_char ('E');
2815     }
2816   else if (TYPE_P (node))
2817     write_type (node);
2818   else if (code == TEMPLATE_DECL)
2819     /* A template appearing as a template arg is a template template arg.  */
2820     write_template_template_arg (node);
2821   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
2822            || (abi_version_at_least (2) && code == CONST_DECL))
2823     write_template_arg_literal (node);
2824   else if (DECL_P (node))
2825     {
2826       /* Until ABI version 2, non-type template arguments of
2827          enumeration type were mangled using their names.  */
2828       if (code == CONST_DECL && !abi_version_at_least (2))
2829         G.need_abi_warning = 1;
2830       write_char ('L');
2831       /* Until ABI version 3, the underscore before the mangled name
2832          was incorrectly omitted.  */
2833       if (!abi_version_at_least (3))
2834         {
2835           G.need_abi_warning = 1;
2836           write_char ('Z');
2837         }
2838       else
2839         write_string ("_Z");
2840       write_encoding (node);
2841       write_char ('E');
2842     }
2843   else
2844     {
2845       /* Template arguments may be expressions.  */
2846       write_char ('X');
2847       write_expression (node);
2848       write_char ('E');
2849     }
2850 }
2851
2852 /*  <template-template-arg>
2853                         ::= <name>
2854                         ::= <substitution>  */
2855
2856 static void
2857 write_template_template_arg (const tree decl)
2858 {
2859   MANGLE_TRACE_TREE ("template-template-arg", decl);
2860
2861   if (find_substitution (decl))
2862     return;
2863   write_name (decl, /*ignore_local_scope=*/0);
2864   add_substitution (decl);
2865 }
2866
2867
2868 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2869
2870      <array-type> ::= A [</dimension/ number>] _ </element/ type>
2871                   ::= A <expression> _ </element/ type>
2872
2873      "Array types encode the dimension (number of elements) and the
2874      element type. For variable length arrays, the dimension (but not
2875      the '_' separator) is omitted."  */
2876
2877 static void
2878 write_array_type (const tree type)
2879 {
2880   write_char ('A');
2881   if (TYPE_DOMAIN (type))
2882     {
2883       tree index_type;
2884       tree max;
2885
2886       index_type = TYPE_DOMAIN (type);
2887       /* The INDEX_TYPE gives the upper and lower bounds of the
2888          array.  */
2889       max = TYPE_MAX_VALUE (index_type);
2890       if (TREE_CODE (max) == INTEGER_CST)
2891         {
2892           /* The ABI specifies that we should mangle the number of
2893              elements in the array, not the largest allowed index.  */
2894           max = size_binop (PLUS_EXPR, max, size_one_node);
2895           write_unsigned_number (tree_low_cst (max, 1));
2896         }
2897       else
2898         {
2899           max = TREE_OPERAND (max, 0);
2900           if (!abi_version_at_least (2))
2901             {
2902               /* value_dependent_expression_p presumes nothing is
2903                  dependent when PROCESSING_TEMPLATE_DECL is zero.  */
2904               ++processing_template_decl;
2905               if (!value_dependent_expression_p (max))
2906                 G.need_abi_warning = 1;
2907               --processing_template_decl;
2908             }
2909           write_expression (max);
2910         }
2911
2912     }
2913   write_char ('_');
2914   write_type (TREE_TYPE (type));
2915 }
2916
2917 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2918    variables.  TYPE is a pointer-to-member POINTER_TYPE.
2919
2920      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2921
2922 static void
2923 write_pointer_to_member_type (const tree type)
2924 {
2925   write_char ('M');
2926   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2927   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2928 }
2929
2930 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2931    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2932    TEMPLATE_PARM_INDEX.
2933
2934      <template-param> ::= T </parameter/ number> _  */
2935
2936 static void
2937 write_template_param (const tree parm)
2938 {
2939   int parm_index;
2940
2941   MANGLE_TRACE_TREE ("template-parm", parm);
2942
2943   switch (TREE_CODE (parm))
2944     {
2945     case TEMPLATE_TYPE_PARM:
2946     case TEMPLATE_TEMPLATE_PARM:
2947     case BOUND_TEMPLATE_TEMPLATE_PARM:
2948       parm_index = TEMPLATE_TYPE_IDX (parm);
2949       break;
2950
2951     case TEMPLATE_PARM_INDEX:
2952       parm_index = TEMPLATE_PARM_IDX (parm);
2953       break;
2954
2955     default:
2956       gcc_unreachable ();
2957     }
2958
2959   write_char ('T');
2960   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2961      earliest template param denoted by `_'.  */
2962   write_compact_number (parm_index);
2963 }
2964
2965 /*  <template-template-param>
2966                         ::= <template-param>
2967                         ::= <substitution>  */
2968
2969 static void
2970 write_template_template_param (const tree parm)
2971 {
2972   tree templ = NULL_TREE;
2973
2974   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2975      template template parameter.  The substitution candidate here is
2976      only the template.  */
2977   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2978     {
2979       templ
2980         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2981       if (find_substitution (templ))
2982         return;
2983     }
2984
2985   /* <template-param> encodes only the template parameter position,
2986      not its template arguments, which is fine here.  */
2987   write_template_param (parm);
2988   if (templ)
2989     add_substitution (templ);
2990 }
2991
2992 /* Non-terminal <substitution>.
2993
2994       <substitution> ::= S <seq-id> _
2995                      ::= S_  */
2996
2997 static void
2998 write_substitution (const int seq_id)
2999 {
3000   MANGLE_TRACE ("substitution", "");
3001
3002   write_char ('S');
3003   if (seq_id > 0)
3004     write_number (seq_id - 1, /*unsigned=*/1, 36);
3005   write_char ('_');
3006 }
3007
3008 /* Start mangling ENTITY.  */
3009
3010 static inline void
3011 start_mangling (const tree entity)
3012 {
3013   G.entity = entity;
3014   G.need_abi_warning = false;
3015   obstack_free (&name_obstack, name_base);
3016   mangle_obstack = &name_obstack;
3017   name_base = obstack_alloc (&name_obstack, 0);
3018 }
3019
3020 /* Done with mangling. If WARN is true, and the name of G.entity will
3021    be mangled differently in a future version of the ABI, issue a
3022    warning.  */
3023
3024 static void
3025 finish_mangling_internal (const bool warn)
3026 {
3027   if (warn_abi && warn && G.need_abi_warning)
3028     warning (OPT_Wabi, "the mangled name of %qD will change in a future "
3029              "version of GCC",
3030              G.entity);
3031
3032   /* Clear all the substitutions.  */
3033   VEC_truncate (tree, G.substitutions, 0);
3034
3035   /* Null-terminate the string.  */
3036   write_char ('\0');
3037 }
3038
3039
3040 /* Like finish_mangling_internal, but return the mangled string.  */
3041
3042 static inline const char *
3043 finish_mangling (const bool warn)
3044 {
3045   finish_mangling_internal (warn);
3046   return (const char *) obstack_finish (mangle_obstack);
3047 }
3048
3049 /* Like finish_mangling_internal, but return an identifier.  */
3050
3051 static tree
3052 finish_mangling_get_identifier (const bool warn)
3053 {
3054   finish_mangling_internal (warn);
3055   /* Don't obstack_finish here, and the next start_mangling will
3056      remove the identifier.  */
3057   return get_identifier ((const char *) obstack_base (mangle_obstack));
3058 }
3059
3060 /* Initialize data structures for mangling.  */
3061
3062 void
3063 init_mangle (void)
3064 {
3065   gcc_obstack_init (&name_obstack);
3066   name_base = obstack_alloc (&name_obstack, 0);
3067   G.substitutions = NULL;
3068
3069   /* Cache these identifiers for quick comparison when checking for
3070      standard substitutions.  */
3071   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
3072   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
3073   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
3074   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
3075   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
3076   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
3077 }
3078
3079 /* Generate the mangled name of DECL.  */
3080
3081 static tree
3082 mangle_decl_string (const tree decl)
3083 {
3084   tree result;
3085   location_t saved_loc = input_location;
3086   tree saved_fn = NULL_TREE;
3087   bool template_p = false;
3088
3089   if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3090     {
3091       struct tinst_level *tl = current_instantiation ();
3092       if (!tl || tl->decl != decl)
3093         {
3094           template_p = true;
3095           saved_fn = current_function_decl;
3096           push_tinst_level (decl);
3097           current_function_decl = NULL_TREE;
3098         }
3099     }
3100   input_location = DECL_SOURCE_LOCATION (decl);
3101
3102   start_mangling (decl);
3103
3104   if (TREE_CODE (decl) == TYPE_DECL)
3105     write_type (TREE_TYPE (decl));
3106   else
3107     write_mangled_name (decl, true);
3108
3109   result = finish_mangling_get_identifier (/*warn=*/true);
3110   if (DEBUG_MANGLE)
3111     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
3112              IDENTIFIER_POINTER (result));
3113
3114   if (template_p)
3115     {
3116       pop_tinst_level ();
3117       current_function_decl = saved_fn;
3118     }
3119   input_location = saved_loc;
3120
3121   return result;
3122 }
3123
3124 /* Create an identifier for the external mangled name of DECL.  */
3125
3126 void
3127 mangle_decl (const tree decl)
3128 {
3129   tree id = mangle_decl_string (decl);
3130   id = targetm.mangle_decl_assembler_name (decl, id);
3131   SET_DECL_ASSEMBLER_NAME (decl, id);
3132
3133   if (G.need_abi_warning)
3134     {
3135 #ifdef ASM_OUTPUT_DEF
3136       /* If the mangling will change in the future, emit an alias with the
3137          future mangled name for forward-compatibility.  */
3138       int save_ver;
3139       tree id2, alias;
3140 #endif
3141
3142       SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3143       if (IDENTIFIER_GLOBAL_VALUE (id) != decl)
3144         inform (DECL_SOURCE_LOCATION (decl), "-fabi-version=4 (or =0) "
3145                 "avoids this error with a change in vector mangling");
3146
3147 #ifdef ASM_OUTPUT_DEF
3148       save_ver = flag_abi_version;
3149       flag_abi_version = 0;
3150       id2 = mangle_decl_string (decl);
3151       id2 = targetm.mangle_decl_assembler_name (decl, id2);
3152       flag_abi_version = save_ver;
3153
3154       alias = make_alias_for (decl, id2);
3155       DECL_IGNORED_P (alias) = 1;
3156       TREE_PUBLIC (alias) = TREE_PUBLIC (decl);
3157       DECL_VISIBILITY (alias) = DECL_VISIBILITY (decl);
3158       if (vague_linkage_p (decl))
3159         DECL_WEAK (alias) = 1;
3160       if (TREE_CODE (decl) == FUNCTION_DECL)
3161         cgraph_same_body_alias (cgraph_get_create_node (decl), alias, decl);
3162       else
3163         varpool_extra_name_alias (alias, decl);
3164 #endif
3165     }
3166 }
3167
3168 /* Generate the mangled representation of TYPE.  */
3169
3170 const char *
3171 mangle_type_string (const tree type)
3172 {
3173   const char *result;
3174
3175   start_mangling (type);
3176   write_type (type);
3177   result = finish_mangling (/*warn=*/false);
3178   if (DEBUG_MANGLE)
3179     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
3180   return result;
3181 }
3182
3183 /* Create an identifier for the mangled name of a special component
3184    for belonging to TYPE.  CODE is the ABI-specified code for this
3185    component.  */
3186
3187 static tree
3188 mangle_special_for_type (const tree type, const char *code)
3189 {
3190   tree result;
3191
3192   /* We don't have an actual decl here for the special component, so
3193      we can't just process the <encoded-name>.  Instead, fake it.  */
3194   start_mangling (type);
3195
3196   /* Start the mangling.  */
3197   write_string ("_Z");
3198   write_string (code);
3199
3200   /* Add the type.  */
3201   write_type (type);
3202   result = finish_mangling_get_identifier (/*warn=*/false);
3203
3204   if (DEBUG_MANGLE)
3205     fprintf (stderr, "mangle_special_for_type = %s\n\n",
3206              IDENTIFIER_POINTER (result));
3207
3208   return result;
3209 }
3210
3211 /* Create an identifier for the mangled representation of the typeinfo
3212    structure for TYPE.  */
3213
3214 tree
3215 mangle_typeinfo_for_type (const tree type)
3216 {
3217   return mangle_special_for_type (type, "TI");
3218 }
3219
3220 /* Create an identifier for the mangled name of the NTBS containing
3221    the mangled name of TYPE.  */
3222
3223 tree
3224 mangle_typeinfo_string_for_type (const tree type)
3225 {
3226   return mangle_special_for_type (type, "TS");
3227 }
3228
3229 /* Create an identifier for the mangled name of the vtable for TYPE.  */
3230
3231 tree
3232 mangle_vtbl_for_type (const tree type)
3233 {
3234   return mangle_special_for_type (type, "TV");
3235 }
3236
3237 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
3238
3239 tree
3240 mangle_vtt_for_type (const tree type)
3241 {
3242   return mangle_special_for_type (type, "TT");
3243 }
3244
3245 /* Return an identifier for a construction vtable group.  TYPE is
3246    the most derived class in the hierarchy; BINFO is the base
3247    subobject for which this construction vtable group will be used.
3248
3249    This mangling isn't part of the ABI specification; in the ABI
3250    specification, the vtable group is dumped in the same COMDAT as the
3251    main vtable, and is referenced only from that vtable, so it doesn't
3252    need an external name.  For binary formats without COMDAT sections,
3253    though, we need external names for the vtable groups.
3254
3255    We use the production
3256
3257     <special-name> ::= CT <type> <offset number> _ <base type>  */
3258
3259 tree
3260 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
3261 {
3262   tree result;
3263
3264   start_mangling (type);
3265
3266   write_string ("_Z");
3267   write_string ("TC");
3268   write_type (type);
3269   write_integer_cst (BINFO_OFFSET (binfo));
3270   write_char ('_');
3271   write_type (BINFO_TYPE (binfo));
3272
3273   result = finish_mangling_get_identifier (/*warn=*/false);
3274   if (DEBUG_MANGLE)
3275     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
3276              IDENTIFIER_POINTER (result));
3277   return result;
3278 }
3279
3280 /* Mangle a this pointer or result pointer adjustment.
3281
3282    <call-offset> ::= h <fixed offset number> _
3283                  ::= v <fixed offset number> _ <virtual offset number> _ */
3284
3285 static void
3286 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
3287 {
3288   write_char (virtual_offset ? 'v' : 'h');
3289
3290   /* For either flavor, write the fixed offset.  */
3291   write_integer_cst (fixed_offset);
3292   write_char ('_');
3293
3294   /* For a virtual thunk, add the virtual offset.  */
3295   if (virtual_offset)
3296     {
3297       write_integer_cst (virtual_offset);
3298       write_char ('_');
3299     }
3300 }
3301
3302 /* Return an identifier for the mangled name of a this-adjusting or
3303    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
3304    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
3305    is a virtual thunk, and it is the vtbl offset in
3306    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
3307    zero for a covariant thunk. Note, that FN_DECL might be a covariant
3308    thunk itself. A covariant thunk name always includes the adjustment
3309    for the this pointer, even if there is none.
3310
3311    <special-name> ::= T <call-offset> <base encoding>
3312                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
3313                                         <base encoding>  */
3314
3315 tree
3316 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
3317               tree virtual_offset)
3318 {
3319   tree result;
3320
3321   start_mangling (fn_decl);
3322
3323   write_string ("_Z");
3324   write_char ('T');
3325
3326   if (!this_adjusting)
3327     {
3328       /* Covariant thunk with no this adjustment */
3329       write_char ('c');
3330       mangle_call_offset (integer_zero_node, NULL_TREE);
3331       mangle_call_offset (fixed_offset, virtual_offset);
3332     }
3333   else if (!DECL_THUNK_P (fn_decl))
3334     /* Plain this adjusting thunk.  */
3335     mangle_call_offset (fixed_offset, virtual_offset);
3336   else
3337     {
3338       /* This adjusting thunk to covariant thunk.  */
3339       write_char ('c');
3340       mangle_call_offset (fixed_offset, virtual_offset);
3341       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
3342       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
3343       if (virtual_offset)
3344         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
3345       mangle_call_offset (fixed_offset, virtual_offset);
3346       fn_decl = THUNK_TARGET (fn_decl);
3347     }
3348
3349   /* Scoped name.  */
3350   write_encoding (fn_decl);
3351
3352   result = finish_mangling_get_identifier (/*warn=*/false);
3353   if (DEBUG_MANGLE)
3354     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
3355   return result;
3356 }
3357
3358 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3359    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
3360    TYPE.  */
3361
3362 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
3363
3364 /* Hash a node (VAL1) in the table.  */
3365
3366 static hashval_t
3367 hash_type (const void *val)
3368 {
3369   return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val));
3370 }
3371
3372 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
3373
3374 static int
3375 compare_type (const void *val1, const void *val2)
3376 {
3377   return TREE_TYPE ((const_tree) val1) == (const_tree) val2;
3378 }
3379
3380 /* Return an identifier for the mangled unqualified name for a
3381    conversion operator to TYPE.  This mangling is not specified by the
3382    ABI spec; it is only used internally.  */
3383
3384 tree
3385 mangle_conv_op_name_for_type (const tree type)
3386 {
3387   void **slot;
3388   tree identifier;
3389
3390   if (type == error_mark_node)
3391     return error_mark_node;
3392
3393   if (conv_type_names == NULL)
3394     conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
3395
3396   slot = htab_find_slot_with_hash (conv_type_names, type,
3397                                    (hashval_t) TYPE_UID (type), INSERT);
3398   identifier = (tree)*slot;
3399   if (!identifier)
3400     {
3401       char buffer[64];
3402
3403        /* Create a unique name corresponding to TYPE.  */
3404       sprintf (buffer, "operator %lu",
3405                (unsigned long) htab_elements (conv_type_names));
3406       identifier = get_identifier (buffer);
3407       *slot = identifier;
3408
3409       /* Hang TYPE off the identifier so it can be found easily later
3410          when performing conversions.  */
3411       TREE_TYPE (identifier) = type;
3412
3413       /* Set bits on the identifier so we know later it's a conversion.  */
3414       IDENTIFIER_OPNAME_P (identifier) = 1;
3415       IDENTIFIER_TYPENAME_P (identifier) = 1;
3416     }
3417
3418   return identifier;
3419 }
3420
3421 /* Return an identifier for the name of an initialization guard
3422    variable for indicated VARIABLE.  */
3423
3424 tree
3425 mangle_guard_variable (const tree variable)
3426 {
3427   start_mangling (variable);
3428   write_string ("_ZGV");
3429   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
3430     /* The name of a guard variable for a reference temporary should refer
3431        to the reference, not the temporary.  */
3432     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
3433   else
3434     write_name (variable, /*ignore_local_scope=*/0);
3435   return finish_mangling_get_identifier (/*warn=*/false);
3436 }
3437
3438 /* Return an identifier for the name of a temporary variable used to
3439    initialize a static reference.  This isn't part of the ABI, but we might
3440    as well call them something readable.  */
3441
3442 tree
3443 mangle_ref_init_variable (const tree variable)
3444 {
3445   start_mangling (variable);
3446   write_string ("_ZGR");
3447   write_name (variable, /*ignore_local_scope=*/0);
3448   return finish_mangling_get_identifier (/*warn=*/false);
3449 }
3450 \f
3451
3452 /* Foreign language type mangling section.  */
3453
3454 /* How to write the type codes for the integer Java type.  */
3455
3456 static void
3457 write_java_integer_type_codes (const tree type)
3458 {
3459   if (type == java_int_type_node)
3460     write_char ('i');
3461   else if (type == java_short_type_node)
3462     write_char ('s');
3463   else if (type == java_byte_type_node)
3464     write_char ('c');
3465   else if (type == java_char_type_node)
3466     write_char ('w');
3467   else if (type == java_long_type_node)
3468     write_char ('x');
3469   else if (type == java_boolean_type_node)
3470     write_char ('b');
3471   else
3472     gcc_unreachable ();
3473 }
3474
3475 #include "gt-cp-mangle.h"