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
1898         gcc_unreachable ();
1899       break;
1900
1901     case FIXED_POINT_TYPE:
1902       write_string ("DF");
1903       if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
1904         write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
1905       if (type == fract_type_node
1906           || type == sat_fract_type_node
1907           || type == accum_type_node
1908           || type == sat_accum_type_node)
1909         write_char ('i');
1910       else if (type == unsigned_fract_type_node
1911                || type == sat_unsigned_fract_type_node
1912                || type == unsigned_accum_type_node
1913                || type == sat_unsigned_accum_type_node)
1914         write_char ('j');
1915       else if (type == short_fract_type_node
1916                || type == sat_short_fract_type_node
1917                || type == short_accum_type_node
1918                || type == sat_short_accum_type_node)
1919         write_char ('s');
1920       else if (type == unsigned_short_fract_type_node
1921                || type == sat_unsigned_short_fract_type_node
1922                || type == unsigned_short_accum_type_node
1923                || type == sat_unsigned_short_accum_type_node)
1924         write_char ('t');
1925       else if (type == long_fract_type_node
1926                || type == sat_long_fract_type_node
1927                || type == long_accum_type_node
1928                || type == sat_long_accum_type_node)
1929         write_char ('l');
1930       else if (type == unsigned_long_fract_type_node
1931                || type == sat_unsigned_long_fract_type_node
1932                || type == unsigned_long_accum_type_node
1933                || type == sat_unsigned_long_accum_type_node)
1934         write_char ('m');
1935       else if (type == long_long_fract_type_node
1936                || type == sat_long_long_fract_type_node
1937                || type == long_long_accum_type_node
1938                || type == sat_long_long_accum_type_node)
1939         write_char ('x');
1940       else if (type == unsigned_long_long_fract_type_node
1941                || type == sat_unsigned_long_long_fract_type_node
1942                || type == unsigned_long_long_accum_type_node
1943                || type == sat_unsigned_long_long_accum_type_node)
1944         write_char ('y');
1945       else
1946         sorry ("mangling unknown fixed point type");
1947       write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
1948       if (TYPE_SATURATING (type))
1949         write_char ('s');
1950       else
1951         write_char ('n');
1952       break;
1953
1954     default:
1955       gcc_unreachable ();
1956     }
1957 }
1958
1959 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
1960    METHOD_TYPE.  The return type is mangled before the parameter
1961    types.
1962
1963      <function-type> ::= F [Y] <bare-function-type> E   */
1964
1965 static void
1966 write_function_type (const tree type)
1967 {
1968   MANGLE_TRACE_TREE ("function-type", type);
1969
1970   /* For a pointer to member function, the function type may have
1971      cv-qualifiers, indicating the quals for the artificial 'this'
1972      parameter.  */
1973   if (TREE_CODE (type) == METHOD_TYPE)
1974     {
1975       /* The first parameter must be a POINTER_TYPE pointing to the
1976          `this' parameter.  */
1977       tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
1978       write_CV_qualifiers_for_type (this_type);
1979     }
1980
1981   write_char ('F');
1982   /* We don't track whether or not a type is `extern "C"'.  Note that
1983      you can have an `extern "C"' function that does not have
1984      `extern "C"' type, and vice versa:
1985
1986        extern "C" typedef void function_t();
1987        function_t f; // f has C++ linkage, but its type is
1988                      // `extern "C"'
1989
1990        typedef void function_t();
1991        extern "C" function_t f; // Vice versa.
1992
1993      See [dcl.link].  */
1994   write_bare_function_type (type, /*include_return_type_p=*/1,
1995                             /*decl=*/NULL);
1996   write_char ('E');
1997 }
1998
1999 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
2000    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
2001    is mangled before the parameter types.  If non-NULL, DECL is
2002    FUNCTION_DECL for the function whose type is being emitted.
2003
2004    If DECL is a member of a Java type, then a literal 'J'
2005    is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2006    were nonzero.
2007
2008      <bare-function-type> ::= [J]</signature/ type>+  */
2009
2010 static void
2011 write_bare_function_type (const tree type, const int include_return_type_p,
2012                           const tree decl)
2013 {
2014   int java_method_p;
2015
2016   MANGLE_TRACE_TREE ("bare-function-type", type);
2017
2018   /* Detect Java methods and emit special encoding.  */
2019   if (decl != NULL
2020       && DECL_FUNCTION_MEMBER_P (decl)
2021       && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
2022       && !DECL_CONSTRUCTOR_P (decl)
2023       && !DECL_DESTRUCTOR_P (decl)
2024       && !DECL_CONV_FN_P (decl))
2025     {
2026       java_method_p = 1;
2027       write_char ('J');
2028     }
2029   else
2030     {
2031       java_method_p = 0;
2032     }
2033
2034   /* Mangle the return type, if requested.  */
2035   if (include_return_type_p || java_method_p)
2036     write_type (TREE_TYPE (type));
2037
2038   /* Now mangle the types of the arguments.  */
2039   write_method_parms (TYPE_ARG_TYPES (type),
2040                       TREE_CODE (type) == METHOD_TYPE,
2041                       decl);
2042 }
2043
2044 /* Write the mangled representation of a method parameter list of
2045    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
2046    considered a non-static method, and the this parameter is omitted.
2047    If non-NULL, DECL is the FUNCTION_DECL for the function whose
2048    parameters are being emitted.  */
2049
2050 static void
2051 write_method_parms (tree parm_types, const int method_p, const tree decl)
2052 {
2053   tree first_parm_type;
2054   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2055
2056   /* Assume this parameter type list is variable-length.  If it ends
2057      with a void type, then it's not.  */
2058   int varargs_p = 1;
2059
2060   /* If this is a member function, skip the first arg, which is the
2061      this pointer.
2062        "Member functions do not encode the type of their implicit this
2063        parameter."
2064
2065      Similarly, there's no need to mangle artificial parameters, like
2066      the VTT parameters for constructors and destructors.  */
2067   if (method_p)
2068     {
2069       parm_types = TREE_CHAIN (parm_types);
2070       parm_decl = parm_decl ? TREE_CHAIN (parm_decl) : NULL_TREE;
2071
2072       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2073         {
2074           parm_types = TREE_CHAIN (parm_types);
2075           parm_decl = TREE_CHAIN (parm_decl);
2076         }
2077     }
2078
2079   for (first_parm_type = parm_types;
2080        parm_types;
2081        parm_types = TREE_CHAIN (parm_types))
2082     {
2083       tree parm = TREE_VALUE (parm_types);
2084       if (parm == void_type_node)
2085         {
2086           /* "Empty parameter lists, whether declared as () or
2087              conventionally as (void), are encoded with a void parameter
2088              (v)."  */
2089           if (parm_types == first_parm_type)
2090             write_type (parm);
2091           /* If the parm list is terminated with a void type, it's
2092              fixed-length.  */
2093           varargs_p = 0;
2094           /* A void type better be the last one.  */
2095           gcc_assert (TREE_CHAIN (parm_types) == NULL);
2096         }
2097       else
2098         write_type (parm);
2099     }
2100
2101   if (varargs_p)
2102     /* <builtin-type> ::= z  # ellipsis  */
2103     write_char ('z');
2104 }
2105
2106 /* <class-enum-type> ::= <name>  */
2107
2108 static void
2109 write_class_enum_type (const tree type)
2110 {
2111   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2112 }
2113
2114 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
2115    arguments.
2116
2117      <template-args> ::= I <template-arg>+ E  */
2118
2119 static void
2120 write_template_args (tree args)
2121 {
2122   int i;
2123   int length = TREE_VEC_LENGTH (args);
2124
2125   MANGLE_TRACE_TREE ("template-args", args);
2126
2127   write_char ('I');
2128
2129   gcc_assert (length > 0);
2130
2131   if (TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2132     {
2133       /* We have nested template args.  We want the innermost template
2134          argument list.  */
2135       args = TREE_VEC_ELT (args, length - 1);
2136       length = TREE_VEC_LENGTH (args);
2137     }
2138   for (i = 0; i < length; ++i)
2139     write_template_arg (TREE_VEC_ELT (args, i));
2140
2141   write_char ('E');
2142 }
2143
2144 /* Write out the
2145    <unqualified-name>
2146    <unqualified-name> <template-args>
2147    part of SCOPE_REF or COMPONENT_REF mangling.  */
2148
2149 static void
2150 write_member_name (tree member)
2151 {
2152   if (TREE_CODE (member) == IDENTIFIER_NODE)
2153     write_source_name (member);
2154   else if (DECL_P (member))
2155     {
2156       /* G++ 3.2 incorrectly put out both the "sr" code and
2157          the nested name of the qualified name.  */
2158       G.need_abi_warning = 1;
2159       write_unqualified_name (member);
2160     }
2161   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2162     {
2163       tree name = TREE_OPERAND (member, 0);
2164       if (TREE_CODE (name) == OVERLOAD)
2165         name = OVL_FUNCTION (name);
2166       write_member_name (name);
2167       write_template_args (TREE_OPERAND (member, 1));
2168     }
2169   else
2170     write_expression (member);
2171 }
2172
2173 /* <expression> ::= <unary operator-name> <expression>
2174                 ::= <binary operator-name> <expression> <expression>
2175                 ::= <expr-primary>
2176
2177    <expr-primary> ::= <template-param>
2178                   ::= L <type> <value number> E         # literal
2179                   ::= L <mangled-name> E                # external name
2180                   ::= st <type>                         # sizeof
2181                   ::= sr <type> <unqualified-name>      # dependent name
2182                   ::= sr <type> <unqualified-name> <template-args> */
2183
2184 static void
2185 write_expression (tree expr)
2186 {
2187   enum tree_code code = TREE_CODE (expr);
2188
2189   /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
2190      is converted (via qualification conversions) to another
2191      type.  */
2192   while (TREE_CODE (expr) == NOP_EXPR
2193          || TREE_CODE (expr) == NON_LVALUE_EXPR)
2194     {
2195       expr = TREE_OPERAND (expr, 0);
2196       code = TREE_CODE (expr);
2197     }
2198
2199   if (code == BASELINK)
2200     {
2201       expr = BASELINK_FUNCTIONS (expr);
2202       code = TREE_CODE (expr);
2203     }
2204
2205   /* Handle pointers-to-members by making them look like expression
2206      nodes.  */
2207   if (code == PTRMEM_CST)
2208     {
2209       expr = build_nt (ADDR_EXPR,
2210                        build_qualified_name (/*type=*/NULL_TREE,
2211                                              PTRMEM_CST_CLASS (expr),
2212                                              PTRMEM_CST_MEMBER (expr),
2213                                              /*template_p=*/false));
2214       code = TREE_CODE (expr);
2215     }
2216
2217   /* Handle template parameters.  */
2218   if (code == TEMPLATE_TYPE_PARM
2219       || code == TEMPLATE_TEMPLATE_PARM
2220       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2221       || code == TEMPLATE_PARM_INDEX)
2222     write_template_param (expr);
2223   /* Handle literals.  */
2224   else if (TREE_CODE_CLASS (code) == tcc_constant
2225            || (abi_version_at_least (2) && code == CONST_DECL))
2226     write_template_arg_literal (expr);
2227   else if (code == PARM_DECL)
2228     {
2229       /* A function parameter used in a late-specified return type.  */
2230       int index = DECL_PARM_INDEX (expr);
2231       gcc_assert (index >= 1);
2232       write_string ("fp");
2233       if (index > 1)
2234         write_unsigned_number (index - 2);
2235       write_char ('_');
2236     }
2237   else if (DECL_P (expr))
2238     {
2239       /* G++ 3.2 incorrectly mangled non-type template arguments of
2240          enumeration type using their names.  */
2241       if (code == CONST_DECL)
2242         G.need_abi_warning = 1;
2243       write_char ('L');
2244       write_mangled_name (expr, false);
2245       write_char ('E');
2246     }
2247   else if (TREE_CODE (expr) == SIZEOF_EXPR
2248            && TYPE_P (TREE_OPERAND (expr, 0)))
2249     {
2250       write_string ("st");
2251       write_type (TREE_OPERAND (expr, 0));
2252     }
2253   else if (TREE_CODE (expr) == ALIGNOF_EXPR
2254            && TYPE_P (TREE_OPERAND (expr, 0)))
2255     {
2256       write_string ("at");
2257       write_type (TREE_OPERAND (expr, 0));
2258     }
2259   else if (abi_version_at_least (2) && TREE_CODE (expr) == SCOPE_REF)
2260     {
2261       tree scope = TREE_OPERAND (expr, 0);
2262       tree member = TREE_OPERAND (expr, 1);
2263
2264       /* If the MEMBER is a real declaration, then the qualifying
2265          scope was not dependent.  Ideally, we would not have a
2266          SCOPE_REF in those cases, but sometimes we do.  If the second
2267          argument is a DECL, then the name must not have been
2268          dependent.  */
2269       if (DECL_P (member))
2270         write_expression (member);
2271       else
2272         {
2273           tree template_args;
2274
2275           write_string ("sr");
2276           write_type (scope);
2277           /* If MEMBER is a template-id, separate the template
2278              from the arguments.  */
2279           if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2280             {
2281               template_args = TREE_OPERAND (member, 1);
2282               member = TREE_OPERAND (member, 0);
2283             }
2284           else
2285             template_args = NULL_TREE;
2286           /* Write out the name of the MEMBER.  */
2287           if (IDENTIFIER_TYPENAME_P (member))
2288             write_conversion_operator_name (TREE_TYPE (member));
2289           else if (IDENTIFIER_OPNAME_P (member))
2290             {
2291               int i;
2292               const char *mangled_name = NULL;
2293
2294               /* Unfortunately, there is no easy way to go from the
2295                  name of the operator back to the corresponding tree
2296                  code.  */
2297               for (i = 0; i < MAX_TREE_CODES; ++i)
2298                 if (operator_name_info[i].identifier == member)
2299                   {
2300                     /* The ABI says that we prefer binary operator
2301                        names to unary operator names.  */
2302                     if (operator_name_info[i].arity == 2)
2303                       {
2304                         mangled_name = operator_name_info[i].mangled_name;
2305                         break;
2306                       }
2307                     else if (!mangled_name)
2308                       mangled_name = operator_name_info[i].mangled_name;
2309                   }
2310                 else if (assignment_operator_name_info[i].identifier
2311                          == member)
2312                   {
2313                     mangled_name
2314                       = assignment_operator_name_info[i].mangled_name;
2315                     break;
2316                   }
2317               write_string (mangled_name);
2318             }
2319           else
2320             write_source_name (member);
2321           /* Write out the template arguments.  */
2322           if (template_args)
2323             write_template_args (template_args);
2324         }
2325     }
2326   else if (TREE_CODE (expr) == INDIRECT_REF
2327            && TREE_TYPE (TREE_OPERAND (expr, 0))
2328            && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2329     {
2330       write_expression (TREE_OPERAND (expr, 0));
2331     }
2332   else
2333     {
2334       int i;
2335       const char *name;
2336
2337       /* When we bind a variable or function to a non-type template
2338          argument with reference type, we create an ADDR_EXPR to show
2339          the fact that the entity's address has been taken.  But, we
2340          don't actually want to output a mangling code for the `&'.  */
2341       if (TREE_CODE (expr) == ADDR_EXPR
2342           && TREE_TYPE (expr)
2343           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2344         {
2345           expr = TREE_OPERAND (expr, 0);
2346           if (DECL_P (expr))
2347             {
2348               write_expression (expr);
2349               return;
2350             }
2351
2352           code = TREE_CODE (expr);
2353         }
2354
2355       if (code == COMPONENT_REF)
2356         {
2357           tree ob = TREE_OPERAND (expr, 0);
2358
2359           if (TREE_CODE (ob) == ARROW_EXPR)
2360             {
2361               write_string (operator_name_info[(int)code].mangled_name);
2362               ob = TREE_OPERAND (ob, 0);
2363             }
2364           else
2365             write_string ("dt");
2366
2367           write_expression (ob);
2368           write_member_name (TREE_OPERAND (expr, 1));
2369           return;
2370         }
2371
2372       /* If it wasn't any of those, recursively expand the expression.  */
2373       name = operator_name_info[(int) code].mangled_name;
2374       if (name == NULL)
2375         {
2376           sorry ("mangling %C", code);
2377           return;
2378         }
2379       else
2380         write_string (name);
2381
2382       switch (code)
2383         {
2384         case CALL_EXPR:
2385           {
2386             tree fn = CALL_EXPR_FN (expr);
2387
2388             if (TREE_CODE (fn) == ADDR_EXPR)
2389               fn = TREE_OPERAND (fn, 0);
2390
2391             /* Mangle a dependent name as the name, not whatever happens to
2392                be the first function in the overload set.  */
2393             if ((TREE_CODE (fn) == FUNCTION_DECL
2394                  || TREE_CODE (fn) == OVERLOAD)
2395                 && type_dependent_expression_p_push (expr))
2396               fn = DECL_NAME (get_first_fn (fn));
2397
2398             if (TREE_CODE (fn) == IDENTIFIER_NODE)
2399               write_source_name (fn);
2400             else
2401               write_expression (fn);
2402           }
2403
2404           for (i = 0; i < call_expr_nargs (expr); ++i)
2405             write_expression (CALL_EXPR_ARG (expr, i));
2406           write_char ('E');
2407           break;
2408
2409         case CAST_EXPR:
2410           write_type (TREE_TYPE (expr));
2411           if (list_length (TREE_OPERAND (expr, 0)) == 1)
2412             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2413           else
2414             {
2415               tree args = TREE_OPERAND (expr, 0);
2416               write_char ('_');
2417               for (; args; args = TREE_CHAIN (args))
2418                 write_expression (TREE_VALUE (args));
2419               write_char ('E');
2420             }
2421           break;
2422
2423           /* FIXME these should have a distinct mangling.  */
2424         case STATIC_CAST_EXPR:
2425         case CONST_CAST_EXPR:
2426           write_type (TREE_TYPE (expr));
2427           write_expression (TREE_OPERAND (expr, 0));
2428           break;
2429
2430         case NEW_EXPR:
2431           sorry ("mangling new-expression");
2432           break;
2433
2434         /* Handle pointers-to-members specially.  */
2435         case SCOPE_REF:
2436           write_type (TREE_OPERAND (expr, 0));
2437           write_member_name (TREE_OPERAND (expr, 1));
2438           break;
2439
2440         default:
2441           for (i = 0; i < TREE_OPERAND_LENGTH (expr); ++i)
2442             {
2443               tree operand = TREE_OPERAND (expr, i);
2444               /* As a GNU extension, the middle operand of a
2445                  conditional may be omitted.  Since expression
2446                  manglings are supposed to represent the input token
2447                  stream, there's no good way to mangle such an
2448                  expression without extending the C++ ABI.  */
2449               if (code == COND_EXPR && i == 1 && !operand)
2450                 {
2451                   error ("omitted middle operand to %<?:%> operand "
2452                          "cannot be mangled");
2453                   continue;
2454                 }
2455               write_expression (operand);
2456             }
2457         }
2458     }
2459 }
2460
2461 /* Literal subcase of non-terminal <template-arg>.
2462
2463      "Literal arguments, e.g. "A<42L>", are encoded with their type
2464      and value. Negative integer values are preceded with "n"; for
2465      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2466      encoded as 0, true as 1."  */
2467
2468 static void
2469 write_template_arg_literal (const tree value)
2470 {
2471   write_char ('L');
2472   write_type (TREE_TYPE (value));
2473
2474   switch (TREE_CODE (value))
2475     {
2476     case CONST_DECL:
2477       write_integer_cst (DECL_INITIAL (value));
2478       break;
2479
2480     case INTEGER_CST:
2481       gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2482                   || integer_zerop (value) || integer_onep (value));
2483       write_integer_cst (value);
2484       break;
2485
2486     case REAL_CST:
2487       write_real_cst (value);
2488       break;
2489
2490     default:
2491       gcc_unreachable ();
2492     }
2493
2494   write_char ('E');
2495 }
2496
2497 /* Non-terminal <template-arg>.
2498
2499      <template-arg> ::= <type>                          # type
2500                     ::= L <type> </value/ number> E     # literal
2501                     ::= LZ <name> E                     # external name
2502                     ::= X <expression> E                # expression  */
2503
2504 static void
2505 write_template_arg (tree node)
2506 {
2507   enum tree_code code = TREE_CODE (node);
2508
2509   MANGLE_TRACE_TREE ("template-arg", node);
2510
2511   /* A template template parameter's argument list contains TREE_LIST
2512      nodes of which the value field is the actual argument.  */
2513   if (code == TREE_LIST)
2514     {
2515       node = TREE_VALUE (node);
2516       /* If it's a decl, deal with its type instead.  */
2517       if (DECL_P (node))
2518         {
2519           node = TREE_TYPE (node);
2520           code = TREE_CODE (node);
2521         }
2522     }
2523
2524   if (TREE_CODE (node) == NOP_EXPR
2525       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2526     {
2527       /* Template parameters can be of reference type. To maintain
2528          internal consistency, such arguments use a conversion from
2529          address of object to reference type.  */
2530       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2531       if (abi_version_at_least (2))
2532         node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2533       else
2534         G.need_abi_warning = 1;
2535     }
2536
2537   if (ARGUMENT_PACK_P (node))
2538     {
2539       /* Expand the template argument pack. */
2540       tree args = ARGUMENT_PACK_ARGS (node);
2541       int i, length = TREE_VEC_LENGTH (args);
2542       write_char ('I');
2543       for (i = 0; i < length; ++i)
2544         write_template_arg (TREE_VEC_ELT (args, i));
2545       write_char ('E');
2546     }
2547   else if (TYPE_P (node))
2548     write_type (node);
2549   else if (code == TEMPLATE_DECL)
2550     /* A template appearing as a template arg is a template template arg.  */
2551     write_template_template_arg (node);
2552   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
2553            || (abi_version_at_least (2) && code == CONST_DECL))
2554     write_template_arg_literal (node);
2555   else if (DECL_P (node))
2556     {
2557       /* Until ABI version 2, non-type template arguments of
2558          enumeration type were mangled using their names.  */
2559       if (code == CONST_DECL && !abi_version_at_least (2))
2560         G.need_abi_warning = 1;
2561       write_char ('L');
2562       /* Until ABI version 3, the underscore before the mangled name
2563          was incorrectly omitted.  */
2564       if (!abi_version_at_least (3))
2565         {
2566           G.need_abi_warning = 1;
2567           write_char ('Z');
2568         }
2569       else
2570         write_string ("_Z");
2571       write_encoding (node);
2572       write_char ('E');
2573     }
2574   else
2575     {
2576       /* Template arguments may be expressions.  */
2577       write_char ('X');
2578       write_expression (node);
2579       write_char ('E');
2580     }
2581 }
2582
2583 /*  <template-template-arg>
2584                         ::= <name>
2585                         ::= <substitution>  */
2586
2587 static void
2588 write_template_template_arg (const tree decl)
2589 {
2590   MANGLE_TRACE_TREE ("template-template-arg", decl);
2591
2592   if (find_substitution (decl))
2593     return;
2594   write_name (decl, /*ignore_local_scope=*/0);
2595   add_substitution (decl);
2596 }
2597
2598
2599 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2600
2601      <array-type> ::= A [</dimension/ number>] _ </element/ type>
2602                   ::= A <expression> _ </element/ type>
2603
2604      "Array types encode the dimension (number of elements) and the
2605      element type. For variable length arrays, the dimension (but not
2606      the '_' separator) is omitted."  */
2607
2608 static void
2609 write_array_type (const tree type)
2610 {
2611   write_char ('A');
2612   if (TYPE_DOMAIN (type))
2613     {
2614       tree index_type;
2615       tree max;
2616
2617       index_type = TYPE_DOMAIN (type);
2618       /* The INDEX_TYPE gives the upper and lower bounds of the
2619          array.  */
2620       max = TYPE_MAX_VALUE (index_type);
2621       if (TREE_CODE (max) == INTEGER_CST)
2622         {
2623           /* The ABI specifies that we should mangle the number of
2624              elements in the array, not the largest allowed index.  */
2625           max = size_binop (PLUS_EXPR, max, size_one_node);
2626           write_unsigned_number (tree_low_cst (max, 1));
2627         }
2628       else
2629         {
2630           max = TREE_OPERAND (max, 0);
2631           if (!abi_version_at_least (2))
2632             {
2633               /* value_dependent_expression_p presumes nothing is
2634                  dependent when PROCESSING_TEMPLATE_DECL is zero.  */
2635               ++processing_template_decl;
2636               if (!value_dependent_expression_p (max))
2637                 G.need_abi_warning = 1;
2638               --processing_template_decl;
2639             }
2640           write_expression (max);
2641         }
2642
2643     }
2644   write_char ('_');
2645   write_type (TREE_TYPE (type));
2646 }
2647
2648 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2649    variables.  TYPE is a pointer-to-member POINTER_TYPE.
2650
2651      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2652
2653 static void
2654 write_pointer_to_member_type (const tree type)
2655 {
2656   write_char ('M');
2657   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2658   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2659 }
2660
2661 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2662    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2663    TEMPLATE_PARM_INDEX.
2664
2665      <template-param> ::= T </parameter/ number> _  */
2666
2667 static void
2668 write_template_param (const tree parm)
2669 {
2670   int parm_index;
2671   int parm_level;
2672   tree parm_type = NULL_TREE;
2673
2674   MANGLE_TRACE_TREE ("template-parm", parm);
2675
2676   switch (TREE_CODE (parm))
2677     {
2678     case TEMPLATE_TYPE_PARM:
2679     case TEMPLATE_TEMPLATE_PARM:
2680     case BOUND_TEMPLATE_TEMPLATE_PARM:
2681       parm_index = TEMPLATE_TYPE_IDX (parm);
2682       parm_level = TEMPLATE_TYPE_LEVEL (parm);
2683       break;
2684
2685     case TEMPLATE_PARM_INDEX:
2686       parm_index = TEMPLATE_PARM_IDX (parm);
2687       parm_level = TEMPLATE_PARM_LEVEL (parm);
2688       parm_type = TREE_TYPE (TEMPLATE_PARM_DECL (parm));
2689       break;
2690
2691     default:
2692       gcc_unreachable ();
2693     }
2694
2695   write_char ('T');
2696   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2697      earliest template param denoted by `_'.  */
2698   if (parm_index > 0)
2699     write_unsigned_number (parm_index - 1);
2700   write_char ('_');
2701 }
2702
2703 /*  <template-template-param>
2704                         ::= <template-param>
2705                         ::= <substitution>  */
2706
2707 static void
2708 write_template_template_param (const tree parm)
2709 {
2710   tree templ = NULL_TREE;
2711
2712   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2713      template template parameter.  The substitution candidate here is
2714      only the template.  */
2715   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2716     {
2717       templ
2718         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2719       if (find_substitution (templ))
2720         return;
2721     }
2722
2723   /* <template-param> encodes only the template parameter position,
2724      not its template arguments, which is fine here.  */
2725   write_template_param (parm);
2726   if (templ)
2727     add_substitution (templ);
2728 }
2729
2730 /* Non-terminal <substitution>.
2731
2732       <substitution> ::= S <seq-id> _
2733                      ::= S_  */
2734
2735 static void
2736 write_substitution (const int seq_id)
2737 {
2738   MANGLE_TRACE ("substitution", "");
2739
2740   write_char ('S');
2741   if (seq_id > 0)
2742     write_number (seq_id - 1, /*unsigned=*/1, 36);
2743   write_char ('_');
2744 }
2745
2746 /* Start mangling ENTITY.  */
2747
2748 static inline void
2749 start_mangling (const tree entity)
2750 {
2751   G.entity = entity;
2752   G.need_abi_warning = false;
2753   obstack_free (&name_obstack, name_base);
2754   mangle_obstack = &name_obstack;
2755   name_base = obstack_alloc (&name_obstack, 0);
2756 }
2757
2758 /* Done with mangling. If WARN is true, and the name of G.entity will
2759    be mangled differently in a future version of the ABI, issue a
2760    warning.  */
2761
2762 static void
2763 finish_mangling_internal (const bool warn)
2764 {
2765   if (warn_abi && warn && G.need_abi_warning)
2766     warning (OPT_Wabi, "the mangled name of %qD will change in a future "
2767              "version of GCC",
2768              G.entity);
2769
2770   /* Clear all the substitutions.  */
2771   VEC_truncate (tree, G.substitutions, 0);
2772
2773   /* Null-terminate the string.  */
2774   write_char ('\0');
2775 }
2776
2777
2778 /* Like finish_mangling_internal, but return the mangled string.  */
2779
2780 static inline const char *
2781 finish_mangling (const bool warn)
2782 {
2783   finish_mangling_internal (warn);
2784   return (const char *) obstack_finish (mangle_obstack);
2785 }
2786
2787 /* Like finish_mangling_internal, but return an identifier.  */
2788
2789 static tree
2790 finish_mangling_get_identifier (const bool warn)
2791 {
2792   finish_mangling_internal (warn);
2793   /* Don't obstack_finish here, and the next start_mangling will
2794      remove the identifier.  */
2795   return get_identifier ((const char *) name_base);
2796 }
2797
2798 /* Initialize data structures for mangling.  */
2799
2800 void
2801 init_mangle (void)
2802 {
2803   gcc_obstack_init (&name_obstack);
2804   name_base = obstack_alloc (&name_obstack, 0);
2805   G.substitutions = NULL;
2806
2807   /* Cache these identifiers for quick comparison when checking for
2808      standard substitutions.  */
2809   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2810   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
2811   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
2812   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
2813   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
2814   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2815 }
2816
2817 /* Generate the mangled name of DECL.  */
2818
2819 static tree
2820 mangle_decl_string (const tree decl)
2821 {
2822   tree result;
2823
2824   start_mangling (decl);
2825
2826   if (TREE_CODE (decl) == TYPE_DECL)
2827     write_type (TREE_TYPE (decl));
2828   else
2829     write_mangled_name (decl, true);
2830
2831   result = finish_mangling_get_identifier (/*warn=*/true);
2832   if (DEBUG_MANGLE)
2833     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
2834              IDENTIFIER_POINTER (result));
2835   return result;
2836 }
2837
2838 /* Create an identifier for the external mangled name of DECL.  */
2839
2840 void
2841 mangle_decl (const tree decl)
2842 {
2843   tree id = mangle_decl_string (decl);
2844   id = targetm.mangle_decl_assembler_name (decl, id);
2845   SET_DECL_ASSEMBLER_NAME (decl, id);
2846 }
2847
2848 /* Generate the mangled representation of TYPE for the typeinfo name.  */
2849
2850 const char *
2851 mangle_type_string_for_rtti (const tree type)
2852 {
2853   const char *result;
2854
2855   start_mangling (type);
2856   /* Mangle in a fake anonymous namespace if necessary.  */
2857   fake_anon_scope = true;
2858   write_type (type);
2859   fake_anon_scope = false;
2860   result = finish_mangling (/*warn=*/false);
2861   if (DEBUG_MANGLE)
2862     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2863   return result;
2864 }
2865
2866 /* Create an identifier for the mangled name of a special component
2867    for belonging to TYPE.  CODE is the ABI-specified code for this
2868    component.  */
2869
2870 static tree
2871 mangle_special_for_type (const tree type, const char *code)
2872 {
2873   tree result;
2874
2875   /* We don't have an actual decl here for the special component, so
2876      we can't just process the <encoded-name>.  Instead, fake it.  */
2877   start_mangling (type);
2878
2879   /* Start the mangling.  */
2880   write_string ("_Z");
2881   write_string (code);
2882
2883   /* Add the type.  */
2884   write_type (type);
2885   result = finish_mangling_get_identifier (/*warn=*/false);
2886
2887   if (DEBUG_MANGLE)
2888     fprintf (stderr, "mangle_special_for_type = %s\n\n",
2889              IDENTIFIER_POINTER (result));
2890
2891   return result;
2892 }
2893
2894 /* Create an identifier for the mangled representation of the typeinfo
2895    structure for TYPE.  */
2896
2897 tree
2898 mangle_typeinfo_for_type (const tree type)
2899 {
2900   return mangle_special_for_type (type, "TI");
2901 }
2902
2903 /* Create an identifier for the mangled name of the NTBS containing
2904    the mangled name of TYPE.  */
2905
2906 tree
2907 mangle_typeinfo_string_for_type (const tree type)
2908 {
2909   return mangle_special_for_type (type, "TS");
2910 }
2911
2912 /* Create an identifier for the mangled name of the vtable for TYPE.  */
2913
2914 tree
2915 mangle_vtbl_for_type (const tree type)
2916 {
2917   return mangle_special_for_type (type, "TV");
2918 }
2919
2920 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
2921
2922 tree
2923 mangle_vtt_for_type (const tree type)
2924 {
2925   return mangle_special_for_type (type, "TT");
2926 }
2927
2928 /* Return an identifier for a construction vtable group.  TYPE is
2929    the most derived class in the hierarchy; BINFO is the base
2930    subobject for which this construction vtable group will be used.
2931
2932    This mangling isn't part of the ABI specification; in the ABI
2933    specification, the vtable group is dumped in the same COMDAT as the
2934    main vtable, and is referenced only from that vtable, so it doesn't
2935    need an external name.  For binary formats without COMDAT sections,
2936    though, we need external names for the vtable groups.
2937
2938    We use the production
2939
2940     <special-name> ::= CT <type> <offset number> _ <base type>  */
2941
2942 tree
2943 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
2944 {
2945   tree result;
2946
2947   start_mangling (type);
2948
2949   write_string ("_Z");
2950   write_string ("TC");
2951   write_type (type);
2952   write_integer_cst (BINFO_OFFSET (binfo));
2953   write_char ('_');
2954   write_type (BINFO_TYPE (binfo));
2955
2956   result = finish_mangling_get_identifier (/*warn=*/false);
2957   if (DEBUG_MANGLE)
2958     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
2959              IDENTIFIER_POINTER (result));
2960   return result;
2961 }
2962
2963 /* Mangle a this pointer or result pointer adjustment.
2964
2965    <call-offset> ::= h <fixed offset number> _
2966                  ::= v <fixed offset number> _ <virtual offset number> _ */
2967
2968 static void
2969 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
2970 {
2971   write_char (virtual_offset ? 'v' : 'h');
2972
2973   /* For either flavor, write the fixed offset.  */
2974   write_integer_cst (fixed_offset);
2975   write_char ('_');
2976
2977   /* For a virtual thunk, add the virtual offset.  */
2978   if (virtual_offset)
2979     {
2980       write_integer_cst (virtual_offset);
2981       write_char ('_');
2982     }
2983 }
2984
2985 /* Return an identifier for the mangled name of a this-adjusting or
2986    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
2987    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
2988    is a virtual thunk, and it is the vtbl offset in
2989    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
2990    zero for a covariant thunk. Note, that FN_DECL might be a covariant
2991    thunk itself. A covariant thunk name always includes the adjustment
2992    for the this pointer, even if there is none.
2993
2994    <special-name> ::= T <call-offset> <base encoding>
2995                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
2996                                         <base encoding>  */
2997
2998 tree
2999 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
3000               tree virtual_offset)
3001 {
3002   tree result;
3003
3004   start_mangling (fn_decl);
3005
3006   write_string ("_Z");
3007   write_char ('T');
3008
3009   if (!this_adjusting)
3010     {
3011       /* Covariant thunk with no this adjustment */
3012       write_char ('c');
3013       mangle_call_offset (integer_zero_node, NULL_TREE);
3014       mangle_call_offset (fixed_offset, virtual_offset);
3015     }
3016   else if (!DECL_THUNK_P (fn_decl))
3017     /* Plain this adjusting thunk.  */
3018     mangle_call_offset (fixed_offset, virtual_offset);
3019   else
3020     {
3021       /* This adjusting thunk to covariant thunk.  */
3022       write_char ('c');
3023       mangle_call_offset (fixed_offset, virtual_offset);
3024       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
3025       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
3026       if (virtual_offset)
3027         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
3028       mangle_call_offset (fixed_offset, virtual_offset);
3029       fn_decl = THUNK_TARGET (fn_decl);
3030     }
3031
3032   /* Scoped name.  */
3033   write_encoding (fn_decl);
3034
3035   result = finish_mangling_get_identifier (/*warn=*/false);
3036   if (DEBUG_MANGLE)
3037     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
3038   return result;
3039 }
3040
3041 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3042    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
3043    TYPE.  */
3044
3045 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
3046
3047 /* Hash a node (VAL1) in the table.  */
3048
3049 static hashval_t
3050 hash_type (const void *val)
3051 {
3052   return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val));
3053 }
3054
3055 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
3056
3057 static int
3058 compare_type (const void *val1, const void *val2)
3059 {
3060   return TREE_TYPE ((const_tree) val1) == (const_tree) val2;
3061 }
3062
3063 /* Return an identifier for the mangled unqualified name for a
3064    conversion operator to TYPE.  This mangling is not specified by the
3065    ABI spec; it is only used internally.  */
3066
3067 tree
3068 mangle_conv_op_name_for_type (const tree type)
3069 {
3070   void **slot;
3071   tree identifier;
3072
3073   if (type == error_mark_node)
3074     return error_mark_node;
3075
3076   if (conv_type_names == NULL)
3077     conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
3078
3079   slot = htab_find_slot_with_hash (conv_type_names, type,
3080                                    (hashval_t) TYPE_UID (type), INSERT);
3081   identifier = (tree)*slot;
3082   if (!identifier)
3083     {
3084       char buffer[64];
3085
3086        /* Create a unique name corresponding to TYPE.  */
3087       sprintf (buffer, "operator %lu",
3088                (unsigned long) htab_elements (conv_type_names));
3089       identifier = get_identifier (buffer);
3090       *slot = identifier;
3091
3092       /* Hang TYPE off the identifier so it can be found easily later
3093          when performing conversions.  */
3094       TREE_TYPE (identifier) = type;
3095
3096       /* Set bits on the identifier so we know later it's a conversion.  */
3097       IDENTIFIER_OPNAME_P (identifier) = 1;
3098       IDENTIFIER_TYPENAME_P (identifier) = 1;
3099     }
3100
3101   return identifier;
3102 }
3103
3104 /* Return an identifier for the name of an initialization guard
3105    variable for indicated VARIABLE.  */
3106
3107 tree
3108 mangle_guard_variable (const tree variable)
3109 {
3110   start_mangling (variable);
3111   write_string ("_ZGV");
3112   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
3113     /* The name of a guard variable for a reference temporary should refer
3114        to the reference, not the temporary.  */
3115     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
3116   else
3117     write_name (variable, /*ignore_local_scope=*/0);
3118   return finish_mangling_get_identifier (/*warn=*/false);
3119 }
3120
3121 /* Return an identifier for the name of a temporary variable used to
3122    initialize a static reference.  This isn't part of the ABI, but we might
3123    as well call them something readable.  */
3124
3125 tree
3126 mangle_ref_init_variable (const tree variable)
3127 {
3128   start_mangling (variable);
3129   write_string ("_ZGR");
3130   write_name (variable, /*ignore_local_scope=*/0);
3131   return finish_mangling_get_identifier (/*warn=*/false);
3132 }
3133 \f
3134
3135 /* Foreign language type mangling section.  */
3136
3137 /* How to write the type codes for the integer Java type.  */
3138
3139 static void
3140 write_java_integer_type_codes (const tree type)
3141 {
3142   if (type == java_int_type_node)
3143     write_char ('i');
3144   else if (type == java_short_type_node)
3145     write_char ('s');
3146   else if (type == java_byte_type_node)
3147     write_char ('c');
3148   else if (type == java_char_type_node)
3149     write_char ('w');
3150   else if (type == java_long_type_node)
3151     write_char ('x');
3152   else if (type == java_boolean_type_node)
3153     write_char ('b');
3154   else
3155     gcc_unreachable ();
3156 }
3157
3158 #include "gt-cp-mangle.h"