gcc/cp/mangle.c

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