gcc/cp/mangle.c

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