gcc/cp/mangle.c

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