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 inline 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   MANGLE_TRACE_TREE ("template-args", args);
1849
1850   write_char ('I');
1851
1852   if (TREE_CODE (args) == TREE_VEC)
1853     {
1854       int i;
1855       int length = TREE_VEC_LENGTH (args);
1856       my_friendly_assert (length > 0, 20000422);
1857
1858       if (TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
1859         {
1860           /* We have nested template args.  We want the innermost template
1861              argument list.  */
1862           args = TREE_VEC_ELT (args, length - 1);
1863           length = TREE_VEC_LENGTH (args);
1864         }
1865       for (i = 0; i < length; ++i)
1866         write_template_arg (TREE_VEC_ELT (args, i));
1867     }
1868   else
1869     {
1870       my_friendly_assert (TREE_CODE (args) == TREE_LIST, 20021014);
1871
1872       while (args)
1873         {
1874           write_template_arg (TREE_VALUE (args));
1875           args = TREE_CHAIN (args);
1876         }
1877     }
1878
1879   write_char ('E');
1880 }
1881
1882 /* <expression> ::= <unary operator-name> <expression>
1883                 ::= <binary operator-name> <expression> <expression>
1884                 ::= <expr-primary>
1885
1886    <expr-primary> ::= <template-param>
1887                   ::= L <type> <value number> E  # literal
1888                   ::= L <mangled-name> E         # external name
1889                   ::= sr <type> <unqualified-name>
1890                   ::= sr <type> <unqualified-name> <template-args> */
1891
1892 static void
1893 write_expression (tree expr)
1894 {
1895   enum tree_code code;
1896
1897   code = TREE_CODE (expr);
1898
1899   /* Handle pointers-to-members by making them look like expression
1900      nodes.  */
1901   if (code == PTRMEM_CST)
1902     {
1903       expr = build_nt (ADDR_EXPR,
1904                        build_nt (SCOPE_REF,
1905                                  PTRMEM_CST_CLASS (expr),
1906                                  PTRMEM_CST_MEMBER (expr)));
1907       code = TREE_CODE (expr);
1908     }
1909
1910   /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
1911      is converted (via qualification conversions) to another
1912      type.  */
1913   while (TREE_CODE (expr) == NOP_EXPR
1914          || TREE_CODE (expr) == NON_LVALUE_EXPR)
1915     {
1916       expr = TREE_OPERAND (expr, 0);
1917       code = TREE_CODE (expr);
1918     }
1919
1920   /* Handle template parameters.  */
1921   if (code == TEMPLATE_TYPE_PARM
1922       || code == TEMPLATE_TEMPLATE_PARM
1923       || code == BOUND_TEMPLATE_TEMPLATE_PARM
1924       || code == TEMPLATE_PARM_INDEX)
1925     write_template_param (expr);
1926   /* Handle literals.  */
1927   else if (TREE_CODE_CLASS (code) == 'c'
1928            || (abi_version_at_least (2) && code == CONST_DECL))
1929     write_template_arg_literal (expr);
1930   else if (DECL_P (expr))
1931     {
1932       /* G++ 3.2 incorrectly mangled non-type template arguments of
1933          enumeration type using their names.  */
1934       if (code == CONST_DECL)
1935         G.need_abi_warning = 1;
1936       write_char ('L');
1937       write_mangled_name (expr, false);
1938       write_char ('E');
1939     }
1940   else if (TREE_CODE (expr) == SIZEOF_EXPR
1941            && TYPE_P (TREE_OPERAND (expr, 0)))
1942     {
1943       write_string ("st");
1944       write_type (TREE_OPERAND (expr, 0));
1945     }
1946   else if (abi_version_at_least (2) && TREE_CODE (expr) == SCOPE_REF)
1947     {
1948       tree scope = TREE_OPERAND (expr, 0);
1949       tree member = TREE_OPERAND (expr, 1);
1950
1951       /* If the MEMBER is a real declaration, then the qualifying
1952          scope was not dependent.  Ideally, we would not have a
1953          SCOPE_REF in those cases, but sometimes we do.  If the second
1954          argument is a DECL, then the name must not have been
1955          dependent.  */
1956       if (DECL_P (member))
1957         write_expression (member);
1958       else
1959         {
1960           tree template_args;
1961
1962           write_string ("sr");
1963           write_type (scope);
1964           /* If MEMBER is a template-id, separate the template
1965              from the arguments.  */
1966           if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
1967             {
1968               template_args = TREE_OPERAND (member, 1);
1969               member = TREE_OPERAND (member, 0);
1970             }
1971           else
1972             template_args = NULL_TREE;
1973           /* Write out the name of the MEMBER.  */
1974           if (IDENTIFIER_TYPENAME_P (member))
1975             write_conversion_operator_name (TREE_TYPE (member));
1976           else if (IDENTIFIER_OPNAME_P (member))
1977             {
1978               int i;
1979               const char *mangled_name = NULL;
1980
1981               /* Unfortunately, there is no easy way to go from the
1982                  name of the operator back to the corresponding tree
1983                  code.  */
1984               for (i = 0; i < LAST_CPLUS_TREE_CODE; ++i)
1985                 if (operator_name_info[i].identifier == member)
1986                   {
1987                     /* The ABI says that we prefer binary operator
1988                        names to unary operator names.  */
1989                     if (operator_name_info[i].arity == 2)
1990                       {
1991                         mangled_name = operator_name_info[i].mangled_name;
1992                         break;
1993                       }
1994                     else if (!mangled_name)
1995                       mangled_name = operator_name_info[i].mangled_name;
1996                   }
1997                 else if (assignment_operator_name_info[i].identifier
1998                          == member)
1999                   {
2000                     mangled_name
2001                       = assignment_operator_name_info[i].mangled_name;
2002                     break;
2003                   }
2004               write_string (mangled_name);
2005             }
2006           else
2007             write_source_name (member);
2008           /* Write out the template arguments.  */
2009           if (template_args)
2010             write_template_args (template_args);
2011         }
2012     }
2013   else
2014     {
2015       int i;
2016
2017       /* When we bind a variable or function to a non-type template
2018          argument with reference type, we create an ADDR_EXPR to show
2019          the fact that the entity's address has been taken.  But, we
2020          don't actually want to output a mangling code for the `&'.  */
2021       if (TREE_CODE (expr) == ADDR_EXPR
2022           && TREE_TYPE (expr)
2023           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2024         {
2025           expr = TREE_OPERAND (expr, 0);
2026           if (DECL_P (expr))
2027             {
2028               write_expression (expr);
2029               return;
2030             }
2031
2032           code = TREE_CODE (expr);
2033         }
2034
2035       /* If it wasn't any of those, recursively expand the expression.  */
2036       write_string (operator_name_info[(int) code].mangled_name);
2037
2038       switch (code)
2039         {
2040         case CALL_EXPR:
2041           sorry ("call_expr cannot be mangled due to a defect in the C++ ABI");
2042           break;
2043
2044         case CAST_EXPR:
2045           write_type (TREE_TYPE (expr));
2046           write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2047           break;
2048
2049         case STATIC_CAST_EXPR:
2050         case CONST_CAST_EXPR:
2051           write_type (TREE_TYPE (expr));
2052           write_expression (TREE_OPERAND (expr, 0));
2053           break;
2054
2055
2056         /* Handle pointers-to-members specially.  */
2057         case SCOPE_REF:
2058           write_type (TREE_OPERAND (expr, 0));
2059           if (TREE_CODE (TREE_OPERAND (expr, 1)) == IDENTIFIER_NODE)
2060             write_source_name (TREE_OPERAND (expr, 1));
2061           else if (TREE_CODE (TREE_OPERAND (expr, 1)) == TEMPLATE_ID_EXPR)
2062             {
2063               tree template_id;
2064               tree name;
2065
2066               template_id = TREE_OPERAND (expr, 1);
2067               name = TREE_OPERAND (template_id, 0);
2068               /* FIXME: What about operators?  */
2069               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE,
2070                                   20030707);
2071               write_source_name (TREE_OPERAND (template_id, 0));
2072               write_template_args (TREE_OPERAND (template_id, 1));
2073             }
2074           else
2075             {
2076               /* G++ 3.2 incorrectly put out both the "sr" code and
2077                  the nested name of the qualified name.  */
2078               G.need_abi_warning = 1;
2079               write_encoding (TREE_OPERAND (expr, 1));
2080             }
2081           break;
2082
2083         default:
2084           for (i = 0; i < TREE_CODE_LENGTH (code); ++i)
2085             {
2086               tree operand = TREE_OPERAND (expr, i);
2087               /* As a GNU expression, the middle operand of a
2088                  conditional may be omitted.  Since expression
2089                  manglings are supposed to represent the input token
2090                  stream, there's no good way to mangle such an
2091                  expression without extending the C++ ABI.  */
2092               if (code == COND_EXPR && i == 1 && !operand)
2093                 {
2094                   error ("omitted middle operand to `?:' operand "
2095                          "cannot be mangled");
2096                   continue;
2097                 }
2098               write_expression (operand);
2099             }
2100         }
2101     }
2102 }
2103
2104 /* Literal subcase of non-terminal <template-arg>.
2105
2106      "Literal arguments, e.g. "A<42L>", are encoded with their type
2107      and value. Negative integer values are preceded with "n"; for
2108      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2109      encoded as 0, true as 1."  */
2110
2111 static void
2112 write_template_arg_literal (const tree value)
2113 {
2114   tree type = TREE_TYPE (value);
2115   write_char ('L');
2116   write_type (type);
2117
2118   if (TREE_CODE (value) == CONST_DECL)
2119     write_integer_cst (DECL_INITIAL (value));
2120   else if (TREE_CODE (value) == INTEGER_CST)
2121     {
2122       if (same_type_p (type, boolean_type_node))
2123         {
2124           if (value == boolean_false_node || integer_zerop (value))
2125             write_unsigned_number (0);
2126           else if (value == boolean_true_node)
2127             write_unsigned_number (1);
2128           else
2129             abort ();
2130         }
2131       else
2132         write_integer_cst (value);
2133     }
2134   else if (TREE_CODE (value) == REAL_CST)
2135     write_real_cst (value);
2136   else
2137     abort ();
2138
2139   write_char ('E');
2140 }
2141
2142 /* Non-terminal <tempalate-arg>.
2143
2144      <template-arg> ::= <type>                        # type
2145                     ::= L <type> </value/ number> E   # literal
2146                     ::= LZ <name> E                   # external name
2147                     ::= X <expression> E              # expression  */
2148
2149 static void
2150 write_template_arg (tree node)
2151 {
2152   enum tree_code code = TREE_CODE (node);
2153
2154   MANGLE_TRACE_TREE ("template-arg", node);
2155
2156   /* A template template parameter's argument list contains TREE_LIST
2157      nodes of which the value field is the the actual argument.  */
2158   if (code == TREE_LIST)
2159     {
2160       node = TREE_VALUE (node);
2161       /* If it's a decl, deal with its type instead.  */
2162       if (DECL_P (node))
2163         {
2164           node = TREE_TYPE (node);
2165           code = TREE_CODE (node);
2166         }
2167     }
2168
2169   if (TYPE_P (node))
2170     write_type (node);
2171   else if (code == TEMPLATE_DECL)
2172     /* A template appearing as a template arg is a template template arg.  */
2173     write_template_template_arg (node);
2174   else if ((TREE_CODE_CLASS (code) == 'c' && code != PTRMEM_CST)
2175            || (abi_version_at_least (2) && code == CONST_DECL))
2176     write_template_arg_literal (node);
2177   else if (DECL_P (node))
2178     {
2179       /* G++ 3.2 incorrectly mangled non-type template arguments of
2180          enumeration type using their names.  */
2181       if (code == CONST_DECL)
2182         G.need_abi_warning = 1;
2183       write_char ('L');
2184       write_char ('Z');
2185       write_encoding (node);
2186       write_char ('E');
2187     }
2188   else
2189     {
2190       /* Template arguments may be expressions.  */
2191       write_char ('X');
2192       write_expression (node);
2193       write_char ('E');
2194     }
2195 }
2196
2197 /*  <template-template-arg>
2198                         ::= <name>
2199                         ::= <substitution>  */
2200
2201 static void
2202 write_template_template_arg (const tree decl)
2203 {
2204   MANGLE_TRACE_TREE ("template-template-arg", decl);
2205
2206   if (find_substitution (decl))
2207     return;
2208   write_name (decl, /*ignore_local_scope=*/0);
2209   add_substitution (decl);
2210 }
2211
2212
2213 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2214
2215      <array-type> ::= A [</dimension/ number>] _ </element/ type>
2216                   ::= A <expression> _ </element/ type>
2217
2218      "Array types encode the dimension (number of elements) and the
2219      element type. For variable length arrays, the dimension (but not
2220      the '_' separator) is omitted."  */
2221
2222 static void
2223 write_array_type (const tree type)
2224 {
2225   write_char ('A');
2226   if (TYPE_DOMAIN (type))
2227     {
2228       tree index_type;
2229       tree max;
2230
2231       index_type = TYPE_DOMAIN (type);
2232       /* The INDEX_TYPE gives the upper and lower bounds of the
2233          array.  */
2234       max = TYPE_MAX_VALUE (index_type);
2235       if (TREE_CODE (max) == INTEGER_CST)
2236         {
2237           /* The ABI specifies that we should mangle the number of
2238              elements in the array, not the largest allowed index.  */
2239           max = size_binop (PLUS_EXPR, max, size_one_node);
2240           write_unsigned_number (tree_low_cst (max, 1));
2241         }
2242       else
2243         write_expression (TREE_OPERAND (max, 0));
2244     }
2245   write_char ('_');
2246   write_type (TREE_TYPE (type));
2247 }
2248
2249 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2250    variables.  TYPE is a pointer-to-member POINTER_TYPE.
2251
2252      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2253
2254 static void
2255 write_pointer_to_member_type (const tree type)
2256 {
2257   write_char ('M');
2258   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2259   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2260 }
2261
2262 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2263    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2264    TEMPLATE_PARM_INDEX.
2265
2266      <template-param> ::= T </parameter/ number> _  */
2267
2268 static void
2269 write_template_param (const tree parm)
2270 {
2271   int parm_index;
2272   int parm_level;
2273   tree parm_type = NULL_TREE;
2274
2275   MANGLE_TRACE_TREE ("template-parm", parm);
2276
2277   switch (TREE_CODE (parm))
2278     {
2279     case TEMPLATE_TYPE_PARM:
2280     case TEMPLATE_TEMPLATE_PARM:
2281     case BOUND_TEMPLATE_TEMPLATE_PARM:
2282       parm_index = TEMPLATE_TYPE_IDX (parm);
2283       parm_level = TEMPLATE_TYPE_LEVEL (parm);
2284       break;
2285
2286     case TEMPLATE_PARM_INDEX:
2287       parm_index = TEMPLATE_PARM_IDX (parm);
2288       parm_level = TEMPLATE_PARM_LEVEL (parm);
2289       parm_type = TREE_TYPE (TEMPLATE_PARM_DECL (parm));
2290       break;
2291
2292     default:
2293       abort ();
2294     }
2295
2296   write_char ('T');
2297   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2298      earliest template param denoted by `_'.  */
2299   if (parm_index > 0)
2300     write_unsigned_number (parm_index - 1);
2301   write_char ('_');
2302 }
2303
2304 /*  <template-template-param>
2305                         ::= <template-param>
2306                         ::= <substitution>  */
2307
2308 static void
2309 write_template_template_param (const tree parm)
2310 {
2311   tree template = NULL_TREE;
2312
2313   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2314      template template parameter.  The substitution candidate here is
2315      only the template.  */
2316   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2317     {
2318       template
2319         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2320       if (find_substitution (template))
2321         return;
2322     }
2323
2324   /* <template-param> encodes only the template parameter position,
2325      not its template arguments, which is fine here.  */
2326   write_template_param (parm);
2327   if (template)
2328     add_substitution (template);
2329 }
2330
2331 /* Non-terminal <substitution>.
2332
2333       <substitution> ::= S <seq-id> _
2334                      ::= S_  */
2335
2336 static void
2337 write_substitution (const int seq_id)
2338 {
2339   MANGLE_TRACE ("substitution", "");
2340
2341   write_char ('S');
2342   if (seq_id > 0)
2343     write_number (seq_id - 1, /*unsigned=*/1, 36);
2344   write_char ('_');
2345 }
2346
2347 /* Start mangling ENTITY.  */
2348
2349 static inline void
2350 start_mangling (const tree entity)
2351 {
2352   G.entity = entity;
2353   G.need_abi_warning = false;
2354   VARRAY_TREE_INIT (G.substitutions, 1, "mangling substitutions");
2355   obstack_free (&G.name_obstack, obstack_base (&G.name_obstack));
2356 }
2357
2358 /* Done with mangling.  Return the generated mangled name.  If WARN is
2359    true, and the name of G.entity will be mangled differently in a
2360    future version of the ABI, issue a warning.  */
2361
2362 static inline const char *
2363 finish_mangling (const bool warn)
2364 {
2365   if (warn_abi && warn && G.need_abi_warning)
2366     warning ("the mangled name of `%D' will change in a future "
2367              "version of GCC",
2368              G.entity);
2369
2370   /* Clear all the substitutions.  */
2371   G.substitutions = 0;
2372
2373   /* Null-terminate the string.  */
2374   write_char ('\0');
2375
2376   return (const char *) obstack_base (&G.name_obstack);
2377 }
2378
2379 /* Initialize data structures for mangling.  */
2380
2381 void
2382 init_mangle (void)
2383 {
2384   gcc_obstack_init (&G.name_obstack);
2385
2386   /* Cache these identifiers for quick comparison when checking for
2387      standard substitutions.  */
2388   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2389   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
2390   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
2391   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
2392   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
2393   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2394 }
2395
2396 /* Generate the mangled name of DECL.  */
2397
2398 static const char *
2399 mangle_decl_string (const tree decl)
2400 {
2401   const char *result;
2402
2403   start_mangling (decl);
2404
2405   if (TREE_CODE (decl) == TYPE_DECL)
2406     write_type (TREE_TYPE (decl));
2407   else
2408     write_mangled_name (decl, true);
2409
2410   result = finish_mangling (/*warn=*/true);
2411   if (DEBUG_MANGLE)
2412     fprintf (stderr, "mangle_decl_string = '%s'\n\n", result);
2413   return result;
2414 }
2415
2416 /* Create an identifier for the external mangled name of DECL.  */
2417
2418 void
2419 mangle_decl (const tree decl)
2420 {
2421   tree id = get_identifier (mangle_decl_string (decl));
2422
2423   SET_DECL_ASSEMBLER_NAME (decl, id);
2424 }
2425
2426 /* Generate the mangled representation of TYPE.  */
2427
2428 const char *
2429 mangle_type_string (const tree type)
2430 {
2431   const char *result;
2432
2433   start_mangling (type);
2434   write_type (type);
2435   result = finish_mangling (/*warn=*/false);
2436   if (DEBUG_MANGLE)
2437     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2438   return result;
2439 }
2440
2441 /* Create an identifier for the mangled representation of TYPE.  */
2442
2443 tree
2444 mangle_type (const tree type)
2445 {
2446   return get_identifier (mangle_type_string (type));
2447 }
2448
2449 /* Create an identifier for the mangled name of a special component
2450    for belonging to TYPE.  CODE is the ABI-specified code for this
2451    component.  */
2452
2453 static tree
2454 mangle_special_for_type (const tree type, const char *code)
2455 {
2456   const char *result;
2457
2458   /* We don't have an actual decl here for the special component, so
2459      we can't just process the <encoded-name>.  Instead, fake it.  */
2460   start_mangling (type);
2461
2462   /* Start the mangling.  */
2463   write_string ("_Z");
2464   write_string (code);
2465
2466   /* Add the type.  */
2467   write_type (type);
2468   result = finish_mangling (/*warn=*/false);
2469
2470   if (DEBUG_MANGLE)
2471     fprintf (stderr, "mangle_special_for_type = %s\n\n", result);
2472
2473   return get_identifier (result);
2474 }
2475
2476 /* Create an identifier for the mangled representation of the typeinfo
2477    structure for TYPE.  */
2478
2479 tree
2480 mangle_typeinfo_for_type (const tree type)
2481 {
2482   return mangle_special_for_type (type, "TI");
2483 }
2484
2485 /* Create an identifier for the mangled name of the NTBS containing
2486    the mangled name of TYPE.  */
2487
2488 tree
2489 mangle_typeinfo_string_for_type (const tree type)
2490 {
2491   return mangle_special_for_type (type, "TS");
2492 }
2493
2494 /* Create an identifier for the mangled name of the vtable for TYPE.  */
2495
2496 tree
2497 mangle_vtbl_for_type (const tree type)
2498 {
2499   return mangle_special_for_type (type, "TV");
2500 }
2501
2502 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
2503
2504 tree
2505 mangle_vtt_for_type (const tree type)
2506 {
2507   return mangle_special_for_type (type, "TT");
2508 }
2509
2510 /* Return an identifier for a construction vtable group.  TYPE is
2511    the most derived class in the hierarchy; BINFO is the base
2512    subobject for which this construction vtable group will be used.
2513
2514    This mangling isn't part of the ABI specification; in the ABI
2515    specification, the vtable group is dumped in the same COMDAT as the
2516    main vtable, and is referenced only from that vtable, so it doesn't
2517    need an external name.  For binary formats without COMDAT sections,
2518    though, we need external names for the vtable groups.
2519
2520    We use the production
2521
2522     <special-name> ::= CT <type> <offset number> _ <base type>  */
2523
2524 tree
2525 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
2526 {
2527   const char *result;
2528
2529   start_mangling (type);
2530
2531   write_string ("_Z");
2532   write_string ("TC");
2533   write_type (type);
2534   write_integer_cst (BINFO_OFFSET (binfo));
2535   write_char ('_');
2536   write_type (BINFO_TYPE (binfo));
2537
2538   result = finish_mangling (/*warn=*/false);
2539   if (DEBUG_MANGLE)
2540     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n", result);
2541   return get_identifier (result);
2542 }
2543
2544 /* Mangle a this pointer or result pointer adjustment.
2545
2546    <call-offset> ::= h <fixed offset number> _
2547                  ::= v <fixed offset number> _ <virtual offset number> _ */
2548
2549 static void
2550 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
2551 {
2552   write_char (virtual_offset ? 'v' : 'h');
2553
2554   /* For either flavor, write the fixed offset.  */
2555   write_integer_cst (fixed_offset);
2556   write_char ('_');
2557
2558   /* For a virtual thunk, add the virtual offset.  */
2559   if (virtual_offset)
2560     {
2561       write_integer_cst (virtual_offset);
2562       write_char ('_');
2563     }
2564 }
2565
2566 /* Return an identifier for the mangled name of a this-adjusting or
2567    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
2568    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
2569    is a virtual thunk, and it is the vtbl offset in
2570    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
2571    zero for a covariant thunk. Note, that FN_DECL might be a covariant
2572    thunk itself. A covariant thunk name always includes the adjustment
2573    for the this pointer, even if there is none.
2574
2575    <special-name> ::= T <call-offset> <base encoding>
2576                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
2577                                         <base encoding>
2578 */
2579
2580 tree
2581 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
2582               tree virtual_offset)
2583 {
2584   const char *result;
2585
2586   start_mangling (fn_decl);
2587
2588   write_string ("_Z");
2589   write_char ('T');
2590
2591   if (!this_adjusting)
2592     {
2593       /* Covariant thunk with no this adjustment */
2594       write_char ('c');
2595       mangle_call_offset (integer_zero_node, NULL_TREE);
2596       mangle_call_offset (fixed_offset, virtual_offset);
2597     }
2598   else if (!DECL_THUNK_P (fn_decl))
2599     /* Plain this adjusting thunk.  */
2600     mangle_call_offset (fixed_offset, virtual_offset);
2601   else
2602     {
2603       /* This adjusting thunk to covariant thunk.  */
2604       write_char ('c');
2605       mangle_call_offset (fixed_offset, virtual_offset);
2606       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
2607       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
2608       if (virtual_offset)
2609         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
2610       mangle_call_offset (fixed_offset, virtual_offset);
2611       fn_decl = THUNK_TARGET (fn_decl);
2612     }
2613
2614   /* Scoped name.  */
2615   write_encoding (fn_decl);
2616
2617   result = finish_mangling (/*warn=*/false);
2618   if (DEBUG_MANGLE)
2619     fprintf (stderr, "mangle_thunk = %s\n\n", result);
2620   return get_identifier (result);
2621 }
2622
2623 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
2624    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
2625    TYPE.  */
2626
2627 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
2628
2629 /* Hash a node (VAL1) in the table.  */
2630
2631 static hashval_t
2632 hash_type (const void *val)
2633 {
2634   return (hashval_t) TYPE_UID (TREE_TYPE ((tree) val));
2635 }
2636
2637 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
2638
2639 static int
2640 compare_type (const void *val1, const void *val2)
2641 {
2642   return TREE_TYPE ((tree) val1) == (tree) val2;
2643 }
2644
2645 /* Return an identifier for the mangled unqualified name for a
2646    conversion operator to TYPE.  This mangling is not specified by the
2647    ABI spec; it is only used internally.  */
2648
2649 tree
2650 mangle_conv_op_name_for_type (const tree type)
2651 {
2652   void **slot;
2653   tree identifier;
2654
2655   if (conv_type_names == NULL)
2656     conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
2657
2658   slot = htab_find_slot_with_hash (conv_type_names, type,
2659                                    (hashval_t) TYPE_UID (type), INSERT);
2660   identifier = (tree)*slot;
2661   if (!identifier)
2662     {
2663       char buffer[64];
2664
2665        /* Create a unique name corresponding to TYPE.  */
2666       sprintf (buffer, "operator %lu",
2667                (unsigned long) htab_elements (conv_type_names));
2668       identifier = get_identifier (buffer);
2669       *slot = identifier;
2670
2671       /* Hang TYPE off the identifier so it can be found easily later
2672          when performing conversions.  */
2673       TREE_TYPE (identifier) = type;
2674
2675       /* Set bits on the identifier so we know later it's a conversion.  */
2676       IDENTIFIER_OPNAME_P (identifier) = 1;
2677       IDENTIFIER_TYPENAME_P (identifier) = 1;
2678     }
2679
2680   return identifier;
2681 }
2682
2683 /* Return an identifier for the name of an initialization guard
2684    variable for indicated VARIABLE.  */
2685
2686 tree
2687 mangle_guard_variable (const tree variable)
2688 {
2689   start_mangling (variable);
2690   write_string ("_ZGV");
2691   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
2692     /* The name of a guard variable for a reference temporary should refer
2693        to the reference, not the temporary.  */
2694     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
2695   else
2696     write_name (variable, /*ignore_local_scope=*/0);
2697   return get_identifier (finish_mangling (/*warn=*/false));
2698 }
2699
2700 /* Return an identifier for the name of a temporary variable used to
2701    initialize a static reference.  This isn't part of the ABI, but we might
2702    as well call them something readable.  */
2703
2704 tree
2705 mangle_ref_init_variable (const tree variable)
2706 {
2707   start_mangling (variable);
2708   write_string ("_ZGR");
2709   write_name (variable, /*ignore_local_scope=*/0);
2710   return get_identifier (finish_mangling (/*warn=*/false));
2711 }
2712 \f
2713
2714 /* Foreign language type mangling section.  */
2715
2716 /* How to write the type codes for the integer Java type.  */
2717
2718 static void
2719 write_java_integer_type_codes (const tree type)
2720 {
2721   if (type == java_int_type_node)
2722     write_char ('i');
2723   else if (type == java_short_type_node)
2724     write_char ('s');
2725   else if (type == java_byte_type_node)
2726     write_char ('c');
2727   else if (type == java_char_type_node)
2728     write_char ('w');
2729   else if (type == java_long_type_node)
2730     write_char ('x');
2731   else if (type == java_boolean_type_node)
2732     write_char ('b');
2733   else
2734     abort ();
2735 }
2736
2737 #include "gt-cp-mangle.h"