gcc/cp/mangle.c

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