gcc/cp/mangle.c

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