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 LANG_TYPE:
1995               /* fall through.  */
1996
1997             default:
1998               gcc_unreachable ();
1999             }
2000         }
2001     }
2002
2003   /* Types other than builtin types are substitution candidates.  */
2004   if (!is_builtin_type)
2005     add_substitution (type);
2006 }
2007
2008 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
2009    CV-qualifiers written for TYPE.
2010
2011      <CV-qualifiers> ::= [r] [V] [K]  */
2012
2013 static int
2014 write_CV_qualifiers_for_type (const tree type)
2015 {
2016   int num_qualifiers = 0;
2017
2018   /* The order is specified by:
2019
2020        "In cases where multiple order-insensitive qualifiers are
2021        present, they should be ordered 'K' (closest to the base type),
2022        'V', 'r', and 'U' (farthest from the base type) ..."
2023
2024      Note that we do not use cp_type_quals below; given "const
2025      int[3]", the "const" is emitted with the "int", not with the
2026      array.  */
2027   cp_cv_quals quals = TYPE_QUALS (type);
2028
2029   if (quals & TYPE_QUAL_RESTRICT)
2030     {
2031       write_char ('r');
2032       ++num_qualifiers;
2033     }
2034   if (quals & TYPE_QUAL_VOLATILE)
2035     {
2036       write_char ('V');
2037       ++num_qualifiers;
2038     }
2039   if (quals & TYPE_QUAL_CONST)
2040     {
2041       write_char ('K');
2042       ++num_qualifiers;
2043     }
2044
2045   return num_qualifiers;
2046 }
2047
2048 /* Non-terminal <builtin-type>.
2049
2050      <builtin-type> ::= v   # void
2051                     ::= b   # bool
2052                     ::= w   # wchar_t
2053                     ::= c   # char
2054                     ::= a   # signed char
2055                     ::= h   # unsigned char
2056                     ::= s   # short
2057                     ::= t   # unsigned short
2058                     ::= i   # int
2059                     ::= j   # unsigned int
2060                     ::= l   # long
2061                     ::= m   # unsigned long
2062                     ::= x   # long long, __int64
2063                     ::= y   # unsigned long long, __int64
2064                     ::= n   # __int128
2065                     ::= o   # unsigned __int128
2066                     ::= f   # float
2067                     ::= d   # double
2068                     ::= e   # long double, __float80
2069                     ::= g   # __float128          [not supported]
2070                     ::= u <source-name>  # vendor extended type */
2071
2072 static void
2073 write_builtin_type (tree type)
2074 {
2075   if (TYPE_CANONICAL (type))
2076     type = TYPE_CANONICAL (type);
2077
2078   switch (TREE_CODE (type))
2079     {
2080     case VOID_TYPE:
2081       write_char ('v');
2082       break;
2083
2084     case BOOLEAN_TYPE:
2085       write_char ('b');
2086       break;
2087
2088     case INTEGER_TYPE:
2089       /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2090          isn't in integer_type_nodes.  */
2091       if (type == wchar_type_node)
2092         write_char ('w');
2093       else if (type == char16_type_node)
2094         write_string ("Ds");
2095       else if (type == char32_type_node)
2096         write_string ("Di");
2097       else if (TYPE_FOR_JAVA (type))
2098         write_java_integer_type_codes (type);
2099       else
2100         {
2101           size_t itk;
2102           /* Assume TYPE is one of the shared integer type nodes.  Find
2103              it in the array of these nodes.  */
2104         iagain:
2105           for (itk = 0; itk < itk_none; ++itk)
2106             if (integer_types[itk] != NULL_TREE
2107                 && type == integer_types[itk])
2108               {
2109                 /* Print the corresponding single-letter code.  */
2110                 write_char (integer_type_codes[itk]);
2111                 break;
2112               }
2113
2114           if (itk == itk_none)
2115             {
2116               tree t = c_common_type_for_mode (TYPE_MODE (type),
2117                                                TYPE_UNSIGNED (type));
2118               if (type != t)
2119                 {
2120                   type = t;
2121                   goto iagain;
2122                 }
2123
2124               if (TYPE_PRECISION (type) == 128)
2125                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
2126               else
2127                 {
2128                   /* Allow for cases where TYPE is not one of the shared
2129                      integer type nodes and write a "vendor extended builtin
2130                      type" with a name the form intN or uintN, respectively.
2131                      Situations like this can happen if you have an
2132                      __attribute__((__mode__(__SI__))) type and use exotic
2133                      switches like '-mint8' on AVR.  Of course, this is
2134                      undefined by the C++ ABI (and '-mint8' is not even
2135                      Standard C conforming), but when using such special
2136                      options you're pretty much in nowhere land anyway.  */
2137                   const char *prefix;
2138                   char prec[11];        /* up to ten digits for an unsigned */
2139
2140                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
2141                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
2142                   write_char ('u');     /* "vendor extended builtin type" */
2143                   write_unsigned_number (strlen (prefix) + strlen (prec));
2144                   write_string (prefix);
2145                   write_string (prec);
2146                 }
2147             }
2148         }
2149       break;
2150
2151     case REAL_TYPE:
2152       if (type == float_type_node
2153           || type == java_float_type_node)
2154         write_char ('f');
2155       else if (type == double_type_node
2156                || type == java_double_type_node)
2157         write_char ('d');
2158       else if (type == long_double_type_node)
2159         write_char ('e');
2160       else if (type == dfloat32_type_node)
2161         write_string ("Df");
2162       else if (type == dfloat64_type_node)
2163         write_string ("Dd");
2164       else if (type == dfloat128_type_node)
2165         write_string ("De");
2166       else
2167         gcc_unreachable ();
2168       break;
2169
2170     case FIXED_POINT_TYPE:
2171       write_string ("DF");
2172       if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
2173         write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
2174       if (type == fract_type_node
2175           || type == sat_fract_type_node
2176           || type == accum_type_node
2177           || type == sat_accum_type_node)
2178         write_char ('i');
2179       else if (type == unsigned_fract_type_node
2180                || type == sat_unsigned_fract_type_node
2181                || type == unsigned_accum_type_node
2182                || type == sat_unsigned_accum_type_node)
2183         write_char ('j');
2184       else if (type == short_fract_type_node
2185                || type == sat_short_fract_type_node
2186                || type == short_accum_type_node
2187                || type == sat_short_accum_type_node)
2188         write_char ('s');
2189       else if (type == unsigned_short_fract_type_node
2190                || type == sat_unsigned_short_fract_type_node
2191                || type == unsigned_short_accum_type_node
2192                || type == sat_unsigned_short_accum_type_node)
2193         write_char ('t');
2194       else if (type == long_fract_type_node
2195                || type == sat_long_fract_type_node
2196                || type == long_accum_type_node
2197                || type == sat_long_accum_type_node)
2198         write_char ('l');
2199       else if (type == unsigned_long_fract_type_node
2200                || type == sat_unsigned_long_fract_type_node
2201                || type == unsigned_long_accum_type_node
2202                || type == sat_unsigned_long_accum_type_node)
2203         write_char ('m');
2204       else if (type == long_long_fract_type_node
2205                || type == sat_long_long_fract_type_node
2206                || type == long_long_accum_type_node
2207                || type == sat_long_long_accum_type_node)
2208         write_char ('x');
2209       else if (type == unsigned_long_long_fract_type_node
2210                || type == sat_unsigned_long_long_fract_type_node
2211                || type == unsigned_long_long_accum_type_node
2212                || type == sat_unsigned_long_long_accum_type_node)
2213         write_char ('y');
2214       else
2215         sorry ("mangling unknown fixed point type");
2216       write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
2217       if (TYPE_SATURATING (type))
2218         write_char ('s');
2219       else
2220         write_char ('n');
2221       break;
2222
2223     default:
2224       gcc_unreachable ();
2225     }
2226 }
2227
2228 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
2229    METHOD_TYPE.  The return type is mangled before the parameter
2230    types.
2231
2232      <function-type> ::= F [Y] <bare-function-type> E   */
2233
2234 static void
2235 write_function_type (const tree type)
2236 {
2237   MANGLE_TRACE_TREE ("function-type", type);
2238
2239   /* For a pointer to member function, the function type may have
2240      cv-qualifiers, indicating the quals for the artificial 'this'
2241      parameter.  */
2242   if (TREE_CODE (type) == METHOD_TYPE)
2243     {
2244       /* The first parameter must be a POINTER_TYPE pointing to the
2245          `this' parameter.  */
2246       tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
2247       write_CV_qualifiers_for_type (this_type);
2248     }
2249
2250   write_char ('F');
2251   /* We don't track whether or not a type is `extern "C"'.  Note that
2252      you can have an `extern "C"' function that does not have
2253      `extern "C"' type, and vice versa:
2254
2255        extern "C" typedef void function_t();
2256        function_t f; // f has C++ linkage, but its type is
2257                      // `extern "C"'
2258
2259        typedef void function_t();
2260        extern "C" function_t f; // Vice versa.
2261
2262      See [dcl.link].  */
2263   write_bare_function_type (type, /*include_return_type_p=*/1,
2264                             /*decl=*/NULL);
2265   write_char ('E');
2266 }
2267
2268 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
2269    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
2270    is mangled before the parameter types.  If non-NULL, DECL is
2271    FUNCTION_DECL for the function whose type is being emitted.
2272
2273    If DECL is a member of a Java type, then a literal 'J'
2274    is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2275    were nonzero.
2276
2277      <bare-function-type> ::= [J]</signature/ type>+  */
2278
2279 static void
2280 write_bare_function_type (const tree type, const int include_return_type_p,
2281                           const tree decl)
2282 {
2283   int java_method_p;
2284
2285   MANGLE_TRACE_TREE ("bare-function-type", type);
2286
2287   /* Detect Java methods and emit special encoding.  */
2288   if (decl != NULL
2289       && DECL_FUNCTION_MEMBER_P (decl)
2290       && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
2291       && !DECL_CONSTRUCTOR_P (decl)
2292       && !DECL_DESTRUCTOR_P (decl)
2293       && !DECL_CONV_FN_P (decl))
2294     {
2295       java_method_p = 1;
2296       write_char ('J');
2297     }
2298   else
2299     {
2300       java_method_p = 0;
2301     }
2302
2303   /* Mangle the return type, if requested.  */
2304   if (include_return_type_p || java_method_p)
2305     write_type (TREE_TYPE (type));
2306
2307   /* Now mangle the types of the arguments.  */
2308   ++G.parm_depth;
2309   write_method_parms (TYPE_ARG_TYPES (type),
2310                       TREE_CODE (type) == METHOD_TYPE,
2311                       decl);
2312   --G.parm_depth;
2313 }
2314
2315 /* Write the mangled representation of a method parameter list of
2316    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
2317    considered a non-static method, and the this parameter is omitted.
2318    If non-NULL, DECL is the FUNCTION_DECL for the function whose
2319    parameters are being emitted.  */
2320
2321 static void
2322 write_method_parms (tree parm_types, const int method_p, const tree decl)
2323 {
2324   tree first_parm_type;
2325   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2326
2327   /* Assume this parameter type list is variable-length.  If it ends
2328      with a void type, then it's not.  */
2329   int varargs_p = 1;
2330
2331   /* If this is a member function, skip the first arg, which is the
2332      this pointer.
2333        "Member functions do not encode the type of their implicit this
2334        parameter."
2335
2336      Similarly, there's no need to mangle artificial parameters, like
2337      the VTT parameters for constructors and destructors.  */
2338   if (method_p)
2339     {
2340       parm_types = TREE_CHAIN (parm_types);
2341       parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
2342
2343       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2344         {
2345           parm_types = TREE_CHAIN (parm_types);
2346           parm_decl = DECL_CHAIN (parm_decl);
2347         }
2348     }
2349
2350   for (first_parm_type = parm_types;
2351        parm_types;
2352        parm_types = TREE_CHAIN (parm_types))
2353     {
2354       tree parm = TREE_VALUE (parm_types);
2355       if (parm == void_type_node)
2356         {
2357           /* "Empty parameter lists, whether declared as () or
2358              conventionally as (void), are encoded with a void parameter
2359              (v)."  */
2360           if (parm_types == first_parm_type)
2361             write_type (parm);
2362           /* If the parm list is terminated with a void type, it's
2363              fixed-length.  */
2364           varargs_p = 0;
2365           /* A void type better be the last one.  */
2366           gcc_assert (TREE_CHAIN (parm_types) == NULL);
2367         }
2368       else
2369         write_type (parm);
2370     }
2371
2372   if (varargs_p)
2373     /* <builtin-type> ::= z  # ellipsis  */
2374     write_char ('z');
2375 }
2376
2377 /* <class-enum-type> ::= <name>  */
2378
2379 static void
2380 write_class_enum_type (const tree type)
2381 {
2382   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2383 }
2384
2385 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
2386    arguments.
2387
2388      <template-args> ::= I <template-arg>* E  */
2389
2390 static void
2391 write_template_args (tree args)
2392 {
2393   int i;
2394   int length = 0;
2395
2396   MANGLE_TRACE_TREE ("template-args", args);
2397
2398   write_char ('I');
2399
2400   if (args)
2401     length = TREE_VEC_LENGTH (args);
2402
2403   if (args && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2404     {
2405       /* We have nested template args.  We want the innermost template
2406          argument list.  */
2407       args = TREE_VEC_ELT (args, length - 1);
2408       length = TREE_VEC_LENGTH (args);
2409     }
2410   for (i = 0; i < length; ++i)
2411     write_template_arg (TREE_VEC_ELT (args, i));
2412
2413   write_char ('E');
2414 }
2415
2416 /* Write out the
2417    <unqualified-name>
2418    <unqualified-name> <template-args>
2419    part of SCOPE_REF or COMPONENT_REF mangling.  */
2420
2421 static void
2422 write_member_name (tree member)
2423 {
2424   if (TREE_CODE (member) == IDENTIFIER_NODE)
2425     write_unqualified_id (member);
2426   else if (DECL_P (member))
2427     write_unqualified_name (member);
2428   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2429     {
2430       tree name = TREE_OPERAND (member, 0);
2431       if (TREE_CODE (name) == OVERLOAD)
2432         name = OVL_FUNCTION (name);
2433       write_member_name (name);
2434       write_template_args (TREE_OPERAND (member, 1));
2435     }
2436   else
2437     write_expression (member);
2438 }
2439
2440 /* <expression> ::= <unary operator-name> <expression>
2441                 ::= <binary operator-name> <expression> <expression>
2442                 ::= <expr-primary>
2443
2444    <expr-primary> ::= <template-param>
2445                   ::= L <type> <value number> E         # literal
2446                   ::= L <mangled-name> E                # external name
2447                   ::= st <type>                         # sizeof
2448                   ::= sr <type> <unqualified-name>      # dependent name
2449                   ::= sr <type> <unqualified-name> <template-args> */
2450
2451 static void
2452 write_expression (tree expr)
2453 {
2454   enum tree_code code = TREE_CODE (expr);
2455
2456   /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
2457      is converted (via qualification conversions) to another
2458      type.  */
2459   while (TREE_CODE (expr) == NOP_EXPR
2460          || TREE_CODE (expr) == NON_LVALUE_EXPR)
2461     {
2462       expr = TREE_OPERAND (expr, 0);
2463       code = TREE_CODE (expr);
2464     }
2465
2466   if (code == BASELINK)
2467     {
2468       expr = BASELINK_FUNCTIONS (expr);
2469       code = TREE_CODE (expr);
2470     }
2471
2472   /* Handle pointers-to-members by making them look like expression
2473      nodes.  */
2474   if (code == PTRMEM_CST)
2475     {
2476       expr = build_nt (ADDR_EXPR,
2477                        build_qualified_name (/*type=*/NULL_TREE,
2478                                              PTRMEM_CST_CLASS (expr),
2479                                              PTRMEM_CST_MEMBER (expr),
2480                                              /*template_p=*/false));
2481       code = TREE_CODE (expr);
2482     }
2483
2484   /* Handle template parameters.  */
2485   if (code == TEMPLATE_TYPE_PARM
2486       || code == TEMPLATE_TEMPLATE_PARM
2487       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2488       || code == TEMPLATE_PARM_INDEX)
2489     write_template_param (expr);
2490   /* Handle literals.  */
2491   else if (TREE_CODE_CLASS (code) == tcc_constant
2492            || (abi_version_at_least (2) && code == CONST_DECL))
2493     write_template_arg_literal (expr);
2494   else if (code == PARM_DECL)
2495     {
2496       /* A function parameter used in a late-specified return type.  */
2497       int index = DECL_PARM_INDEX (expr);
2498       int level = DECL_PARM_LEVEL (expr);
2499       int delta = G.parm_depth - level + 1;
2500       gcc_assert (index >= 1);
2501       write_char ('f');
2502       if (delta != 0)
2503         {
2504           if (abi_version_at_least (5))
2505             {
2506               /* Let L be the number of function prototype scopes from the
2507                  innermost one (in which the parameter reference occurs) up
2508                  to (and including) the one containing the declaration of
2509                  the referenced parameter.  If the parameter declaration
2510                  clause of the innermost function prototype scope has been
2511                  completely seen, it is not counted (in that case -- which
2512                  is perhaps the most common -- L can be zero).  */
2513               write_char ('L');
2514               write_unsigned_number (delta - 1);
2515             }
2516           else
2517             G.need_abi_warning = true;
2518         }
2519       write_char ('p');
2520       write_compact_number (index - 1);
2521     }
2522   else if (DECL_P (expr))
2523     {
2524       /* G++ 3.2 incorrectly mangled non-type template arguments of
2525          enumeration type using their names.  */
2526       if (code == CONST_DECL)
2527         G.need_abi_warning = 1;
2528       write_char ('L');
2529       write_mangled_name (expr, false);
2530       write_char ('E');
2531     }
2532   else if (TREE_CODE (expr) == SIZEOF_EXPR
2533            && TYPE_P (TREE_OPERAND (expr, 0)))
2534     {
2535       write_string ("st");
2536       write_type (TREE_OPERAND (expr, 0));
2537     }
2538   else if (TREE_CODE (expr) == ALIGNOF_EXPR
2539            && TYPE_P (TREE_OPERAND (expr, 0)))
2540     {
2541       write_string ("at");
2542       write_type (TREE_OPERAND (expr, 0));
2543     }
2544   else if (TREE_CODE (expr) == SCOPE_REF)
2545     {
2546       tree scope = TREE_OPERAND (expr, 0);
2547       tree member = TREE_OPERAND (expr, 1);
2548
2549       if (!abi_version_at_least (2) && DECL_P (member))
2550         {
2551           write_string ("sr");
2552           write_type (scope);
2553           /* G++ 3.2 incorrectly put out both the "sr" code and
2554              the nested name of the qualified name.  */
2555           G.need_abi_warning = 1;
2556           write_encoding (member);
2557         }
2558
2559       /* If the MEMBER is a real declaration, then the qualifying
2560          scope was not dependent.  Ideally, we would not have a
2561          SCOPE_REF in those cases, but sometimes we do.  If the second
2562          argument is a DECL, then the name must not have been
2563          dependent.  */
2564       else if (DECL_P (member))
2565         write_expression (member);
2566       else
2567         {
2568           write_string ("sr");
2569           write_type (scope);
2570           write_member_name (member);
2571         }
2572     }
2573   else if (TREE_CODE (expr) == INDIRECT_REF
2574            && TREE_TYPE (TREE_OPERAND (expr, 0))
2575            && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2576     {
2577       write_expression (TREE_OPERAND (expr, 0));
2578     }
2579   else if (TREE_CODE (expr) == IDENTIFIER_NODE)
2580     {
2581       /* An operator name appearing as a dependent name needs to be
2582          specially marked to disambiguate between a use of the operator
2583          name and a use of the operator in an expression.  */
2584       if (IDENTIFIER_OPNAME_P (expr))
2585         write_string ("on");
2586       write_unqualified_id (expr);
2587     }
2588   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
2589     {
2590       tree fn = TREE_OPERAND (expr, 0);
2591       if (is_overloaded_fn (fn))
2592         fn = DECL_NAME (get_first_fn (fn));
2593       if (IDENTIFIER_OPNAME_P (fn))
2594         write_string ("on");
2595       write_unqualified_id (fn);
2596       write_template_args (TREE_OPERAND (expr, 1));
2597     }
2598   else
2599     {
2600       int i, len;
2601       const char *name;
2602
2603       /* When we bind a variable or function to a non-type template
2604          argument with reference type, we create an ADDR_EXPR to show
2605          the fact that the entity's address has been taken.  But, we
2606          don't actually want to output a mangling code for the `&'.  */
2607       if (TREE_CODE (expr) == ADDR_EXPR
2608           && TREE_TYPE (expr)
2609           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2610         {
2611           expr = TREE_OPERAND (expr, 0);
2612           if (DECL_P (expr))
2613             {
2614               write_expression (expr);
2615               return;
2616             }
2617
2618           code = TREE_CODE (expr);
2619         }
2620
2621       if (code == COMPONENT_REF)
2622         {
2623           tree ob = TREE_OPERAND (expr, 0);
2624
2625           if (TREE_CODE (ob) == ARROW_EXPR)
2626             {
2627               write_string (operator_name_info[(int)code].mangled_name);
2628               ob = TREE_OPERAND (ob, 0);
2629             }
2630           else
2631             write_string ("dt");
2632
2633           write_expression (ob);
2634           write_member_name (TREE_OPERAND (expr, 1));
2635           return;
2636         }
2637
2638       /* If it wasn't any of those, recursively expand the expression.  */
2639       name = operator_name_info[(int) code].mangled_name;
2640       if (name == NULL)
2641         {
2642           sorry ("mangling %C", code);
2643           return;
2644         }
2645       else
2646         write_string (name);
2647
2648       switch (code)
2649         {
2650         case CALL_EXPR:
2651           {
2652             tree fn = CALL_EXPR_FN (expr);
2653
2654             if (TREE_CODE (fn) == ADDR_EXPR)
2655               fn = TREE_OPERAND (fn, 0);
2656
2657             /* Mangle a dependent name as the name, not whatever happens to
2658                be the first function in the overload set.  */
2659             if ((TREE_CODE (fn) == FUNCTION_DECL
2660                  || TREE_CODE (fn) == OVERLOAD)
2661                 && type_dependent_expression_p_push (expr))
2662               fn = DECL_NAME (get_first_fn (fn));
2663
2664             write_expression (fn);
2665           }
2666
2667           for (i = 0; i < call_expr_nargs (expr); ++i)
2668             write_expression (CALL_EXPR_ARG (expr, i));
2669           write_char ('E');
2670           break;
2671
2672         case CAST_EXPR:
2673           write_type (TREE_TYPE (expr));
2674           if (list_length (TREE_OPERAND (expr, 0)) == 1)
2675             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2676           else
2677             {
2678               tree args = TREE_OPERAND (expr, 0);
2679               write_char ('_');
2680               for (; args; args = TREE_CHAIN (args))
2681                 write_expression (TREE_VALUE (args));
2682               write_char ('E');
2683             }
2684           break;
2685
2686           /* FIXME these should have a distinct mangling.  */
2687         case STATIC_CAST_EXPR:
2688         case CONST_CAST_EXPR:
2689           write_type (TREE_TYPE (expr));
2690           write_expression (TREE_OPERAND (expr, 0));
2691           break;
2692
2693         case NEW_EXPR:
2694           sorry ("mangling new-expression");
2695           break;
2696
2697         default:
2698           /* In the middle-end, some expressions have more operands than
2699              they do in templates (and mangling).  */
2700           switch (code)
2701             {
2702             case PREINCREMENT_EXPR:
2703             case PREDECREMENT_EXPR:
2704             case POSTINCREMENT_EXPR:
2705             case POSTDECREMENT_EXPR:
2706               len = 1;
2707               break;
2708
2709             case ARRAY_REF:
2710               len = 2;
2711               break;
2712
2713             default:
2714               len = TREE_OPERAND_LENGTH (expr);
2715               break;
2716             }
2717
2718           for (i = 0; i < len; ++i)
2719             {
2720               tree operand = TREE_OPERAND (expr, i);
2721               /* As a GNU extension, the middle operand of a
2722                  conditional may be omitted.  Since expression
2723                  manglings are supposed to represent the input token
2724                  stream, there's no good way to mangle such an
2725                  expression without extending the C++ ABI.  */
2726               if (code == COND_EXPR && i == 1 && !operand)
2727                 {
2728                   error ("omitted middle operand to %<?:%> operand "
2729                          "cannot be mangled");
2730                   continue;
2731                 }
2732               write_expression (operand);
2733             }
2734         }
2735     }
2736 }
2737
2738 /* Literal subcase of non-terminal <template-arg>.
2739
2740      "Literal arguments, e.g. "A<42L>", are encoded with their type
2741      and value. Negative integer values are preceded with "n"; for
2742      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2743      encoded as 0, true as 1."  */
2744
2745 static void
2746 write_template_arg_literal (const tree value)
2747 {
2748   write_char ('L');
2749   write_type (TREE_TYPE (value));
2750
2751   switch (TREE_CODE (value))
2752     {
2753     case CONST_DECL:
2754       write_integer_cst (DECL_INITIAL (value));
2755       break;
2756
2757     case INTEGER_CST:
2758       gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2759                   || integer_zerop (value) || integer_onep (value));
2760       write_integer_cst (value);
2761       break;
2762
2763     case REAL_CST:
2764       write_real_cst (value);
2765       break;
2766
2767     case STRING_CST:
2768       sorry ("string literal in function template signature");
2769       break;
2770
2771     default:
2772       gcc_unreachable ();
2773     }
2774
2775   write_char ('E');
2776 }
2777
2778 /* Non-terminal <template-arg>.
2779
2780      <template-arg> ::= <type>                          # type
2781                     ::= L <type> </value/ number> E     # literal
2782                     ::= LZ <name> E                     # external name
2783                     ::= X <expression> E                # expression  */
2784
2785 static void
2786 write_template_arg (tree node)
2787 {
2788   enum tree_code code = TREE_CODE (node);
2789
2790   MANGLE_TRACE_TREE ("template-arg", node);
2791
2792   /* A template template parameter's argument list contains TREE_LIST
2793      nodes of which the value field is the actual argument.  */
2794   if (code == TREE_LIST)
2795     {
2796       node = TREE_VALUE (node);
2797       /* If it's a decl, deal with its type instead.  */
2798       if (DECL_P (node))
2799         {
2800           node = TREE_TYPE (node);
2801           code = TREE_CODE (node);
2802         }
2803     }
2804
2805   if (TREE_CODE (node) == NOP_EXPR
2806       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2807     {
2808       /* Template parameters can be of reference type. To maintain
2809          internal consistency, such arguments use a conversion from
2810          address of object to reference type.  */
2811       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2812       if (abi_version_at_least (2))
2813         node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2814       else
2815         G.need_abi_warning = 1;
2816     }
2817
2818   if (ARGUMENT_PACK_P (node))
2819     {
2820       /* Expand the template argument pack. */
2821       tree args = ARGUMENT_PACK_ARGS (node);
2822       int i, length = TREE_VEC_LENGTH (args);
2823       write_char ('I');
2824       for (i = 0; i < length; ++i)
2825         write_template_arg (TREE_VEC_ELT (args, i));
2826       write_char ('E');
2827     }
2828   else if (TYPE_P (node))
2829     write_type (node);
2830   else if (code == TEMPLATE_DECL)
2831     /* A template appearing as a template arg is a template template arg.  */
2832     write_template_template_arg (node);
2833   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
2834            || (abi_version_at_least (2) && code == CONST_DECL))
2835     write_template_arg_literal (node);
2836   else if (DECL_P (node))
2837     {
2838       /* Until ABI version 2, non-type template arguments of
2839          enumeration type were mangled using their names.  */
2840       if (code == CONST_DECL && !abi_version_at_least (2))
2841         G.need_abi_warning = 1;
2842       write_char ('L');
2843       /* Until ABI version 3, the underscore before the mangled name
2844          was incorrectly omitted.  */
2845       if (!abi_version_at_least (3))
2846         {
2847           G.need_abi_warning = 1;
2848           write_char ('Z');
2849         }
2850       else
2851         write_string ("_Z");
2852       write_encoding (node);
2853       write_char ('E');
2854     }
2855   else
2856     {
2857       /* Template arguments may be expressions.  */
2858       write_char ('X');
2859       write_expression (node);
2860       write_char ('E');
2861     }
2862 }
2863
2864 /*  <template-template-arg>
2865                         ::= <name>
2866                         ::= <substitution>  */
2867
2868 static void
2869 write_template_template_arg (const tree decl)
2870 {
2871   MANGLE_TRACE_TREE ("template-template-arg", decl);
2872
2873   if (find_substitution (decl))
2874     return;
2875   write_name (decl, /*ignore_local_scope=*/0);
2876   add_substitution (decl);
2877 }
2878
2879
2880 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2881
2882      <array-type> ::= A [</dimension/ number>] _ </element/ type>
2883                   ::= A <expression> _ </element/ type>
2884
2885      "Array types encode the dimension (number of elements) and the
2886      element type. For variable length arrays, the dimension (but not
2887      the '_' separator) is omitted."  */
2888
2889 static void
2890 write_array_type (const tree type)
2891 {
2892   write_char ('A');
2893   if (TYPE_DOMAIN (type))
2894     {
2895       tree index_type;
2896       tree max;
2897
2898       index_type = TYPE_DOMAIN (type);
2899       /* The INDEX_TYPE gives the upper and lower bounds of the
2900          array.  */
2901       max = TYPE_MAX_VALUE (index_type);
2902       if (TREE_CODE (max) == INTEGER_CST)
2903         {
2904           /* The ABI specifies that we should mangle the number of
2905              elements in the array, not the largest allowed index.  */
2906           max = size_binop (PLUS_EXPR, max, size_one_node);
2907           write_unsigned_number (tree_low_cst (max, 1));
2908         }
2909       else
2910         {
2911           max = TREE_OPERAND (max, 0);
2912           if (!abi_version_at_least (2))
2913             {
2914               /* value_dependent_expression_p presumes nothing is
2915                  dependent when PROCESSING_TEMPLATE_DECL is zero.  */
2916               ++processing_template_decl;
2917               if (!value_dependent_expression_p (max))
2918                 G.need_abi_warning = 1;
2919               --processing_template_decl;
2920             }
2921           write_expression (max);
2922         }
2923
2924     }
2925   write_char ('_');
2926   write_type (TREE_TYPE (type));
2927 }
2928
2929 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2930    variables.  TYPE is a pointer-to-member POINTER_TYPE.
2931
2932      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2933
2934 static void
2935 write_pointer_to_member_type (const tree type)
2936 {
2937   write_char ('M');
2938   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2939   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2940 }
2941
2942 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2943    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2944    TEMPLATE_PARM_INDEX.
2945
2946      <template-param> ::= T </parameter/ number> _  */
2947
2948 static void
2949 write_template_param (const tree parm)
2950 {
2951   int parm_index;
2952
2953   MANGLE_TRACE_TREE ("template-parm", parm);
2954
2955   switch (TREE_CODE (parm))
2956     {
2957     case TEMPLATE_TYPE_PARM:
2958     case TEMPLATE_TEMPLATE_PARM:
2959     case BOUND_TEMPLATE_TEMPLATE_PARM:
2960       parm_index = TEMPLATE_TYPE_IDX (parm);
2961       break;
2962
2963     case TEMPLATE_PARM_INDEX:
2964       parm_index = TEMPLATE_PARM_IDX (parm);
2965       break;
2966
2967     default:
2968       gcc_unreachable ();
2969     }
2970
2971   write_char ('T');
2972   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2973      earliest template param denoted by `_'.  */
2974   write_compact_number (parm_index);
2975 }
2976
2977 /*  <template-template-param>
2978                         ::= <template-param>
2979                         ::= <substitution>  */
2980
2981 static void
2982 write_template_template_param (const tree parm)
2983 {
2984   tree templ = NULL_TREE;
2985
2986   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2987      template template parameter.  The substitution candidate here is
2988      only the template.  */
2989   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2990     {
2991       templ
2992         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2993       if (find_substitution (templ))
2994         return;
2995     }
2996
2997   /* <template-param> encodes only the template parameter position,
2998      not its template arguments, which is fine here.  */
2999   write_template_param (parm);
3000   if (templ)
3001     add_substitution (templ);
3002 }
3003
3004 /* Non-terminal <substitution>.
3005
3006       <substitution> ::= S <seq-id> _
3007                      ::= S_  */
3008
3009 static void
3010 write_substitution (const int seq_id)
3011 {
3012   MANGLE_TRACE ("substitution", "");
3013
3014   write_char ('S');
3015   if (seq_id > 0)
3016     write_number (seq_id - 1, /*unsigned=*/1, 36);
3017   write_char ('_');
3018 }
3019
3020 /* Start mangling ENTITY.  */
3021
3022 static inline void
3023 start_mangling (const tree entity)
3024 {
3025   G.entity = entity;
3026   G.need_abi_warning = false;
3027   obstack_free (&name_obstack, name_base);
3028   mangle_obstack = &name_obstack;
3029   name_base = obstack_alloc (&name_obstack, 0);
3030 }
3031
3032 /* Done with mangling. If WARN is true, and the name of G.entity will
3033    be mangled differently in a future version of the ABI, issue a
3034    warning.  */
3035
3036 static void
3037 finish_mangling_internal (const bool warn)
3038 {
3039   if (warn_abi && warn && G.need_abi_warning)
3040     warning (OPT_Wabi, "the mangled name of %qD will change in a future "
3041              "version of GCC",
3042              G.entity);
3043
3044   /* Clear all the substitutions.  */
3045   VEC_truncate (tree, G.substitutions, 0);
3046
3047   /* Null-terminate the string.  */
3048   write_char ('\0');
3049 }
3050
3051
3052 /* Like finish_mangling_internal, but return the mangled string.  */
3053
3054 static inline const char *
3055 finish_mangling (const bool warn)
3056 {
3057   finish_mangling_internal (warn);
3058   return (const char *) obstack_finish (mangle_obstack);
3059 }
3060
3061 /* Like finish_mangling_internal, but return an identifier.  */
3062
3063 static tree
3064 finish_mangling_get_identifier (const bool warn)
3065 {
3066   finish_mangling_internal (warn);
3067   /* Don't obstack_finish here, and the next start_mangling will
3068      remove the identifier.  */
3069   return get_identifier ((const char *) obstack_base (mangle_obstack));
3070 }
3071
3072 /* Initialize data structures for mangling.  */
3073
3074 void
3075 init_mangle (void)
3076 {
3077   gcc_obstack_init (&name_obstack);
3078   name_base = obstack_alloc (&name_obstack, 0);
3079   G.substitutions = NULL;
3080
3081   /* Cache these identifiers for quick comparison when checking for
3082      standard substitutions.  */
3083   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
3084   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
3085   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
3086   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
3087   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
3088   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
3089 }
3090
3091 /* Generate the mangled name of DECL.  */
3092
3093 static tree
3094 mangle_decl_string (const tree decl)
3095 {
3096   tree result;
3097   location_t saved_loc = input_location;
3098   tree saved_fn = NULL_TREE;
3099   bool template_p = false;
3100
3101   if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3102     {
3103       struct tinst_level *tl = current_instantiation ();
3104       if (!tl || tl->decl != decl)
3105         {
3106           template_p = true;
3107           saved_fn = current_function_decl;
3108           push_tinst_level (decl);
3109           current_function_decl = NULL_TREE;
3110         }
3111     }
3112   input_location = DECL_SOURCE_LOCATION (decl);
3113
3114   start_mangling (decl);
3115
3116   if (TREE_CODE (decl) == TYPE_DECL)
3117     write_type (TREE_TYPE (decl));
3118   else
3119     write_mangled_name (decl, true);
3120
3121   result = finish_mangling_get_identifier (/*warn=*/true);
3122   if (DEBUG_MANGLE)
3123     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
3124              IDENTIFIER_POINTER (result));
3125
3126   if (template_p)
3127     {
3128       pop_tinst_level ();
3129       current_function_decl = saved_fn;
3130     }
3131   input_location = saved_loc;
3132
3133   return result;
3134 }
3135
3136 /* Create an identifier for the external mangled name of DECL.  */
3137
3138 void
3139 mangle_decl (const tree decl)
3140 {
3141   tree id = mangle_decl_string (decl);
3142   id = targetm.mangle_decl_assembler_name (decl, id);
3143   SET_DECL_ASSEMBLER_NAME (decl, id);
3144
3145   if (G.need_abi_warning)
3146     {
3147 #ifdef ASM_OUTPUT_DEF
3148       /* If the mangling will change in the future, emit an alias with the
3149          future mangled name for forward-compatibility.  */
3150       int save_ver;
3151       tree id2, alias;
3152 #endif
3153
3154       SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3155       if (IDENTIFIER_GLOBAL_VALUE (id) != decl)
3156         inform (DECL_SOURCE_LOCATION (decl), "-fabi-version=4 (or =0) "
3157                 "avoids this error with a change in vector mangling");
3158
3159 #ifdef ASM_OUTPUT_DEF
3160       save_ver = flag_abi_version;
3161       flag_abi_version = 0;
3162       id2 = mangle_decl_string (decl);
3163       id2 = targetm.mangle_decl_assembler_name (decl, id2);
3164       flag_abi_version = save_ver;
3165
3166       alias = make_alias_for (decl, id2);
3167       DECL_IGNORED_P (alias) = 1;
3168       TREE_PUBLIC (alias) = TREE_PUBLIC (decl);
3169       DECL_VISIBILITY (alias) = DECL_VISIBILITY (decl);
3170       if (vague_linkage_p (decl))
3171         DECL_WEAK (alias) = 1;
3172       if (TREE_CODE (decl) == FUNCTION_DECL)
3173         cgraph_same_body_alias (cgraph_node (decl), alias, decl);
3174       else
3175         varpool_extra_name_alias (alias, decl);
3176 #endif
3177     }
3178 }
3179
3180 /* Generate the mangled representation of TYPE.  */
3181
3182 const char *
3183 mangle_type_string (const tree type)
3184 {
3185   const char *result;
3186
3187   start_mangling (type);
3188   write_type (type);
3189   result = finish_mangling (/*warn=*/false);
3190   if (DEBUG_MANGLE)
3191     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
3192   return result;
3193 }
3194
3195 /* Create an identifier for the mangled name of a special component
3196    for belonging to TYPE.  CODE is the ABI-specified code for this
3197    component.  */
3198
3199 static tree
3200 mangle_special_for_type (const tree type, const char *code)
3201 {
3202   tree result;
3203
3204   /* We don't have an actual decl here for the special component, so
3205      we can't just process the <encoded-name>.  Instead, fake it.  */
3206   start_mangling (type);
3207
3208   /* Start the mangling.  */
3209   write_string ("_Z");
3210   write_string (code);
3211
3212   /* Add the type.  */
3213   write_type (type);
3214   result = finish_mangling_get_identifier (/*warn=*/false);
3215
3216   if (DEBUG_MANGLE)
3217     fprintf (stderr, "mangle_special_for_type = %s\n\n",
3218              IDENTIFIER_POINTER (result));
3219
3220   return result;
3221 }
3222
3223 /* Create an identifier for the mangled representation of the typeinfo
3224    structure for TYPE.  */
3225
3226 tree
3227 mangle_typeinfo_for_type (const tree type)
3228 {
3229   return mangle_special_for_type (type, "TI");
3230 }
3231
3232 /* Create an identifier for the mangled name of the NTBS containing
3233    the mangled name of TYPE.  */
3234
3235 tree
3236 mangle_typeinfo_string_for_type (const tree type)
3237 {
3238   return mangle_special_for_type (type, "TS");
3239 }
3240
3241 /* Create an identifier for the mangled name of the vtable for TYPE.  */
3242
3243 tree
3244 mangle_vtbl_for_type (const tree type)
3245 {
3246   return mangle_special_for_type (type, "TV");
3247 }
3248
3249 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
3250
3251 tree
3252 mangle_vtt_for_type (const tree type)
3253 {
3254   return mangle_special_for_type (type, "TT");
3255 }
3256
3257 /* Return an identifier for a construction vtable group.  TYPE is
3258    the most derived class in the hierarchy; BINFO is the base
3259    subobject for which this construction vtable group will be used.
3260
3261    This mangling isn't part of the ABI specification; in the ABI
3262    specification, the vtable group is dumped in the same COMDAT as the
3263    main vtable, and is referenced only from that vtable, so it doesn't
3264    need an external name.  For binary formats without COMDAT sections,
3265    though, we need external names for the vtable groups.
3266
3267    We use the production
3268
3269     <special-name> ::= CT <type> <offset number> _ <base type>  */
3270
3271 tree
3272 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
3273 {
3274   tree result;
3275
3276   start_mangling (type);
3277
3278   write_string ("_Z");
3279   write_string ("TC");
3280   write_type (type);
3281   write_integer_cst (BINFO_OFFSET (binfo));
3282   write_char ('_');
3283   write_type (BINFO_TYPE (binfo));
3284
3285   result = finish_mangling_get_identifier (/*warn=*/false);
3286   if (DEBUG_MANGLE)
3287     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
3288              IDENTIFIER_POINTER (result));
3289   return result;
3290 }
3291
3292 /* Mangle a this pointer or result pointer adjustment.
3293
3294    <call-offset> ::= h <fixed offset number> _
3295                  ::= v <fixed offset number> _ <virtual offset number> _ */
3296
3297 static void
3298 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
3299 {
3300   write_char (virtual_offset ? 'v' : 'h');
3301
3302   /* For either flavor, write the fixed offset.  */
3303   write_integer_cst (fixed_offset);
3304   write_char ('_');
3305
3306   /* For a virtual thunk, add the virtual offset.  */
3307   if (virtual_offset)
3308     {
3309       write_integer_cst (virtual_offset);
3310       write_char ('_');
3311     }
3312 }
3313
3314 /* Return an identifier for the mangled name of a this-adjusting or
3315    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
3316    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
3317    is a virtual thunk, and it is the vtbl offset in
3318    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
3319    zero for a covariant thunk. Note, that FN_DECL might be a covariant
3320    thunk itself. A covariant thunk name always includes the adjustment
3321    for the this pointer, even if there is none.
3322
3323    <special-name> ::= T <call-offset> <base encoding>
3324                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
3325                                         <base encoding>  */
3326
3327 tree
3328 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
3329               tree virtual_offset)
3330 {
3331   tree result;
3332
3333   start_mangling (fn_decl);
3334
3335   write_string ("_Z");
3336   write_char ('T');
3337
3338   if (!this_adjusting)
3339     {
3340       /* Covariant thunk with no this adjustment */
3341       write_char ('c');
3342       mangle_call_offset (integer_zero_node, NULL_TREE);
3343       mangle_call_offset (fixed_offset, virtual_offset);
3344     }
3345   else if (!DECL_THUNK_P (fn_decl))
3346     /* Plain this adjusting thunk.  */
3347     mangle_call_offset (fixed_offset, virtual_offset);
3348   else
3349     {
3350       /* This adjusting thunk to covariant thunk.  */
3351       write_char ('c');
3352       mangle_call_offset (fixed_offset, virtual_offset);
3353       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
3354       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
3355       if (virtual_offset)
3356         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
3357       mangle_call_offset (fixed_offset, virtual_offset);
3358       fn_decl = THUNK_TARGET (fn_decl);
3359     }
3360
3361   /* Scoped name.  */
3362   write_encoding (fn_decl);
3363
3364   result = finish_mangling_get_identifier (/*warn=*/false);
3365   if (DEBUG_MANGLE)
3366     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
3367   return result;
3368 }
3369
3370 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3371    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
3372    TYPE.  */
3373
3374 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
3375
3376 /* Hash a node (VAL1) in the table.  */
3377
3378 static hashval_t
3379 hash_type (const void *val)
3380 {
3381   return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val));
3382 }
3383
3384 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
3385
3386 static int
3387 compare_type (const void *val1, const void *val2)
3388 {
3389   return TREE_TYPE ((const_tree) val1) == (const_tree) val2;
3390 }
3391
3392 /* Return an identifier for the mangled unqualified name for a
3393    conversion operator to TYPE.  This mangling is not specified by the
3394    ABI spec; it is only used internally.  */
3395
3396 tree
3397 mangle_conv_op_name_for_type (const tree type)
3398 {
3399   void **slot;
3400   tree identifier;
3401
3402   if (type == error_mark_node)
3403     return error_mark_node;
3404
3405   if (conv_type_names == NULL)
3406     conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
3407
3408   slot = htab_find_slot_with_hash (conv_type_names, type,
3409                                    (hashval_t) TYPE_UID (type), INSERT);
3410   identifier = (tree)*slot;
3411   if (!identifier)
3412     {
3413       char buffer[64];
3414
3415        /* Create a unique name corresponding to TYPE.  */
3416       sprintf (buffer, "operator %lu",
3417                (unsigned long) htab_elements (conv_type_names));
3418       identifier = get_identifier (buffer);
3419       *slot = identifier;
3420
3421       /* Hang TYPE off the identifier so it can be found easily later
3422          when performing conversions.  */
3423       TREE_TYPE (identifier) = type;
3424
3425       /* Set bits on the identifier so we know later it's a conversion.  */
3426       IDENTIFIER_OPNAME_P (identifier) = 1;
3427       IDENTIFIER_TYPENAME_P (identifier) = 1;
3428     }
3429
3430   return identifier;
3431 }
3432
3433 /* Return an identifier for the name of an initialization guard
3434    variable for indicated VARIABLE.  */
3435
3436 tree
3437 mangle_guard_variable (const tree variable)
3438 {
3439   start_mangling (variable);
3440   write_string ("_ZGV");
3441   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
3442     /* The name of a guard variable for a reference temporary should refer
3443        to the reference, not the temporary.  */
3444     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
3445   else
3446     write_name (variable, /*ignore_local_scope=*/0);
3447   return finish_mangling_get_identifier (/*warn=*/false);
3448 }
3449
3450 /* Return an identifier for the name of a temporary variable used to
3451    initialize a static reference.  This isn't part of the ABI, but we might
3452    as well call them something readable.  */
3453
3454 tree
3455 mangle_ref_init_variable (const tree variable)
3456 {
3457   start_mangling (variable);
3458   write_string ("_ZGR");
3459   write_name (variable, /*ignore_local_scope=*/0);
3460   return finish_mangling_get_identifier (/*warn=*/false);
3461 }
3462 \f
3463
3464 /* Foreign language type mangling section.  */
3465
3466 /* How to write the type codes for the integer Java type.  */
3467
3468 static void
3469 write_java_integer_type_codes (const tree type)
3470 {
3471   if (type == java_int_type_node)
3472     write_char ('i');
3473   else if (type == java_short_type_node)
3474     write_char ('s');
3475   else if (type == java_byte_type_node)
3476     write_char ('c');
3477   else if (type == java_char_type_node)
3478     write_char ('w');
3479   else if (type == java_long_type_node)
3480     write_char ('x');
3481   else if (type == java_boolean_type_node)
3482     write_char ('b');
3483   else
3484     gcc_unreachable ();
3485 }
3486
3487 #include "gt-cp-mangle.h"