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 template;
 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     template = TI_TEMPLATE (template_info);
 985   else
 986     {
 987       gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
 988
 989       template = 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, template);
1016   else
1017     substitution = template;
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 (template)) == TEMPLATE_TEMPLATE_PARM
1024       && !abi_version_at_least (2))
1025     G.need_abi_warning = true;
1026
1027   if (TREE_CODE (TREE_TYPE (template)) == TEMPLATE_TEMPLATE_PARM
1028       && abi_version_at_least (2))
1029     write_template_param (TREE_TYPE (template));
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     write_source_name (DECL_ASSEMBLER_NAME (decl));
1060   else if (DECL_CONV_FN_P (decl))
1061     {
1062       /* Conversion operator. Handle it right here.
1063            <operator> ::= cv <type>  */
1064       tree type;
1065       if (decl_is_template_id (decl, NULL))
1066         {
1067           tree fn_type;
1068           fn_type = get_mostly_instantiated_function_type (decl);
1069           type = TREE_TYPE (fn_type);
1070         }
1071       else
1072         type = DECL_CONV_FN_TYPE (decl);
1073       write_conversion_operator_name (type);
1074     }
1075   else if (DECL_OVERLOADED_OPERATOR_P (decl))
1076     {
1077       operator_name_info_t *oni;
1078       if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1079         oni = assignment_operator_name_info;
1080       else
1081         oni = operator_name_info;
1082
1083       write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1084     }
1085   else if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
1086            && DECL_NAMESPACE_SCOPE_P (decl)
1087            && decl_linkage (decl) == lk_internal)
1088     {
1089       MANGLE_TRACE_TREE ("local-source-name", decl);
1090       write_char ('L');
1091       write_source_name (DECL_NAME (decl));
1092       /* The default discriminator is 1, and that's all we ever use,
1093          so there's no code to output one here.  */
1094     }
1095   else
1096     write_source_name (DECL_NAME (decl));
1097 }
1098
1099 /* Write the unqualified-name for a conversion operator to TYPE.  */
1100
1101 static void
1102 write_conversion_operator_name (const tree type)
1103 {
1104   write_string ("cv");
1105   write_type (type);
1106 }
1107
1108 /* Non-terminal <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
1109
1110      <source-name> ::= </length/ number> <identifier>  */
1111
1112 static void
1113 write_source_name (tree identifier)
1114 {
1115   MANGLE_TRACE_TREE ("source-name", identifier);
1116
1117   /* Never write the whole template-id name including the template
1118      arguments; we only want the template name.  */
1119   if (IDENTIFIER_TEMPLATE (identifier))
1120     identifier = IDENTIFIER_TEMPLATE (identifier);
1121
1122   write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1123   write_identifier (IDENTIFIER_POINTER (identifier));
1124 }
1125
1126 /* Convert NUMBER to ascii using base BASE and generating at least
1127    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1128    into which to store the characters. Returns the number of
1129    characters generated (these will be layed out in advance of where
1130    BUFFER points).  */
1131
1132 static int
1133 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1134                 char *buffer, const unsigned int min_digits)
1135 {
1136   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1137   unsigned digits = 0;
1138
1139   while (number)
1140     {
1141       unsigned HOST_WIDE_INT d = number / base;
1142
1143       *--buffer = base_digits[number - d * base];
1144       digits++;
1145       number = d;
1146     }
1147   while (digits < min_digits)
1148     {
1149       *--buffer = base_digits[0];
1150       digits++;
1151     }
1152   return digits;
1153 }
1154
1155 /* Non-terminal <number>.
1156
1157      <number> ::= [n] </decimal integer/>  */
1158
1159 static void
1160 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1161               const unsigned int base)
1162 {
1163   char buffer[sizeof (HOST_WIDE_INT) * 8];
1164   unsigned count = 0;
1165
1166   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1167     {
1168       write_char ('n');
1169       number = -((HOST_WIDE_INT) number);
1170     }
1171   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1172   write_chars (buffer + sizeof (buffer) - count, count);
1173 }
1174
1175 /* Write out an integral CST in decimal. Most numbers are small, and
1176    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1177    bigger than that, which we must deal with.  */
1178
1179 static inline void
1180 write_integer_cst (const tree cst)
1181 {
1182   int sign = tree_int_cst_sgn (cst);
1183
1184   if (TREE_INT_CST_HIGH (cst) + (sign < 0))
1185     {
1186       /* A bignum. We do this in chunks, each of which fits in a
1187          HOST_WIDE_INT.  */
1188       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1189       unsigned HOST_WIDE_INT chunk;
1190       unsigned chunk_digits;
1191       char *ptr = buffer + sizeof (buffer);
1192       unsigned count = 0;
1193       tree n, base, type;
1194       int done;
1195
1196       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1197          representable.  */
1198       chunk = 1000000000;
1199       chunk_digits = 9;
1200
1201       if (sizeof (HOST_WIDE_INT) >= 8)
1202         {
1203           /* It is at least 64 bits, so 10^18 is representable.  */
1204           chunk_digits = 18;
1205           chunk *= chunk;
1206         }
1207
1208       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1209       base = build_int_cstu (type, chunk);
1210       n = build_int_cst_wide (type,
1211                               TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
1212
1213       if (sign < 0)
1214         {
1215           write_char ('n');
1216           n = fold_build1 (NEGATE_EXPR, type, n);
1217         }
1218       do
1219         {
1220           tree d = fold_build2 (FLOOR_DIV_EXPR, type, n, base);
1221           tree tmp = fold_build2 (MULT_EXPR, type, d, base);
1222           unsigned c;
1223
1224           done = integer_zerop (d);
1225           tmp = fold_build2 (MINUS_EXPR, type, n, tmp);
1226           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1227                               done ? 1 : chunk_digits);
1228           ptr -= c;
1229           count += c;
1230           n = d;
1231         }
1232       while (!done);
1233       write_chars (ptr, count);
1234     }
1235   else
1236     {
1237       /* A small num.  */
1238       unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
1239
1240       if (sign < 0)
1241         {
1242           write_char ('n');
1243           low = -low;
1244         }
1245       write_unsigned_number (low);
1246     }
1247 }
1248
1249 /* Write out a floating-point literal.
1250
1251     "Floating-point literals are encoded using the bit pattern of the
1252     target processor's internal representation of that number, as a
1253     fixed-length lowercase hexadecimal string, high-order bytes first
1254     (even if the target processor would store low-order bytes first).
1255     The "n" prefix is not used for floating-point literals; the sign
1256     bit is encoded with the rest of the number.
1257
1258     Here are some examples, assuming the IEEE standard representation
1259     for floating point numbers.  (Spaces are for readability, not
1260     part of the encoding.)
1261
1262         1.0f                    Lf 3f80 0000 E
1263        -1.0f                    Lf bf80 0000 E
1264         1.17549435e-38f         Lf 0080 0000 E
1265         1.40129846e-45f         Lf 0000 0001 E
1266         0.0f                    Lf 0000 0000 E"
1267
1268    Caller is responsible for the Lx and the E.  */
1269 static void
1270 write_real_cst (const tree value)
1271 {
1272   if (abi_version_at_least (2))
1273     {
1274       long target_real[4];  /* largest supported float */
1275       char buffer[9];       /* eight hex digits in a 32-bit number */
1276       int i, limit, dir;
1277
1278       tree type = TREE_TYPE (value);
1279       int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1280
1281       real_to_target (target_real, &TREE_REAL_CST (value),
1282                       TYPE_MODE (type));
1283
1284       /* The value in target_real is in the target word order,
1285          so we must write it out backward if that happens to be
1286          little-endian.  write_number cannot be used, it will
1287          produce uppercase.  */
1288       if (FLOAT_WORDS_BIG_ENDIAN)
1289         i = 0, limit = words, dir = 1;
1290       else
1291         i = words - 1, limit = -1, dir = -1;
1292
1293       for (; i != limit; i += dir)
1294         {
1295           sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1296           write_chars (buffer, 8);
1297         }
1298     }
1299   else
1300     {
1301       /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out
1302          literally.  Note that compatibility with 3.2 is impossible,
1303          because the old floating-point emulator used a different
1304          format for REAL_VALUE_TYPE.  */
1305       size_t i;
1306       for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1307         write_number (((unsigned char *) &TREE_REAL_CST (value))[i],
1308                       /*unsigned_p*/ 1,
1309                       /*base*/ 16);
1310       G.need_abi_warning = 1;
1311     }
1312 }
1313
1314 /* Non-terminal <identifier>.
1315
1316      <identifier> ::= </unqualified source code identifier>  */
1317
1318 static void
1319 write_identifier (const char *identifier)
1320 {
1321   MANGLE_TRACE ("identifier", identifier);
1322   write_string (identifier);
1323 }
1324
1325 /* Handle constructor productions of non-terminal <special-name>.
1326    CTOR is a constructor FUNCTION_DECL.
1327
1328      <special-name> ::= C1   # complete object constructor
1329                     ::= C2   # base object constructor
1330                     ::= C3   # complete object allocating constructor
1331
1332    Currently, allocating constructors are never used.
1333
1334    We also need to provide mangled names for the maybe-in-charge
1335    constructor, so we treat it here too.  mangle_decl_string will
1336    append *INTERNAL* to that, to make sure we never emit it.  */
1337
1338 static void
1339 write_special_name_constructor (const tree ctor)
1340 {
1341   if (DECL_BASE_CONSTRUCTOR_P (ctor))
1342     write_string ("C2");
1343   else
1344     {
1345       gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1346                   /* Even though we don't ever emit a definition of
1347                      the old-style destructor, we still have to
1348                      consider entities (like static variables) nested
1349                      inside it.  */
1350                   || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor));
1351       write_string ("C1");
1352     }
1353 }
1354
1355 /* Handle destructor productions of non-terminal <special-name>.
1356    DTOR is a destructor FUNCTION_DECL.
1357
1358      <special-name> ::= D0 # deleting (in-charge) destructor
1359                     ::= D1 # complete object (in-charge) destructor
1360                     ::= D2 # base object (not-in-charge) destructor
1361
1362    We also need to provide mangled names for the maybe-incharge
1363    destructor, so we treat it here too.  mangle_decl_string will
1364    append *INTERNAL* to that, to make sure we never emit it.  */
1365
1366 static void
1367 write_special_name_destructor (const tree dtor)
1368 {
1369   if (DECL_DELETING_DESTRUCTOR_P (dtor))
1370     write_string ("D0");
1371   else if (DECL_BASE_DESTRUCTOR_P (dtor))
1372     write_string ("D2");
1373   else
1374     {
1375       gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1376                   /* Even though we don't ever emit a definition of
1377                      the old-style destructor, we still have to
1378                      consider entities (like static variables) nested
1379                      inside it.  */
1380                   || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor));
1381       write_string ("D1");
1382     }
1383 }
1384
1385 /* Return the discriminator for ENTITY appearing inside
1386    FUNCTION.  The discriminator is the lexical ordinal of VAR among
1387    entities with the same name in the same FUNCTION.  */
1388
1389 static int
1390 discriminator_for_local_entity (tree entity)
1391 {
1392   /* Assume this is the only local entity with this name.  */
1393   int discriminator = 0;
1394
1395   if (DECL_DISCRIMINATOR_P (entity) && DECL_LANG_SPECIFIC (entity))
1396     discriminator = DECL_DISCRIMINATOR (entity);
1397   else if (TREE_CODE (entity) == TYPE_DECL)
1398     {
1399       int ix;
1400
1401       /* Scan the list of local classes.  */
1402       entity = TREE_TYPE (entity);
1403       for (ix = 0; ; ix++)
1404         {
1405           tree type = VEC_index (tree, local_classes, ix);
1406           if (type == entity)
1407             break;
1408           if (TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (entity)
1409               && TYPE_CONTEXT (type) == TYPE_CONTEXT (entity))
1410             ++discriminator;
1411         }
1412     }
1413
1414   return discriminator;
1415 }
1416
1417 /* Return the discriminator for STRING, a string literal used inside
1418    FUNCTION.  The discriminator is the lexical ordinal of STRING among
1419    string literals used in FUNCTION.  */
1420
1421 static int
1422 discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED,
1423                                   tree string ATTRIBUTE_UNUSED)
1424 {
1425   /* For now, we don't discriminate amongst string literals.  */
1426   return 0;
1427 }
1428
1429 /*   <discriminator> := _ <number>
1430
1431    The discriminator is used only for the second and later occurrences
1432    of the same name within a single function. In this case <number> is
1433    n - 2, if this is the nth occurrence, in lexical order.  */
1434
1435 static void
1436 write_discriminator (const int discriminator)
1437 {
1438   /* If discriminator is zero, don't write anything.  Otherwise...  */
1439   if (discriminator > 0)
1440     {
1441       write_char ('_');
1442       write_unsigned_number (discriminator - 1);
1443     }
1444 }
1445
1446 /* Mangle the name of a function-scope entity.  FUNCTION is the
1447    FUNCTION_DECL for the enclosing function.  ENTITY is the decl for
1448    the entity itself.  LOCAL_ENTITY is the entity that's directly
1449    scoped in FUNCTION_DECL, either ENTITY itself or an enclosing scope
1450    of ENTITY.
1451
1452      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1453                   := Z <function encoding> E s [<discriminator>]  */
1454
1455 static void
1456 write_local_name (const tree function, const tree local_entity,
1457                   const tree entity)
1458 {
1459   MANGLE_TRACE_TREE ("local-name", entity);
1460
1461   write_char ('Z');
1462   write_encoding (function);
1463   write_char ('E');
1464   if (TREE_CODE (entity) == STRING_CST)
1465     {
1466       write_char ('s');
1467       write_discriminator (discriminator_for_string_literal (function,
1468                                                              entity));
1469     }
1470   else
1471     {
1472       /* Now the <entity name>.  Let write_name know its being called
1473          from <local-name>, so it doesn't try to process the enclosing
1474          function scope again.  */
1475       write_name (entity, /*ignore_local_scope=*/1);
1476       write_discriminator (discriminator_for_local_entity (local_entity));
1477     }
1478 }
1479
1480 /* Non-terminals <type> and <CV-qualifier>.
1481
1482      <type> ::= <builtin-type>
1483             ::= <function-type>
1484             ::= <class-enum-type>
1485             ::= <array-type>
1486             ::= <pointer-to-member-type>
1487             ::= <template-param>
1488             ::= <substitution>
1489             ::= <CV-qualifier>
1490             ::= P <type>    # pointer-to
1491             ::= R <type>    # reference-to
1492             ::= C <type>    # complex pair (C 2000)
1493             ::= G <type>    # imaginary (C 2000)     [not supported]
1494             ::= U <source-name> <type>   # vendor extended type qualifier
1495
1496    C++0x extensions
1497
1498      <type> ::= RR <type>   # rvalue reference-to
1499      <type> ::= Dt <expression> # decltype of an id-expression or
1500                                 # class member access
1501      <type> ::= DT <expression> # decltype of an expression
1502
1503    TYPE is a type node.  */
1504
1505 static void
1506 write_type (tree type)
1507 {
1508   /* This gets set to nonzero if TYPE turns out to be a (possibly
1509      CV-qualified) builtin type.  */
1510   int is_builtin_type = 0;
1511
1512   MANGLE_TRACE_TREE ("type", type);
1513
1514   if (type == error_mark_node)
1515     return;
1516
1517   if (find_substitution (type))
1518     return;
1519
1520   if (write_CV_qualifiers_for_type (type) > 0)
1521     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1522        mangle the unqualified type.  The recursive call is needed here
1523        since both the qualified and unqualified types are substitution
1524        candidates.  */
1525     write_type (TYPE_MAIN_VARIANT (type));
1526   else if (TREE_CODE (type) == ARRAY_TYPE)
1527     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1528        so that the cv-qualification of the element type is available
1529        in write_array_type.  */
1530     write_array_type (type);
1531   else
1532     {
1533       tree type_orig = type;
1534
1535       /* See through any typedefs.  */
1536       type = TYPE_MAIN_VARIANT (type);
1537
1538       if (TYPE_PTRMEM_P (type))
1539         write_pointer_to_member_type (type);
1540       else
1541         {
1542           /* Handle any target-specific fundamental types.  */
1543           const char *target_mangling
1544             = targetm.mangle_type (type_orig);
1545
1546           if (target_mangling)
1547             {
1548               write_string (target_mangling);
1549               return;
1550             }
1551
1552           switch (TREE_CODE (type))
1553             {
1554             case VOID_TYPE:
1555             case BOOLEAN_TYPE:
1556             case INTEGER_TYPE:  /* Includes wchar_t.  */
1557             case REAL_TYPE:
1558               {
1559                 /* If this is a typedef, TYPE may not be one of
1560                    the standard builtin type nodes, but an alias of one.  Use
1561                    TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
1562                 write_builtin_type (TYPE_MAIN_VARIANT (type));
1563                 ++is_builtin_type;
1564               }
1565               break;
1566
1567             case COMPLEX_TYPE:
1568               write_char ('C');
1569               write_type (TREE_TYPE (type));
1570               break;
1571
1572             case FUNCTION_TYPE:
1573             case METHOD_TYPE:
1574               write_function_type (type);
1575               break;
1576
1577             case UNION_TYPE:
1578             case RECORD_TYPE:
1579             case ENUMERAL_TYPE:
1580               /* A pointer-to-member function is represented as a special
1581                  RECORD_TYPE, so check for this first.  */
1582               if (TYPE_PTRMEMFUNC_P (type))
1583                 write_pointer_to_member_type (type);
1584               else
1585                 write_class_enum_type (type);
1586               break;
1587
1588             case TYPENAME_TYPE:
1589             case UNBOUND_CLASS_TEMPLATE:
1590               /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1591                  ordinary nested names.  */
1592               write_nested_name (TYPE_STUB_DECL (type));
1593               break;
1594
1595             case POINTER_TYPE:
1596               write_char ('P');
1597               write_type (TREE_TYPE (type));
1598               break;
1599
1600             case REFERENCE_TYPE:
1601               if (TYPE_REF_IS_RVALUE (type))
1602                 write_char('O');
1603               else
1604                 write_char ('R');
1605               write_type (TREE_TYPE (type));
1606               break;
1607
1608             case TEMPLATE_TYPE_PARM:
1609             case TEMPLATE_PARM_INDEX:
1610               write_template_param (type);
1611               break;
1612
1613             case TEMPLATE_TEMPLATE_PARM:
1614               write_template_template_param (type);
1615               break;
1616
1617             case BOUND_TEMPLATE_TEMPLATE_PARM:
1618               write_template_template_param (type);
1619               write_template_args
1620                 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1621               break;
1622
1623             case VECTOR_TYPE:
1624               write_string ("U8__vector");
1625               write_type (TREE_TYPE (type));
1626               break;
1627
1628             case TYPE_PACK_EXPANSION:
1629               write_string ("U10__variadic");
1630               write_type (PACK_EXPANSION_PATTERN (type));
1631               break;
1632
1633             case DECLTYPE_TYPE:
1634               write_char ('D');
1635               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
1636                 write_char ('t');
1637               else
1638                 write_char ('T');
1639               write_expression (DECLTYPE_TYPE_EXPR (type));
1640               write_char ('E');
1641               break;
1642
1643             case TYPEOF_TYPE:
1644               sorry ("mangling typeof, use decltype instead");
1645               break;
1646
1647             default:
1648               gcc_unreachable ();
1649             }
1650         }
1651     }
1652
1653   /* Types other than builtin types are substitution candidates.  */
1654   if (!is_builtin_type)
1655     add_substitution (type);
1656 }
1657
1658 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
1659    CV-qualifiers written for TYPE.
1660
1661      <CV-qualifiers> ::= [r] [V] [K]  */
1662
1663 static int
1664 write_CV_qualifiers_for_type (const tree type)
1665 {
1666   int num_qualifiers = 0;
1667
1668   /* The order is specified by:
1669
1670        "In cases where multiple order-insensitive qualifiers are
1671        present, they should be ordered 'K' (closest to the base type),
1672        'V', 'r', and 'U' (farthest from the base type) ..."
1673
1674      Note that we do not use cp_type_quals below; given "const
1675      int[3]", the "const" is emitted with the "int", not with the
1676      array.  */
1677
1678   if (TYPE_QUALS (type) & TYPE_QUAL_RESTRICT)
1679     {
1680       write_char ('r');
1681       ++num_qualifiers;
1682     }
1683   if (TYPE_QUALS (type) & TYPE_QUAL_VOLATILE)
1684     {
1685       write_char ('V');
1686       ++num_qualifiers;
1687     }
1688   if (TYPE_QUALS (type) & TYPE_QUAL_CONST)
1689     {
1690       write_char ('K');
1691       ++num_qualifiers;
1692     }
1693
1694   return num_qualifiers;
1695 }
1696
1697 /* Non-terminal <builtin-type>.
1698
1699      <builtin-type> ::= v   # void
1700                     ::= b   # bool
1701                     ::= w   # wchar_t
1702                     ::= c   # char
1703                     ::= a   # signed char
1704                     ::= h   # unsigned char
1705                     ::= s   # short
1706                     ::= t   # unsigned short
1707                     ::= i   # int
1708                     ::= j   # unsigned int
1709                     ::= l   # long
1710                     ::= m   # unsigned long
1711                     ::= x   # long long, __int64
1712                     ::= y   # unsigned long long, __int64
1713                     ::= n   # __int128
1714                     ::= o   # unsigned __int128
1715                     ::= f   # float
1716                     ::= d   # double
1717                     ::= e   # long double, __float80
1718                     ::= g   # __float128          [not supported]
1719                     ::= u <source-name>  # vendor extended type */
1720
1721 static void
1722 write_builtin_type (tree type)
1723 {
1724   if (TYPE_CANONICAL (type))
1725     type = TYPE_CANONICAL (type);
1726
1727   switch (TREE_CODE (type))
1728     {
1729     case VOID_TYPE:
1730       write_char ('v');
1731       break;
1732
1733     case BOOLEAN_TYPE:
1734       write_char ('b');
1735       break;
1736
1737     case INTEGER_TYPE:
1738       /* TYPE may still be wchar_t, char16_t, or char32_t, since that
1739          isn't in integer_type_nodes.  */
1740       if (type == wchar_type_node)
1741         write_char ('w');
1742       else if (type == char16_type_node)
1743         write_string ("u8char16_t");
1744       else if (type == char32_type_node)
1745         write_string ("u8char32_t");
1746       else if (TYPE_FOR_JAVA (type))
1747         write_java_integer_type_codes (type);
1748       else
1749         {
1750           size_t itk;
1751           /* Assume TYPE is one of the shared integer type nodes.  Find
1752              it in the array of these nodes.  */
1753         iagain:
1754           for (itk = 0; itk < itk_none; ++itk)
1755             if (type == integer_types[itk])
1756               {
1757                 /* Print the corresponding single-letter code.  */
1758                 write_char (integer_type_codes[itk]);
1759                 break;
1760               }
1761
1762           if (itk == itk_none)
1763             {
1764               tree t = c_common_type_for_mode (TYPE_MODE (type),
1765                                                TYPE_UNSIGNED (type));
1766               if (type != t)
1767                 {
1768                   type = t;
1769                   goto iagain;
1770                 }
1771
1772               if (TYPE_PRECISION (type) == 128)
1773                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
1774               else
1775                 {
1776                   /* Allow for cases where TYPE is not one of the shared
1777                      integer type nodes and write a "vendor extended builtin
1778                      type" with a name the form intN or uintN, respectively.
1779                      Situations like this can happen if you have an
1780                      __attribute__((__mode__(__SI__))) type and use exotic
1781                      switches like '-mint8' on AVR.  Of course, this is
1782                      undefined by the C++ ABI (and '-mint8' is not even
1783                      Standard C conforming), but when using such special
1784                      options you're pretty much in nowhere land anyway.  */
1785                   const char *prefix;
1786                   char prec[11];        /* up to ten digits for an unsigned */
1787
1788                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
1789                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
1790                   write_char ('u');     /* "vendor extended builtin type" */
1791                   write_unsigned_number (strlen (prefix) + strlen (prec));
1792                   write_string (prefix);
1793                   write_string (prec);
1794                 }
1795             }
1796         }
1797       break;
1798
1799     case REAL_TYPE:
1800       if (type == float_type_node
1801           || type == java_float_type_node)
1802         write_char ('f');
1803       else if (type == double_type_node
1804                || type == java_double_type_node)
1805         write_char ('d');
1806       else if (type == long_double_type_node)
1807         write_char ('e');
1808       else
1809         gcc_unreachable ();
1810       break;
1811
1812     default:
1813       gcc_unreachable ();
1814     }
1815 }
1816
1817 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
1818    METHOD_TYPE.  The return type is mangled before the parameter
1819    types.
1820
1821      <function-type> ::= F [Y] <bare-function-type> E   */
1822
1823 static void
1824 write_function_type (const tree type)
1825 {
1826   MANGLE_TRACE_TREE ("function-type", type);
1827
1828   /* For a pointer to member function, the function type may have
1829      cv-qualifiers, indicating the quals for the artificial 'this'
1830      parameter.  */
1831   if (TREE_CODE (type) == METHOD_TYPE)
1832     {
1833       /* The first parameter must be a POINTER_TYPE pointing to the
1834          `this' parameter.  */
1835       tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
1836       write_CV_qualifiers_for_type (this_type);
1837     }
1838
1839   write_char ('F');
1840   /* We don't track whether or not a type is `extern "C"'.  Note that
1841      you can have an `extern "C"' function that does not have
1842      `extern "C"' type, and vice versa:
1843
1844        extern "C" typedef void function_t();
1845        function_t f; // f has C++ linkage, but its type is
1846                      // `extern "C"'
1847
1848        typedef void function_t();
1849        extern "C" function_t f; // Vice versa.
1850
1851      See [dcl.link].  */
1852   write_bare_function_type (type, /*include_return_type_p=*/1,
1853                             /*decl=*/NULL);
1854   write_char ('E');
1855 }
1856
1857 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
1858    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
1859    is mangled before the parameter types.  If non-NULL, DECL is
1860    FUNCTION_DECL for the function whose type is being emitted.
1861
1862    If DECL is a member of a Java type, then a literal 'J'
1863    is output and the return type is mangled as if INCLUDE_RETURN_TYPE
1864    were nonzero.
1865
1866      <bare-function-type> ::= [J]</signature/ type>+  */
1867
1868 static void
1869 write_bare_function_type (const tree type, const int include_return_type_p,
1870                           const tree decl)
1871 {
1872   int java_method_p;
1873
1874   MANGLE_TRACE_TREE ("bare-function-type", type);
1875
1876   /* Detect Java methods and emit special encoding.  */
1877   if (decl != NULL
1878       && DECL_FUNCTION_MEMBER_P (decl)
1879       && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
1880       && !DECL_CONSTRUCTOR_P (decl)
1881       && !DECL_DESTRUCTOR_P (decl)
1882       && !DECL_CONV_FN_P (decl))
1883     {
1884       java_method_p = 1;
1885       write_char ('J');
1886     }
1887   else
1888     {
1889       java_method_p = 0;
1890     }
1891
1892   /* Mangle the return type, if requested.  */
1893   if (include_return_type_p || java_method_p)
1894     write_type (TREE_TYPE (type));
1895
1896   /* Now mangle the types of the arguments.  */
1897   write_method_parms (TYPE_ARG_TYPES (type),
1898                       TREE_CODE (type) == METHOD_TYPE,
1899                       decl);
1900 }
1901
1902 /* Write the mangled representation of a method parameter list of
1903    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
1904    considered a non-static method, and the this parameter is omitted.
1905    If non-NULL, DECL is the FUNCTION_DECL for the function whose
1906    parameters are being emitted.  */
1907
1908 static void
1909 write_method_parms (tree parm_types, const int method_p, const tree decl)
1910 {
1911   tree first_parm_type;
1912   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
1913
1914   /* Assume this parameter type list is variable-length.  If it ends
1915      with a void type, then it's not.  */
1916   int varargs_p = 1;
1917
1918   /* If this is a member function, skip the first arg, which is the
1919      this pointer.
1920        "Member functions do not encode the type of their implicit this
1921        parameter."
1922
1923      Similarly, there's no need to mangle artificial parameters, like
1924      the VTT parameters for constructors and destructors.  */
1925   if (method_p)
1926     {
1927       parm_types = TREE_CHAIN (parm_types);
1928       parm_decl = parm_decl ? TREE_CHAIN (parm_decl) : NULL_TREE;
1929
1930       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
1931         {
1932           parm_types = TREE_CHAIN (parm_types);
1933           parm_decl = TREE_CHAIN (parm_decl);
1934         }
1935     }
1936
1937   for (first_parm_type = parm_types;
1938        parm_types;
1939        parm_types = TREE_CHAIN (parm_types))
1940     {
1941       tree parm = TREE_VALUE (parm_types);
1942       if (parm == void_type_node)
1943         {
1944           /* "Empty parameter lists, whether declared as () or
1945              conventionally as (void), are encoded with a void parameter
1946              (v)."  */
1947           if (parm_types == first_parm_type)
1948             write_type (parm);
1949           /* If the parm list is terminated with a void type, it's
1950              fixed-length.  */
1951           varargs_p = 0;
1952           /* A void type better be the last one.  */
1953           gcc_assert (TREE_CHAIN (parm_types) == NULL);
1954         }
1955       else
1956         write_type (parm);
1957     }
1958
1959   if (varargs_p)
1960     /* <builtin-type> ::= z  # ellipsis  */
1961     write_char ('z');
1962 }
1963
1964 /* <class-enum-type> ::= <name>  */
1965
1966 static void
1967 write_class_enum_type (const tree type)
1968 {
1969   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
1970 }
1971
1972 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
1973    arguments.
1974
1975      <template-args> ::= I <template-arg>+ E  */
1976
1977 static void
1978 write_template_args (tree args)
1979 {
1980   int i;
1981   int length = TREE_VEC_LENGTH (args);
1982
1983   MANGLE_TRACE_TREE ("template-args", args);
1984
1985   write_char ('I');
1986
1987   gcc_assert (length > 0);
1988
1989   if (TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
1990     {
1991       /* We have nested template args.  We want the innermost template
1992          argument list.  */
1993       args = TREE_VEC_ELT (args, length - 1);
1994       length = TREE_VEC_LENGTH (args);
1995     }
1996   for (i = 0; i < length; ++i)
1997     write_template_arg (TREE_VEC_ELT (args, i));
1998
1999   write_char ('E');
2000 }
2001
2002 /* <expression> ::= <unary operator-name> <expression>
2003                 ::= <binary operator-name> <expression> <expression>
2004                 ::= <expr-primary>
2005
2006    <expr-primary> ::= <template-param>
2007                   ::= L <type> <value number> E         # literal
2008                   ::= L <mangled-name> E                # external name
2009                   ::= sr <type> <unqualified-name>
2010                   ::= sr <type> <unqualified-name> <template-args> */
2011
2012 static void
2013 write_expression (tree expr)
2014 {
2015   enum tree_code code;
2016
2017   code = TREE_CODE (expr);
2018
2019   /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
2020      is converted (via qualification conversions) to another
2021      type.  */
2022   while (TREE_CODE (expr) == NOP_EXPR
2023          || TREE_CODE (expr) == NON_LVALUE_EXPR)
2024     {
2025       expr = TREE_OPERAND (expr, 0);
2026       code = TREE_CODE (expr);
2027     }
2028
2029   if (code == BASELINK)
2030     {
2031       expr = BASELINK_FUNCTIONS (expr);
2032       code = TREE_CODE (expr);
2033     }
2034
2035   /* Handle pointers-to-members by making them look like expression
2036      nodes.  */
2037   if (code == PTRMEM_CST)
2038     {
2039       expr = build_nt (ADDR_EXPR,
2040                        build_qualified_name (/*type=*/NULL_TREE,
2041                                              PTRMEM_CST_CLASS (expr),
2042                                              PTRMEM_CST_MEMBER (expr),
2043                                              /*template_p=*/false));
2044       code = TREE_CODE (expr);
2045     }
2046
2047   /* Handle template parameters.  */
2048   if (code == TEMPLATE_TYPE_PARM
2049       || code == TEMPLATE_TEMPLATE_PARM
2050       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2051       || code == TEMPLATE_PARM_INDEX)
2052     write_template_param (expr);
2053   /* Handle literals.  */
2054   else if (TREE_CODE_CLASS (code) == tcc_constant
2055            || (abi_version_at_least (2) && code == CONST_DECL))
2056     write_template_arg_literal (expr);
2057   else if (DECL_P (expr))
2058     {
2059       /* G++ 3.2 incorrectly mangled non-type template arguments of
2060          enumeration type using their names.  */
2061       if (code == CONST_DECL)
2062         G.need_abi_warning = 1;
2063       write_char ('L');
2064       write_mangled_name (expr, false);
2065       write_char ('E');
2066     }
2067   else if (TREE_CODE (expr) == SIZEOF_EXPR
2068            && TYPE_P (TREE_OPERAND (expr, 0)))
2069     {
2070       write_string ("st");
2071       write_type (TREE_OPERAND (expr, 0));
2072     }
2073   else if (abi_version_at_least (2) && TREE_CODE (expr) == SCOPE_REF)
2074     {
2075       tree scope = TREE_OPERAND (expr, 0);
2076       tree member = TREE_OPERAND (expr, 1);
2077
2078       /* If the MEMBER is a real declaration, then the qualifying
2079          scope was not dependent.  Ideally, we would not have a
2080          SCOPE_REF in those cases, but sometimes we do.  If the second
2081          argument is a DECL, then the name must not have been
2082          dependent.  */
2083       if (DECL_P (member))
2084         write_expression (member);
2085       else
2086         {
2087           tree template_args;
2088
2089           write_string ("sr");
2090           write_type (scope);
2091           /* If MEMBER is a template-id, separate the template
2092              from the arguments.  */
2093           if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2094             {
2095               template_args = TREE_OPERAND (member, 1);
2096               member = TREE_OPERAND (member, 0);
2097             }
2098           else
2099             template_args = NULL_TREE;
2100           /* Write out the name of the MEMBER.  */
2101           if (IDENTIFIER_TYPENAME_P (member))
2102             write_conversion_operator_name (TREE_TYPE (member));
2103           else if (IDENTIFIER_OPNAME_P (member))
2104             {
2105               int i;
2106               const char *mangled_name = NULL;
2107
2108               /* Unfortunately, there is no easy way to go from the
2109                  name of the operator back to the corresponding tree
2110                  code.  */
2111               for (i = 0; i < MAX_TREE_CODES; ++i)
2112                 if (operator_name_info[i].identifier == member)
2113                   {
2114                     /* The ABI says that we prefer binary operator
2115                        names to unary operator names.  */
2116                     if (operator_name_info[i].arity == 2)
2117                       {
2118                         mangled_name = operator_name_info[i].mangled_name;
2119                         break;
2120                       }
2121                     else if (!mangled_name)
2122                       mangled_name = operator_name_info[i].mangled_name;
2123                   }
2124                 else if (assignment_operator_name_info[i].identifier
2125                          == member)
2126                   {
2127                     mangled_name
2128                       = assignment_operator_name_info[i].mangled_name;
2129                     break;
2130                   }
2131               write_string (mangled_name);
2132             }
2133           else
2134             write_source_name (member);
2135           /* Write out the template arguments.  */
2136           if (template_args)
2137             write_template_args (template_args);
2138         }
2139     }
2140   else
2141     {
2142       int i;
2143
2144       /* When we bind a variable or function to a non-type template
2145          argument with reference type, we create an ADDR_EXPR to show
2146          the fact that the entity's address has been taken.  But, we
2147          don't actually want to output a mangling code for the `&'.  */
2148       if (TREE_CODE (expr) == ADDR_EXPR
2149           && TREE_TYPE (expr)
2150           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2151         {
2152           expr = TREE_OPERAND (expr, 0);
2153           if (DECL_P (expr))
2154             {
2155               write_expression (expr);
2156               return;
2157             }
2158
2159           code = TREE_CODE (expr);
2160         }
2161
2162       /* If it wasn't any of those, recursively expand the expression.  */
2163       write_string (operator_name_info[(int) code].mangled_name);
2164
2165       switch (code)
2166         {
2167         case CALL_EXPR:
2168           sorry ("call_expr cannot be mangled due to a defect in the C++ ABI");
2169           break;
2170
2171         case CAST_EXPR:
2172           write_type (TREE_TYPE (expr));
2173           /* There is no way to mangle a zero-operand cast like
2174              "T()".  */
2175           if (!TREE_OPERAND (expr, 0))
2176             sorry ("zero-operand casts cannot be mangled due to a defect "
2177                    "in the C++ ABI");
2178           else
2179             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2180           break;
2181
2182         case STATIC_CAST_EXPR:
2183         case CONST_CAST_EXPR:
2184           write_type (TREE_TYPE (expr));
2185           write_expression (TREE_OPERAND (expr, 0));
2186           break;
2187
2188
2189         /* Handle pointers-to-members specially.  */
2190         case SCOPE_REF:
2191           write_type (TREE_OPERAND (expr, 0));
2192           if (TREE_CODE (TREE_OPERAND (expr, 1)) == IDENTIFIER_NODE)
2193             write_source_name (TREE_OPERAND (expr, 1));
2194           else if (TREE_CODE (TREE_OPERAND (expr, 1)) == TEMPLATE_ID_EXPR)
2195             {
2196               tree template_id;
2197               tree name;
2198
2199               template_id = TREE_OPERAND (expr, 1);
2200               name = TREE_OPERAND (template_id, 0);
2201               /* FIXME: What about operators?  */
2202               gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2203               write_source_name (TREE_OPERAND (template_id, 0));
2204               write_template_args (TREE_OPERAND (template_id, 1));
2205             }
2206           else
2207             {
2208               /* G++ 3.2 incorrectly put out both the "sr" code and
2209                  the nested name of the qualified name.  */
2210               G.need_abi_warning = 1;
2211               write_encoding (TREE_OPERAND (expr, 1));
2212             }
2213           break;
2214
2215         default:
2216           for (i = 0; i < TREE_OPERAND_LENGTH (expr); ++i)
2217             {
2218               tree operand = TREE_OPERAND (expr, i);
2219               /* As a GNU extension, the middle operand of a
2220                  conditional may be omitted.  Since expression
2221                  manglings are supposed to represent the input token
2222                  stream, there's no good way to mangle such an
2223                  expression without extending the C++ ABI.  */
2224               if (code == COND_EXPR && i == 1 && !operand)
2225                 {
2226                   error ("omitted middle operand to %<?:%> operand "
2227                          "cannot be mangled");
2228                   continue;
2229                 }
2230               write_expression (operand);
2231             }
2232         }
2233     }
2234 }
2235
2236 /* Literal subcase of non-terminal <template-arg>.
2237
2238      "Literal arguments, e.g. "A<42L>", are encoded with their type
2239      and value. Negative integer values are preceded with "n"; for
2240      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2241      encoded as 0, true as 1."  */
2242
2243 static void
2244 write_template_arg_literal (const tree value)
2245 {
2246   write_char ('L');
2247   write_type (TREE_TYPE (value));
2248
2249   switch (TREE_CODE (value))
2250     {
2251     case CONST_DECL:
2252       write_integer_cst (DECL_INITIAL (value));
2253       break;
2254
2255     case INTEGER_CST:
2256       gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2257                   || integer_zerop (value) || integer_onep (value));
2258       write_integer_cst (value);
2259       break;
2260
2261     case REAL_CST:
2262       write_real_cst (value);
2263       break;
2264
2265     default:
2266       gcc_unreachable ();
2267     }
2268
2269   write_char ('E');
2270 }
2271
2272 /* Non-terminal <template-arg>.
2273
2274      <template-arg> ::= <type>                          # type
2275                     ::= L <type> </value/ number> E     # literal
2276                     ::= LZ <name> E                     # external name
2277                     ::= X <expression> E                # expression  */
2278
2279 static void
2280 write_template_arg (tree node)
2281 {
2282   enum tree_code code = TREE_CODE (node);
2283
2284   MANGLE_TRACE_TREE ("template-arg", node);
2285
2286   /* A template template parameter's argument list contains TREE_LIST
2287      nodes of which the value field is the actual argument.  */
2288   if (code == TREE_LIST)
2289     {
2290       node = TREE_VALUE (node);
2291       /* If it's a decl, deal with its type instead.  */
2292       if (DECL_P (node))
2293         {
2294           node = TREE_TYPE (node);
2295           code = TREE_CODE (node);
2296         }
2297     }
2298
2299   if (TREE_CODE (node) == NOP_EXPR
2300       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2301     {
2302       /* Template parameters can be of reference type. To maintain
2303          internal consistency, such arguments use a conversion from
2304          address of object to reference type.  */
2305       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2306       if (abi_version_at_least (2))
2307         node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2308       else
2309         G.need_abi_warning = 1;
2310     }
2311
2312   if (ARGUMENT_PACK_P (node))
2313     {
2314       /* Expand the template argument pack. */
2315       tree args = ARGUMENT_PACK_ARGS (node);
2316       int i, length = TREE_VEC_LENGTH (args);
2317       for (i = 0; i < length; ++i)
2318         write_template_arg (TREE_VEC_ELT (args, i));
2319     }
2320   else if (TYPE_P (node))
2321     write_type (node);
2322   else if (code == TEMPLATE_DECL)
2323     /* A template appearing as a template arg is a template template arg.  */
2324     write_template_template_arg (node);
2325   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
2326            || (abi_version_at_least (2) && code == CONST_DECL))
2327     write_template_arg_literal (node);
2328   else if (DECL_P (node))
2329     {
2330       /* Until ABI version 2, non-type template arguments of
2331          enumeration type were mangled using their names.  */
2332       if (code == CONST_DECL && !abi_version_at_least (2))
2333         G.need_abi_warning = 1;
2334       write_char ('L');
2335       /* Until ABI version 3, the underscore before the mangled name
2336          was incorrectly omitted.  */
2337       if (!abi_version_at_least (3))
2338         {
2339           G.need_abi_warning = 1;
2340           write_char ('Z');
2341         }
2342       else
2343         write_string ("_Z");
2344       write_encoding (node);
2345       write_char ('E');
2346     }
2347   else
2348     {
2349       /* Template arguments may be expressions.  */
2350       write_char ('X');
2351       write_expression (node);
2352       write_char ('E');
2353     }
2354 }
2355
2356 /*  <template-template-arg>
2357                         ::= <name>
2358                         ::= <substitution>  */
2359
2360 static void
2361 write_template_template_arg (const tree decl)
2362 {
2363   MANGLE_TRACE_TREE ("template-template-arg", decl);
2364
2365   if (find_substitution (decl))
2366     return;
2367   write_name (decl, /*ignore_local_scope=*/0);
2368   add_substitution (decl);
2369 }
2370
2371
2372 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2373
2374      <array-type> ::= A [</dimension/ number>] _ </element/ type>
2375                   ::= A <expression> _ </element/ type>
2376
2377      "Array types encode the dimension (number of elements) and the
2378      element type. For variable length arrays, the dimension (but not
2379      the '_' separator) is omitted."  */
2380
2381 static void
2382 write_array_type (const tree type)
2383 {
2384   write_char ('A');
2385   if (TYPE_DOMAIN (type))
2386     {
2387       tree index_type;
2388       tree max;
2389
2390       index_type = TYPE_DOMAIN (type);
2391       /* The INDEX_TYPE gives the upper and lower bounds of the
2392          array.  */
2393       max = TYPE_MAX_VALUE (index_type);
2394       if (TREE_CODE (max) == INTEGER_CST)
2395         {
2396           /* The ABI specifies that we should mangle the number of
2397              elements in the array, not the largest allowed index.  */
2398           max = size_binop (PLUS_EXPR, max, size_one_node);
2399           write_unsigned_number (tree_low_cst (max, 1));
2400         }
2401       else
2402         {
2403           max = TREE_OPERAND (max, 0);
2404           if (!abi_version_at_least (2))
2405             {
2406               /* value_dependent_expression_p presumes nothing is
2407                  dependent when PROCESSING_TEMPLATE_DECL is zero.  */
2408               ++processing_template_decl;
2409               if (!value_dependent_expression_p (max))
2410                 G.need_abi_warning = 1;
2411               --processing_template_decl;
2412             }
2413           write_expression (max);
2414         }
2415
2416     }
2417   write_char ('_');
2418   write_type (TREE_TYPE (type));
2419 }
2420
2421 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2422    variables.  TYPE is a pointer-to-member POINTER_TYPE.
2423
2424      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2425
2426 static void
2427 write_pointer_to_member_type (const tree type)
2428 {
2429   write_char ('M');
2430   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2431   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2432 }
2433
2434 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2435    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2436    TEMPLATE_PARM_INDEX.
2437
2438      <template-param> ::= T </parameter/ number> _  */
2439
2440 static void
2441 write_template_param (const tree parm)
2442 {
2443   int parm_index;
2444   int parm_level;
2445   tree parm_type = NULL_TREE;
2446
2447   MANGLE_TRACE_TREE ("template-parm", parm);
2448
2449   switch (TREE_CODE (parm))
2450     {
2451     case TEMPLATE_TYPE_PARM:
2452     case TEMPLATE_TEMPLATE_PARM:
2453     case BOUND_TEMPLATE_TEMPLATE_PARM:
2454       parm_index = TEMPLATE_TYPE_IDX (parm);
2455       parm_level = TEMPLATE_TYPE_LEVEL (parm);
2456       break;
2457
2458     case TEMPLATE_PARM_INDEX:
2459       parm_index = TEMPLATE_PARM_IDX (parm);
2460       parm_level = TEMPLATE_PARM_LEVEL (parm);
2461       parm_type = TREE_TYPE (TEMPLATE_PARM_DECL (parm));
2462       break;
2463
2464     default:
2465       gcc_unreachable ();
2466     }
2467
2468   write_char ('T');
2469   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2470      earliest template param denoted by `_'.  */
2471   if (parm_index > 0)
2472     write_unsigned_number (parm_index - 1);
2473   write_char ('_');
2474 }
2475
2476 /*  <template-template-param>
2477                         ::= <template-param>
2478                         ::= <substitution>  */
2479
2480 static void
2481 write_template_template_param (const tree parm)
2482 {
2483   tree template = NULL_TREE;
2484
2485   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2486      template template parameter.  The substitution candidate here is
2487      only the template.  */
2488   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2489     {
2490       template
2491         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2492       if (find_substitution (template))
2493         return;
2494     }
2495
2496   /* <template-param> encodes only the template parameter position,
2497      not its template arguments, which is fine here.  */
2498   write_template_param (parm);
2499   if (template)
2500     add_substitution (template);
2501 }
2502
2503 /* Non-terminal <substitution>.
2504
2505       <substitution> ::= S <seq-id> _
2506                      ::= S_  */
2507
2508 static void
2509 write_substitution (const int seq_id)
2510 {
2511   MANGLE_TRACE ("substitution", "");
2512
2513   write_char ('S');
2514   if (seq_id > 0)
2515     write_number (seq_id - 1, /*unsigned=*/1, 36);
2516   write_char ('_');
2517 }
2518
2519 /* Start mangling ENTITY.  */
2520
2521 static inline void
2522 start_mangling (const tree entity)
2523 {
2524   G.entity = entity;
2525   G.need_abi_warning = false;
2526   obstack_free (&name_obstack, name_base);
2527   mangle_obstack = &name_obstack;
2528   name_base = obstack_alloc (&name_obstack, 0);
2529 }
2530
2531 /* Done with mangling. If WARN is true, and the name of G.entity will
2532    be mangled differently in a future version of the ABI, issue a
2533    warning.  */
2534
2535 static void
2536 finish_mangling_internal (const bool warn)
2537 {
2538   if (warn_abi && warn && G.need_abi_warning)
2539     warning (OPT_Wabi, "the mangled name of %qD will change in a future "
2540              "version of GCC",
2541              G.entity);
2542
2543   /* Clear all the substitutions.  */
2544   VEC_truncate (tree, G.substitutions, 0);
2545
2546   /* Null-terminate the string.  */
2547   write_char ('\0');
2548 }
2549
2550
2551 /* Like finish_mangling_internal, but return the mangled string.  */
2552
2553 static inline const char *
2554 finish_mangling (const bool warn)
2555 {
2556   finish_mangling_internal (warn);
2557   return (const char *) obstack_finish (mangle_obstack);
2558 }
2559
2560 /* Like finish_mangling_internal, but return an identifier.  */
2561
2562 static tree
2563 finish_mangling_get_identifier (const bool warn)
2564 {
2565   finish_mangling_internal (warn);
2566   /* Don't obstack_finish here, and the next start_mangling will
2567      remove the identifier.  */
2568   return get_identifier ((const char *) name_base);
2569 }
2570
2571 /* Initialize data structures for mangling.  */
2572
2573 void
2574 init_mangle (void)
2575 {
2576   gcc_obstack_init (&name_obstack);
2577   name_base = obstack_alloc (&name_obstack, 0);
2578   G.substitutions = NULL;
2579
2580   /* Cache these identifiers for quick comparison when checking for
2581      standard substitutions.  */
2582   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2583   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
2584   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
2585   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
2586   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
2587   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2588 }
2589
2590 /* Generate the mangled name of DECL.  */
2591
2592 static tree
2593 mangle_decl_string (const tree decl)
2594 {
2595   tree result;
2596
2597   start_mangling (decl);
2598
2599   if (TREE_CODE (decl) == TYPE_DECL)
2600     write_type (TREE_TYPE (decl));
2601   else
2602     write_mangled_name (decl, true);
2603
2604   result = finish_mangling_get_identifier (/*warn=*/true);
2605   if (DEBUG_MANGLE)
2606     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
2607              IDENTIFIER_POINTER (result));
2608   return result;
2609 }
2610
2611 /* Create an identifier for the external mangled name of DECL.  */
2612
2613 void
2614 mangle_decl (const tree decl)
2615 {
2616   tree id = mangle_decl_string (decl);
2617   id = targetm.mangle_decl_assembler_name (decl, id);
2618   SET_DECL_ASSEMBLER_NAME (decl, id);
2619 }
2620
2621 /* Generate the mangled representation of TYPE.  */
2622
2623 const char *
2624 mangle_type_string (const tree type)
2625 {
2626   const char *result;
2627
2628   start_mangling (type);
2629   write_type (type);
2630   result = finish_mangling (/*warn=*/false);
2631   if (DEBUG_MANGLE)
2632     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2633   return result;
2634 }
2635
2636 /* Create an identifier for the mangled name of a special component
2637    for belonging to TYPE.  CODE is the ABI-specified code for this
2638    component.  */
2639
2640 static tree
2641 mangle_special_for_type (const tree type, const char *code)
2642 {
2643   tree result;
2644
2645   /* We don't have an actual decl here for the special component, so
2646      we can't just process the <encoded-name>.  Instead, fake it.  */
2647   start_mangling (type);
2648
2649   /* Start the mangling.  */
2650   write_string ("_Z");
2651   write_string (code);
2652
2653   /* Add the type.  */
2654   write_type (type);
2655   result = finish_mangling_get_identifier (/*warn=*/false);
2656
2657   if (DEBUG_MANGLE)
2658     fprintf (stderr, "mangle_special_for_type = %s\n\n",
2659              IDENTIFIER_POINTER (result));
2660
2661   return result;
2662 }
2663
2664 /* Create an identifier for the mangled representation of the typeinfo
2665    structure for TYPE.  */
2666
2667 tree
2668 mangle_typeinfo_for_type (const tree type)
2669 {
2670   return mangle_special_for_type (type, "TI");
2671 }
2672
2673 /* Create an identifier for the mangled name of the NTBS containing
2674    the mangled name of TYPE.  */
2675
2676 tree
2677 mangle_typeinfo_string_for_type (const tree type)
2678 {
2679   return mangle_special_for_type (type, "TS");
2680 }
2681
2682 /* Create an identifier for the mangled name of the vtable for TYPE.  */
2683
2684 tree
2685 mangle_vtbl_for_type (const tree type)
2686 {
2687   return mangle_special_for_type (type, "TV");
2688 }
2689
2690 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
2691
2692 tree
2693 mangle_vtt_for_type (const tree type)
2694 {
2695   return mangle_special_for_type (type, "TT");
2696 }
2697
2698 /* Return an identifier for a construction vtable group.  TYPE is
2699    the most derived class in the hierarchy; BINFO is the base
2700    subobject for which this construction vtable group will be used.
2701
2702    This mangling isn't part of the ABI specification; in the ABI
2703    specification, the vtable group is dumped in the same COMDAT as the
2704    main vtable, and is referenced only from that vtable, so it doesn't
2705    need an external name.  For binary formats without COMDAT sections,
2706    though, we need external names for the vtable groups.
2707
2708    We use the production
2709
2710     <special-name> ::= CT <type> <offset number> _ <base type>  */
2711
2712 tree
2713 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
2714 {
2715   tree result;
2716
2717   start_mangling (type);
2718
2719   write_string ("_Z");
2720   write_string ("TC");
2721   write_type (type);
2722   write_integer_cst (BINFO_OFFSET (binfo));
2723   write_char ('_');
2724   write_type (BINFO_TYPE (binfo));
2725
2726   result = finish_mangling_get_identifier (/*warn=*/false);
2727   if (DEBUG_MANGLE)
2728     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
2729              IDENTIFIER_POINTER (result));
2730   return result;
2731 }
2732
2733 /* Mangle a this pointer or result pointer adjustment.
2734
2735    <call-offset> ::= h <fixed offset number> _
2736                  ::= v <fixed offset number> _ <virtual offset number> _ */
2737
2738 static void
2739 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
2740 {
2741   write_char (virtual_offset ? 'v' : 'h');
2742
2743   /* For either flavor, write the fixed offset.  */
2744   write_integer_cst (fixed_offset);
2745   write_char ('_');
2746
2747   /* For a virtual thunk, add the virtual offset.  */
2748   if (virtual_offset)
2749     {
2750       write_integer_cst (virtual_offset);
2751       write_char ('_');
2752     }
2753 }
2754
2755 /* Return an identifier for the mangled name of a this-adjusting or
2756    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
2757    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
2758    is a virtual thunk, and it is the vtbl offset in
2759    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
2760    zero for a covariant thunk. Note, that FN_DECL might be a covariant
2761    thunk itself. A covariant thunk name always includes the adjustment
2762    for the this pointer, even if there is none.
2763
2764    <special-name> ::= T <call-offset> <base encoding>
2765                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
2766                                         <base encoding>  */
2767
2768 tree
2769 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
2770               tree virtual_offset)
2771 {
2772   tree result;
2773
2774   start_mangling (fn_decl);
2775
2776   write_string ("_Z");
2777   write_char ('T');
2778
2779   if (!this_adjusting)
2780     {
2781       /* Covariant thunk with no this adjustment */
2782       write_char ('c');
2783       mangle_call_offset (integer_zero_node, NULL_TREE);
2784       mangle_call_offset (fixed_offset, virtual_offset);
2785     }
2786   else if (!DECL_THUNK_P (fn_decl))
2787     /* Plain this adjusting thunk.  */
2788     mangle_call_offset (fixed_offset, virtual_offset);
2789   else
2790     {
2791       /* This adjusting thunk to covariant thunk.  */
2792       write_char ('c');
2793       mangle_call_offset (fixed_offset, virtual_offset);
2794       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
2795       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
2796       if (virtual_offset)
2797         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
2798       mangle_call_offset (fixed_offset, virtual_offset);
2799       fn_decl = THUNK_TARGET (fn_decl);
2800     }
2801
2802   /* Scoped name.  */
2803   write_encoding (fn_decl);
2804
2805   result = finish_mangling_get_identifier (/*warn=*/false);
2806   if (DEBUG_MANGLE)
2807     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
2808   return result;
2809 }
2810
2811 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
2812    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
2813    TYPE.  */
2814
2815 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
2816
2817 /* Hash a node (VAL1) in the table.  */
2818
2819 static hashval_t
2820 hash_type (const void *val)
2821 {
2822   return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val));
2823 }
2824
2825 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
2826
2827 static int
2828 compare_type (const void *val1, const void *val2)
2829 {
2830   return TREE_TYPE ((const_tree) val1) == (const_tree) val2;
2831 }
2832
2833 /* Return an identifier for the mangled unqualified name for a
2834    conversion operator to TYPE.  This mangling is not specified by the
2835    ABI spec; it is only used internally.  */
2836
2837 tree
2838 mangle_conv_op_name_for_type (const tree type)
2839 {
2840   void **slot;
2841   tree identifier;
2842
2843   if (type == error_mark_node)
2844     return error_mark_node;
2845
2846   if (conv_type_names == NULL)
2847     conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
2848
2849   slot = htab_find_slot_with_hash (conv_type_names, type,
2850                                    (hashval_t) TYPE_UID (type), INSERT);
2851   identifier = (tree)*slot;
2852   if (!identifier)
2853     {
2854       char buffer[64];
2855
2856        /* Create a unique name corresponding to TYPE.  */
2857       sprintf (buffer, "operator %lu",
2858                (unsigned long) htab_elements (conv_type_names));
2859       identifier = get_identifier (buffer);
2860       *slot = identifier;
2861
2862       /* Hang TYPE off the identifier so it can be found easily later
2863          when performing conversions.  */
2864       TREE_TYPE (identifier) = type;
2865
2866       /* Set bits on the identifier so we know later it's a conversion.  */
2867       IDENTIFIER_OPNAME_P (identifier) = 1;
2868       IDENTIFIER_TYPENAME_P (identifier) = 1;
2869     }
2870
2871   return identifier;
2872 }
2873
2874 /* Return an identifier for the name of an initialization guard
2875    variable for indicated VARIABLE.  */
2876
2877 tree
2878 mangle_guard_variable (const tree variable)
2879 {
2880   start_mangling (variable);
2881   write_string ("_ZGV");
2882   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
2883     /* The name of a guard variable for a reference temporary should refer
2884        to the reference, not the temporary.  */
2885     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
2886   else
2887     write_name (variable, /*ignore_local_scope=*/0);
2888   return finish_mangling_get_identifier (/*warn=*/false);
2889 }
2890
2891 /* Return an identifier for the name of a temporary variable used to
2892    initialize a static reference.  This isn't part of the ABI, but we might
2893    as well call them something readable.  */
2894
2895 tree
2896 mangle_ref_init_variable (const tree variable)
2897 {
2898   start_mangling (variable);
2899   write_string ("_ZGR");
2900   write_name (variable, /*ignore_local_scope=*/0);
2901   return finish_mangling_get_identifier (/*warn=*/false);
2902 }
2903 \f
2904
2905 /* Foreign language type mangling section.  */
2906
2907 /* How to write the type codes for the integer Java type.  */
2908
2909 static void
2910 write_java_integer_type_codes (const tree type)
2911 {
2912   if (type == java_int_type_node)
2913     write_char ('i');
2914   else if (type == java_short_type_node)
2915     write_char ('s');
2916   else if (type == java_byte_type_node)
2917     write_char ('c');
2918   else if (type == java_char_type_node)
2919     write_char ('w');
2920   else if (type == java_long_type_node)
2921     write_char ('x');
2922   else if (type == java_boolean_type_node)
2923     write_char ('b');
2924   else
2925     gcc_unreachable ();
2926 }
2927
2928 #include "gt-cp-mangle.h"