gcc/cp/mangle.c

   1 /* Name mangling for the 3.0 C++ ABI.
   2    Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   3    Written by Alex Samuel <sameul@codesourcery.com>
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  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 */
  49
  50 #include "config.h"
  51 #include "system.h"
  52 #include "coretypes.h"
  53 #include "tm.h"
  54 #include "tree.h"
  55 #include "tm_p.h"
  56 #include "cp-tree.h"
  57 #include "real.h"
  58 #include "obstack.h"
  59 #include "toplev.h"
  60 #include "varray.h"
  61
  62 /* Debugging support.  */
  63
  64 /* Define DEBUG_MANGLE to enable very verbose trace messages.  */
  65 #ifndef DEBUG_MANGLE
  66 #define DEBUG_MANGLE 0
  67 #endif
  68
  69 /* Macros for tracing the write_* functions.  */
  70 #if DEBUG_MANGLE
  71 # define MANGLE_TRACE(FN, INPUT) \
  72   fprintf (stderr, "  %-24s: %-24s\n", (FN), (INPUT))
  73 # define MANGLE_TRACE_TREE(FN, NODE) \
  74   fprintf (stderr, "  %-24s: %-24s (%p)\n", \
  75            (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE))
  76 #else
  77 # define MANGLE_TRACE(FN, INPUT)
  78 # define MANGLE_TRACE_TREE(FN, NODE)
  79 #endif
  80
  81 /* Nonzero if NODE is a class template-id.  We can't rely on
  82    CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
  83    that hard to distinguish A<T> from A, where A<T> is the type as
  84    instantiated outside of the template, and A is the type used
  85    without parameters inside the template.  */
  86 #define CLASSTYPE_TEMPLATE_ID_P(NODE)                                   \
  87   (TYPE_LANG_SPECIFIC (NODE) != NULL                                    \
  88    && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM                 \
  89        || (CLASSTYPE_TEMPLATE_INFO (NODE) != NULL                       \
  90            && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))))
  91
  92 /* Things we only need one of.  This module is not reentrant.  */
  93 static struct globals
  94 {
  95   /* The name in which we're building the mangled name.  */
  96   struct obstack name_obstack;
  97
  98   /* An array of the current substitution candidates, in the order
  99      we've seen them.  */
 100   varray_type substitutions;
 101
 102   /* The entity that is being mangled.  */
 103   tree entity;
 104
 105   /* True if the mangling will be different in a future version of the
 106      ABI.  */
 107   bool need_abi_warning;
 108 } G;
 109
 110 /* Indices into subst_identifiers.  These are identifiers used in
 111    special substitution rules.  */
 112 typedef enum
 113 {
 114   SUBID_ALLOCATOR,
 115   SUBID_BASIC_STRING,
 116   SUBID_CHAR_TRAITS,
 117   SUBID_BASIC_ISTREAM,
 118   SUBID_BASIC_OSTREAM,
 119   SUBID_BASIC_IOSTREAM,
 120   SUBID_MAX
 121 }
 122 substitution_identifier_index_t;
 123
 124 /* For quick substitution checks, look up these common identifiers
 125    once only.  */
 126 static GTY(()) tree subst_identifiers[SUBID_MAX];
 127
 128 /* Single-letter codes for builtin integer types, defined in
 129    <builtin-type>.  These are indexed by integer_type_kind values.  */
 130 static const char
 131 integer_type_codes[itk_none] =
 132 {
 133   'c',  /* itk_char */
 134   'a',  /* itk_signed_char */
 135   'h',  /* itk_unsigned_char */
 136   's',  /* itk_short */
 137   't',  /* itk_unsigned_short */
 138   'i',  /* itk_int */
 139   'j',  /* itk_unsigned_int */
 140   'l',  /* itk_long */
 141   'm',  /* itk_unsigned_long */
 142   'x',  /* itk_long_long */
 143   'y'   /* itk_unsigned_long_long */
 144 };
 145
 146 static int decl_is_template_id (const tree, tree* const);
 147
 148 /* Functions for handling substitutions.  */
 149
 150 static inline tree canonicalize_for_substitution (tree);
 151 static void add_substitution (tree);
 152 static inline int is_std_substitution (const tree,
 153                                        const substitution_identifier_index_t);
 154 static inline int is_std_substitution_char (const tree,
 155                                             const substitution_identifier_index_t);
 156 static int find_substitution (tree);
 157 static void mangle_call_offset (const tree, const tree);
 158
 159 /* Functions for emitting mangled representations of things.  */
 160
 161 static void write_mangled_name (const tree, bool);
 162 static void write_encoding (const tree);
 163 static void write_name (tree, const int);
 164 static void write_unscoped_name (const tree);
 165 static void write_unscoped_template_name (const tree);
 166 static void write_nested_name (const tree);
 167 static void write_prefix (const tree);
 168 static void write_template_prefix (const tree);
 169 static void write_unqualified_name (const tree);
 170 static void write_conversion_operator_name (const tree);
 171 static void write_source_name (tree);
 172 static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
 173                            const unsigned int);
 174 static void write_number (unsigned HOST_WIDE_INT, const int,
 175                           const unsigned int);
 176 static void write_integer_cst (const tree);
 177 static void write_real_cst (const tree);
 178 static void write_identifier (const char *);
 179 static void write_special_name_constructor (const tree);
 180 static void write_special_name_destructor (const tree);
 181 static void write_type (tree);
 182 static int write_CV_qualifiers_for_type (const tree);
 183 static void write_builtin_type (tree);
 184 static void write_function_type (const tree);
 185 static void write_bare_function_type (const tree, const int, const tree);
 186 static void write_method_parms (tree, const int, const tree);
 187 static void write_class_enum_type (const tree);
 188 static void write_template_args (tree);
 189 static void write_expression (tree);
 190 static void write_template_arg_literal (const tree);
 191 static void write_template_arg (tree);
 192 static void write_template_template_arg (const tree);
 193 static void write_array_type (const tree);
 194 static void write_pointer_to_member_type (const tree);
 195 static void write_template_param (const tree);
 196 static void write_template_template_param (const tree);
 197 static void write_substitution (const int);
 198 static int discriminator_for_local_entity (tree);
 199 static int discriminator_for_string_literal (tree, tree);
 200 static void write_discriminator (const int);
 201 static void write_local_name (const tree, const tree, const tree);
 202 static void dump_substitution_candidates (void);
 203 static const char *mangle_decl_string (const tree);
 204
 205 /* Control functions.  */
 206
 207 static inline void start_mangling (const tree);
 208 static inline const char *finish_mangling (const bool);
 209 static tree mangle_special_for_type (const tree, const char *);
 210
 211 /* Foreign language functions.  */
 212
 213 static void write_java_integer_type_codes (const tree);
 214
 215 /* Append a single character to the end of the mangled
 216    representation.  */
 217 #define write_char(CHAR)                                              \
 218   obstack_1grow (&G.name_obstack, (CHAR))
 219
 220 /* Append a sized buffer to the end of the mangled representation.  */
 221 #define write_chars(CHAR, LEN)                                        \
 222   obstack_grow (&G.name_obstack, (CHAR), (LEN))
 223
 224 /* Append a NUL-terminated string to the end of the mangled
 225    representation.  */
 226 #define write_string(STRING)                                          \
 227   obstack_grow (&G.name_obstack, (STRING), strlen (STRING))
 228
 229 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
 230    same purpose (context, which may be a type) and value (template
 231    decl).  See write_template_prefix for more information on what this
 232    is used for.  */
 233 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2)                         \
 234   (TREE_CODE (NODE1) == TREE_LIST                                     \
 235    && TREE_CODE (NODE2) == TREE_LIST                                  \
 236    && ((TYPE_P (TREE_PURPOSE (NODE1))                                 \
 237         && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2)))\
 238        || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2))             \
 239    && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
 240
 241 /* Write out an unsigned quantity in base 10.  */
 242 #define write_unsigned_number(NUMBER) \
 243   write_number ((NUMBER), /*unsigned_p=*/1, 10)
 244
 245 /* If DECL is a template instance, return nonzero and, if
 246    TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
 247    Otherwise return zero.  */
 248
 249 static int
 250 decl_is_template_id (const tree decl, tree* const template_info)
 251 {
 252   if (TREE_CODE (decl) == TYPE_DECL)
 253     {
 254       /* TYPE_DECLs are handled specially.  Look at its type to decide
 255          if this is a template instantiation.  */
 256       const tree type = TREE_TYPE (decl);
 257
 258       if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
 259         {
 260           if (template_info != NULL)
 261             /* For a templated TYPE_DECL, the template info is hanging
 262                off the type.  */
 263             *template_info = TYPE_TEMPLATE_INFO (type);
 264           return 1;
 265         }
 266     }
 267   else
 268     {
 269       /* Check if this is a primary template.  */
 270       if (DECL_LANG_SPECIFIC (decl) != NULL
 271           && DECL_USE_TEMPLATE (decl)
 272           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
 273           && TREE_CODE (decl) != TEMPLATE_DECL)
 274         {
 275           if (template_info != NULL)
 276             /* For most templated decls, the template info is hanging
 277                off the decl.  */
 278             *template_info = DECL_TEMPLATE_INFO (decl);
 279           return 1;
 280         }
 281     }
 282
 283   /* It's not a template id.  */
 284   return 0;
 285 }
 286
 287 /* Produce debugging output of current substitution candidates.  */
 288
 289 static void
 290 dump_substitution_candidates (void)
 291 {
 292   unsigned i;
 293
 294   fprintf (stderr, "  ++ substitutions  ");
 295   for (i = 0; i < VARRAY_ACTIVE_SIZE (G.substitutions); ++i)
 296     {
 297       tree el = VARRAY_TREE (G.substitutions, i);
 298       const char *name = "???";
 299
 300       if (i > 0)
 301         fprintf (stderr, "                    ");
 302       if (DECL_P (el))
 303         name = IDENTIFIER_POINTER (DECL_NAME (el));
 304       else if (TREE_CODE (el) == TREE_LIST)
 305         name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
 306       else if (TYPE_NAME (el))
 307         name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el)));
 308       fprintf (stderr, " S%d_ = ", i - 1);
 309       if (TYPE_P (el) &&
 310           (CP_TYPE_RESTRICT_P (el)
 311            || CP_TYPE_VOLATILE_P (el)
 312            || CP_TYPE_CONST_P (el)))
 313         fprintf (stderr, "CV-");
 314       fprintf (stderr, "%s (%s at %p)\n",
 315                name, tree_code_name[TREE_CODE (el)], (void *) el);
 316     }
 317 }
 318
 319 /* Both decls and types can be substitution candidates, but sometimes
 320    they refer to the same thing.  For instance, a TYPE_DECL and
 321    RECORD_TYPE for the same class refer to the same thing, and should
 322    be treated accordingly in substitutions.  This function returns a
 323    canonicalized tree node representing NODE that is used when adding
 324    and substitution candidates and finding matches.  */
 325
 326 static inline tree
 327 canonicalize_for_substitution (tree node)
 328 {
 329   /* For a TYPE_DECL, use the type instead.  */
 330   if (TREE_CODE (node) == TYPE_DECL)
 331     node = TREE_TYPE (node);
 332   if (TYPE_P (node))
 333     node = canonical_type_variant (node);
 334
 335   return node;
 336 }
 337
 338 /* Add NODE as a substitution candidate.  NODE must not already be on
 339    the list of candidates.  */
 340
 341 static void
 342 add_substitution (tree node)
 343 {
 344   tree c;
 345
 346   if (DEBUG_MANGLE)
 347     fprintf (stderr, "  ++ add_substitution (%s at %10p)\n",
 348              tree_code_name[TREE_CODE (node)], (void *) node);
 349
 350   /* Get the canonicalized substitution candidate for NODE.  */
 351   c = canonicalize_for_substitution (node);
 352   if (DEBUG_MANGLE && c != node)
 353     fprintf (stderr, "  ++ using candidate (%s at %10p)\n",
 354              tree_code_name[TREE_CODE (node)], (void *) node);
 355   node = c;
 356
 357 #if ENABLE_CHECKING
 358   /* Make sure NODE isn't already a candidate.  */
 359   {
 360     int i;
 361     for (i = VARRAY_ACTIVE_SIZE (G.substitutions); --i >= 0; )
 362       {
 363         const tree candidate = VARRAY_TREE (G.substitutions, i);
 364         if ((DECL_P (node)
 365              && node == candidate)
 366             || (TYPE_P (node)
 367                 && TYPE_P (candidate)
 368                 && same_type_p (node, candidate)))
 369           abort ();
 370       }
 371   }
 372 #endif /* ENABLE_CHECKING */
 373
 374   /* Put the decl onto the varray of substitution candidates.  */
 375   VARRAY_PUSH_TREE (G.substitutions, node);
 376
 377   if (DEBUG_MANGLE)
 378     dump_substitution_candidates ();
 379 }
 380
 381 /* Helper function for find_substitution.  Returns nonzero if NODE,
 382    which may be a decl or a CLASS_TYPE, is a template-id with template
 383    name of substitution_index[INDEX] in the ::std namespace.  */
 384
 385 static inline int
 386 is_std_substitution (const tree node,
 387                      const substitution_identifier_index_t index)
 388 {
 389   tree type = NULL;
 390   tree decl = NULL;
 391
 392   if (DECL_P (node))
 393     {
 394       type = TREE_TYPE (node);
 395       decl = node;
 396     }
 397   else if (CLASS_TYPE_P (node))
 398     {
 399       type = node;
 400       decl = TYPE_NAME (node);
 401     }
 402   else
 403     /* These are not the droids you're looking for.  */
 404     return 0;
 405
 406   return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
 407           && TYPE_LANG_SPECIFIC (type)
 408           && TYPE_TEMPLATE_INFO (type)
 409           && (DECL_NAME (TYPE_TI_TEMPLATE (type))
 410               == subst_identifiers[index]));
 411 }
 412
 413 /* Helper function for find_substitution.  Returns nonzero if NODE,
 414    which may be a decl or a CLASS_TYPE, is the template-id
 415    ::std::identifier<char>, where identifier is
 416    substitution_index[INDEX].  */
 417
 418 static inline int
 419 is_std_substitution_char (const tree node,
 420                           const substitution_identifier_index_t index)
 421 {
 422   tree args;
 423   /* Check NODE's name is ::std::identifier.  */
 424   if (!is_std_substitution (node, index))
 425     return 0;
 426   /* Figure out its template args.  */
 427   if (DECL_P (node))
 428     args = DECL_TI_ARGS (node);
 429   else if (CLASS_TYPE_P (node))
 430     args = CLASSTYPE_TI_ARGS (node);
 431   else
 432     /* Oops, not a template.  */
 433     return 0;
 434   /* NODE's template arg list should be <char>.  */
 435   return
 436     TREE_VEC_LENGTH (args) == 1
 437     && TREE_VEC_ELT (args, 0) == char_type_node;
 438 }
 439
 440 /* Check whether a substitution should be used to represent NODE in
 441    the mangling.
 442
 443    First, check standard special-case substitutions.
 444
 445      <substitution> ::= St
 446          # ::std
 447
 448                     ::= Sa
 449          # ::std::allocator
 450
 451                     ::= Sb
 452          # ::std::basic_string
 453
 454                     ::= Ss
 455          # ::std::basic_string<char,
 456                                ::std::char_traits<char>,
 457                                ::std::allocator<char> >
 458
 459                     ::= Si
 460          # ::std::basic_istream<char, ::std::char_traits<char> >
 461
 462                     ::= So
 463          # ::std::basic_ostream<char, ::std::char_traits<char> >
 464
 465                     ::= Sd
 466          # ::std::basic_iostream<char, ::std::char_traits<char> >
 467
 468    Then examine the stack of currently available substitution
 469    candidates for entities appearing earlier in the same mangling
 470
 471    If a substitution is found, write its mangled representation and
 472    return nonzero.  If none is found, just return zero.  */
 473
 474 static int
 475 find_substitution (tree node)
 476 {
 477   int i;
 478   const int size = VARRAY_ACTIVE_SIZE (G.substitutions);
 479   tree decl;
 480   tree type;
 481
 482   if (DEBUG_MANGLE)
 483     fprintf (stderr, "  ++ find_substitution (%s at %p)\n",
 484              tree_code_name[TREE_CODE (node)], (void *) node);
 485
 486   /* Obtain the canonicalized substitution representation for NODE.
 487      This is what we'll compare against.  */
 488   node = canonicalize_for_substitution (node);
 489
 490   /* Check for builtin substitutions.  */
 491
 492   decl = TYPE_P (node) ? TYPE_NAME (node) : node;
 493   type = TYPE_P (node) ? node : TREE_TYPE (node);
 494
 495   /* Check for std::allocator.  */
 496   if (decl
 497       && is_std_substitution (decl, SUBID_ALLOCATOR)
 498       && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
 499     {
 500       write_string ("Sa");
 501       return 1;
 502     }
 503
 504   /* Check for std::basic_string.  */
 505   if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
 506     {
 507       if (TYPE_P (node))
 508         {
 509           /* If this is a type (i.e. a fully-qualified template-id),
 510              check for
 511                  std::basic_string <char,
 512                                     std::char_traits<char>,
 513                                     std::allocator<char> > .  */
 514           if (cp_type_quals (type) == TYPE_UNQUALIFIED
 515               && CLASSTYPE_USE_TEMPLATE (type))
 516             {
 517               tree args = CLASSTYPE_TI_ARGS (type);
 518               if (TREE_VEC_LENGTH (args) == 3
 519                   && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 520                   && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 521                                                SUBID_CHAR_TRAITS)
 522                   && is_std_substitution_char (TREE_VEC_ELT (args, 2),
 523                                                SUBID_ALLOCATOR))
 524                 {
 525                   write_string ("Ss");
 526                   return 1;
 527                 }
 528             }
 529         }
 530       else
 531         /* Substitute for the template name only if this isn't a type.  */
 532         {
 533           write_string ("Sb");
 534           return 1;
 535         }
 536     }
 537
 538   /* Check for basic_{i,o,io}stream.  */
 539   if (TYPE_P (node)
 540       && cp_type_quals (type) == TYPE_UNQUALIFIED
 541       && CLASS_TYPE_P (type)
 542       && CLASSTYPE_USE_TEMPLATE (type)
 543       && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
 544     {
 545       /* First, check for the template
 546          args <char, std::char_traits<char> > .  */
 547       tree args = CLASSTYPE_TI_ARGS (type);
 548       if (TREE_VEC_LENGTH (args) == 2
 549           && TYPE_P (TREE_VEC_ELT (args, 0))
 550           && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 551           && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 552                                        SUBID_CHAR_TRAITS))
 553         {
 554           /* Got them.  Is this basic_istream?  */
 555           tree name = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type));
 556           if (name == subst_identifiers[SUBID_BASIC_ISTREAM])
 557             {
 558               write_string ("Si");
 559               return 1;
 560             }
 561           /* Or basic_ostream?  */
 562           else if (name == subst_identifiers[SUBID_BASIC_OSTREAM])
 563             {
 564               write_string ("So");
 565               return 1;
 566             }
 567           /* Or basic_iostream?  */
 568           else if (name == subst_identifiers[SUBID_BASIC_IOSTREAM])
 569             {
 570               write_string ("Sd");
 571               return 1;
 572             }
 573         }
 574     }
 575
 576   /* Check for namespace std.  */
 577   if (decl && DECL_NAMESPACE_STD_P (decl))
 578     {
 579       write_string ("St");
 580       return 1;
 581     }
 582
 583   /* Now check the list of available substitutions for this mangling
 584      operation.  */
 585   for (i = 0; i < size; ++i)
 586     {
 587       tree candidate = VARRAY_TREE (G.substitutions, i);
 588       /* NODE is a matched to a candidate if it's the same decl node or
 589          if it's the same type.  */
 590       if (decl == candidate
 591           || (TYPE_P (candidate) && type && TYPE_P (type)
 592               && same_type_p (type, candidate))
 593           || NESTED_TEMPLATE_MATCH (node, candidate))
 594         {
 595           write_substitution (i);
 596           return 1;
 597         }
 598     }
 599
 600   /* No substitution found.  */
 601   return 0;
 602 }
 603
 604
 605 /* TOP_LEVEL is true, if this is being called at outermost level of
 606   mangling. It should be false when mangling a decl appearing in an
 607   expression within some other mangling.
 608
 609   <mangled-name>      ::= _Z <encoding>  */
 610
 611 static void
 612 write_mangled_name (const tree decl, bool top_level)
 613 {
 614   MANGLE_TRACE_TREE ("mangled-name", decl);
 615
 616   if (/* The names of `extern "C"' functions are not mangled.  */
 617       DECL_EXTERN_C_FUNCTION_P (decl)
 618       /* But overloaded operator names *are* mangled.  */
 619       && !DECL_OVERLOADED_OPERATOR_P (decl))
 620     {
 621     unmangled_name:;
 622
 623       if (top_level)
 624         write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
 625       else
 626         {
 627           /* The standard notes: "The <encoding> of an extern "C"
 628              function is treated like global-scope data, i.e. as its
 629              <source-name> without a type."  We cannot write
 630              overloaded operators that way though, because it contains
 631              characters invalid in assembler.  */
 632           if (abi_version_at_least (2))
 633             write_string ("_Z");
 634           else
 635             G.need_abi_warning = true;
 636           write_source_name (DECL_NAME (decl));
 637         }
 638     }
 639   else if (TREE_CODE (decl) == VAR_DECL
 640            /* The names of global variables aren't mangled.  */
 641            && (CP_DECL_CONTEXT (decl) == global_namespace
 642                /* And neither are `extern "C"' variables.  */
 643                || DECL_EXTERN_C_P (decl)))
 644     {
 645       if (top_level || abi_version_at_least (2))
 646         goto unmangled_name;
 647       else
 648         {
 649           G.need_abi_warning = true;
 650           goto mangled_name;
 651         }
 652     }
 653   else
 654     {
 655     mangled_name:;
 656       write_string ("_Z");
 657       write_encoding (decl);
 658       if (DECL_LANG_SPECIFIC (decl)
 659           && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
 660               || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
 661         /* We need a distinct mangled name for these entities, but
 662            we should never actually output it.  So, we append some
 663            characters the assembler won't like.  */
 664         write_string (" *INTERNAL* ");
 665     }
 666 }
 667
 668 /*   <encoding>         ::= <function name> <bare-function-type>
 669                         ::= <data name>  */
 670
 671 static void
 672 write_encoding (const tree decl)
 673 {
 674   MANGLE_TRACE_TREE ("encoding", decl);
 675
 676   if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
 677     {
 678       /* For overloaded operators write just the mangled name
 679          without arguments.  */
 680       if (DECL_OVERLOADED_OPERATOR_P (decl))
 681         write_name (decl, /*ignore_local_scope=*/0);
 682       else
 683         write_source_name (DECL_NAME (decl));
 684       return;
 685     }
 686
 687   write_name (decl, /*ignore_local_scope=*/0);
 688   if (TREE_CODE (decl) == FUNCTION_DECL)
 689     {
 690       tree fn_type;
 691
 692       if (decl_is_template_id (decl, NULL))
 693         fn_type = get_mostly_instantiated_function_type (decl);
 694       else
 695         fn_type = TREE_TYPE (decl);
 696
 697       write_bare_function_type (fn_type,
 698                                 (!DECL_CONSTRUCTOR_P (decl)
 699                                  && !DECL_DESTRUCTOR_P (decl)
 700                                  && !DECL_CONV_FN_P (decl)
 701                                  && decl_is_template_id (decl, NULL)),
 702                                 decl);
 703     }
 704 }
 705
 706 /* <name> ::= <unscoped-name>
 707           ::= <unscoped-template-name> <template-args>
 708           ::= <nested-name>
 709           ::= <local-name>
 710
 711    If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
 712    called from <local-name>, which mangles the enclosing scope
 713    elsewhere and then uses this function to mangle just the part
 714    underneath the function scope.  So don't use the <local-name>
 715    production, to avoid an infinite recursion.  */
 716
 717 static void
 718 write_name (tree decl, const int ignore_local_scope)
 719 {
 720   tree context;
 721
 722   MANGLE_TRACE_TREE ("name", decl);
 723
 724   if (TREE_CODE (decl) == TYPE_DECL)
 725     {
 726       /* In case this is a typedef, fish out the corresponding
 727          TYPE_DECL for the main variant.  */
 728       decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
 729       context = TYPE_CONTEXT (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
 730     }
 731   else
 732     context = (DECL_CONTEXT (decl) == NULL) ? NULL : CP_DECL_CONTEXT (decl);
 733
 734   /* A decl in :: or ::std scope is treated specially.  The former is
 735      mangled using <unscoped-name> or <unscoped-template-name>, the
 736      latter with a special substitution.  Also, a name that is
 737      directly in a local function scope is also mangled with
 738      <unscoped-name> rather than a full <nested-name>.  */
 739   if (context == NULL
 740       || context == global_namespace
 741       || DECL_NAMESPACE_STD_P (context)
 742       || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL))
 743     {
 744       tree template_info;
 745       /* Is this a template instance?  */
 746       if (decl_is_template_id (decl, &template_info))
 747         {
 748           /* Yes: use <unscoped-template-name>.  */
 749           write_unscoped_template_name (TI_TEMPLATE (template_info));
 750           write_template_args (TI_ARGS (template_info));
 751         }
 752       else
 753         /* Everything else gets an <unqualified-name>.  */
 754         write_unscoped_name (decl);
 755     }
 756   else
 757     {
 758       /* Handle local names, unless we asked not to (that is, invoked
 759          under <local-name>, to handle only the part of the name under
 760          the local scope).  */
 761       if (!ignore_local_scope)
 762         {
 763           /* Scan up the list of scope context, looking for a
 764              function.  If we find one, this entity is in local
 765              function scope.  local_entity tracks context one scope
 766              level down, so it will contain the element that's
 767              directly in that function's scope, either decl or one of
 768              its enclosing scopes.  */
 769           tree local_entity = decl;
 770           while (context != NULL && context != global_namespace)
 771             {
 772               /* Make sure we're always dealing with decls.  */
 773               if (context != NULL && TYPE_P (context))
 774                 context = TYPE_NAME (context);
 775               /* Is this a function?  */
 776               if (TREE_CODE (context) == FUNCTION_DECL)
 777                 {
 778                   /* Yes, we have local scope.  Use the <local-name>
 779                      production for the innermost function scope.  */
 780                   write_local_name (context, local_entity, decl);
 781                   return;
 782                 }
 783               /* Up one scope level.  */
 784               local_entity = context;
 785               context = CP_DECL_CONTEXT (context);
 786             }
 787
 788           /* No local scope found?  Fall through to <nested-name>.  */
 789         }
 790
 791       /* Other decls get a <nested-name> to encode their scope.  */
 792       write_nested_name (decl);
 793     }
 794 }
 795
 796 /* <unscoped-name> ::= <unqualified-name>
 797                    ::= St <unqualified-name>   # ::std::  */
 798
 799 static void
 800 write_unscoped_name (const tree decl)
 801 {
 802   tree context = CP_DECL_CONTEXT (decl);
 803
 804   MANGLE_TRACE_TREE ("unscoped-name", decl);
 805
 806   /* Is DECL in ::std?  */
 807   if (DECL_NAMESPACE_STD_P (context))
 808     {
 809       write_string ("St");
 810       write_unqualified_name (decl);
 811     }
 812   /* If not, it should be either in the global namespace, or directly
 813      in a local function scope.  */
 814   else if (context == global_namespace
 815            || context == NULL
 816            || TREE_CODE (context) == FUNCTION_DECL)
 817     write_unqualified_name (decl);
 818   else
 819     abort ();
 820 }
 821
 822 /* <unscoped-template-name> ::= <unscoped-name>
 823                             ::= <substitution>  */
 824
 825 static void
 826 write_unscoped_template_name (const tree decl)
 827 {
 828   MANGLE_TRACE_TREE ("unscoped-template-name", decl);
 829
 830   if (find_substitution (decl))
 831     return;
 832   write_unscoped_name (decl);
 833   add_substitution (decl);
 834 }
 835
 836 /* Write the nested name, including CV-qualifiers, of DECL.
 837
 838    <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
 839                  ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
 840
 841    <CV-qualifiers> ::= [r] [V] [K]  */
 842
 843 static void
 844 write_nested_name (const tree decl)
 845 {
 846   tree template_info;
 847
 848   MANGLE_TRACE_TREE ("nested-name", decl);
 849
 850   write_char ('N');
 851
 852   /* Write CV-qualifiers, if this is a member function.  */
 853   if (TREE_CODE (decl) == FUNCTION_DECL
 854       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
 855     {
 856       if (DECL_VOLATILE_MEMFUNC_P (decl))
 857         write_char ('V');
 858       if (DECL_CONST_MEMFUNC_P (decl))
 859         write_char ('K');
 860     }
 861
 862   /* Is this a template instance?  */
 863   if (decl_is_template_id (decl, &template_info))
 864     {
 865       /* Yes, use <template-prefix>.  */
 866       write_template_prefix (decl);
 867       write_template_args (TI_ARGS (template_info));
 868     }
 869   else
 870     {
 871       /* No, just use <prefix>  */
 872       write_prefix (DECL_CONTEXT (decl));
 873       write_unqualified_name (decl);
 874     }
 875   write_char ('E');
 876 }
 877
 878 /* <prefix> ::= <prefix> <unqualified-name>
 879             ::= <template-param>
 880             ::= <template-prefix> <template-args>
 881             ::= # empty
 882             ::= <substitution>  */
 883
 884 static void
 885 write_prefix (const tree node)
 886 {
 887   tree decl;
 888   /* Non-NULL if NODE represents a template-id.  */
 889   tree template_info = NULL;
 890
 891   MANGLE_TRACE_TREE ("prefix", node);
 892
 893   if (node == NULL
 894       || node == global_namespace)
 895     return;
 896
 897   if (find_substitution (node))
 898     return;
 899
 900   if (DECL_P (node))
 901     {
 902       /* If this is a function decl, that means we've hit function
 903          scope, so this prefix must be for a local name.  In this
 904          case, we're under the <local-name> production, which encodes
 905          the enclosing function scope elsewhere.  So don't continue
 906          here.  */
 907       if (TREE_CODE (node) == FUNCTION_DECL)
 908         return;
 909
 910       decl = node;
 911       decl_is_template_id (decl, &template_info);
 912     }
 913   else
 914     {
 915       /* Node is a type.  */
 916       decl = TYPE_NAME (node);
 917       if (CLASSTYPE_TEMPLATE_ID_P (node))
 918         template_info = TYPE_TEMPLATE_INFO (node);
 919     }
 920
 921   /* In G++ 3.2, the name of the template parameter was used.  */
 922   if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
 923       && !abi_version_at_least (2))
 924     G.need_abi_warning = true;
 925
 926   if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
 927       && abi_version_at_least (2))
 928     write_template_param (node);
 929   else if (template_info != NULL)
 930     /* Templated.  */
 931     {
 932       write_template_prefix (decl);
 933       write_template_args (TI_ARGS (template_info));
 934     }
 935   else
 936     /* Not templated.  */
 937     {
 938       write_prefix (CP_DECL_CONTEXT (decl));
 939       write_unqualified_name (decl);
 940     }
 941
 942   add_substitution (node);
 943 }
 944
 945 /* <template-prefix> ::= <prefix> <template component>
 946                      ::= <template-param>
 947                      ::= <substitution>  */
 948
 949 static void
 950 write_template_prefix (const tree node)
 951 {
 952   tree decl = DECL_P (node) ? node : TYPE_NAME (node);
 953   tree type = DECL_P (node) ? TREE_TYPE (node) : node;
 954   tree context = CP_DECL_CONTEXT (decl);
 955   tree template_info;
 956   tree template;
 957   tree substitution;
 958
 959   MANGLE_TRACE_TREE ("template-prefix", node);
 960
 961   /* Find the template decl.  */
 962   if (decl_is_template_id (decl, &template_info))
 963     template = TI_TEMPLATE (template_info);
 964   else if (CLASSTYPE_TEMPLATE_ID_P (type))
 965     template = TYPE_TI_TEMPLATE (type);
 966   else
 967     /* Oops, not a template.  */
 968     abort ();
 969
 970   /* For a member template, though, the template name for the
 971      innermost name must have all the outer template levels
 972      instantiated.  For instance, consider
 973
 974        template<typename T> struct Outer {
 975          template<typename U> struct Inner {};
 976        };
 977
 978      The template name for `Inner' in `Outer<int>::Inner<float>' is
 979      `Outer<int>::Inner<U>'.  In g++, we don't instantiate the template
 980      levels separately, so there's no TEMPLATE_DECL available for this
 981      (there's only `Outer<T>::Inner<U>').
 982
 983      In order to get the substitutions right, we create a special
 984      TREE_LIST to represent the substitution candidate for a nested
 985      template.  The TREE_PURPOSE is the template's context, fully
 986      instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
 987      template.
 988
 989      So, for the example above, `Outer<int>::Inner' is represented as a
 990      substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
 991      and whose value is `Outer<T>::Inner<U>'.  */
 992   if (TYPE_P (context))
 993     substitution = build_tree_list (context, template);
 994   else
 995     substitution = template;
 996
 997   if (find_substitution (substitution))
 998     return;
 999
1000   /* In G++ 3.2, the name of the template template parameter was used.  */
1001   if (TREE_CODE (TREE_TYPE (template)) == TEMPLATE_TEMPLATE_PARM
1002       && !abi_version_at_least (2))
1003     G.need_abi_warning = true;
1004
1005   if (TREE_CODE (TREE_TYPE (template)) == TEMPLATE_TEMPLATE_PARM
1006       && abi_version_at_least (2))
1007     write_template_param (TREE_TYPE (template));
1008   else
1009     {
1010       write_prefix (context);
1011       write_unqualified_name (decl);
1012     }
1013
1014   add_substitution (substitution);
1015 }
1016
1017 /* We don't need to handle thunks, vtables, or VTTs here.  Those are
1018    mangled through special entry points.
1019
1020     <unqualified-name>  ::= <operator-name>
1021                         ::= <special-name>
1022                         ::= <source-name>  */
1023
1024 static void
1025 write_unqualified_name (const tree decl)
1026 {
1027   MANGLE_TRACE_TREE ("unqualified-name", decl);
1028
1029   if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_CONSTRUCTOR_P (decl))
1030     write_special_name_constructor (decl);
1031   else if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_DESTRUCTOR_P (decl))
1032     write_special_name_destructor (decl);
1033   else if (DECL_NAME (decl) == NULL_TREE)
1034     write_source_name (DECL_ASSEMBLER_NAME (decl));
1035   else if (DECL_CONV_FN_P (decl))
1036     {
1037       /* Conversion operator. Handle it right here.
1038            <operator> ::= cv <type>  */
1039       tree type;
1040       if (decl_is_template_id (decl, NULL))
1041         {
1042           tree fn_type = get_mostly_instantiated_function_type (decl);
1043           type = TREE_TYPE (fn_type);
1044         }
1045       else
1046         type = DECL_CONV_FN_TYPE (decl);
1047       write_conversion_operator_name (type);
1048     }
1049   else if (DECL_OVERLOADED_OPERATOR_P (decl))
1050     {
1051       operator_name_info_t *oni;
1052       if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1053         oni = assignment_operator_name_info;
1054       else
1055         oni = operator_name_info;
1056
1057       write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1058     }
1059   else
1060     write_source_name (DECL_NAME (decl));
1061 }
1062
1063 /* Write the unqualified-name for a conversion operator to TYPE.  */
1064
1065 static void
1066 write_conversion_operator_name (const tree type)
1067 {
1068   write_string ("cv");
1069   write_type (type);
1070 }
1071
1072 /* Non-terminal <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
1073
1074      <source-name> ::= </length/ number> <identifier>  */
1075
1076 static void
1077 write_source_name (tree identifier)
1078 {
1079   MANGLE_TRACE_TREE ("source-name", identifier);
1080
1081   /* Never write the whole template-id name including the template
1082      arguments; we only want the template name.  */
1083   if (IDENTIFIER_TEMPLATE (identifier))
1084     identifier = IDENTIFIER_TEMPLATE (identifier);
1085
1086   write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1087   write_identifier (IDENTIFIER_POINTER (identifier));
1088 }
1089
1090 /* Convert NUMBER to ascii using base BASE and generating at least
1091    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1092    into which to store the characters. Returns the number of
1093    characters generated (these will be layed out in advance of where
1094    BUFFER points).  */
1095
1096 static int
1097 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1098                 char *buffer, const unsigned int min_digits)
1099 {
1100   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1101   unsigned digits = 0;
1102
1103   while (number)
1104     {
1105       unsigned HOST_WIDE_INT d = number / base;
1106
1107       *--buffer = base_digits[number - d * base];
1108       digits++;
1109       number = d;
1110     }
1111   while (digits < min_digits)
1112     {
1113       *--buffer = base_digits[0];
1114       digits++;
1115     }
1116   return digits;
1117 }
1118
1119 /* Non-terminal <number>.
1120
1121      <number> ::= [n] </decimal integer/>  */
1122
1123 static void
1124 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1125               const unsigned int base)
1126 {
1127   char buffer[sizeof (HOST_WIDE_INT) * 8];
1128   unsigned count = 0;
1129
1130   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1131     {
1132       write_char ('n');
1133       number = -((HOST_WIDE_INT) number);
1134     }
1135   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1136   write_chars (buffer + sizeof (buffer) - count, count);
1137 }
1138
1139 /* Write out an integral CST in decimal. Most numbers are small, and
1140    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1141    bigger than that, which we must deal with.  */
1142
1143 static inline void
1144 write_integer_cst (const tree cst)
1145 {
1146   int sign = tree_int_cst_sgn (cst);
1147
1148   if (TREE_INT_CST_HIGH (cst) + (sign < 0))
1149     {
1150       /* A bignum. We do this in chunks, each of which fits in a
1151          HOST_WIDE_INT.  */
1152       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1153       unsigned HOST_WIDE_INT chunk;
1154       unsigned chunk_digits;
1155       char *ptr = buffer + sizeof (buffer);
1156       unsigned count = 0;
1157       tree n, base, type;
1158       int done;
1159
1160       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1161          representable.  */
1162       chunk = 1000000000;
1163       chunk_digits = 9;
1164
1165       if (sizeof (HOST_WIDE_INT) >= 8)
1166         {
1167           /* It is at least 64 bits, so 10^18 is representable.  */
1168           chunk_digits = 18;
1169           chunk *= chunk;
1170         }
1171
1172       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1173       base = build_int_2 (chunk, 0);
1174       n = build_int_2 (TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
1175       TREE_TYPE (n) = TREE_TYPE (base) = type;
1176
1177       if (sign < 0)
1178         {
1179           write_char ('n');
1180           n = fold (build1 (NEGATE_EXPR, type, n));
1181         }
1182       do
1183         {
1184           tree d = fold (build (FLOOR_DIV_EXPR, type, n, base));
1185           tree tmp = fold (build (MULT_EXPR, type, d, base));
1186           unsigned c;
1187
1188           done = integer_zerop (d);
1189           tmp = fold (build (MINUS_EXPR, type, n, tmp));
1190           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1191                                 done ? 1 : chunk_digits);
1192           ptr -= c;
1193           count += c;
1194           n = d;
1195         }
1196       while (!done);
1197       write_chars (ptr, count);
1198     }
1199   else
1200     {
1201       /* A small num.  */
1202       unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
1203
1204       if (sign < 0)
1205         {
1206           write_char ('n');
1207           low = -low;
1208         }
1209       write_unsigned_number (low);
1210     }
1211 }
1212
1213 /* Write out a floating-point literal.
1214
1215     "Floating-point literals are encoded using the bit pattern of the
1216     target processor's internal representation of that number, as a
1217     fixed-length lowercase hexadecimal string, high-order bytes first
1218     (even if the target processor would store low-order bytes first).
1219     The "n" prefix is not used for floating-point literals; the sign
1220     bit is encoded with the rest of the number.
1221
1222     Here are some examples, assuming the IEEE standard representation
1223     for floating point numbers.  (Spaces are for readability, not
1224     part of the encoding.)
1225
1226         1.0f                    Lf 3f80 0000 E
1227        -1.0f                    Lf bf80 0000 E
1228         1.17549435e-38f         Lf 0080 0000 E
1229         1.40129846e-45f         Lf 0000 0001 E
1230         0.0f                    Lf 0000 0000 E"
1231
1232    Caller is responsible for the Lx and the E.  */
1233 static void
1234 write_real_cst (const tree value)
1235 {
1236   if (abi_version_at_least (2))
1237     {
1238       long target_real[4];  /* largest supported float */
1239       char buffer[9];       /* eight hex digits in a 32-bit number */
1240       int i, limit, dir;
1241
1242       tree type = TREE_TYPE (value);
1243       int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1244
1245       real_to_target (target_real, &TREE_REAL_CST (value),
1246                       TYPE_MODE (type));
1247
1248       /* The value in target_real is in the target word order,
1249          so we must write it out backward if that happens to be
1250          little-endian.  write_number cannot be used, it will
1251          produce uppercase.  */
1252       if (FLOAT_WORDS_BIG_ENDIAN)
1253         i = 0, limit = words, dir = 1;
1254       else
1255         i = words - 1, limit = -1, dir = -1;
1256
1257       for (; i != limit; i += dir)
1258         {
1259           sprintf (buffer, "%08lx", target_real[i]);
1260           write_chars (buffer, 8);
1261         }
1262     }
1263   else
1264     {
1265       /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out
1266          literally.  Note that compatibility with 3.2 is impossible,
1267          because the old floating-point emulator used a different
1268          format for REAL_VALUE_TYPE.  */
1269       size_t i;
1270       for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1271         write_number (((unsigned char *) &TREE_REAL_CST (value))[i],
1272                       /*unsigned_p*/ 1,
1273                       /*base*/ 16);
1274       G.need_abi_warning = 1;
1275     }
1276 }
1277
1278 /* Non-terminal <identifier>.
1279
1280      <identifier> ::= </unqualified source code identifier>  */
1281
1282 static void
1283 write_identifier (const char *identifier)
1284 {
1285   MANGLE_TRACE ("identifier", identifier);
1286   write_string (identifier);
1287 }
1288
1289 /* Handle constructor productions of non-terminal <special-name>.
1290    CTOR is a constructor FUNCTION_DECL.
1291
1292      <special-name> ::= C1   # complete object constructor
1293                     ::= C2   # base object constructor
1294                     ::= C3   # complete object allocating constructor
1295
1296    Currently, allocating constructors are never used.
1297
1298    We also need to provide mangled names for the maybe-in-charge
1299    constructor, so we treat it here too.  mangle_decl_string will
1300    append *INTERNAL* to that, to make sure we never emit it.  */
1301
1302 static void
1303 write_special_name_constructor (const tree ctor)
1304 {
1305   if (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1306       /* Even though we don't ever emit a definition of the
1307          old-style destructor, we still have to consider entities
1308          (like static variables) nested inside it.  */
1309       || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
1310     write_string ("C1");
1311   else if (DECL_BASE_CONSTRUCTOR_P (ctor))
1312     write_string ("C2");
1313   else
1314     abort ();
1315 }
1316
1317 /* Handle destructor productions of non-terminal <special-name>.
1318    DTOR is a destructor FUNCTION_DECL.
1319
1320      <special-name> ::= D0 # deleting (in-charge) destructor
1321                     ::= D1 # complete object (in-charge) destructor
1322                     ::= D2 # base object (not-in-charge) destructor
1323
1324    We also need to provide mangled names for the maybe-incharge
1325    destructor, so we treat it here too.  mangle_decl_string will
1326    append *INTERNAL* to that, to make sure we never emit it.  */
1327
1328 static void
1329 write_special_name_destructor (const tree dtor)
1330 {
1331   if (DECL_DELETING_DESTRUCTOR_P (dtor))
1332     write_string ("D0");
1333   else if (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1334            /* Even though we don't ever emit a definition of the
1335               old-style destructor, we still have to consider entities
1336               (like static variables) nested inside it.  */
1337            || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
1338     write_string ("D1");
1339   else if (DECL_BASE_DESTRUCTOR_P (dtor))
1340     write_string ("D2");
1341   else
1342     abort ();
1343 }
1344
1345 /* Return the discriminator for ENTITY appearing inside
1346    FUNCTION.  The discriminator is the lexical ordinal of VAR among
1347    entities with the same name in the same FUNCTION.  */
1348
1349 static int
1350 discriminator_for_local_entity (tree entity)
1351 {
1352   tree *type;
1353
1354   /* Assume this is the only local entity with this name.  */
1355   int discriminator = 0;
1356
1357   if (DECL_DISCRIMINATOR_P (entity) && DECL_LANG_SPECIFIC (entity))
1358     discriminator = DECL_DISCRIMINATOR (entity);
1359   else if (TREE_CODE (entity) == TYPE_DECL)
1360     {
1361       /* Scan the list of local classes.  */
1362       entity = TREE_TYPE (entity);
1363       for (type = &VARRAY_TREE (local_classes, 0); *type != entity; ++type)
1364         if (TYPE_IDENTIFIER (*type) == TYPE_IDENTIFIER (entity)
1365             && TYPE_CONTEXT (*type) == TYPE_CONTEXT (entity))
1366           ++discriminator;
1367     }
1368
1369   return discriminator;
1370 }
1371
1372 /* Return the discriminator for STRING, a string literal used inside
1373    FUNCTION.  The discriminator is the lexical ordinal of STRING among
1374    string literals used in FUNCTION.  */
1375
1376 static int
1377 discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED,
1378                                   tree string ATTRIBUTE_UNUSED)
1379 {
1380   /* For now, we don't discriminate amongst string literals.  */
1381   return 0;
1382 }
1383
1384 /*   <discriminator> := _ <number>
1385
1386    The discriminator is used only for the second and later occurrences
1387    of the same name within a single function. In this case <number> is
1388    n - 2, if this is the nth occurrence, in lexical order.  */
1389
1390 static void
1391 write_discriminator (const int discriminator)
1392 {
1393   /* If discriminator is zero, don't write anything.  Otherwise...  */
1394   if (discriminator > 0)
1395     {
1396       write_char ('_');
1397       write_unsigned_number (discriminator - 1);
1398     }
1399 }
1400
1401 /* Mangle the name of a function-scope entity.  FUNCTION is the
1402    FUNCTION_DECL for the enclosing function.  ENTITY is the decl for
1403    the entity itself.  LOCAL_ENTITY is the entity that's directly
1404    scoped in FUNCTION_DECL, either ENTITY itself or an enclosing scope
1405    of ENTITY.
1406
1407      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1408                   := Z <function encoding> E s [<discriminator>]  */
1409
1410 static void
1411 write_local_name (const tree function, const tree local_entity,
1412                   const tree entity)
1413 {
1414   MANGLE_TRACE_TREE ("local-name", entity);
1415
1416   write_char ('Z');
1417   write_encoding (function);
1418   write_char ('E');
1419   if (TREE_CODE (entity) == STRING_CST)
1420     {
1421       write_char ('s');
1422       write_discriminator (discriminator_for_string_literal (function,
1423                                                              entity));
1424     }
1425   else
1426     {
1427       /* Now the <entity name>.  Let write_name know its being called
1428          from <local-name>, so it doesn't try to process the enclosing
1429          function scope again.  */
1430       write_name (entity, /*ignore_local_scope=*/1);
1431       write_discriminator (discriminator_for_local_entity (local_entity));
1432     }
1433 }
1434
1435 /* Non-terminals <type> and <CV-qualifier>.
1436
1437      <type> ::= <builtin-type>
1438             ::= <function-type>
1439             ::= <class-enum-type>
1440             ::= <array-type>
1441             ::= <pointer-to-member-type>
1442             ::= <template-param>
1443             ::= <substitution>
1444             ::= <CV-qualifier>
1445             ::= P <type>    # pointer-to
1446             ::= R <type>    # reference-to
1447             ::= C <type>    # complex pair (C 2000)
1448             ::= G <type>    # imaginary (C 2000)     [not supported]
1449             ::= U <source-name> <type>   # vendor extended type qualifier
1450
1451    TYPE is a type node.  */
1452
1453 static void
1454 write_type (tree type)
1455 {
1456   /* This gets set to nonzero if TYPE turns out to be a (possibly
1457      CV-qualified) builtin type.  */
1458   int is_builtin_type = 0;
1459
1460   MANGLE_TRACE_TREE ("type", type);
1461
1462   if (type == error_mark_node)
1463     return;
1464
1465   if (find_substitution (type))
1466     return;
1467
1468   if (write_CV_qualifiers_for_type (type) > 0)
1469     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1470        mangle the unqualified type.  The recursive call is needed here
1471        since both the qualified and unqualified types are substitution
1472        candidates.  */
1473     write_type (TYPE_MAIN_VARIANT (type));
1474   else if (TREE_CODE (type) == ARRAY_TYPE)
1475     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1476        so that the cv-qualification of the element type is available
1477        in write_array_type.  */
1478     write_array_type (type);
1479   else
1480     {
1481       /* See through any typedefs.  */
1482       type = TYPE_MAIN_VARIANT (type);
1483
1484       if (TYPE_PTRMEM_P (type))
1485         write_pointer_to_member_type (type);
1486       else switch (TREE_CODE (type))
1487         {
1488         case VOID_TYPE:
1489         case BOOLEAN_TYPE:
1490         case INTEGER_TYPE:  /* Includes wchar_t.  */
1491         case REAL_TYPE:
1492           /* If this is a typedef, TYPE may not be one of
1493              the standard builtin type nodes, but an alias of one.  Use
1494              TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
1495           write_builtin_type (TYPE_MAIN_VARIANT (type));
1496           ++is_builtin_type;
1497           break;
1498
1499         case COMPLEX_TYPE:
1500           write_char ('C');
1501           write_type (TREE_TYPE (type));
1502           break;
1503
1504         case FUNCTION_TYPE:
1505         case METHOD_TYPE:
1506           write_function_type (type);
1507           break;
1508
1509         case UNION_TYPE:
1510         case RECORD_TYPE:
1511         case ENUMERAL_TYPE:
1512           /* A pointer-to-member function is represented as a special
1513              RECORD_TYPE, so check for this first.  */
1514           if (TYPE_PTRMEMFUNC_P (type))
1515             write_pointer_to_member_type (type);
1516           else
1517             write_class_enum_type (type);
1518           break;
1519
1520         case TYPENAME_TYPE:
1521         case UNBOUND_CLASS_TEMPLATE:
1522           /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1523              ordinary nested names.  */
1524           write_nested_name (TYPE_STUB_DECL (type));
1525           break;
1526
1527         case POINTER_TYPE:
1528           write_char ('P');
1529           write_type (TREE_TYPE (type));
1530           break;
1531
1532         case REFERENCE_TYPE:
1533           write_char ('R');
1534           write_type (TREE_TYPE (type));
1535           break;
1536
1537         case TEMPLATE_TYPE_PARM:
1538         case TEMPLATE_PARM_INDEX:
1539           write_template_param (type);
1540           break;
1541
1542         case TEMPLATE_TEMPLATE_PARM:
1543           write_template_template_param (type);
1544           break;
1545
1546         case BOUND_TEMPLATE_TEMPLATE_PARM:
1547           write_template_template_param (type);
1548           write_template_args
1549             (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1550           break;
1551
1552         case VECTOR_TYPE:
1553           write_string ("U8__vector");
1554           write_type (TREE_TYPE (type));
1555           break;
1556
1557         default:
1558           abort ();
1559         }
1560     }
1561
1562   /* Types other than builtin types are substitution candidates.  */
1563   if (!is_builtin_type)
1564     add_substitution (type);
1565 }
1566
1567 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
1568    CV-qualifiers written for TYPE.
1569
1570      <CV-qualifiers> ::= [r] [V] [K]  */
1571
1572 static int
1573 write_CV_qualifiers_for_type (const tree type)
1574 {
1575   int num_qualifiers = 0;
1576
1577   /* The order is specified by:
1578
1579        "In cases where multiple order-insensitive qualifiers are
1580        present, they should be ordered 'K' (closest to the base type),
1581        'V', 'r', and 'U' (farthest from the base type) ..."
1582
1583      Note that we do not use cp_type_quals below; given "const
1584      int[3]", the "const" is emitted with the "int", not with the
1585      array.  */
1586
1587   if (TYPE_QUALS (type) & TYPE_QUAL_RESTRICT)
1588     {
1589       write_char ('r');
1590       ++num_qualifiers;
1591     }
1592   if (TYPE_QUALS (type) & TYPE_QUAL_VOLATILE)
1593     {
1594       write_char ('V');
1595       ++num_qualifiers;
1596     }
1597   if (TYPE_QUALS (type) & TYPE_QUAL_CONST)
1598     {
1599       write_char ('K');
1600       ++num_qualifiers;
1601     }
1602
1603   return num_qualifiers;
1604 }
1605
1606 /* Non-terminal <builtin-type>.
1607
1608      <builtin-type> ::= v   # void
1609                     ::= b   # bool
1610                     ::= w   # wchar_t
1611                     ::= c   # char
1612                     ::= a   # signed char
1613                     ::= h   # unsigned char
1614                     ::= s   # short
1615                     ::= t   # unsigned short
1616                     ::= i   # int
1617                     ::= j   # unsigned int
1618                     ::= l   # long
1619                     ::= m   # unsigned long
1620                     ::= x   # long long, __int64
1621                     ::= y   # unsigned long long, __int64
1622                     ::= n   # __int128
1623                     ::= o   # unsigned __int128
1624                     ::= f   # float
1625                     ::= d   # double
1626                     ::= e   # long double, __float80
1627                     ::= g   # __float128          [not supported]
1628                     ::= u <source-name>  # vendor extended type */
1629
1630 static void
1631 write_builtin_type (tree type)
1632 {
1633   switch (TREE_CODE (type))
1634     {
1635     case VOID_TYPE:
1636       write_char ('v');
1637       break;
1638
1639     case BOOLEAN_TYPE:
1640       write_char ('b');
1641       break;
1642
1643     case INTEGER_TYPE:
1644       /* If this is size_t, get the underlying int type.  */
1645       if (TYPE_IS_SIZETYPE (type))
1646         type = TYPE_DOMAIN (type);
1647
1648       /* TYPE may still be wchar_t, since that isn't in
1649          integer_type_nodes.  */
1650       if (type == wchar_type_node)
1651         write_char ('w');
1652       else if (TYPE_FOR_JAVA (type))
1653         write_java_integer_type_codes (type);
1654       else
1655         {
1656           size_t itk;
1657           /* Assume TYPE is one of the shared integer type nodes.  Find
1658              it in the array of these nodes.  */
1659         iagain:
1660           for (itk = 0; itk < itk_none; ++itk)
1661             if (type == integer_types[itk])
1662               {
1663                 /* Print the corresponding single-letter code.  */
1664                 write_char (integer_type_codes[itk]);
1665                 break;
1666               }
1667
1668           if (itk == itk_none)
1669             {
1670               tree t = c_common_type_for_mode (TYPE_MODE (type),
1671                                                TREE_UNSIGNED (type));
1672               if (type == t)
1673                 {
1674                   if (TYPE_PRECISION (type) == 128)
1675                     write_char (TREE_UNSIGNED (type) ? 'o' : 'n');
1676                   else
1677                     /* Couldn't find this type.  */
1678                     abort ();
1679                 }
1680               else
1681                 {
1682                   type = t;
1683                   goto iagain;
1684                 }
1685             }
1686         }
1687       break;
1688
1689     case REAL_TYPE:
1690       if (type == float_type_node
1691           || type == java_float_type_node)
1692         write_char ('f');
1693       else if (type == double_type_node
1694                || type == java_double_type_node)
1695         write_char ('d');
1696       else if (type == long_double_type_node)
1697         write_char ('e');
1698       else
1699         abort ();
1700       break;
1701
1702     default:
1703       abort ();
1704     }
1705 }
1706
1707 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
1708    METHOD_TYPE.  The return type is mangled before the parameter
1709    types.
1710
1711      <function-type> ::= F [Y] <bare-function-type> E   */
1712
1713 static void
1714 write_function_type (const tree type)
1715 {
1716   MANGLE_TRACE_TREE ("function-type", type);
1717
1718   /* For a pointer to member function, the function type may have
1719      cv-qualifiers, indicating the quals for the artificial 'this'
1720      parameter.  */
1721   if (TREE_CODE (type) == METHOD_TYPE)
1722     {
1723       /* The first parameter must be a POINTER_TYPE pointing to the
1724          `this' parameter.  */
1725       tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
1726       write_CV_qualifiers_for_type (this_type);
1727     }
1728
1729   write_char ('F');
1730   /* We don't track whether or not a type is `extern "C"'.  Note that
1731      you can have an `extern "C"' function that does not have
1732      `extern "C"' type, and vice versa:
1733
1734        extern "C" typedef void function_t();
1735        function_t f; // f has C++ linkage, but its type is
1736                      // `extern "C"'
1737
1738        typedef void function_t();
1739        extern "C" function_t f; // Vice versa.
1740
1741      See [dcl.link].  */
1742   write_bare_function_type (type, /*include_return_type_p=*/1,
1743                             /*decl=*/NULL);
1744   write_char ('E');
1745 }
1746
1747 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
1748    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
1749    is mangled before the parameter types.  If non-NULL, DECL is
1750    FUNCTION_DECL for the function whose type is being emitted.
1751
1752      <bare-function-type> ::= </signature/ type>+  */
1753
1754 static void
1755 write_bare_function_type (const tree type, const int include_return_type_p,
1756                           const tree decl)
1757 {
1758   MANGLE_TRACE_TREE ("bare-function-type", type);
1759
1760   /* Mangle the return type, if requested.  */
1761   if (include_return_type_p)
1762     write_type (TREE_TYPE (type));
1763
1764   /* Now mangle the types of the arguments.  */
1765   write_method_parms (TYPE_ARG_TYPES (type),
1766                       TREE_CODE (type) == METHOD_TYPE,
1767                       decl);
1768 }
1769
1770 /* Write the mangled representation of a method parameter list of
1771    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
1772    considered a non-static method, and the this parameter is omitted.
1773    If non-NULL, DECL is the FUNCTION_DECL for the function whose
1774    parameters are being emitted.  */
1775
1776 static void
1777 write_method_parms (tree parm_types, const int method_p, const tree decl)
1778 {
1779   tree first_parm_type;
1780   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
1781
1782   /* Assume this parameter type list is variable-length.  If it ends
1783      with a void type, then it's not.  */
1784   int varargs_p = 1;
1785
1786   /* If this is a member function, skip the first arg, which is the
1787      this pointer.
1788        "Member functions do not encode the type of their implicit this
1789        parameter."
1790
1791      Similarly, there's no need to mangle artificial parameters, like
1792      the VTT parameters for constructors and destructors.  */
1793   if (method_p)
1794     {
1795       parm_types = TREE_CHAIN (parm_types);
1796       parm_decl = parm_decl ? TREE_CHAIN (parm_decl) : NULL_TREE;
1797
1798       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
1799         {
1800           parm_types = TREE_CHAIN (parm_types);
1801           parm_decl = TREE_CHAIN (parm_decl);
1802         }
1803     }
1804
1805   for (first_parm_type = parm_types;
1806        parm_types;
1807        parm_types = TREE_CHAIN (parm_types))
1808     {
1809       tree parm = TREE_VALUE (parm_types);
1810       if (parm == void_type_node)
1811         {
1812           /* "Empty parameter lists, whether declared as () or
1813              conventionally as (void), are encoded with a void parameter
1814              (v)."  */
1815           if (parm_types == first_parm_type)
1816             write_type (parm);
1817           /* If the parm list is terminated with a void type, it's
1818              fixed-length.  */
1819           varargs_p = 0;
1820           /* A void type better be the last one.  */
1821           my_friendly_assert (TREE_CHAIN (parm_types) == NULL, 20000523);
1822         }
1823       else
1824         write_type (parm);
1825     }
1826
1827   if (varargs_p)
1828     /* <builtin-type> ::= z  # ellipsis  */
1829     write_char ('z');
1830 }
1831
1832 /* <class-enum-type> ::= <name>  */
1833
1834 static void
1835 write_class_enum_type (const tree type)
1836 {
1837   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
1838 }
1839
1840 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
1841    arguments.
1842
1843      <template-args> ::= I <template-arg>+ E  */
1844
1845 static void
1846 write_template_args (tree args)
1847 {
1848   int i;
1849   int length = TREE_VEC_LENGTH (args);
1850
1851   MANGLE_TRACE_TREE ("template-args", args);
1852
1853   write_char ('I');
1854
1855   my_friendly_assert (length > 0, 20000422);
1856
1857   if (TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
1858     {
1859       /* We have nested template args.  We want the innermost template
1860          argument list.  */
1861       args = TREE_VEC_ELT (args, length - 1);
1862       length = TREE_VEC_LENGTH (args);
1863     }
1864   for (i = 0; i < length; ++i)
1865     write_template_arg (TREE_VEC_ELT (args, i));
1866
1867   write_char ('E');
1868 }
1869
1870 /* <expression> ::= <unary operator-name> <expression>
1871                 ::= <binary operator-name> <expression> <expression>
1872                 ::= <expr-primary>
1873
1874    <expr-primary> ::= <template-param>
1875                   ::= L <type> <value number> E  # literal
1876                   ::= L <mangled-name> E         # external name
1877                   ::= sr <type> <unqualified-name>
1878                   ::= sr <type> <unqualified-name> <template-args> */
1879
1880 static void
1881 write_expression (tree expr)
1882 {
1883   enum tree_code code;
1884
1885   code = TREE_CODE (expr);
1886
1887   /* Handle pointers-to-members by making them look like expression
1888      nodes.  */
1889   if (code == PTRMEM_CST)
1890     {
1891       expr = build_nt (ADDR_EXPR,
1892                        build_nt (SCOPE_REF,
1893                                  PTRMEM_CST_CLASS (expr),
1894                                  PTRMEM_CST_MEMBER (expr)));
1895       code = TREE_CODE (expr);
1896     }
1897
1898   /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
1899      is converted (via qualification conversions) to another
1900      type.  */
1901   while (TREE_CODE (expr) == NOP_EXPR
1902          || TREE_CODE (expr) == NON_LVALUE_EXPR)
1903     {
1904       expr = TREE_OPERAND (expr, 0);
1905       code = TREE_CODE (expr);
1906     }
1907
1908   /* Handle template parameters.  */
1909   if (code == TEMPLATE_TYPE_PARM
1910       || code == TEMPLATE_TEMPLATE_PARM
1911       || code == BOUND_TEMPLATE_TEMPLATE_PARM
1912       || code == TEMPLATE_PARM_INDEX)
1913     write_template_param (expr);
1914   /* Handle literals.  */
1915   else if (TREE_CODE_CLASS (code) == 'c'
1916            || (abi_version_at_least (2) && code == CONST_DECL))
1917     write_template_arg_literal (expr);
1918   else if (DECL_P (expr))
1919     {
1920       /* G++ 3.2 incorrectly mangled non-type template arguments of
1921          enumeration type using their names.  */
1922       if (code == CONST_DECL)
1923         G.need_abi_warning = 1;
1924       write_char ('L');
1925       write_mangled_name (expr, false);
1926       write_char ('E');
1927     }
1928   else if (TREE_CODE (expr) == SIZEOF_EXPR
1929            && TYPE_P (TREE_OPERAND (expr, 0)))
1930     {
1931       write_string ("st");
1932       write_type (TREE_OPERAND (expr, 0));
1933     }
1934   else if (abi_version_at_least (2) && TREE_CODE (expr) == SCOPE_REF)
1935     {
1936       tree scope = TREE_OPERAND (expr, 0);
1937       tree member = TREE_OPERAND (expr, 1);
1938
1939       /* If the MEMBER is a real declaration, then the qualifying
1940          scope was not dependent.  Ideally, we would not have a
1941          SCOPE_REF in those cases, but sometimes we do.  If the second
1942          argument is a DECL, then the name must not have been
1943          dependent.  */
1944       if (DECL_P (member))
1945         write_expression (member);
1946       else
1947         {
1948           tree template_args;
1949
1950           write_string ("sr");
1951           write_type (scope);
1952           /* If MEMBER is a template-id, separate the template
1953              from the arguments.  */
1954           if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
1955             {
1956               template_args = TREE_OPERAND (member, 1);
1957               member = TREE_OPERAND (member, 0);
1958             }
1959           else
1960             template_args = NULL_TREE;
1961           /* Write out the name of the MEMBER.  */
1962           if (IDENTIFIER_TYPENAME_P (member))
1963             write_conversion_operator_name (TREE_TYPE (member));
1964           else if (IDENTIFIER_OPNAME_P (member))
1965             {
1966               int i;
1967               const char *mangled_name = NULL;
1968
1969               /* Unfortunately, there is no easy way to go from the
1970                  name of the operator back to the corresponding tree
1971                  code.  */
1972               for (i = 0; i < LAST_CPLUS_TREE_CODE; ++i)
1973                 if (operator_name_info[i].identifier == member)
1974                   {
1975                     /* The ABI says that we prefer binary operator
1976                        names to unary operator names.  */
1977                     if (operator_name_info[i].arity == 2)
1978                       {
1979                         mangled_name = operator_name_info[i].mangled_name;
1980                         break;
1981                       }
1982                     else if (!mangled_name)
1983                       mangled_name = operator_name_info[i].mangled_name;
1984                   }
1985                 else if (assignment_operator_name_info[i].identifier
1986                          == member)
1987                   {
1988                     mangled_name
1989                       = assignment_operator_name_info[i].mangled_name;
1990                     break;
1991                   }
1992               write_string (mangled_name);
1993             }
1994           else
1995             write_source_name (member);
1996           /* Write out the template arguments.  */
1997           if (template_args)
1998             write_template_args (template_args);
1999         }
2000     }
2001   else
2002     {
2003       int i;
2004
2005       /* When we bind a variable or function to a non-type template
2006          argument with reference type, we create an ADDR_EXPR to show
2007          the fact that the entity's address has been taken.  But, we
2008          don't actually want to output a mangling code for the `&'.  */
2009       if (TREE_CODE (expr) == ADDR_EXPR
2010           && TREE_TYPE (expr)
2011           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2012         {
2013           expr = TREE_OPERAND (expr, 0);
2014           if (DECL_P (expr))
2015             {
2016               write_expression (expr);
2017               return;
2018             }
2019
2020           code = TREE_CODE (expr);
2021         }
2022
2023       /* If it wasn't any of those, recursively expand the expression.  */
2024       write_string (operator_name_info[(int) code].mangled_name);
2025
2026       switch (code)
2027         {
2028         case CALL_EXPR:
2029           sorry ("call_expr cannot be mangled due to a defect in the C++ ABI");
2030           break;
2031
2032         case CAST_EXPR:
2033           write_type (TREE_TYPE (expr));
2034           write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2035           break;
2036
2037         case STATIC_CAST_EXPR:
2038         case CONST_CAST_EXPR:
2039           write_type (TREE_TYPE (expr));
2040           write_expression (TREE_OPERAND (expr, 0));
2041           break;
2042
2043
2044         /* Handle pointers-to-members specially.  */
2045         case SCOPE_REF:
2046           write_type (TREE_OPERAND (expr, 0));
2047           if (TREE_CODE (TREE_OPERAND (expr, 1)) == IDENTIFIER_NODE)
2048             write_source_name (TREE_OPERAND (expr, 1));
2049           else if (TREE_CODE (TREE_OPERAND (expr, 1)) == TEMPLATE_ID_EXPR)
2050             {
2051               tree template_id;
2052               tree name;
2053
2054               template_id = TREE_OPERAND (expr, 1);
2055               name = TREE_OPERAND (template_id, 0);
2056               /* FIXME: What about operators?  */
2057               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE,
2058                                   20030707);
2059               write_source_name (TREE_OPERAND (template_id, 0));
2060               write_template_args (TREE_OPERAND (template_id, 1));
2061             }
2062           else
2063             {
2064               /* G++ 3.2 incorrectly put out both the "sr" code and
2065                  the nested name of the qualified name.  */
2066               G.need_abi_warning = 1;
2067               write_encoding (TREE_OPERAND (expr, 1));
2068             }
2069           break;
2070
2071         default:
2072           for (i = 0; i < TREE_CODE_LENGTH (code); ++i)
2073             {
2074               tree operand = TREE_OPERAND (expr, i);
2075               /* As a GNU expression, the middle operand of a
2076                  conditional may be omitted.  Since expression
2077                  manglings are supposed to represent the input token
2078                  stream, there's no good way to mangle such an
2079                  expression without extending the C++ ABI.  */
2080               if (code == COND_EXPR && i == 1 && !operand)
2081                 {
2082                   error ("omitted middle operand to `?:' operand "
2083                          "cannot be mangled");
2084                   continue;
2085                 }
2086               write_expression (operand);
2087             }
2088         }
2089     }
2090 }
2091
2092 /* Literal subcase of non-terminal <template-arg>.
2093
2094      "Literal arguments, e.g. "A<42L>", are encoded with their type
2095      and value. Negative integer values are preceded with "n"; for
2096      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2097      encoded as 0, true as 1."  */
2098
2099 static void
2100 write_template_arg_literal (const tree value)
2101 {
2102   tree type = TREE_TYPE (value);
2103   write_char ('L');
2104   write_type (type);
2105
2106   if (TREE_CODE (value) == CONST_DECL)
2107     write_integer_cst (DECL_INITIAL (value));
2108   else if (TREE_CODE (value) == INTEGER_CST)
2109     {
2110       if (same_type_p (type, boolean_type_node))
2111         {
2112           if (value == boolean_false_node || integer_zerop (value))
2113             write_unsigned_number (0);
2114           else if (value == boolean_true_node)
2115             write_unsigned_number (1);
2116           else
2117             abort ();
2118         }
2119       else
2120         write_integer_cst (value);
2121     }
2122   else if (TREE_CODE (value) == REAL_CST)
2123     write_real_cst (value);
2124   else
2125     abort ();
2126
2127   write_char ('E');
2128 }
2129
2130 /* Non-terminal <tempalate-arg>.
2131
2132      <template-arg> ::= <type>                        # type
2133                     ::= L <type> </value/ number> E   # literal
2134                     ::= LZ <name> E                   # external name
2135                     ::= X <expression> E              # expression  */
2136
2137 static void
2138 write_template_arg (tree node)
2139 {
2140   enum tree_code code = TREE_CODE (node);
2141
2142   MANGLE_TRACE_TREE ("template-arg", node);
2143
2144   /* A template template parameter's argument list contains TREE_LIST
2145      nodes of which the value field is the the actual argument.  */
2146   if (code == TREE_LIST)
2147     {
2148       node = TREE_VALUE (node);
2149       /* If it's a decl, deal with its type instead.  */
2150       if (DECL_P (node))
2151         {
2152           node = TREE_TYPE (node);
2153           code = TREE_CODE (node);
2154         }
2155     }
2156
2157   if (TREE_CODE (node) == NOP_EXPR
2158       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2159     {
2160       /* Template parameters can be of reference type. To maintain
2161          internal consistency, such arguments use a conversion from
2162          address of object to reference type.  */
2163       my_friendly_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR,
2164                           20031215);
2165       if (abi_version_at_least (2))
2166         node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2167       else
2168         G.need_abi_warning = 1;
2169     }
2170
2171   if (TYPE_P (node))
2172     write_type (node);
2173   else if (code == TEMPLATE_DECL)
2174     /* A template appearing as a template arg is a template template arg.  */
2175     write_template_template_arg (node);
2176   else if ((TREE_CODE_CLASS (code) == 'c' && code != PTRMEM_CST)
2177            || (abi_version_at_least (2) && code == CONST_DECL))
2178     write_template_arg_literal (node);
2179   else if (DECL_P (node))
2180     {
2181       /* G++ 3.2 incorrectly mangled non-type template arguments of
2182          enumeration type using their names.  */
2183       if (code == CONST_DECL)
2184         G.need_abi_warning = 1;
2185       write_char ('L');
2186       write_char ('Z');
2187       write_encoding (node);
2188       write_char ('E');
2189     }
2190   else
2191     {
2192       /* Template arguments may be expressions.  */
2193       write_char ('X');
2194       write_expression (node);
2195       write_char ('E');
2196     }
2197 }
2198
2199 /*  <template-template-arg>
2200                         ::= <name>
2201                         ::= <substitution>  */
2202
2203 static void
2204 write_template_template_arg (const tree decl)
2205 {
2206   MANGLE_TRACE_TREE ("template-template-arg", decl);
2207
2208   if (find_substitution (decl))
2209     return;
2210   write_name (decl, /*ignore_local_scope=*/0);
2211   add_substitution (decl);
2212 }
2213
2214
2215 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2216
2217      <array-type> ::= A [</dimension/ number>] _ </element/ type>
2218                   ::= A <expression> _ </element/ type>
2219
2220      "Array types encode the dimension (number of elements) and the
2221      element type. For variable length arrays, the dimension (but not
2222      the '_' separator) is omitted."  */
2223
2224 static void
2225 write_array_type (const tree type)
2226 {
2227   write_char ('A');
2228   if (TYPE_DOMAIN (type))
2229     {
2230       tree index_type;
2231       tree max;
2232
2233       index_type = TYPE_DOMAIN (type);
2234       /* The INDEX_TYPE gives the upper and lower bounds of the
2235          array.  */
2236       max = TYPE_MAX_VALUE (index_type);
2237       if (TREE_CODE (max) == INTEGER_CST)
2238         {
2239           /* The ABI specifies that we should mangle the number of
2240              elements in the array, not the largest allowed index.  */
2241           max = size_binop (PLUS_EXPR, max, size_one_node);
2242           write_unsigned_number (tree_low_cst (max, 1));
2243         }
2244       else
2245         {
2246           max = TREE_OPERAND (max, 0);
2247           if (!abi_version_at_least (2))
2248             {
2249               /* value_dependent_expression_p presumes nothing is
2250                  dependent when PROCESSING_TEMPLATE_DECL is zero.  */
2251               ++processing_template_decl;
2252               if (!value_dependent_expression_p (max))
2253                 G.need_abi_warning = 1;
2254               --processing_template_decl;
2255             }
2256           write_expression (max);
2257         }
2258
2259     }
2260   write_char ('_');
2261   write_type (TREE_TYPE (type));
2262 }
2263
2264 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2265    variables.  TYPE is a pointer-to-member POINTER_TYPE.
2266
2267      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2268
2269 static void
2270 write_pointer_to_member_type (const tree type)
2271 {
2272   write_char ('M');
2273   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2274   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2275 }
2276
2277 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2278    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2279    TEMPLATE_PARM_INDEX.
2280
2281      <template-param> ::= T </parameter/ number> _  */
2282
2283 static void
2284 write_template_param (const tree parm)
2285 {
2286   int parm_index;
2287   int parm_level;
2288   tree parm_type = NULL_TREE;
2289
2290   MANGLE_TRACE_TREE ("template-parm", parm);
2291
2292   switch (TREE_CODE (parm))
2293     {
2294     case TEMPLATE_TYPE_PARM:
2295     case TEMPLATE_TEMPLATE_PARM:
2296     case BOUND_TEMPLATE_TEMPLATE_PARM:
2297       parm_index = TEMPLATE_TYPE_IDX (parm);
2298       parm_level = TEMPLATE_TYPE_LEVEL (parm);
2299       break;
2300
2301     case TEMPLATE_PARM_INDEX:
2302       parm_index = TEMPLATE_PARM_IDX (parm);
2303       parm_level = TEMPLATE_PARM_LEVEL (parm);
2304       parm_type = TREE_TYPE (TEMPLATE_PARM_DECL (parm));
2305       break;
2306
2307     default:
2308       abort ();
2309     }
2310
2311   write_char ('T');
2312   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2313      earliest template param denoted by `_'.  */
2314   if (parm_index > 0)
2315     write_unsigned_number (parm_index - 1);
2316   write_char ('_');
2317 }
2318
2319 /*  <template-template-param>
2320                         ::= <template-param>
2321                         ::= <substitution>  */
2322
2323 static void
2324 write_template_template_param (const tree parm)
2325 {
2326   tree template = NULL_TREE;
2327
2328   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2329      template template parameter.  The substitution candidate here is
2330      only the template.  */
2331   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2332     {
2333       template
2334         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2335       if (find_substitution (template))
2336         return;
2337     }
2338
2339   /* <template-param> encodes only the template parameter position,
2340      not its template arguments, which is fine here.  */
2341   write_template_param (parm);
2342   if (template)
2343     add_substitution (template);
2344 }
2345
2346 /* Non-terminal <substitution>.
2347
2348       <substitution> ::= S <seq-id> _
2349                      ::= S_  */
2350
2351 static void
2352 write_substitution (const int seq_id)
2353 {
2354   MANGLE_TRACE ("substitution", "");
2355
2356   write_char ('S');
2357   if (seq_id > 0)
2358     write_number (seq_id - 1, /*unsigned=*/1, 36);
2359   write_char ('_');
2360 }
2361
2362 /* Start mangling ENTITY.  */
2363
2364 static inline void
2365 start_mangling (const tree entity)
2366 {
2367   G.entity = entity;
2368   G.need_abi_warning = false;
2369   VARRAY_TREE_INIT (G.substitutions, 1, "mangling substitutions");
2370   obstack_free (&G.name_obstack, obstack_base (&G.name_obstack));
2371 }
2372
2373 /* Done with mangling.  Return the generated mangled name.  If WARN is
2374    true, and the name of G.entity will be mangled differently in a
2375    future version of the ABI, issue a warning.  */
2376
2377 static inline const char *
2378 finish_mangling (const bool warn)
2379 {
2380   if (warn_abi && warn && G.need_abi_warning)
2381     warning ("the mangled name of `%D' will change in a future "
2382              "version of GCC",
2383              G.entity);
2384
2385   /* Clear all the substitutions.  */
2386   G.substitutions = 0;
2387
2388   /* Null-terminate the string.  */
2389   write_char ('\0');
2390
2391   return (const char *) obstack_base (&G.name_obstack);
2392 }
2393
2394 /* Initialize data structures for mangling.  */
2395
2396 void
2397 init_mangle (void)
2398 {
2399   gcc_obstack_init (&G.name_obstack);
2400
2401   /* Cache these identifiers for quick comparison when checking for
2402      standard substitutions.  */
2403   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2404   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
2405   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
2406   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
2407   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
2408   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2409 }
2410
2411 /* Generate the mangled name of DECL.  */
2412
2413 static const char *
2414 mangle_decl_string (const tree decl)
2415 {
2416   const char *result;
2417
2418   start_mangling (decl);
2419
2420   if (TREE_CODE (decl) == TYPE_DECL)
2421     write_type (TREE_TYPE (decl));
2422   else
2423     write_mangled_name (decl, true);
2424
2425   result = finish_mangling (/*warn=*/true);
2426   if (DEBUG_MANGLE)
2427     fprintf (stderr, "mangle_decl_string = '%s'\n\n", result);
2428   return result;
2429 }
2430
2431 /* Create an identifier for the external mangled name of DECL.  */
2432
2433 void
2434 mangle_decl (const tree decl)
2435 {
2436   tree id = get_identifier (mangle_decl_string (decl));
2437
2438   SET_DECL_ASSEMBLER_NAME (decl, id);
2439 }
2440
2441 /* Generate the mangled representation of TYPE.  */
2442
2443 const char *
2444 mangle_type_string (const tree type)
2445 {
2446   const char *result;
2447
2448   start_mangling (type);
2449   write_type (type);
2450   result = finish_mangling (/*warn=*/false);
2451   if (DEBUG_MANGLE)
2452     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2453   return result;
2454 }
2455
2456 /* Create an identifier for the mangled representation of TYPE.  */
2457
2458 tree
2459 mangle_type (const tree type)
2460 {
2461   return get_identifier (mangle_type_string (type));
2462 }
2463
2464 /* Create an identifier for the mangled name of a special component
2465    for belonging to TYPE.  CODE is the ABI-specified code for this
2466    component.  */
2467
2468 static tree
2469 mangle_special_for_type (const tree type, const char *code)
2470 {
2471   const char *result;
2472
2473   /* We don't have an actual decl here for the special component, so
2474      we can't just process the <encoded-name>.  Instead, fake it.  */
2475   start_mangling (type);
2476
2477   /* Start the mangling.  */
2478   write_string ("_Z");
2479   write_string (code);
2480
2481   /* Add the type.  */
2482   write_type (type);
2483   result = finish_mangling (/*warn=*/false);
2484
2485   if (DEBUG_MANGLE)
2486     fprintf (stderr, "mangle_special_for_type = %s\n\n", result);
2487
2488   return get_identifier (result);
2489 }
2490
2491 /* Create an identifier for the mangled representation of the typeinfo
2492    structure for TYPE.  */
2493
2494 tree
2495 mangle_typeinfo_for_type (const tree type)
2496 {
2497   return mangle_special_for_type (type, "TI");
2498 }
2499
2500 /* Create an identifier for the mangled name of the NTBS containing
2501    the mangled name of TYPE.  */
2502
2503 tree
2504 mangle_typeinfo_string_for_type (const tree type)
2505 {
2506   return mangle_special_for_type (type, "TS");
2507 }
2508
2509 /* Create an identifier for the mangled name of the vtable for TYPE.  */
2510
2511 tree
2512 mangle_vtbl_for_type (const tree type)
2513 {
2514   return mangle_special_for_type (type, "TV");
2515 }
2516
2517 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
2518
2519 tree
2520 mangle_vtt_for_type (const tree type)
2521 {
2522   return mangle_special_for_type (type, "TT");
2523 }
2524
2525 /* Return an identifier for a construction vtable group.  TYPE is
2526    the most derived class in the hierarchy; BINFO is the base
2527    subobject for which this construction vtable group will be used.
2528
2529    This mangling isn't part of the ABI specification; in the ABI
2530    specification, the vtable group is dumped in the same COMDAT as the
2531    main vtable, and is referenced only from that vtable, so it doesn't
2532    need an external name.  For binary formats without COMDAT sections,
2533    though, we need external names for the vtable groups.
2534
2535    We use the production
2536
2537     <special-name> ::= CT <type> <offset number> _ <base type>  */
2538
2539 tree
2540 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
2541 {
2542   const char *result;
2543
2544   start_mangling (type);
2545
2546   write_string ("_Z");
2547   write_string ("TC");
2548   write_type (type);
2549   write_integer_cst (BINFO_OFFSET (binfo));
2550   write_char ('_');
2551   write_type (BINFO_TYPE (binfo));
2552
2553   result = finish_mangling (/*warn=*/false);
2554   if (DEBUG_MANGLE)
2555     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n", result);
2556   return get_identifier (result);
2557 }
2558
2559 /* Mangle a this pointer or result pointer adjustment.
2560
2561    <call-offset> ::= h <fixed offset number> _
2562                  ::= v <fixed offset number> _ <virtual offset number> _ */
2563
2564 static void
2565 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
2566 {
2567   write_char (virtual_offset ? 'v' : 'h');
2568
2569   /* For either flavor, write the fixed offset.  */
2570   write_integer_cst (fixed_offset);
2571   write_char ('_');
2572
2573   /* For a virtual thunk, add the virtual offset.  */
2574   if (virtual_offset)
2575     {
2576       write_integer_cst (virtual_offset);
2577       write_char ('_');
2578     }
2579 }
2580
2581 /* Return an identifier for the mangled name of a this-adjusting or
2582    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
2583    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
2584    is a virtual thunk, and it is the vtbl offset in
2585    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
2586    zero for a covariant thunk. Note, that FN_DECL might be a covariant
2587    thunk itself. A covariant thunk name always includes the adjustment
2588    for the this pointer, even if there is none.
2589
2590    <special-name> ::= T <call-offset> <base encoding>
2591                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
2592                                         <base encoding>
2593 */
2594
2595 tree
2596 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
2597               tree virtual_offset)
2598 {
2599   const char *result;
2600
2601   start_mangling (fn_decl);
2602
2603   write_string ("_Z");
2604   write_char ('T');
2605
2606   if (!this_adjusting)
2607     {
2608       /* Covariant thunk with no this adjustment */
2609       write_char ('c');
2610       mangle_call_offset (integer_zero_node, NULL_TREE);
2611       mangle_call_offset (fixed_offset, virtual_offset);
2612     }
2613   else if (!DECL_THUNK_P (fn_decl))
2614     /* Plain this adjusting thunk.  */
2615     mangle_call_offset (fixed_offset, virtual_offset);
2616   else
2617     {
2618       /* This adjusting thunk to covariant thunk.  */
2619       write_char ('c');
2620       mangle_call_offset (fixed_offset, virtual_offset);
2621       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
2622       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
2623       if (virtual_offset)
2624         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
2625       mangle_call_offset (fixed_offset, virtual_offset);
2626       fn_decl = THUNK_TARGET (fn_decl);
2627     }
2628
2629   /* Scoped name.  */
2630   write_encoding (fn_decl);
2631
2632   result = finish_mangling (/*warn=*/false);
2633   if (DEBUG_MANGLE)
2634     fprintf (stderr, "mangle_thunk = %s\n\n", result);
2635   return get_identifier (result);
2636 }
2637
2638 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
2639    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
2640    TYPE.  */
2641
2642 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
2643
2644 /* Hash a node (VAL1) in the table.  */
2645
2646 static hashval_t
2647 hash_type (const void *val)
2648 {
2649   return (hashval_t) TYPE_UID (TREE_TYPE ((tree) val));
2650 }
2651
2652 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
2653
2654 static int
2655 compare_type (const void *val1, const void *val2)
2656 {
2657   return TREE_TYPE ((tree) val1) == (tree) val2;
2658 }
2659
2660 /* Return an identifier for the mangled unqualified name for a
2661    conversion operator to TYPE.  This mangling is not specified by the
2662    ABI spec; it is only used internally.  */
2663
2664 tree
2665 mangle_conv_op_name_for_type (const tree type)
2666 {
2667   void **slot;
2668   tree identifier;
2669
2670   if (conv_type_names == NULL)
2671     conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
2672
2673   slot = htab_find_slot_with_hash (conv_type_names, type,
2674                                    (hashval_t) TYPE_UID (type), INSERT);
2675   identifier = (tree)*slot;
2676   if (!identifier)
2677     {
2678       char buffer[64];
2679
2680        /* Create a unique name corresponding to TYPE.  */
2681       sprintf (buffer, "operator %lu",
2682                (unsigned long) htab_elements (conv_type_names));
2683       identifier = get_identifier (buffer);
2684       *slot = identifier;
2685
2686       /* Hang TYPE off the identifier so it can be found easily later
2687          when performing conversions.  */
2688       TREE_TYPE (identifier) = type;
2689
2690       /* Set bits on the identifier so we know later it's a conversion.  */
2691       IDENTIFIER_OPNAME_P (identifier) = 1;
2692       IDENTIFIER_TYPENAME_P (identifier) = 1;
2693     }
2694
2695   return identifier;
2696 }
2697
2698 /* Return an identifier for the name of an initialization guard
2699    variable for indicated VARIABLE.  */
2700
2701 tree
2702 mangle_guard_variable (const tree variable)
2703 {
2704   start_mangling (variable);
2705   write_string ("_ZGV");
2706   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
2707     /* The name of a guard variable for a reference temporary should refer
2708        to the reference, not the temporary.  */
2709     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
2710   else
2711     write_name (variable, /*ignore_local_scope=*/0);
2712   return get_identifier (finish_mangling (/*warn=*/false));
2713 }
2714
2715 /* Return an identifier for the name of a temporary variable used to
2716    initialize a static reference.  This isn't part of the ABI, but we might
2717    as well call them something readable.  */
2718
2719 tree
2720 mangle_ref_init_variable (const tree variable)
2721 {
2722   start_mangling (variable);
2723   write_string ("_ZGR");
2724   write_name (variable, /*ignore_local_scope=*/0);
2725   return get_identifier (finish_mangling (/*warn=*/false));
2726 }
2727 \f
2728
2729 /* Foreign language type mangling section.  */
2730
2731 /* How to write the type codes for the integer Java type.  */
2732
2733 static void
2734 write_java_integer_type_codes (const tree type)
2735 {
2736   if (type == java_int_type_node)
2737     write_char ('i');
2738   else if (type == java_short_type_node)
2739     write_char ('s');
2740   else if (type == java_byte_type_node)
2741     write_char ('c');
2742   else if (type == java_char_type_node)
2743     write_char ('w');
2744   else if (type == java_long_type_node)
2745     write_char ('x');
2746   else if (type == java_boolean_type_node)
2747     write_char ('b');
2748   else
2749     abort ();
2750 }
2751
2752 #include "gt-cp-mangle.h"