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