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