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, 2010,
   3    2011  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 "obstack.h"
  56 #include "flags.h"
  57 #include "target.h"
  58 #include "cgraph.h"
  59
  60 /* Debugging support.  */
  61
  62 /* Define DEBUG_MANGLE to enable very verbose trace messages.  */
  63 #ifndef DEBUG_MANGLE
  64 #define DEBUG_MANGLE 0
  65 #endif
  66
  67 /* Macros for tracing the write_* functions.  */
  68 #if DEBUG_MANGLE
  69 # define MANGLE_TRACE(FN, INPUT) \
  70   fprintf (stderr, "  %-24s: %-24s\n", (FN), (INPUT))
  71 # define MANGLE_TRACE_TREE(FN, NODE) \
  72   fprintf (stderr, "  %-24s: %-24s (%p)\n", \
  73            (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE))
  74 #else
  75 # define MANGLE_TRACE(FN, INPUT)
  76 # define MANGLE_TRACE_TREE(FN, NODE)
  77 #endif
  78
  79 /* Nonzero if NODE is a class template-id.  We can't rely on
  80    CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
  81    that hard to distinguish A<T> from A, where A<T> is the type as
  82    instantiated outside of the template, and A is the type used
  83    without parameters inside the template.  */
  84 #define CLASSTYPE_TEMPLATE_ID_P(NODE)                                   \
  85   (TYPE_LANG_SPECIFIC (NODE) != NULL                                    \
  86    && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM                 \
  87        || (CLASSTYPE_TEMPLATE_INFO (NODE) != NULL                       \
  88            && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))))
  89
  90 /* Things we only need one of.  This module is not reentrant.  */
  91 typedef struct GTY(()) globals {
  92   /* An array of the current substitution candidates, in the order
  93      we've seen them.  */
  94   VEC(tree,gc) *substitutions;
  95
  96   /* The entity that is being mangled.  */
  97   tree GTY ((skip)) entity;
  98
  99   /* How many parameter scopes we are inside.  */
 100   int parm_depth;
 101
 102   /* True if the mangling will be different in a future version of the
 103      ABI.  */
 104   bool need_abi_warning;
 105 } globals;
 106
 107 static GTY (()) globals G;
 108
 109 /* The obstack on which we build mangled names.  */
 110 static struct obstack *mangle_obstack;
 111
 112 /* The obstack on which we build mangled names that are not going to
 113    be IDENTIFIER_NODEs.  */
 114 static struct obstack name_obstack;
 115
 116 /* The first object on the name_obstack; we use this to free memory
 117    allocated on the name_obstack.  */
 118 static void *name_base;
 119
 120 /* Indices into subst_identifiers.  These are identifiers used in
 121    special substitution rules.  */
 122 typedef enum
 123 {
 124   SUBID_ALLOCATOR,
 125   SUBID_BASIC_STRING,
 126   SUBID_CHAR_TRAITS,
 127   SUBID_BASIC_ISTREAM,
 128   SUBID_BASIC_OSTREAM,
 129   SUBID_BASIC_IOSTREAM,
 130   SUBID_MAX
 131 }
 132 substitution_identifier_index_t;
 133
 134 /* For quick substitution checks, look up these common identifiers
 135    once only.  */
 136 static GTY(()) tree subst_identifiers[SUBID_MAX];
 137
 138 /* Single-letter codes for builtin integer types, defined in
 139    <builtin-type>.  These are indexed by integer_type_kind values.  */
 140 static const char
 141 integer_type_codes[itk_none] =
 142 {
 143   'c',  /* itk_char */
 144   'a',  /* itk_signed_char */
 145   'h',  /* itk_unsigned_char */
 146   's',  /* itk_short */
 147   't',  /* itk_unsigned_short */
 148   'i',  /* itk_int */
 149   'j',  /* itk_unsigned_int */
 150   'l',  /* itk_long */
 151   'm',  /* itk_unsigned_long */
 152   'x',  /* itk_long_long */
 153   'y',  /* itk_unsigned_long_long */
 154   'n',  /* itk_int128 */
 155   'o',  /* itk_unsigned_int128  */
 156 };
 157
 158 static int decl_is_template_id (const tree, tree* const);
 159
 160 /* Functions for handling substitutions.  */
 161
 162 static inline tree canonicalize_for_substitution (tree);
 163 static void add_substitution (tree);
 164 static inline int is_std_substitution (const tree,
 165                                        const substitution_identifier_index_t);
 166 static inline int is_std_substitution_char (const tree,
 167                                             const substitution_identifier_index_t);
 168 static int find_substitution (tree);
 169 static void mangle_call_offset (const tree, const tree);
 170
 171 /* Functions for emitting mangled representations of things.  */
 172
 173 static void write_mangled_name (const tree, bool);
 174 static void write_encoding (const tree);
 175 static void write_name (tree, const int);
 176 static void write_unscoped_name (const tree);
 177 static void write_unscoped_template_name (const tree);
 178 static void write_nested_name (const tree);
 179 static void write_prefix (const tree);
 180 static void write_template_prefix (const tree);
 181 static void write_unqualified_name (const tree);
 182 static void write_conversion_operator_name (const tree);
 183 static void write_source_name (tree);
 184 static void write_literal_operator_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_EACH_VEC_ELT (tree, G.substitutions, i, el)
 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     {
 353       /* Here we want to strip the topmost typedef only.
 354          We need to do that so is_std_substitution can do proper
 355          name matching.  */
 356       if (TREE_CODE (node) == FUNCTION_TYPE)
 357         /* Use build_qualified_type and TYPE_QUALS here to preserve
 358            the old buggy mangling of attribute noreturn with abi<5.  */
 359         node = build_qualified_type (TYPE_MAIN_VARIANT (node),
 360                                      TYPE_QUALS (node));
 361       else
 362         node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node),
 363                                         cp_type_quals (node));
 364     }
 365   return node;
 366 }
 367
 368 /* Add NODE as a substitution candidate.  NODE must not already be on
 369    the list of candidates.  */
 370
 371 static void
 372 add_substitution (tree node)
 373 {
 374   tree c;
 375
 376   if (DEBUG_MANGLE)
 377     fprintf (stderr, "  ++ add_substitution (%s at %10p)\n",
 378              tree_code_name[TREE_CODE (node)], (void *) node);
 379
 380   /* Get the canonicalized substitution candidate for NODE.  */
 381   c = canonicalize_for_substitution (node);
 382   if (DEBUG_MANGLE && c != node)
 383     fprintf (stderr, "  ++ using candidate (%s at %10p)\n",
 384              tree_code_name[TREE_CODE (node)], (void *) node);
 385   node = c;
 386
 387 #if ENABLE_CHECKING
 388   /* Make sure NODE isn't already a candidate.  */
 389   {
 390     int i;
 391     tree candidate;
 392
 393     FOR_EACH_VEC_ELT (tree, G.substitutions, i, candidate)
 394       {
 395         gcc_assert (!(DECL_P (node) && node == candidate));
 396         gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
 397                       && same_type_p (node, candidate)));
 398       }
 399   }
 400 #endif /* ENABLE_CHECKING */
 401
 402   /* Put the decl onto the varray of substitution candidates.  */
 403   VEC_safe_push (tree, gc, G.substitutions, node);
 404
 405   if (DEBUG_MANGLE)
 406     dump_substitution_candidates ();
 407 }
 408
 409 /* Helper function for find_substitution.  Returns nonzero if NODE,
 410    which may be a decl or a CLASS_TYPE, is a template-id with template
 411    name of substitution_index[INDEX] in the ::std namespace.  */
 412
 413 static inline int
 414 is_std_substitution (const tree node,
 415                      const substitution_identifier_index_t index)
 416 {
 417   tree type = NULL;
 418   tree decl = NULL;
 419
 420   if (DECL_P (node))
 421     {
 422       type = TREE_TYPE (node);
 423       decl = node;
 424     }
 425   else if (CLASS_TYPE_P (node))
 426     {
 427       type = node;
 428       decl = TYPE_NAME (node);
 429     }
 430   else
 431     /* These are not the droids you're looking for.  */
 432     return 0;
 433
 434   return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
 435           && TYPE_LANG_SPECIFIC (type)
 436           && TYPE_TEMPLATE_INFO (type)
 437           && (DECL_NAME (TYPE_TI_TEMPLATE (type))
 438               == subst_identifiers[index]));
 439 }
 440
 441 /* Helper function for find_substitution.  Returns nonzero if NODE,
 442    which may be a decl or a CLASS_TYPE, is the template-id
 443    ::std::identifier<char>, where identifier is
 444    substitution_index[INDEX].  */
 445
 446 static inline int
 447 is_std_substitution_char (const tree node,
 448                           const substitution_identifier_index_t index)
 449 {
 450   tree args;
 451   /* Check NODE's name is ::std::identifier.  */
 452   if (!is_std_substitution (node, index))
 453     return 0;
 454   /* Figure out its template args.  */
 455   if (DECL_P (node))
 456     args = DECL_TI_ARGS (node);
 457   else if (CLASS_TYPE_P (node))
 458     args = CLASSTYPE_TI_ARGS (node);
 459   else
 460     /* Oops, not a template.  */
 461     return 0;
 462   /* NODE's template arg list should be <char>.  */
 463   return
 464     TREE_VEC_LENGTH (args) == 1
 465     && TREE_VEC_ELT (args, 0) == char_type_node;
 466 }
 467
 468 /* Check whether a substitution should be used to represent NODE in
 469    the mangling.
 470
 471    First, check standard special-case substitutions.
 472
 473      <substitution> ::= St
 474          # ::std
 475
 476                     ::= Sa
 477          # ::std::allocator
 478
 479                     ::= Sb
 480          # ::std::basic_string
 481
 482                     ::= Ss
 483          # ::std::basic_string<char,
 484                                ::std::char_traits<char>,
 485                                ::std::allocator<char> >
 486
 487                     ::= Si
 488          # ::std::basic_istream<char, ::std::char_traits<char> >
 489
 490                     ::= So
 491          # ::std::basic_ostream<char, ::std::char_traits<char> >
 492
 493                     ::= Sd
 494          # ::std::basic_iostream<char, ::std::char_traits<char> >
 495
 496    Then examine the stack of currently available substitution
 497    candidates for entities appearing earlier in the same mangling
 498
 499    If a substitution is found, write its mangled representation and
 500    return nonzero.  If none is found, just return zero.  */
 501
 502 static int
 503 find_substitution (tree node)
 504 {
 505   int i;
 506   const int size = VEC_length (tree, G.substitutions);
 507   tree decl;
 508   tree type;
 509
 510   if (DEBUG_MANGLE)
 511     fprintf (stderr, "  ++ find_substitution (%s at %p)\n",
 512              tree_code_name[TREE_CODE (node)], (void *) node);
 513
 514   /* Obtain the canonicalized substitution representation for NODE.
 515      This is what we'll compare against.  */
 516   node = canonicalize_for_substitution (node);
 517
 518   /* Check for builtin substitutions.  */
 519
 520   decl = TYPE_P (node) ? TYPE_NAME (node) : node;
 521   type = TYPE_P (node) ? node : TREE_TYPE (node);
 522
 523   /* Check for std::allocator.  */
 524   if (decl
 525       && is_std_substitution (decl, SUBID_ALLOCATOR)
 526       && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
 527     {
 528       write_string ("Sa");
 529       return 1;
 530     }
 531
 532   /* Check for std::basic_string.  */
 533   if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
 534     {
 535       if (TYPE_P (node))
 536         {
 537           /* If this is a type (i.e. a fully-qualified template-id),
 538              check for
 539                  std::basic_string <char,
 540                                     std::char_traits<char>,
 541                                     std::allocator<char> > .  */
 542           if (cp_type_quals (type) == TYPE_UNQUALIFIED
 543               && CLASSTYPE_USE_TEMPLATE (type))
 544             {
 545               tree args = CLASSTYPE_TI_ARGS (type);
 546               if (TREE_VEC_LENGTH (args) == 3
 547                   && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 548                   && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 549                                                SUBID_CHAR_TRAITS)
 550                   && is_std_substitution_char (TREE_VEC_ELT (args, 2),
 551                                                SUBID_ALLOCATOR))
 552                 {
 553                   write_string ("Ss");
 554                   return 1;
 555                 }
 556             }
 557         }
 558       else
 559         /* Substitute for the template name only if this isn't a type.  */
 560         {
 561           write_string ("Sb");
 562           return 1;
 563         }
 564     }
 565
 566   /* Check for basic_{i,o,io}stream.  */
 567   if (TYPE_P (node)
 568       && cp_type_quals (type) == TYPE_UNQUALIFIED
 569       && CLASS_TYPE_P (type)
 570       && CLASSTYPE_USE_TEMPLATE (type)
 571       && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
 572     {
 573       /* First, check for the template
 574          args <char, std::char_traits<char> > .  */
 575       tree args = CLASSTYPE_TI_ARGS (type);
 576       if (TREE_VEC_LENGTH (args) == 2
 577           && TYPE_P (TREE_VEC_ELT (args, 0))
 578           && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 579           && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 580                                        SUBID_CHAR_TRAITS))
 581         {
 582           /* Got them.  Is this basic_istream?  */
 583           if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
 584             {
 585               write_string ("Si");
 586               return 1;
 587             }
 588           /* Or basic_ostream?  */
 589           else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
 590             {
 591               write_string ("So");
 592               return 1;
 593             }
 594           /* Or basic_iostream?  */
 595           else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
 596             {
 597               write_string ("Sd");
 598               return 1;
 599             }
 600         }
 601     }
 602
 603   /* Check for namespace std.  */
 604   if (decl && DECL_NAMESPACE_STD_P (decl))
 605     {
 606       write_string ("St");
 607       return 1;
 608     }
 609
 610   /* Now check the list of available substitutions for this mangling
 611      operation.  */
 612   for (i = 0; i < size; ++i)
 613     {
 614       tree candidate = VEC_index (tree, G.substitutions, i);
 615       /* NODE is a matched to a candidate if it's the same decl node or
 616          if it's the same type.  */
 617       if (decl == candidate
 618           || (TYPE_P (candidate) && type && TYPE_P (node)
 619               && same_type_p (type, candidate))
 620           || NESTED_TEMPLATE_MATCH (node, candidate))
 621         {
 622           write_substitution (i);
 623           return 1;
 624         }
 625     }
 626
 627   /* No substitution found.  */
 628   return 0;
 629 }
 630
 631
 632 /* TOP_LEVEL is true, if this is being called at outermost level of
 633   mangling. It should be false when mangling a decl appearing in an
 634   expression within some other mangling.
 635
 636   <mangled-name>      ::= _Z <encoding>  */
 637
 638 static void
 639 write_mangled_name (const tree decl, bool top_level)
 640 {
 641   MANGLE_TRACE_TREE ("mangled-name", decl);
 642
 643   if (/* The names of `extern "C"' functions are not mangled.  */
 644       DECL_EXTERN_C_FUNCTION_P (decl)
 645       /* But overloaded operator names *are* mangled.  */
 646       && !DECL_OVERLOADED_OPERATOR_P (decl))
 647     {
 648     unmangled_name:;
 649
 650       if (top_level)
 651         write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
 652       else
 653         {
 654           /* The standard notes: "The <encoding> of an extern "C"
 655              function is treated like global-scope data, i.e. as its
 656              <source-name> without a type."  We cannot write
 657              overloaded operators that way though, because it contains
 658              characters invalid in assembler.  */
 659           if (abi_version_at_least (2))
 660             write_string ("_Z");
 661           else
 662             G.need_abi_warning = true;
 663           write_source_name (DECL_NAME (decl));
 664         }
 665     }
 666   else if (TREE_CODE (decl) == VAR_DECL
 667            /* The names of non-static global variables aren't mangled.  */
 668            && DECL_EXTERNAL_LINKAGE_P (decl)
 669            && (CP_DECL_CONTEXT (decl) == global_namespace
 670                /* And neither are `extern "C"' variables.  */
 671                || DECL_EXTERN_C_P (decl)))
 672     {
 673       if (top_level || abi_version_at_least (2))
 674         goto unmangled_name;
 675       else
 676         {
 677           G.need_abi_warning = true;
 678           goto mangled_name;
 679         }
 680     }
 681   else
 682     {
 683     mangled_name:;
 684       write_string ("_Z");
 685       write_encoding (decl);
 686       if (DECL_LANG_SPECIFIC (decl)
 687           && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
 688               || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
 689         /* We need a distinct mangled name for these entities, but
 690            we should never actually output it.  So, we append some
 691            characters the assembler won't like.  */
 692         write_string (" *INTERNAL* ");
 693     }
 694 }
 695
 696 /*   <encoding>         ::= <function name> <bare-function-type>
 697                         ::= <data name>  */
 698
 699 static void
 700 write_encoding (const tree decl)
 701 {
 702   MANGLE_TRACE_TREE ("encoding", decl);
 703
 704   if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
 705     {
 706       /* For overloaded operators write just the mangled name
 707          without arguments.  */
 708       if (DECL_OVERLOADED_OPERATOR_P (decl))
 709         write_name (decl, /*ignore_local_scope=*/0);
 710       else
 711         write_source_name (DECL_NAME (decl));
 712       return;
 713     }
 714
 715   write_name (decl, /*ignore_local_scope=*/0);
 716   if (TREE_CODE (decl) == FUNCTION_DECL)
 717     {
 718       tree fn_type;
 719       tree d;
 720
 721       if (decl_is_template_id (decl, NULL))
 722         {
 723           fn_type = get_mostly_instantiated_function_type (decl);
 724           /* FN_TYPE will not have parameter types for in-charge or
 725              VTT parameters.  Therefore, we pass NULL_TREE to
 726              write_bare_function_type -- otherwise, it will get
 727              confused about which artificial parameters to skip.  */
 728           d = NULL_TREE;
 729         }
 730       else
 731         {
 732           fn_type = TREE_TYPE (decl);
 733           d = decl;
 734         }
 735
 736       write_bare_function_type (fn_type,
 737                                 (!DECL_CONSTRUCTOR_P (decl)
 738                                  && !DECL_DESTRUCTOR_P (decl)
 739                                  && !DECL_CONV_FN_P (decl)
 740                                  && decl_is_template_id (decl, NULL)),
 741                                 d);
 742     }
 743 }
 744
 745 /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
 746    or PARM_DECL context, which doesn't belong in DECL_CONTEXT.  */
 747
 748 static tree
 749 decl_mangling_context (tree decl)
 750 {
 751   tree tcontext = targetm.cxx.decl_mangling_context (decl);
 752
 753   if (tcontext != NULL_TREE)
 754     return tcontext;
 755
 756   if (TREE_CODE (decl) == TYPE_DECL
 757       && LAMBDA_TYPE_P (TREE_TYPE (decl)))
 758     {
 759       tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl));
 760       if (extra)
 761         return extra;
 762     }
 763     else if (TREE_CODE (decl) == TYPE_DECL
 764              && TREE_CODE (TREE_TYPE (decl)) == TEMPLATE_TYPE_PARM)
 765      /* template type parms have no mangling context.  */
 766       return NULL_TREE;
 767   return CP_DECL_CONTEXT (decl);
 768 }
 769
 770 /* <name> ::= <unscoped-name>
 771           ::= <unscoped-template-name> <template-args>
 772           ::= <nested-name>
 773           ::= <local-name>
 774
 775    If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
 776    called from <local-name>, which mangles the enclosing scope
 777    elsewhere and then uses this function to mangle just the part
 778    underneath the function scope.  So don't use the <local-name>
 779    production, to avoid an infinite recursion.  */
 780
 781 static void
 782 write_name (tree decl, const int ignore_local_scope)
 783 {
 784   tree context;
 785
 786   MANGLE_TRACE_TREE ("name", decl);
 787
 788   if (TREE_CODE (decl) == TYPE_DECL)
 789     {
 790       /* In case this is a typedef, fish out the corresponding
 791          TYPE_DECL for the main variant.  */
 792       decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
 793     }
 794
 795   context = decl_mangling_context (decl);
 796
 797   /* A decl in :: or ::std scope is treated specially.  The former is
 798      mangled using <unscoped-name> or <unscoped-template-name>, the
 799      latter with a special substitution.  Also, a name that is
 800      directly in a local function scope is also mangled with
 801      <unscoped-name> rather than a full <nested-name>.  */
 802   if (context == NULL
 803       || context == global_namespace
 804       || DECL_NAMESPACE_STD_P (context)
 805       || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL))
 806     {
 807       tree template_info;
 808       /* Is this a template instance?  */
 809       if (decl_is_template_id (decl, &template_info))
 810         {
 811           /* Yes: use <unscoped-template-name>.  */
 812           write_unscoped_template_name (TI_TEMPLATE (template_info));
 813           write_template_args (TI_ARGS (template_info));
 814         }
 815       else
 816         /* Everything else gets an <unqualified-name>.  */
 817         write_unscoped_name (decl);
 818     }
 819   else
 820     {
 821       /* Handle local names, unless we asked not to (that is, invoked
 822          under <local-name>, to handle only the part of the name under
 823          the local scope).  */
 824       if (!ignore_local_scope)
 825         {
 826           /* Scan up the list of scope context, looking for a
 827              function.  If we find one, this entity is in local
 828              function scope.  local_entity tracks context one scope
 829              level down, so it will contain the element that's
 830              directly in that function's scope, either decl or one of
 831              its enclosing scopes.  */
 832           tree local_entity = decl;
 833           while (context != NULL && context != global_namespace)
 834             {
 835               /* Make sure we're always dealing with decls.  */
 836               if (context != NULL && TYPE_P (context))
 837                 context = TYPE_NAME (context);
 838               /* Is this a function?  */
 839               if (TREE_CODE (context) == FUNCTION_DECL
 840                   || TREE_CODE (context) == PARM_DECL)
 841                 {
 842                   /* Yes, we have local scope.  Use the <local-name>
 843                      production for the innermost function scope.  */
 844                   write_local_name (context, local_entity, decl);
 845                   return;
 846                 }
 847               /* Up one scope level.  */
 848               local_entity = context;
 849               context = decl_mangling_context (context);
 850             }
 851
 852           /* No local scope found?  Fall through to <nested-name>.  */
 853         }
 854
 855       /* Other decls get a <nested-name> to encode their scope.  */
 856       write_nested_name (decl);
 857     }
 858 }
 859
 860 /* <unscoped-name> ::= <unqualified-name>
 861                    ::= St <unqualified-name>   # ::std::  */
 862
 863 static void
 864 write_unscoped_name (const tree decl)
 865 {
 866   tree context = decl_mangling_context (decl);
 867
 868   MANGLE_TRACE_TREE ("unscoped-name", decl);
 869
 870   /* Is DECL in ::std?  */
 871   if (DECL_NAMESPACE_STD_P (context))
 872     {
 873       write_string ("St");
 874       write_unqualified_name (decl);
 875     }
 876   else
 877     {
 878       /* If not, it should be either in the global namespace, or directly
 879          in a local function scope.  */
 880       gcc_assert (context == global_namespace
 881                   || context != NULL
 882                   || TREE_CODE (context) == FUNCTION_DECL);
 883
 884       write_unqualified_name (decl);
 885     }
 886 }
 887
 888 /* <unscoped-template-name> ::= <unscoped-name>
 889                             ::= <substitution>  */
 890
 891 static void
 892 write_unscoped_template_name (const tree decl)
 893 {
 894   MANGLE_TRACE_TREE ("unscoped-template-name", decl);
 895
 896   if (find_substitution (decl))
 897     return;
 898   write_unscoped_name (decl);
 899   add_substitution (decl);
 900 }
 901
 902 /* Write the nested name, including CV-qualifiers, of DECL.
 903
 904    <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
 905                  ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
 906
 907    <CV-qualifiers> ::= [r] [V] [K]  */
 908
 909 static void
 910 write_nested_name (const tree decl)
 911 {
 912   tree template_info;
 913
 914   MANGLE_TRACE_TREE ("nested-name", decl);
 915
 916   write_char ('N');
 917
 918   /* Write CV-qualifiers, if this is a member function.  */
 919   if (TREE_CODE (decl) == FUNCTION_DECL
 920       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
 921     {
 922       if (DECL_VOLATILE_MEMFUNC_P (decl))
 923         write_char ('V');
 924       if (DECL_CONST_MEMFUNC_P (decl))
 925         write_char ('K');
 926     }
 927
 928   /* Is this a template instance?  */
 929   if (decl_is_template_id (decl, &template_info))
 930     {
 931       /* Yes, use <template-prefix>.  */
 932       write_template_prefix (decl);
 933       write_template_args (TI_ARGS (template_info));
 934     }
 935   else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
 936     {
 937       tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
 938       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
 939         {
 940           write_template_prefix (decl);
 941           write_template_args (TREE_OPERAND (name, 1));
 942         }
 943       else
 944         {
 945           write_prefix (CP_DECL_CONTEXT (decl));
 946           write_unqualified_name (decl);
 947         }
 948     }
 949   else
 950     {
 951       /* No, just use <prefix>  */
 952       write_prefix (decl_mangling_context (decl));
 953       write_unqualified_name (decl);
 954     }
 955   write_char ('E');
 956 }
 957
 958 /* <prefix> ::= <prefix> <unqualified-name>
 959             ::= <template-param>
 960             ::= <template-prefix> <template-args>
 961             ::= <decltype>
 962             ::= # empty
 963             ::= <substitution>  */
 964
 965 static void
 966 write_prefix (const tree node)
 967 {
 968   tree decl;
 969   /* Non-NULL if NODE represents a template-id.  */
 970   tree template_info = NULL;
 971
 972   if (node == NULL
 973       || node == global_namespace)
 974     return;
 975
 976   MANGLE_TRACE_TREE ("prefix", node);
 977
 978   if (TREE_CODE (node) == DECLTYPE_TYPE)
 979     {
 980       write_type (node);
 981       return;
 982     }
 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_id (tree identifier)
1145 {
1146   if (IDENTIFIER_TYPENAME_P (identifier))
1147     write_conversion_operator_name (TREE_TYPE (identifier));
1148   else if (IDENTIFIER_OPNAME_P (identifier))
1149     {
1150       int i;
1151       const char *mangled_name = NULL;
1152
1153       /* Unfortunately, there is no easy way to go from the
1154          name of the operator back to the corresponding tree
1155          code.  */
1156       for (i = 0; i < MAX_TREE_CODES; ++i)
1157         if (operator_name_info[i].identifier == identifier)
1158           {
1159             /* The ABI says that we prefer binary operator
1160                names to unary operator names.  */
1161             if (operator_name_info[i].arity == 2)
1162               {
1163                 mangled_name = operator_name_info[i].mangled_name;
1164                 break;
1165               }
1166             else if (!mangled_name)
1167               mangled_name = operator_name_info[i].mangled_name;
1168           }
1169         else if (assignment_operator_name_info[i].identifier
1170                  == identifier)
1171           {
1172             mangled_name
1173               = assignment_operator_name_info[i].mangled_name;
1174             break;
1175           }
1176       write_string (mangled_name);
1177     }
1178   else if (UDLIT_OPER_P (identifier))
1179     write_literal_operator_name (identifier);
1180   else
1181     write_source_name (identifier);
1182 }
1183
1184 static void
1185 write_unqualified_name (const tree decl)
1186 {
1187   MANGLE_TRACE_TREE ("unqualified-name", decl);
1188
1189   if (TREE_CODE (decl) == IDENTIFIER_NODE)
1190     {
1191       write_unqualified_id (decl);
1192       return;
1193     }
1194
1195   if (DECL_NAME (decl) == NULL_TREE)
1196     {
1197       gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
1198       write_source_name (DECL_ASSEMBLER_NAME (decl));
1199       return;
1200     }
1201   else if (DECL_DECLARES_FUNCTION_P (decl))
1202     {
1203       bool found = true;
1204       if (DECL_CONSTRUCTOR_P (decl))
1205         write_special_name_constructor (decl);
1206       else if (DECL_DESTRUCTOR_P (decl))
1207         write_special_name_destructor (decl);
1208       else if (DECL_CONV_FN_P (decl))
1209         {
1210           /* Conversion operator. Handle it right here.
1211              <operator> ::= cv <type>  */
1212           tree type;
1213           if (decl_is_template_id (decl, NULL))
1214             {
1215               tree fn_type;
1216               fn_type = get_mostly_instantiated_function_type (decl);
1217               type = TREE_TYPE (fn_type);
1218             }
1219           else
1220             type = DECL_CONV_FN_TYPE (decl);
1221           write_conversion_operator_name (type);
1222         }
1223       else if (DECL_OVERLOADED_OPERATOR_P (decl))
1224         {
1225           operator_name_info_t *oni;
1226           if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1227             oni = assignment_operator_name_info;
1228           else
1229             oni = operator_name_info;
1230
1231           write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1232         }
1233       else if (UDLIT_OPER_P (DECL_NAME (decl)))
1234         write_literal_operator_name (DECL_NAME (decl));
1235       else
1236         found = false;
1237
1238       if (found)
1239         return;
1240     }
1241
1242   if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
1243       && DECL_NAMESPACE_SCOPE_P (decl)
1244       && decl_linkage (decl) == lk_internal)
1245     {
1246       MANGLE_TRACE_TREE ("local-source-name", decl);
1247       write_char ('L');
1248       write_source_name (DECL_NAME (decl));
1249       /* The default discriminator is 1, and that's all we ever use,
1250          so there's no code to output one here.  */
1251     }
1252   else
1253     {
1254       tree type = TREE_TYPE (decl);
1255
1256       if (TREE_CODE (decl) == TYPE_DECL
1257           && TYPE_ANONYMOUS_P (type))
1258         write_unnamed_type_name (type);
1259       else if (TREE_CODE (decl) == TYPE_DECL
1260                && LAMBDA_TYPE_P (type))
1261         write_closure_type_name (type);
1262       else
1263         write_source_name (DECL_NAME (decl));
1264     }
1265 }
1266
1267 /* Write the unqualified-name for a conversion operator to TYPE.  */
1268
1269 static void
1270 write_conversion_operator_name (const tree type)
1271 {
1272   write_string ("cv");
1273   write_type (type);
1274 }
1275
1276 /* Non-terminal <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
1277
1278      <source-name> ::= </length/ number> <identifier>  */
1279
1280 static void
1281 write_source_name (tree identifier)
1282 {
1283   MANGLE_TRACE_TREE ("source-name", identifier);
1284
1285   /* Never write the whole template-id name including the template
1286      arguments; we only want the template name.  */
1287   if (IDENTIFIER_TEMPLATE (identifier))
1288     identifier = IDENTIFIER_TEMPLATE (identifier);
1289
1290   write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1291   write_identifier (IDENTIFIER_POINTER (identifier));
1292 }
1293
1294 /* Write a user-defined literal operator.
1295    IDENTIFIER is an LITERAL_IDENTIFIER_NODE.  */
1296
1297 static void
1298 write_literal_operator_name (tree identifier)
1299 {
1300   const char* suffix = UDLIT_OP_SUFFIX (identifier);
1301   char* buffer = XNEWVEC (char, strlen (UDLIT_OP_MANGLED_PREFIX)
1302                               + strlen (suffix) + 10);
1303   sprintf (buffer, UDLIT_OP_MANGLED_FORMAT, suffix);
1304
1305   write_unsigned_number (strlen (buffer));
1306   write_identifier (buffer);
1307 }
1308
1309 /* Encode 0 as _, and 1+ as n-1_.  */
1310
1311 static void
1312 write_compact_number (int num)
1313 {
1314   if (num > 0)
1315     write_unsigned_number (num - 1);
1316   write_char ('_');
1317 }
1318
1319 /* Return how many unnamed types precede TYPE in its enclosing class.  */
1320
1321 static int
1322 nested_anon_class_index (tree type)
1323 {
1324   int index = 0;
1325   tree member = TYPE_FIELDS (TYPE_CONTEXT (type));
1326   for (; member; member = DECL_CHAIN (member))
1327     if (DECL_IMPLICIT_TYPEDEF_P (member))
1328       {
1329         tree memtype = TREE_TYPE (member);
1330         if (memtype == type)
1331           return index;
1332         else if (TYPE_ANONYMOUS_P (memtype))
1333           ++index;
1334       }
1335
1336   gcc_unreachable ();
1337 }
1338
1339 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1340
1341 static void
1342 write_unnamed_type_name (const tree type ATTRIBUTE_UNUSED)
1343 {
1344   int discriminator;
1345   MANGLE_TRACE_TREE ("unnamed-type-name", type);
1346
1347   if (TYPE_FUNCTION_SCOPE_P (type))
1348     discriminator = local_class_index (type);
1349   else if (TYPE_CLASS_SCOPE_P (type))
1350     discriminator = nested_anon_class_index (type);
1351   else
1352     {
1353       gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
1354       /* Just use the old mangling at namespace scope.  */
1355       write_source_name (TYPE_IDENTIFIER (type));
1356       return;
1357     }
1358
1359   write_string ("Ut");
1360   write_compact_number (discriminator);
1361 }
1362
1363 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1364    <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters */
1365
1366 static void
1367 write_closure_type_name (const tree type)
1368 {
1369   tree fn = lambda_function (type);
1370   tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
1371   tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
1372
1373   MANGLE_TRACE_TREE ("closure-type-name", type);
1374
1375   write_string ("Ul");
1376   write_method_parms (parms, /*method_p=*/1, fn);
1377   write_char ('E');
1378   write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda));
1379 }
1380
1381 /* Convert NUMBER to ascii using base BASE and generating at least
1382    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1383    into which to store the characters. Returns the number of
1384    characters generated (these will be layed out in advance of where
1385    BUFFER points).  */
1386
1387 static int
1388 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1389                 char *buffer, const unsigned int min_digits)
1390 {
1391   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1392   unsigned digits = 0;
1393
1394   while (number)
1395     {
1396       unsigned HOST_WIDE_INT d = number / base;
1397
1398       *--buffer = base_digits[number - d * base];
1399       digits++;
1400       number = d;
1401     }
1402   while (digits < min_digits)
1403     {
1404       *--buffer = base_digits[0];
1405       digits++;
1406     }
1407   return digits;
1408 }
1409
1410 /* Non-terminal <number>.
1411
1412      <number> ::= [n] </decimal integer/>  */
1413
1414 static void
1415 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1416               const unsigned int base)
1417 {
1418   char buffer[sizeof (HOST_WIDE_INT) * 8];
1419   unsigned count = 0;
1420
1421   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1422     {
1423       write_char ('n');
1424       number = -((HOST_WIDE_INT) number);
1425     }
1426   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1427   write_chars (buffer + sizeof (buffer) - count, count);
1428 }
1429
1430 /* Write out an integral CST in decimal. Most numbers are small, and
1431    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1432    bigger than that, which we must deal with.  */
1433
1434 static inline void
1435 write_integer_cst (const tree cst)
1436 {
1437   int sign = tree_int_cst_sgn (cst);
1438
1439   if (TREE_INT_CST_HIGH (cst) + (sign < 0))
1440     {
1441       /* A bignum. We do this in chunks, each of which fits in a
1442          HOST_WIDE_INT.  */
1443       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1444       unsigned HOST_WIDE_INT chunk;
1445       unsigned chunk_digits;
1446       char *ptr = buffer + sizeof (buffer);
1447       unsigned count = 0;
1448       tree n, base, type;
1449       int done;
1450
1451       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1452          representable.  */
1453       chunk = 1000000000;
1454       chunk_digits = 9;
1455
1456       if (sizeof (HOST_WIDE_INT) >= 8)
1457         {
1458           /* It is at least 64 bits, so 10^18 is representable.  */
1459           chunk_digits = 18;
1460           chunk *= chunk;
1461         }
1462
1463       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1464       base = build_int_cstu (type, chunk);
1465       n = build_int_cst_wide (type,
1466                               TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
1467
1468       if (sign < 0)
1469         {
1470           write_char ('n');
1471           n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
1472         }
1473       do
1474         {
1475           tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
1476           tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
1477           unsigned c;
1478
1479           done = integer_zerop (d);
1480           tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
1481           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1482                               done ? 1 : chunk_digits);
1483           ptr -= c;
1484           count += c;
1485           n = d;
1486         }
1487       while (!done);
1488       write_chars (ptr, count);
1489     }
1490   else
1491     {
1492       /* A small num.  */
1493       unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
1494
1495       if (sign < 0)
1496         {
1497           write_char ('n');
1498           low = -low;
1499         }
1500       write_unsigned_number (low);
1501     }
1502 }
1503
1504 /* Write out a floating-point literal.
1505
1506     "Floating-point literals are encoded using the bit pattern of the
1507     target processor's internal representation of that number, as a
1508     fixed-length lowercase hexadecimal string, high-order bytes first
1509     (even if the target processor would store low-order bytes first).
1510     The "n" prefix is not used for floating-point literals; the sign
1511     bit is encoded with the rest of the number.
1512
1513     Here are some examples, assuming the IEEE standard representation
1514     for floating point numbers.  (Spaces are for readability, not
1515     part of the encoding.)
1516
1517         1.0f                    Lf 3f80 0000 E
1518        -1.0f                    Lf bf80 0000 E
1519         1.17549435e-38f         Lf 0080 0000 E
1520         1.40129846e-45f         Lf 0000 0001 E
1521         0.0f                    Lf 0000 0000 E"
1522
1523    Caller is responsible for the Lx and the E.  */
1524 static void
1525 write_real_cst (const tree value)
1526 {
1527   if (abi_version_at_least (2))
1528     {
1529       long target_real[4];  /* largest supported float */
1530       char buffer[9];       /* eight hex digits in a 32-bit number */
1531       int i, limit, dir;
1532
1533       tree type = TREE_TYPE (value);
1534       int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1535
1536       real_to_target (target_real, &TREE_REAL_CST (value),
1537                       TYPE_MODE (type));
1538
1539       /* The value in target_real is in the target word order,
1540          so we must write it out backward if that happens to be
1541          little-endian.  write_number cannot be used, it will
1542          produce uppercase.  */
1543       if (FLOAT_WORDS_BIG_ENDIAN)
1544         i = 0, limit = words, dir = 1;
1545       else
1546         i = words - 1, limit = -1, dir = -1;
1547
1548       for (; i != limit; i += dir)
1549         {
1550           sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1551           write_chars (buffer, 8);
1552         }
1553     }
1554   else
1555     {
1556       /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out
1557          literally.  Note that compatibility with 3.2 is impossible,
1558          because the old floating-point emulator used a different
1559          format for REAL_VALUE_TYPE.  */
1560       size_t i;
1561       for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1562         write_number (((unsigned char *) &TREE_REAL_CST (value))[i],
1563                       /*unsigned_p*/ 1,
1564                       /*base*/ 16);
1565       G.need_abi_warning = 1;
1566     }
1567 }
1568
1569 /* Non-terminal <identifier>.
1570
1571      <identifier> ::= </unqualified source code identifier>  */
1572
1573 static void
1574 write_identifier (const char *identifier)
1575 {
1576   MANGLE_TRACE ("identifier", identifier);
1577   write_string (identifier);
1578 }
1579
1580 /* Handle constructor productions of non-terminal <special-name>.
1581    CTOR is a constructor FUNCTION_DECL.
1582
1583      <special-name> ::= C1   # complete object constructor
1584                     ::= C2   # base object constructor
1585                     ::= C3   # complete object allocating constructor
1586
1587    Currently, allocating constructors are never used.
1588
1589    We also need to provide mangled names for the maybe-in-charge
1590    constructor, so we treat it here too.  mangle_decl_string will
1591    append *INTERNAL* to that, to make sure we never emit it.  */
1592
1593 static void
1594 write_special_name_constructor (const tree ctor)
1595 {
1596   if (DECL_BASE_CONSTRUCTOR_P (ctor))
1597     write_string ("C2");
1598   else
1599     {
1600       gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1601                   /* Even though we don't ever emit a definition of
1602                      the old-style destructor, we still have to
1603                      consider entities (like static variables) nested
1604                      inside it.  */
1605                   || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor));
1606       write_string ("C1");
1607     }
1608 }
1609
1610 /* Handle destructor productions of non-terminal <special-name>.
1611    DTOR is a destructor FUNCTION_DECL.
1612
1613      <special-name> ::= D0 # deleting (in-charge) destructor
1614                     ::= D1 # complete object (in-charge) destructor
1615                     ::= D2 # base object (not-in-charge) destructor
1616
1617    We also need to provide mangled names for the maybe-incharge
1618    destructor, so we treat it here too.  mangle_decl_string will
1619    append *INTERNAL* to that, to make sure we never emit it.  */
1620
1621 static void
1622 write_special_name_destructor (const tree dtor)
1623 {
1624   if (DECL_DELETING_DESTRUCTOR_P (dtor))
1625     write_string ("D0");
1626   else if (DECL_BASE_DESTRUCTOR_P (dtor))
1627     write_string ("D2");
1628   else
1629     {
1630       gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1631                   /* Even though we don't ever emit a definition of
1632                      the old-style destructor, we still have to
1633                      consider entities (like static variables) nested
1634                      inside it.  */
1635                   || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor));
1636       write_string ("D1");
1637     }
1638 }
1639
1640 /* Scan the vector of local classes and return how many others with the
1641    same name (or same no name) and context precede ENTITY.  */
1642
1643 static int
1644 local_class_index (tree entity)
1645 {
1646   int ix, discriminator = 0;
1647   tree name = (TYPE_ANONYMOUS_P (entity) ? NULL_TREE
1648                : TYPE_IDENTIFIER (entity));
1649   tree ctx = TYPE_CONTEXT (entity);
1650   for (ix = 0; ; ix++)
1651     {
1652       tree type = VEC_index (tree, local_classes, ix);
1653       if (type == entity)
1654         return discriminator;
1655       if (TYPE_CONTEXT (type) == ctx
1656           && (name ? TYPE_IDENTIFIER (type) == name
1657               : TYPE_ANONYMOUS_P (type)))
1658         ++discriminator;
1659     }
1660   gcc_unreachable ();
1661 }
1662
1663 /* Return the discriminator for ENTITY appearing inside
1664    FUNCTION.  The discriminator is the lexical ordinal of VAR among
1665    entities with the same name in the same FUNCTION.  */
1666
1667 static int
1668 discriminator_for_local_entity (tree entity)
1669 {
1670   if (DECL_DISCRIMINATOR_P (entity))
1671     {
1672       if (DECL_DISCRIMINATOR_SET_P (entity))
1673         return DECL_DISCRIMINATOR (entity);
1674       else
1675         /* The first entity with a particular name doesn't get
1676            DECL_DISCRIMINATOR set up.  */
1677         return 0;
1678     }
1679   else if (TREE_CODE (entity) == TYPE_DECL)
1680     {
1681       /* Scan the list of local classes.  */
1682       entity = TREE_TYPE (entity);
1683
1684       /* Lambdas and unnamed types have their own discriminators.  */
1685       if (LAMBDA_TYPE_P (entity) || TYPE_ANONYMOUS_P (entity))
1686         return 0;
1687
1688       return local_class_index (entity);
1689     }
1690   else
1691     gcc_unreachable ();
1692 }
1693
1694 /* Return the discriminator for STRING, a string literal used inside
1695    FUNCTION.  The discriminator is the lexical ordinal of STRING among
1696    string literals used in FUNCTION.  */
1697
1698 static int
1699 discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED,
1700                                   tree string ATTRIBUTE_UNUSED)
1701 {
1702   /* For now, we don't discriminate amongst string literals.  */
1703   return 0;
1704 }
1705
1706 /*   <discriminator> := _ <number>
1707
1708    The discriminator is used only for the second and later occurrences
1709    of the same name within a single function. In this case <number> is
1710    n - 2, if this is the nth occurrence, in lexical order.  */
1711
1712 static void
1713 write_discriminator (const int discriminator)
1714 {
1715   /* If discriminator is zero, don't write anything.  Otherwise...  */
1716   if (discriminator > 0)
1717     {
1718       write_char ('_');
1719       write_unsigned_number (discriminator - 1);
1720     }
1721 }
1722
1723 /* Mangle the name of a function-scope entity.  FUNCTION is the
1724    FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1725    default argument scope.  ENTITY is the decl for the entity itself.
1726    LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1727    either ENTITY itself or an enclosing scope of ENTITY.
1728
1729      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1730                   := Z <function encoding> E s [<discriminator>]
1731                   := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1732
1733 static void
1734 write_local_name (tree function, const tree local_entity,
1735                   const tree entity)
1736 {
1737   tree parm = NULL_TREE;
1738
1739   MANGLE_TRACE_TREE ("local-name", entity);
1740
1741   if (TREE_CODE (function) == PARM_DECL)
1742     {
1743       parm = function;
1744       function = DECL_CONTEXT (parm);
1745     }
1746
1747   write_char ('Z');
1748   write_encoding (function);
1749   write_char ('E');
1750
1751   /* For this purpose, parameters are numbered from right-to-left.  */
1752   if (parm)
1753     {
1754       tree t;
1755       int i = 0;
1756       for (t = DECL_ARGUMENTS (function); t; t = DECL_CHAIN (t))
1757         {
1758           if (t == parm)
1759             i = 1;
1760           else if (i)
1761             ++i;
1762         }
1763       write_char ('d');
1764       write_compact_number (i - 1);
1765     }
1766
1767   if (TREE_CODE (entity) == STRING_CST)
1768     {
1769       write_char ('s');
1770       write_discriminator (discriminator_for_string_literal (function,
1771                                                              entity));
1772     }
1773   else
1774     {
1775       /* Now the <entity name>.  Let write_name know its being called
1776          from <local-name>, so it doesn't try to process the enclosing
1777          function scope again.  */
1778       write_name (entity, /*ignore_local_scope=*/1);
1779       write_discriminator (discriminator_for_local_entity (local_entity));
1780     }
1781 }
1782
1783 /* Non-terminals <type> and <CV-qualifier>.
1784
1785      <type> ::= <builtin-type>
1786             ::= <function-type>
1787             ::= <class-enum-type>
1788             ::= <array-type>
1789             ::= <pointer-to-member-type>
1790             ::= <template-param>
1791             ::= <substitution>
1792             ::= <CV-qualifier>
1793             ::= P <type>    # pointer-to
1794             ::= R <type>    # reference-to
1795             ::= C <type>    # complex pair (C 2000)
1796             ::= G <type>    # imaginary (C 2000)     [not supported]
1797             ::= U <source-name> <type>   # vendor extended type qualifier
1798
1799    C++0x extensions
1800
1801      <type> ::= RR <type>   # rvalue reference-to
1802      <type> ::= Dt <expression> # decltype of an id-expression or
1803                                 # class member access
1804      <type> ::= DT <expression> # decltype of an expression
1805      <type> ::= Dn              # decltype of nullptr
1806
1807    TYPE is a type node.  */
1808
1809 static void
1810 write_type (tree type)
1811 {
1812   /* This gets set to nonzero if TYPE turns out to be a (possibly
1813      CV-qualified) builtin type.  */
1814   int is_builtin_type = 0;
1815
1816   MANGLE_TRACE_TREE ("type", type);
1817
1818   if (type == error_mark_node)
1819     return;
1820
1821   type = canonicalize_for_substitution (type);
1822   if (find_substitution (type))
1823     return;
1824
1825
1826   if (write_CV_qualifiers_for_type (type) > 0)
1827     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1828        mangle the unqualified type.  The recursive call is needed here
1829        since both the qualified and unqualified types are substitution
1830        candidates.  */
1831     write_type (TYPE_MAIN_VARIANT (type));
1832   else if (TREE_CODE (type) == ARRAY_TYPE)
1833     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1834        so that the cv-qualification of the element type is available
1835        in write_array_type.  */
1836     write_array_type (type);
1837   else
1838     {
1839       tree type_orig = type;
1840
1841       /* See through any typedefs.  */
1842       type = TYPE_MAIN_VARIANT (type);
1843
1844       /* According to the C++ ABI, some library classes are passed the
1845          same as the scalar type of their single member and use the same
1846          mangling.  */
1847       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
1848         type = TREE_TYPE (first_field (type));
1849
1850       if (TYPE_PTRMEM_P (type))
1851         write_pointer_to_member_type (type);
1852       else
1853         {
1854           /* Handle any target-specific fundamental types.  */
1855           const char *target_mangling
1856             = targetm.mangle_type (type_orig);
1857
1858           if (target_mangling)
1859             {
1860               write_string (target_mangling);
1861               /* Add substitutions for types other than fundamental
1862                  types.  */
1863               if (TREE_CODE (type) != VOID_TYPE
1864                   && TREE_CODE (type) != INTEGER_TYPE
1865                   && TREE_CODE (type) != REAL_TYPE
1866                   && TREE_CODE (type) != BOOLEAN_TYPE)
1867                 add_substitution (type);
1868               return;
1869             }
1870
1871           switch (TREE_CODE (type))
1872             {
1873             case VOID_TYPE:
1874             case BOOLEAN_TYPE:
1875             case INTEGER_TYPE:  /* Includes wchar_t.  */
1876             case REAL_TYPE:
1877             case FIXED_POINT_TYPE:
1878               {
1879                 /* If this is a typedef, TYPE may not be one of
1880                    the standard builtin type nodes, but an alias of one.  Use
1881                    TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
1882                 write_builtin_type (TYPE_MAIN_VARIANT (type));
1883                 ++is_builtin_type;
1884               }
1885               break;
1886
1887             case COMPLEX_TYPE:
1888               write_char ('C');
1889               write_type (TREE_TYPE (type));
1890               break;
1891
1892             case FUNCTION_TYPE:
1893             case METHOD_TYPE:
1894               write_function_type (type);
1895               break;
1896
1897             case UNION_TYPE:
1898             case RECORD_TYPE:
1899             case ENUMERAL_TYPE:
1900               /* A pointer-to-member function is represented as a special
1901                  RECORD_TYPE, so check for this first.  */
1902               if (TYPE_PTRMEMFUNC_P (type))
1903                 write_pointer_to_member_type (type);
1904               else
1905                 write_class_enum_type (type);
1906               break;
1907
1908             case TYPENAME_TYPE:
1909             case UNBOUND_CLASS_TEMPLATE:
1910               /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1911                  ordinary nested names.  */
1912               write_nested_name (TYPE_STUB_DECL (type));
1913               break;
1914
1915             case POINTER_TYPE:
1916             case REFERENCE_TYPE:
1917               if (TREE_CODE (type) == POINTER_TYPE)
1918                 write_char ('P');
1919               else if (TYPE_REF_IS_RVALUE (type))
1920                 write_char ('O');
1921               else
1922                 write_char ('R');
1923               {
1924                 tree target = TREE_TYPE (type);
1925                 /* Attribute const/noreturn are not reflected in mangling.
1926                    We strip them here rather than at a lower level because
1927                    a typedef or template argument can have function type
1928                    with function-cv-quals (that use the same representation),
1929                    but you can't have a pointer/reference to such a type.  */
1930                 if (abi_version_at_least (5)
1931                     && TREE_CODE (target) == FUNCTION_TYPE)
1932                   target = build_qualified_type (target, TYPE_UNQUALIFIED);
1933                 write_type (target);
1934               }
1935               break;
1936
1937             case TEMPLATE_TYPE_PARM:
1938             case TEMPLATE_PARM_INDEX:
1939               write_template_param (type);
1940               break;
1941
1942             case TEMPLATE_TEMPLATE_PARM:
1943               write_template_template_param (type);
1944               break;
1945
1946             case BOUND_TEMPLATE_TEMPLATE_PARM:
1947               write_template_template_param (type);
1948               write_template_args
1949                 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1950               break;
1951
1952             case VECTOR_TYPE:
1953               if (abi_version_at_least (4))
1954                 {
1955                   write_string ("Dv");
1956                   /* Non-constant vector size would be encoded with
1957                      _ expression, but we don't support that yet.  */
1958                   write_unsigned_number (TYPE_VECTOR_SUBPARTS (type));
1959                   write_char ('_');
1960                 }
1961               else
1962                 {
1963                   G.need_abi_warning = 1;
1964                   write_string ("U8__vector");
1965                 }
1966               write_type (TREE_TYPE (type));
1967               break;
1968
1969             case TYPE_PACK_EXPANSION:
1970               write_string ("Dp");
1971               write_type (PACK_EXPANSION_PATTERN (type));
1972               break;
1973
1974             case DECLTYPE_TYPE:
1975               /* These shouldn't make it into mangling.  */
1976               gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
1977                           && !DECLTYPE_FOR_LAMBDA_PROXY (type));
1978
1979               /* In ABI <5, we stripped decltype of a plain decl.  */
1980               if (!abi_version_at_least (5)
1981                   && DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
1982                 {
1983                   tree expr = DECLTYPE_TYPE_EXPR (type);
1984                   tree etype = NULL_TREE;
1985                   switch (TREE_CODE (expr))
1986                     {
1987                     case VAR_DECL:
1988                     case PARM_DECL:
1989                     case RESULT_DECL:
1990                     case FUNCTION_DECL:
1991                     case CONST_DECL:
1992                     case TEMPLATE_PARM_INDEX:
1993                       etype = TREE_TYPE (expr);
1994                       break;
1995
1996                     default:
1997                       break;
1998                     }
1999
2000                   if (etype && !type_uses_auto (etype))
2001                     {
2002                       G.need_abi_warning = 1;
2003                       write_type (etype);
2004                       return;
2005                     }
2006                 }
2007
2008               write_char ('D');
2009               if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2010                 write_char ('t');
2011               else
2012                 write_char ('T');
2013               ++cp_unevaluated_operand;
2014               write_expression (DECLTYPE_TYPE_EXPR (type));
2015               --cp_unevaluated_operand;
2016               write_char ('E');
2017               break;
2018
2019             case NULLPTR_TYPE:
2020               write_string ("Dn");
2021               break;
2022
2023             case TYPEOF_TYPE:
2024               sorry ("mangling typeof, use decltype instead");
2025               break;
2026
2027             case UNDERLYING_TYPE:
2028               sorry ("mangling __underlying_type");
2029               break;
2030
2031             case LANG_TYPE:
2032               /* fall through.  */
2033
2034             default:
2035               gcc_unreachable ();
2036             }
2037         }
2038     }
2039
2040   /* Types other than builtin types are substitution candidates.  */
2041   if (!is_builtin_type)
2042     add_substitution (type);
2043 }
2044
2045 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
2046    CV-qualifiers written for TYPE.
2047
2048      <CV-qualifiers> ::= [r] [V] [K]  */
2049
2050 static int
2051 write_CV_qualifiers_for_type (const tree type)
2052 {
2053   int num_qualifiers = 0;
2054
2055   /* The order is specified by:
2056
2057        "In cases where multiple order-insensitive qualifiers are
2058        present, they should be ordered 'K' (closest to the base type),
2059        'V', 'r', and 'U' (farthest from the base type) ..."
2060
2061      Note that we do not use cp_type_quals below; given "const
2062      int[3]", the "const" is emitted with the "int", not with the
2063      array.  */
2064   cp_cv_quals quals = TYPE_QUALS (type);
2065
2066   if (quals & TYPE_QUAL_RESTRICT)
2067     {
2068       write_char ('r');
2069       ++num_qualifiers;
2070     }
2071   if (quals & TYPE_QUAL_VOLATILE)
2072     {
2073       write_char ('V');
2074       ++num_qualifiers;
2075     }
2076   if (quals & TYPE_QUAL_CONST)
2077     {
2078       write_char ('K');
2079       ++num_qualifiers;
2080     }
2081
2082   return num_qualifiers;
2083 }
2084
2085 /* Non-terminal <builtin-type>.
2086
2087      <builtin-type> ::= v   # void
2088                     ::= b   # bool
2089                     ::= w   # wchar_t
2090                     ::= c   # char
2091                     ::= a   # signed char
2092                     ::= h   # unsigned char
2093                     ::= s   # short
2094                     ::= t   # unsigned short
2095                     ::= i   # int
2096                     ::= j   # unsigned int
2097                     ::= l   # long
2098                     ::= m   # unsigned long
2099                     ::= x   # long long, __int64
2100                     ::= y   # unsigned long long, __int64
2101                     ::= n   # __int128
2102                     ::= o   # unsigned __int128
2103                     ::= f   # float
2104                     ::= d   # double
2105                     ::= e   # long double, __float80
2106                     ::= g   # __float128          [not supported]
2107                     ::= u <source-name>  # vendor extended type */
2108
2109 static void
2110 write_builtin_type (tree type)
2111 {
2112   if (TYPE_CANONICAL (type))
2113     type = TYPE_CANONICAL (type);
2114
2115   switch (TREE_CODE (type))
2116     {
2117     case VOID_TYPE:
2118       write_char ('v');
2119       break;
2120
2121     case BOOLEAN_TYPE:
2122       write_char ('b');
2123       break;
2124
2125     case INTEGER_TYPE:
2126       /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2127          isn't in integer_type_nodes.  */
2128       if (type == wchar_type_node)
2129         write_char ('w');
2130       else if (type == char16_type_node)
2131         write_string ("Ds");
2132       else if (type == char32_type_node)
2133         write_string ("Di");
2134       else if (TYPE_FOR_JAVA (type))
2135         write_java_integer_type_codes (type);
2136       else
2137         {
2138           size_t itk;
2139           /* Assume TYPE is one of the shared integer type nodes.  Find
2140              it in the array of these nodes.  */
2141         iagain:
2142           for (itk = 0; itk < itk_none; ++itk)
2143             if (integer_types[itk] != NULL_TREE
2144                 && type == integer_types[itk])
2145               {
2146                 /* Print the corresponding single-letter code.  */
2147                 write_char (integer_type_codes[itk]);
2148                 break;
2149               }
2150
2151           if (itk == itk_none)
2152             {
2153               tree t = c_common_type_for_mode (TYPE_MODE (type),
2154                                                TYPE_UNSIGNED (type));
2155               if (type != t)
2156                 {
2157                   type = t;
2158                   goto iagain;
2159                 }
2160
2161               if (TYPE_PRECISION (type) == 128)
2162                 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
2163               else
2164                 {
2165                   /* Allow for cases where TYPE is not one of the shared
2166                      integer type nodes and write a "vendor extended builtin
2167                      type" with a name the form intN or uintN, respectively.
2168                      Situations like this can happen if you have an
2169                      __attribute__((__mode__(__SI__))) type and use exotic
2170                      switches like '-mint8' on AVR.  Of course, this is
2171                      undefined by the C++ ABI (and '-mint8' is not even
2172                      Standard C conforming), but when using such special
2173                      options you're pretty much in nowhere land anyway.  */
2174                   const char *prefix;
2175                   char prec[11];        /* up to ten digits for an unsigned */
2176
2177                   prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
2178                   sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
2179                   write_char ('u');     /* "vendor extended builtin type" */
2180                   write_unsigned_number (strlen (prefix) + strlen (prec));
2181                   write_string (prefix);
2182                   write_string (prec);
2183                 }
2184             }
2185         }
2186       break;
2187
2188     case REAL_TYPE:
2189       if (type == float_type_node
2190           || type == java_float_type_node)
2191         write_char ('f');
2192       else if (type == double_type_node
2193                || type == java_double_type_node)
2194         write_char ('d');
2195       else if (type == long_double_type_node)
2196         write_char ('e');
2197       else if (type == dfloat32_type_node)
2198         write_string ("Df");
2199       else if (type == dfloat64_type_node)
2200         write_string ("Dd");
2201       else if (type == dfloat128_type_node)
2202         write_string ("De");
2203       else
2204         gcc_unreachable ();
2205       break;
2206
2207     case FIXED_POINT_TYPE:
2208       write_string ("DF");
2209       if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
2210         write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
2211       if (type == fract_type_node
2212           || type == sat_fract_type_node
2213           || type == accum_type_node
2214           || type == sat_accum_type_node)
2215         write_char ('i');
2216       else if (type == unsigned_fract_type_node
2217                || type == sat_unsigned_fract_type_node
2218                || type == unsigned_accum_type_node
2219                || type == sat_unsigned_accum_type_node)
2220         write_char ('j');
2221       else if (type == short_fract_type_node
2222                || type == sat_short_fract_type_node
2223                || type == short_accum_type_node
2224                || type == sat_short_accum_type_node)
2225         write_char ('s');
2226       else if (type == unsigned_short_fract_type_node
2227                || type == sat_unsigned_short_fract_type_node
2228                || type == unsigned_short_accum_type_node
2229                || type == sat_unsigned_short_accum_type_node)
2230         write_char ('t');
2231       else if (type == long_fract_type_node
2232                || type == sat_long_fract_type_node
2233                || type == long_accum_type_node
2234                || type == sat_long_accum_type_node)
2235         write_char ('l');
2236       else if (type == unsigned_long_fract_type_node
2237                || type == sat_unsigned_long_fract_type_node
2238                || type == unsigned_long_accum_type_node
2239                || type == sat_unsigned_long_accum_type_node)
2240         write_char ('m');
2241       else if (type == long_long_fract_type_node
2242                || type == sat_long_long_fract_type_node
2243                || type == long_long_accum_type_node
2244                || type == sat_long_long_accum_type_node)
2245         write_char ('x');
2246       else if (type == unsigned_long_long_fract_type_node
2247                || type == sat_unsigned_long_long_fract_type_node
2248                || type == unsigned_long_long_accum_type_node
2249                || type == sat_unsigned_long_long_accum_type_node)
2250         write_char ('y');
2251       else
2252         sorry ("mangling unknown fixed point type");
2253       write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
2254       if (TYPE_SATURATING (type))
2255         write_char ('s');
2256       else
2257         write_char ('n');
2258       break;
2259
2260     default:
2261       gcc_unreachable ();
2262     }
2263 }
2264
2265 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
2266    METHOD_TYPE.  The return type is mangled before the parameter
2267    types.
2268
2269      <function-type> ::= F [Y] <bare-function-type> E   */
2270
2271 static void
2272 write_function_type (const tree type)
2273 {
2274   MANGLE_TRACE_TREE ("function-type", type);
2275
2276   /* For a pointer to member function, the function type may have
2277      cv-qualifiers, indicating the quals for the artificial 'this'
2278      parameter.  */
2279   if (TREE_CODE (type) == METHOD_TYPE)
2280     {
2281       /* The first parameter must be a POINTER_TYPE pointing to the
2282          `this' parameter.  */
2283       tree this_type = class_of_this_parm (type);
2284       write_CV_qualifiers_for_type (this_type);
2285     }
2286
2287   write_char ('F');
2288   /* We don't track whether or not a type is `extern "C"'.  Note that
2289      you can have an `extern "C"' function that does not have
2290      `extern "C"' type, and vice versa:
2291
2292        extern "C" typedef void function_t();
2293        function_t f; // f has C++ linkage, but its type is
2294                      // `extern "C"'
2295
2296        typedef void function_t();
2297        extern "C" function_t f; // Vice versa.
2298
2299      See [dcl.link].  */
2300   write_bare_function_type (type, /*include_return_type_p=*/1,
2301                             /*decl=*/NULL);
2302   write_char ('E');
2303 }
2304
2305 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
2306    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is nonzero, the return value
2307    is mangled before the parameter types.  If non-NULL, DECL is
2308    FUNCTION_DECL for the function whose type is being emitted.
2309
2310    If DECL is a member of a Java type, then a literal 'J'
2311    is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2312    were nonzero.
2313
2314      <bare-function-type> ::= [J]</signature/ type>+  */
2315
2316 static void
2317 write_bare_function_type (const tree type, const int include_return_type_p,
2318                           const tree decl)
2319 {
2320   int java_method_p;
2321
2322   MANGLE_TRACE_TREE ("bare-function-type", type);
2323
2324   /* Detect Java methods and emit special encoding.  */
2325   if (decl != NULL
2326       && DECL_FUNCTION_MEMBER_P (decl)
2327       && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
2328       && !DECL_CONSTRUCTOR_P (decl)
2329       && !DECL_DESTRUCTOR_P (decl)
2330       && !DECL_CONV_FN_P (decl))
2331     {
2332       java_method_p = 1;
2333       write_char ('J');
2334     }
2335   else
2336     {
2337       java_method_p = 0;
2338     }
2339
2340   /* Mangle the return type, if requested.  */
2341   if (include_return_type_p || java_method_p)
2342     write_type (TREE_TYPE (type));
2343
2344   /* Now mangle the types of the arguments.  */
2345   ++G.parm_depth;
2346   write_method_parms (TYPE_ARG_TYPES (type),
2347                       TREE_CODE (type) == METHOD_TYPE,
2348                       decl);
2349   --G.parm_depth;
2350 }
2351
2352 /* Write the mangled representation of a method parameter list of
2353    types given in PARM_TYPES.  If METHOD_P is nonzero, the function is
2354    considered a non-static method, and the this parameter is omitted.
2355    If non-NULL, DECL is the FUNCTION_DECL for the function whose
2356    parameters are being emitted.  */
2357
2358 static void
2359 write_method_parms (tree parm_types, const int method_p, const tree decl)
2360 {
2361   tree first_parm_type;
2362   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2363
2364   /* Assume this parameter type list is variable-length.  If it ends
2365      with a void type, then it's not.  */
2366   int varargs_p = 1;
2367
2368   /* If this is a member function, skip the first arg, which is the
2369      this pointer.
2370        "Member functions do not encode the type of their implicit this
2371        parameter."
2372
2373      Similarly, there's no need to mangle artificial parameters, like
2374      the VTT parameters for constructors and destructors.  */
2375   if (method_p)
2376     {
2377       parm_types = TREE_CHAIN (parm_types);
2378       parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
2379
2380       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2381         {
2382           parm_types = TREE_CHAIN (parm_types);
2383           parm_decl = DECL_CHAIN (parm_decl);
2384         }
2385     }
2386
2387   for (first_parm_type = parm_types;
2388        parm_types;
2389        parm_types = TREE_CHAIN (parm_types))
2390     {
2391       tree parm = TREE_VALUE (parm_types);
2392       if (parm == void_type_node)
2393         {
2394           /* "Empty parameter lists, whether declared as () or
2395              conventionally as (void), are encoded with a void parameter
2396              (v)."  */
2397           if (parm_types == first_parm_type)
2398             write_type (parm);
2399           /* If the parm list is terminated with a void type, it's
2400              fixed-length.  */
2401           varargs_p = 0;
2402           /* A void type better be the last one.  */
2403           gcc_assert (TREE_CHAIN (parm_types) == NULL);
2404         }
2405       else
2406         write_type (parm);
2407     }
2408
2409   if (varargs_p)
2410     /* <builtin-type> ::= z  # ellipsis  */
2411     write_char ('z');
2412 }
2413
2414 /* <class-enum-type> ::= <name>  */
2415
2416 static void
2417 write_class_enum_type (const tree type)
2418 {
2419   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2420 }
2421
2422 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
2423    arguments.
2424
2425      <template-args> ::= I <template-arg>* E  */
2426
2427 static void
2428 write_template_args (tree args)
2429 {
2430   int i;
2431   int length = 0;
2432
2433   MANGLE_TRACE_TREE ("template-args", args);
2434
2435   write_char ('I');
2436
2437   if (args)
2438     length = TREE_VEC_LENGTH (args);
2439
2440   if (args && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2441     {
2442       /* We have nested template args.  We want the innermost template
2443          argument list.  */
2444       args = TREE_VEC_ELT (args, length - 1);
2445       length = TREE_VEC_LENGTH (args);
2446     }
2447   for (i = 0; i < length; ++i)
2448     write_template_arg (TREE_VEC_ELT (args, i));
2449
2450   write_char ('E');
2451 }
2452
2453 /* Write out the
2454    <unqualified-name>
2455    <unqualified-name> <template-args>
2456    part of SCOPE_REF or COMPONENT_REF mangling.  */
2457
2458 static void
2459 write_member_name (tree member)
2460 {
2461   if (TREE_CODE (member) == IDENTIFIER_NODE)
2462     write_unqualified_id (member);
2463   else if (DECL_P (member))
2464     write_unqualified_name (member);
2465   else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2466     {
2467       tree name = TREE_OPERAND (member, 0);
2468       if (TREE_CODE (name) == OVERLOAD)
2469         name = OVL_FUNCTION (name);
2470       write_member_name (name);
2471       write_template_args (TREE_OPERAND (member, 1));
2472     }
2473   else
2474     write_expression (member);
2475 }
2476
2477 /* <expression> ::= <unary operator-name> <expression>
2478                 ::= <binary operator-name> <expression> <expression>
2479                 ::= <expr-primary>
2480
2481    <expr-primary> ::= <template-param>
2482                   ::= L <type> <value number> E         # literal
2483                   ::= L <mangled-name> E                # external name
2484                   ::= st <type>                         # sizeof
2485                   ::= sr <type> <unqualified-name>      # dependent name
2486                   ::= sr <type> <unqualified-name> <template-args> */
2487
2488 static void
2489 write_expression (tree expr)
2490 {
2491   enum tree_code code = TREE_CODE (expr);
2492
2493   /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
2494      is converted (via qualification conversions) to another
2495      type.  */
2496   while (TREE_CODE (expr) == NOP_EXPR
2497          || TREE_CODE (expr) == NON_LVALUE_EXPR)
2498     {
2499       expr = TREE_OPERAND (expr, 0);
2500       code = TREE_CODE (expr);
2501     }
2502
2503   if (code == BASELINK
2504       && (!type_unknown_p (expr)
2505           || !BASELINK_QUALIFIED_P (expr)))
2506     {
2507       expr = BASELINK_FUNCTIONS (expr);
2508       code = TREE_CODE (expr);
2509     }
2510
2511   /* Handle pointers-to-members by making them look like expression
2512      nodes.  */
2513   if (code == PTRMEM_CST)
2514     {
2515       expr = build_nt (ADDR_EXPR,
2516                        build_qualified_name (/*type=*/NULL_TREE,
2517                                              PTRMEM_CST_CLASS (expr),
2518                                              PTRMEM_CST_MEMBER (expr),
2519                                              /*template_p=*/false));
2520       code = TREE_CODE (expr);
2521     }
2522
2523   /* Handle template parameters.  */
2524   if (code == TEMPLATE_TYPE_PARM
2525       || code == TEMPLATE_TEMPLATE_PARM
2526       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2527       || code == TEMPLATE_PARM_INDEX)
2528     write_template_param (expr);
2529   /* Handle literals.  */
2530   else if (TREE_CODE_CLASS (code) == tcc_constant
2531            || (abi_version_at_least (2) && code == CONST_DECL))
2532     write_template_arg_literal (expr);
2533   else if (code == PARM_DECL && DECL_ARTIFICIAL (expr))
2534     {
2535       gcc_assert (!strcmp ("this", IDENTIFIER_POINTER (DECL_NAME (expr))));
2536       write_string ("fpT");
2537     }
2538   else if (code == PARM_DECL)
2539     {
2540       /* A function parameter used in a late-specified return type.  */
2541       int index = DECL_PARM_INDEX (expr);
2542       int level = DECL_PARM_LEVEL (expr);
2543       int delta = G.parm_depth - level + 1;
2544       gcc_assert (index >= 1);
2545       write_char ('f');
2546       if (delta != 0)
2547         {
2548           if (abi_version_at_least (5))
2549             {
2550               /* Let L be the number of function prototype scopes from the
2551                  innermost one (in which the parameter reference occurs) up
2552                  to (and including) the one containing the declaration of
2553                  the referenced parameter.  If the parameter declaration
2554                  clause of the innermost function prototype scope has been
2555                  completely seen, it is not counted (in that case -- which
2556                  is perhaps the most common -- L can be zero).  */
2557               write_char ('L');
2558               write_unsigned_number (delta - 1);
2559             }
2560           else
2561             G.need_abi_warning = true;
2562         }
2563       write_char ('p');
2564       write_compact_number (index - 1);
2565     }
2566   else if (DECL_P (expr))
2567     {
2568       /* G++ 3.2 incorrectly mangled non-type template arguments of
2569          enumeration type using their names.  */
2570       if (code == CONST_DECL)
2571         G.need_abi_warning = 1;
2572       write_char ('L');
2573       write_mangled_name (expr, false);
2574       write_char ('E');
2575     }
2576   else if (TREE_CODE (expr) == SIZEOF_EXPR
2577            && TYPE_P (TREE_OPERAND (expr, 0)))
2578     {
2579       write_string ("st");
2580       write_type (TREE_OPERAND (expr, 0));
2581     }
2582   else if (TREE_CODE (expr) == ALIGNOF_EXPR
2583            && TYPE_P (TREE_OPERAND (expr, 0)))
2584     {
2585       write_string ("at");
2586       write_type (TREE_OPERAND (expr, 0));
2587     }
2588   else if (code == SCOPE_REF
2589            || code == BASELINK)
2590     {
2591       tree scope, member;
2592       if (code == SCOPE_REF)
2593         {
2594           scope = TREE_OPERAND (expr, 0);
2595           member = TREE_OPERAND (expr, 1);
2596         }
2597       else
2598         {
2599           scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr));
2600           member = BASELINK_FUNCTIONS (expr);
2601         }
2602
2603       if (!abi_version_at_least (2) && DECL_P (member))
2604         {
2605           write_string ("sr");
2606           write_type (scope);
2607           /* G++ 3.2 incorrectly put out both the "sr" code and
2608              the nested name of the qualified name.  */
2609           G.need_abi_warning = 1;
2610           write_encoding (member);
2611         }
2612
2613       /* If the MEMBER is a real declaration, then the qualifying
2614          scope was not dependent.  Ideally, we would not have a
2615          SCOPE_REF in those cases, but sometimes we do.  If the second
2616          argument is a DECL, then the name must not have been
2617          dependent.  */
2618       else if (DECL_P (member))
2619         write_expression (member);
2620       else
2621         {
2622           write_string ("sr");
2623           write_type (scope);
2624           write_member_name (member);
2625         }
2626     }
2627   else if (TREE_CODE (expr) == INDIRECT_REF
2628            && TREE_TYPE (TREE_OPERAND (expr, 0))
2629            && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2630     {
2631       write_expression (TREE_OPERAND (expr, 0));
2632     }
2633   else if (TREE_CODE (expr) == IDENTIFIER_NODE)
2634     {
2635       /* An operator name appearing as a dependent name needs to be
2636          specially marked to disambiguate between a use of the operator
2637          name and a use of the operator in an expression.  */
2638       if (IDENTIFIER_OPNAME_P (expr))
2639         write_string ("on");
2640       write_unqualified_id (expr);
2641     }
2642   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
2643     {
2644       tree fn = TREE_OPERAND (expr, 0);
2645       if (is_overloaded_fn (fn))
2646         fn = DECL_NAME (get_first_fn (fn));
2647       if (IDENTIFIER_OPNAME_P (fn))
2648         write_string ("on");
2649       write_unqualified_id (fn);
2650       write_template_args (TREE_OPERAND (expr, 1));
2651     }
2652   else if (TREE_CODE (expr) == MODOP_EXPR)
2653     {
2654       enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1));
2655       const char *name = (assignment_operator_name_info[(int) subop]
2656                           .mangled_name);
2657       write_string (name);
2658       write_expression (TREE_OPERAND (expr, 0));
2659       write_expression (TREE_OPERAND (expr, 2));
2660     }
2661   else if (code == NEW_EXPR || code == VEC_NEW_EXPR)
2662     {
2663       /* ::= [gs] nw <expression>* _ <type> E
2664          ::= [gs] nw <expression>* _ <type> <initializer>
2665          ::= [gs] na <expression>* _ <type> E
2666          ::= [gs] na <expression>* _ <type> <initializer>
2667          <initializer> ::= pi <expression>* E  */
2668       tree placement = TREE_OPERAND (expr, 0);
2669       tree type = TREE_OPERAND (expr, 1);
2670       tree nelts = TREE_OPERAND (expr, 2);
2671       tree init = TREE_OPERAND (expr, 3);
2672       tree t;
2673
2674       gcc_assert (code == NEW_EXPR);
2675       if (TREE_OPERAND (expr, 2))
2676         code = VEC_NEW_EXPR;
2677
2678       if (NEW_EXPR_USE_GLOBAL (expr))
2679         write_string ("gs");
2680
2681       write_string (operator_name_info[(int) code].mangled_name);
2682
2683       for (t = placement; t; t = TREE_CHAIN (t))
2684         write_expression (TREE_VALUE (t));
2685
2686       write_char ('_');
2687
2688       if (nelts)
2689         {
2690           tree domain;
2691           ++processing_template_decl;
2692           domain = compute_array_index_type (NULL_TREE, nelts,
2693                                              tf_warning_or_error);
2694           type = build_cplus_array_type (type, domain);
2695           --processing_template_decl;
2696         }
2697       write_type (type);
2698
2699       if (init && TREE_CODE (init) == TREE_LIST
2700           && TREE_CODE (TREE_VALUE (init)) == CONSTRUCTOR
2701           && CONSTRUCTOR_IS_DIRECT_INIT (TREE_VALUE (init)))
2702         write_expression (TREE_VALUE (init));
2703       else
2704         {
2705           if (init)
2706             write_string ("pi");
2707           if (init && init != void_zero_node)
2708             for (t = init; t; t = TREE_CHAIN (t))
2709               write_expression (TREE_VALUE (t));
2710           write_char ('E');
2711         }
2712     }
2713   else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR)
2714     {
2715       gcc_assert (code == DELETE_EXPR);
2716       if (DELETE_EXPR_USE_VEC (expr))
2717         code = VEC_DELETE_EXPR;
2718
2719       if (DELETE_EXPR_USE_GLOBAL (expr))
2720         write_string ("gs");
2721
2722       write_string (operator_name_info[(int) code].mangled_name);
2723
2724       write_expression (TREE_OPERAND (expr, 0));
2725     }
2726   else if (code == THROW_EXPR)
2727     {
2728       tree op = TREE_OPERAND (expr, 0);
2729       if (op)
2730         {
2731           write_string ("tw");
2732           write_expression (op);
2733         }
2734       else
2735         write_string ("tr");
2736     }
2737   else if (code == CONSTRUCTOR)
2738     {
2739       VEC(constructor_elt,gc)* elts = CONSTRUCTOR_ELTS (expr);
2740       unsigned i; tree val;
2741
2742       if (BRACE_ENCLOSED_INITIALIZER_P (expr))
2743         write_string ("il");
2744       else
2745         {
2746           write_string ("tl");
2747           write_type (TREE_TYPE (expr));
2748         }
2749       FOR_EACH_CONSTRUCTOR_VALUE (elts, i, val)
2750         write_expression (val);
2751       write_char ('E');
2752     }
2753   else if (dependent_name (expr))
2754     {
2755       write_unqualified_id (dependent_name (expr));
2756     }
2757   else
2758     {
2759       int i, len;
2760       const char *name;
2761
2762       /* When we bind a variable or function to a non-type template
2763          argument with reference type, we create an ADDR_EXPR to show
2764          the fact that the entity's address has been taken.  But, we
2765          don't actually want to output a mangling code for the `&'.  */
2766       if (TREE_CODE (expr) == ADDR_EXPR
2767           && TREE_TYPE (expr)
2768           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2769         {
2770           expr = TREE_OPERAND (expr, 0);
2771           if (DECL_P (expr))
2772             {
2773               write_expression (expr);
2774               return;
2775             }
2776
2777           code = TREE_CODE (expr);
2778         }
2779
2780       if (code == COMPONENT_REF)
2781         {
2782           tree ob = TREE_OPERAND (expr, 0);
2783
2784           if (TREE_CODE (ob) == ARROW_EXPR)
2785             {
2786               write_string (operator_name_info[(int)code].mangled_name);
2787               ob = TREE_OPERAND (ob, 0);
2788             }
2789           else
2790             write_string ("dt");
2791
2792           write_expression (ob);
2793           write_member_name (TREE_OPERAND (expr, 1));
2794           return;
2795         }
2796
2797       /* If it wasn't any of those, recursively expand the expression.  */
2798       name = operator_name_info[(int) code].mangled_name;
2799
2800       /* We used to mangle const_cast and static_cast like a C cast.  */
2801       if (!abi_version_at_least (6)
2802           && (code == CONST_CAST_EXPR
2803               || code == STATIC_CAST_EXPR))
2804         {
2805           name = operator_name_info[CAST_EXPR].mangled_name;
2806           G.need_abi_warning = 1;
2807         }
2808
2809       if (name == NULL)
2810         {
2811           sorry ("mangling %C", code);
2812           return;
2813         }
2814       else
2815         write_string (name);
2816
2817       switch (code)
2818         {
2819         case CALL_EXPR:
2820           {
2821             tree fn = CALL_EXPR_FN (expr);
2822
2823             if (TREE_CODE (fn) == ADDR_EXPR)
2824               fn = TREE_OPERAND (fn, 0);
2825
2826             /* Mangle a dependent name as the name, not whatever happens to
2827                be the first function in the overload set.  */
2828             if ((TREE_CODE (fn) == FUNCTION_DECL
2829                  || TREE_CODE (fn) == OVERLOAD)
2830                 && type_dependent_expression_p_push (expr))
2831               fn = DECL_NAME (get_first_fn (fn));
2832
2833             write_expression (fn);
2834           }
2835
2836           for (i = 0; i < call_expr_nargs (expr); ++i)
2837             write_expression (CALL_EXPR_ARG (expr, i));
2838           write_char ('E');
2839           break;
2840
2841         case CAST_EXPR:
2842           write_type (TREE_TYPE (expr));
2843           if (list_length (TREE_OPERAND (expr, 0)) == 1)
2844             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2845           else
2846             {
2847               tree args = TREE_OPERAND (expr, 0);
2848               write_char ('_');
2849               for (; args; args = TREE_CHAIN (args))
2850                 write_expression (TREE_VALUE (args));
2851               write_char ('E');
2852             }
2853           break;
2854
2855         case DYNAMIC_CAST_EXPR:
2856         case REINTERPRET_CAST_EXPR:
2857         case STATIC_CAST_EXPR:
2858         case CONST_CAST_EXPR:
2859           write_type (TREE_TYPE (expr));
2860           write_expression (TREE_OPERAND (expr, 0));
2861           break;
2862
2863         case PREINCREMENT_EXPR:
2864         case PREDECREMENT_EXPR:
2865           if (abi_version_at_least (6))
2866             write_char ('_');
2867           else
2868             G.need_abi_warning = 1;
2869           /* Fall through.  */
2870
2871         default:
2872           /* In the middle-end, some expressions have more operands than
2873              they do in templates (and mangling).  */
2874           len = cp_tree_operand_length (expr);
2875
2876           for (i = 0; i < len; ++i)
2877             {
2878               tree operand = TREE_OPERAND (expr, i);
2879               /* As a GNU extension, the middle operand of a
2880                  conditional may be omitted.  Since expression
2881                  manglings are supposed to represent the input token
2882                  stream, there's no good way to mangle such an
2883                  expression without extending the C++ ABI.  */
2884               if (code == COND_EXPR && i == 1 && !operand)
2885                 {
2886                   error ("omitted middle operand to %<?:%> operand "
2887                          "cannot be mangled");
2888                   continue;
2889                 }
2890               write_expression (operand);
2891             }
2892         }
2893     }
2894 }
2895
2896 /* Literal subcase of non-terminal <template-arg>.
2897
2898      "Literal arguments, e.g. "A<42L>", are encoded with their type
2899      and value. Negative integer values are preceded with "n"; for
2900      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2901      encoded as 0, true as 1."  */
2902
2903 static void
2904 write_template_arg_literal (const tree value)
2905 {
2906   write_char ('L');
2907   write_type (TREE_TYPE (value));
2908
2909   /* Write a null member pointer value as (type)0, regardless of its
2910      real representation.  */
2911   if (null_member_pointer_value_p (value))
2912     write_integer_cst (integer_zero_node);
2913   else
2914     switch (TREE_CODE (value))
2915       {
2916       case CONST_DECL:
2917         write_integer_cst (DECL_INITIAL (value));
2918         break;
2919
2920       case INTEGER_CST:
2921         gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2922                     || integer_zerop (value) || integer_onep (value));
2923         write_integer_cst (value);
2924         break;
2925
2926       case REAL_CST:
2927         write_real_cst (value);
2928         break;
2929
2930       case COMPLEX_CST:
2931         if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST
2932             && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST)
2933           {
2934             write_integer_cst (TREE_REALPART (value));
2935             write_char ('_');
2936             write_integer_cst (TREE_IMAGPART (value));
2937           }
2938         else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST
2939                  && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST)
2940           {
2941             write_real_cst (TREE_REALPART (value));
2942             write_char ('_');
2943             write_real_cst (TREE_IMAGPART (value));
2944           }
2945         else
2946           gcc_unreachable ();
2947         break;
2948
2949       case STRING_CST:
2950         sorry ("string literal in function template signature");
2951         break;
2952
2953       default:
2954         gcc_unreachable ();
2955       }
2956
2957   write_char ('E');
2958 }
2959
2960 /* Non-terminal <template-arg>.
2961
2962      <template-arg> ::= <type>                          # type
2963                     ::= L <type> </value/ number> E     # literal
2964                     ::= LZ <name> E                     # external name
2965                     ::= X <expression> E                # expression  */
2966
2967 static void
2968 write_template_arg (tree node)
2969 {
2970   enum tree_code code = TREE_CODE (node);
2971
2972   MANGLE_TRACE_TREE ("template-arg", node);
2973
2974   /* A template template parameter's argument list contains TREE_LIST
2975      nodes of which the value field is the actual argument.  */
2976   if (code == TREE_LIST)
2977     {
2978       node = TREE_VALUE (node);
2979       /* If it's a decl, deal with its type instead.  */
2980       if (DECL_P (node))
2981         {
2982           node = TREE_TYPE (node);
2983           code = TREE_CODE (node);
2984         }
2985     }
2986
2987   if (TREE_CODE (node) == NOP_EXPR
2988       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2989     {
2990       /* Template parameters can be of reference type. To maintain
2991          internal consistency, such arguments use a conversion from
2992          address of object to reference type.  */
2993       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2994       if (abi_version_at_least (2))
2995         node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2996       else
2997         G.need_abi_warning = 1;
2998     }
2999
3000   if (TREE_CODE (node) == BASELINK
3001       && !type_unknown_p (node))
3002     {
3003       if (abi_version_at_least (6))
3004         node = BASELINK_FUNCTIONS (node);
3005       else
3006         /* We wrongly wrapped a class-scope function in X/E.  */
3007         G.need_abi_warning = 1;
3008     }
3009
3010   if (ARGUMENT_PACK_P (node))
3011     {
3012       /* Expand the template argument pack. */
3013       tree args = ARGUMENT_PACK_ARGS (node);
3014       int i, length = TREE_VEC_LENGTH (args);
3015       if (abi_version_at_least (6))
3016         write_char ('J');
3017       else
3018         {
3019           write_char ('I');
3020           G.need_abi_warning = 1;
3021         }
3022       for (i = 0; i < length; ++i)
3023         write_template_arg (TREE_VEC_ELT (args, i));
3024       write_char ('E');
3025     }
3026   else if (TYPE_P (node))
3027     write_type (node);
3028   else if (code == TEMPLATE_DECL)
3029     /* A template appearing as a template arg is a template template arg.  */
3030     write_template_template_arg (node);
3031   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
3032            || (abi_version_at_least (2) && code == CONST_DECL)
3033            || null_member_pointer_value_p (node))
3034     write_template_arg_literal (node);
3035   else if (DECL_P (node))
3036     {
3037       /* Until ABI version 2, non-type template arguments of
3038          enumeration type were mangled using their names.  */
3039       if (code == CONST_DECL && !abi_version_at_least (2))
3040         G.need_abi_warning = 1;
3041       write_char ('L');
3042       /* Until ABI version 3, the underscore before the mangled name
3043          was incorrectly omitted.  */
3044       if (!abi_version_at_least (3))
3045         {
3046           G.need_abi_warning = 1;
3047           write_char ('Z');
3048         }
3049       else
3050         write_string ("_Z");
3051       write_encoding (node);
3052       write_char ('E');
3053     }
3054   else
3055     {
3056       /* Template arguments may be expressions.  */
3057       write_char ('X');
3058       write_expression (node);
3059       write_char ('E');
3060     }
3061 }
3062
3063 /*  <template-template-arg>
3064                         ::= <name>
3065                         ::= <substitution>  */
3066
3067 static void
3068 write_template_template_arg (const tree decl)
3069 {
3070   MANGLE_TRACE_TREE ("template-template-arg", decl);
3071
3072   if (find_substitution (decl))
3073     return;
3074   write_name (decl, /*ignore_local_scope=*/0);
3075   add_substitution (decl);
3076 }
3077
3078
3079 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
3080
3081      <array-type> ::= A [</dimension/ number>] _ </element/ type>
3082                   ::= A <expression> _ </element/ type>
3083
3084      "Array types encode the dimension (number of elements) and the
3085      element type. For variable length arrays, the dimension (but not
3086      the '_' separator) is omitted."  */
3087
3088 static void
3089 write_array_type (const tree type)
3090 {
3091   write_char ('A');
3092   if (TYPE_DOMAIN (type))
3093     {
3094       tree index_type;
3095       tree max;
3096
3097       index_type = TYPE_DOMAIN (type);
3098       /* The INDEX_TYPE gives the upper and lower bounds of the
3099          array.  */
3100       max = TYPE_MAX_VALUE (index_type);
3101       if (TREE_CODE (max) == INTEGER_CST)
3102         {
3103           /* The ABI specifies that we should mangle the number of
3104              elements in the array, not the largest allowed index.  */
3105           max = size_binop (PLUS_EXPR, max, size_one_node);
3106           write_unsigned_number (tree_low_cst (max, 1));
3107         }
3108       else
3109         {
3110           max = TREE_OPERAND (max, 0);
3111           if (!abi_version_at_least (2))
3112             {
3113               /* value_dependent_expression_p presumes nothing is
3114                  dependent when PROCESSING_TEMPLATE_DECL is zero.  */
3115               ++processing_template_decl;
3116               if (!value_dependent_expression_p (max))
3117                 G.need_abi_warning = 1;
3118               --processing_template_decl;
3119             }
3120           write_expression (max);
3121         }
3122
3123     }
3124   write_char ('_');
3125   write_type (TREE_TYPE (type));
3126 }
3127
3128 /* Non-terminal <pointer-to-member-type> for pointer-to-member
3129    variables.  TYPE is a pointer-to-member POINTER_TYPE.
3130
3131      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
3132
3133 static void
3134 write_pointer_to_member_type (const tree type)
3135 {
3136   write_char ('M');
3137   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
3138   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
3139 }
3140
3141 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
3142    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3143    TEMPLATE_PARM_INDEX.
3144
3145      <template-param> ::= T </parameter/ number> _  */
3146
3147 static void
3148 write_template_param (const tree parm)
3149 {
3150   int parm_index;
3151
3152   MANGLE_TRACE_TREE ("template-parm", parm);
3153
3154   switch (TREE_CODE (parm))
3155     {
3156     case TEMPLATE_TYPE_PARM:
3157     case TEMPLATE_TEMPLATE_PARM:
3158     case BOUND_TEMPLATE_TEMPLATE_PARM:
3159       parm_index = TEMPLATE_TYPE_IDX (parm);
3160       break;
3161
3162     case TEMPLATE_PARM_INDEX:
3163       parm_index = TEMPLATE_PARM_IDX (parm);
3164       break;
3165
3166     default:
3167       gcc_unreachable ();
3168     }
3169
3170   write_char ('T');
3171   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3172      earliest template param denoted by `_'.  */
3173   write_compact_number (parm_index);
3174 }
3175
3176 /*  <template-template-param>
3177                         ::= <template-param>
3178                         ::= <substitution>  */
3179
3180 static void
3181 write_template_template_param (const tree parm)
3182 {
3183   tree templ = NULL_TREE;
3184
3185   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3186      template template parameter.  The substitution candidate here is
3187      only the template.  */
3188   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
3189     {
3190       templ
3191         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
3192       if (find_substitution (templ))
3193         return;
3194     }
3195
3196   /* <template-param> encodes only the template parameter position,
3197      not its template arguments, which is fine here.  */
3198   write_template_param (parm);
3199   if (templ)
3200     add_substitution (templ);
3201 }
3202
3203 /* Non-terminal <substitution>.
3204
3205       <substitution> ::= S <seq-id> _
3206                      ::= S_  */
3207
3208 static void
3209 write_substitution (const int seq_id)
3210 {
3211   MANGLE_TRACE ("substitution", "");
3212
3213   write_char ('S');
3214   if (seq_id > 0)
3215     write_number (seq_id - 1, /*unsigned=*/1, 36);
3216   write_char ('_');
3217 }
3218
3219 /* Start mangling ENTITY.  */
3220
3221 static inline void
3222 start_mangling (const tree entity)
3223 {
3224   G.entity = entity;
3225   G.need_abi_warning = false;
3226   obstack_free (&name_obstack, name_base);
3227   mangle_obstack = &name_obstack;
3228   name_base = obstack_alloc (&name_obstack, 0);
3229 }
3230
3231 /* Done with mangling. If WARN is true, and the name of G.entity will
3232    be mangled differently in a future version of the ABI, issue a
3233    warning.  */
3234
3235 static void
3236 finish_mangling_internal (const bool warn)
3237 {
3238   if (warn_abi && warn && G.need_abi_warning)
3239     warning (OPT_Wabi, "the mangled name of %qD will change in a future "
3240              "version of GCC",
3241              G.entity);
3242
3243   /* Clear all the substitutions.  */
3244   VEC_truncate (tree, G.substitutions, 0);
3245
3246   /* Null-terminate the string.  */
3247   write_char ('\0');
3248 }
3249
3250
3251 /* Like finish_mangling_internal, but return the mangled string.  */
3252
3253 static inline const char *
3254 finish_mangling (const bool warn)
3255 {
3256   finish_mangling_internal (warn);
3257   return (const char *) obstack_finish (mangle_obstack);
3258 }
3259
3260 /* Like finish_mangling_internal, but return an identifier.  */
3261
3262 static tree
3263 finish_mangling_get_identifier (const bool warn)
3264 {
3265   finish_mangling_internal (warn);
3266   /* Don't obstack_finish here, and the next start_mangling will
3267      remove the identifier.  */
3268   return get_identifier ((const char *) obstack_base (mangle_obstack));
3269 }
3270
3271 /* Initialize data structures for mangling.  */
3272
3273 void
3274 init_mangle (void)
3275 {
3276   gcc_obstack_init (&name_obstack);
3277   name_base = obstack_alloc (&name_obstack, 0);
3278   G.substitutions = NULL;
3279
3280   /* Cache these identifiers for quick comparison when checking for
3281      standard substitutions.  */
3282   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
3283   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
3284   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
3285   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
3286   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
3287   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
3288 }
3289
3290 /* Generate the mangled name of DECL.  */
3291
3292 static tree
3293 mangle_decl_string (const tree decl)
3294 {
3295   tree result;
3296   location_t saved_loc = input_location;
3297   tree saved_fn = NULL_TREE;
3298   bool template_p = false;
3299
3300   /* We shouldn't be trying to mangle an uninstantiated template.  */
3301   gcc_assert (!type_dependent_expression_p (decl));
3302
3303   if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3304     {
3305       struct tinst_level *tl = current_instantiation ();
3306       if ((!tl || tl->decl != decl)
3307           && push_tinst_level (decl))
3308         {
3309           template_p = true;
3310           saved_fn = current_function_decl;
3311           current_function_decl = NULL_TREE;
3312         }
3313     }
3314   input_location = DECL_SOURCE_LOCATION (decl);
3315
3316   start_mangling (decl);
3317
3318   if (TREE_CODE (decl) == TYPE_DECL)
3319     write_type (TREE_TYPE (decl));
3320   else
3321     write_mangled_name (decl, true);
3322
3323   result = finish_mangling_get_identifier (/*warn=*/true);
3324   if (DEBUG_MANGLE)
3325     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
3326              IDENTIFIER_POINTER (result));
3327
3328   if (template_p)
3329     {
3330       pop_tinst_level ();
3331       current_function_decl = saved_fn;
3332     }
3333   input_location = saved_loc;
3334
3335   return result;
3336 }
3337
3338 /* Return an identifier for the external mangled name of DECL.  */
3339
3340 static tree
3341 get_mangled_id (tree decl)
3342 {
3343   tree id = mangle_decl_string (decl);
3344   return targetm.mangle_decl_assembler_name (decl, id);
3345 }
3346
3347 /* Create an identifier for the external mangled name of DECL.  */
3348
3349 void
3350 mangle_decl (const tree decl)
3351 {
3352   tree id;
3353   bool dep;
3354
3355   /* Don't bother mangling uninstantiated templates.  */
3356   ++processing_template_decl;
3357   if (TREE_CODE (decl) == TYPE_DECL)
3358     dep = dependent_type_p (TREE_TYPE (decl));
3359   else
3360     dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
3361            && any_dependent_template_arguments_p (DECL_TI_ARGS (decl)));
3362   --processing_template_decl;
3363   if (dep)
3364     return;
3365
3366   id = get_mangled_id (decl);
3367   SET_DECL_ASSEMBLER_NAME (decl, id);
3368
3369   if (G.need_abi_warning
3370       /* Don't do this for a fake symbol we aren't going to emit anyway.  */
3371       && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
3372       && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3373     {
3374 #ifdef ASM_OUTPUT_DEF
3375       /* If the mangling will change in the future, emit an alias with the
3376          future mangled name for forward-compatibility.  */
3377       int save_ver;
3378       tree id2, alias;
3379 #endif
3380
3381       SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3382       if (IDENTIFIER_GLOBAL_VALUE (id) != decl)
3383         inform (DECL_SOURCE_LOCATION (decl), "-fabi-version=6 (or =0) "
3384                 "avoids this error with a change in mangling");
3385
3386 #ifdef ASM_OUTPUT_DEF
3387       save_ver = flag_abi_version;
3388       flag_abi_version = 0;
3389       id2 = mangle_decl_string (decl);
3390       id2 = targetm.mangle_decl_assembler_name (decl, id2);
3391       flag_abi_version = save_ver;
3392
3393       alias = make_alias_for (decl, id2);
3394       DECL_IGNORED_P (alias) = 1;
3395       TREE_PUBLIC (alias) = TREE_PUBLIC (decl);
3396       DECL_VISIBILITY (alias) = DECL_VISIBILITY (decl);
3397       if (vague_linkage_p (decl))
3398         DECL_WEAK (alias) = 1;
3399       if (TREE_CODE (decl) == FUNCTION_DECL)
3400         cgraph_same_body_alias (cgraph_get_create_node (decl), alias, decl);
3401       else
3402         varpool_extra_name_alias (alias, decl);
3403 #endif
3404     }
3405 }
3406
3407 /* Generate the mangled representation of TYPE.  */
3408
3409 const char *
3410 mangle_type_string (const tree type)
3411 {
3412   const char *result;
3413
3414   start_mangling (type);
3415   write_type (type);
3416   result = finish_mangling (/*warn=*/false);
3417   if (DEBUG_MANGLE)
3418     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
3419   return result;
3420 }
3421
3422 /* Create an identifier for the mangled name of a special component
3423    for belonging to TYPE.  CODE is the ABI-specified code for this
3424    component.  */
3425
3426 static tree
3427 mangle_special_for_type (const tree type, const char *code)
3428 {
3429   tree result;
3430
3431   /* We don't have an actual decl here for the special component, so
3432      we can't just process the <encoded-name>.  Instead, fake it.  */
3433   start_mangling (type);
3434
3435   /* Start the mangling.  */
3436   write_string ("_Z");
3437   write_string (code);
3438
3439   /* Add the type.  */
3440   write_type (type);
3441   result = finish_mangling_get_identifier (/*warn=*/false);
3442
3443   if (DEBUG_MANGLE)
3444     fprintf (stderr, "mangle_special_for_type = %s\n\n",
3445              IDENTIFIER_POINTER (result));
3446
3447   return result;
3448 }
3449
3450 /* Create an identifier for the mangled representation of the typeinfo
3451    structure for TYPE.  */
3452
3453 tree
3454 mangle_typeinfo_for_type (const tree type)
3455 {
3456   return mangle_special_for_type (type, "TI");
3457 }
3458
3459 /* Create an identifier for the mangled name of the NTBS containing
3460    the mangled name of TYPE.  */
3461
3462 tree
3463 mangle_typeinfo_string_for_type (const tree type)
3464 {
3465   return mangle_special_for_type (type, "TS");
3466 }
3467
3468 /* Create an identifier for the mangled name of the vtable for TYPE.  */
3469
3470 tree
3471 mangle_vtbl_for_type (const tree type)
3472 {
3473   return mangle_special_for_type (type, "TV");
3474 }
3475
3476 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
3477
3478 tree
3479 mangle_vtt_for_type (const tree type)
3480 {
3481   return mangle_special_for_type (type, "TT");
3482 }
3483
3484 /* Return an identifier for a construction vtable group.  TYPE is
3485    the most derived class in the hierarchy; BINFO is the base
3486    subobject for which this construction vtable group will be used.
3487
3488    This mangling isn't part of the ABI specification; in the ABI
3489    specification, the vtable group is dumped in the same COMDAT as the
3490    main vtable, and is referenced only from that vtable, so it doesn't
3491    need an external name.  For binary formats without COMDAT sections,
3492    though, we need external names for the vtable groups.
3493
3494    We use the production
3495
3496     <special-name> ::= CT <type> <offset number> _ <base type>  */
3497
3498 tree
3499 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
3500 {
3501   tree result;
3502
3503   start_mangling (type);
3504
3505   write_string ("_Z");
3506   write_string ("TC");
3507   write_type (type);
3508   write_integer_cst (BINFO_OFFSET (binfo));
3509   write_char ('_');
3510   write_type (BINFO_TYPE (binfo));
3511
3512   result = finish_mangling_get_identifier (/*warn=*/false);
3513   if (DEBUG_MANGLE)
3514     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
3515              IDENTIFIER_POINTER (result));
3516   return result;
3517 }
3518
3519 /* Mangle a this pointer or result pointer adjustment.
3520
3521    <call-offset> ::= h <fixed offset number> _
3522                  ::= v <fixed offset number> _ <virtual offset number> _ */
3523
3524 static void
3525 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
3526 {
3527   write_char (virtual_offset ? 'v' : 'h');
3528
3529   /* For either flavor, write the fixed offset.  */
3530   write_integer_cst (fixed_offset);
3531   write_char ('_');
3532
3533   /* For a virtual thunk, add the virtual offset.  */
3534   if (virtual_offset)
3535     {
3536       write_integer_cst (virtual_offset);
3537       write_char ('_');
3538     }
3539 }
3540
3541 /* Return an identifier for the mangled name of a this-adjusting or
3542    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
3543    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
3544    is a virtual thunk, and it is the vtbl offset in
3545    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
3546    zero for a covariant thunk. Note, that FN_DECL might be a covariant
3547    thunk itself. A covariant thunk name always includes the adjustment
3548    for the this pointer, even if there is none.
3549
3550    <special-name> ::= T <call-offset> <base encoding>
3551                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
3552                                         <base encoding>  */
3553
3554 tree
3555 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
3556               tree virtual_offset)
3557 {
3558   tree result;
3559
3560   start_mangling (fn_decl);
3561
3562   write_string ("_Z");
3563   write_char ('T');
3564
3565   if (!this_adjusting)
3566     {
3567       /* Covariant thunk with no this adjustment */
3568       write_char ('c');
3569       mangle_call_offset (integer_zero_node, NULL_TREE);
3570       mangle_call_offset (fixed_offset, virtual_offset);
3571     }
3572   else if (!DECL_THUNK_P (fn_decl))
3573     /* Plain this adjusting thunk.  */
3574     mangle_call_offset (fixed_offset, virtual_offset);
3575   else
3576     {
3577       /* This adjusting thunk to covariant thunk.  */
3578       write_char ('c');
3579       mangle_call_offset (fixed_offset, virtual_offset);
3580       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
3581       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
3582       if (virtual_offset)
3583         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
3584       mangle_call_offset (fixed_offset, virtual_offset);
3585       fn_decl = THUNK_TARGET (fn_decl);
3586     }
3587
3588   /* Scoped name.  */
3589   write_encoding (fn_decl);
3590
3591   result = finish_mangling_get_identifier (/*warn=*/false);
3592   if (DEBUG_MANGLE)
3593     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
3594   return result;
3595 }
3596
3597 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3598    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
3599    TYPE.  */
3600
3601 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
3602
3603 /* Hash a node (VAL1) in the table.  */
3604
3605 static hashval_t
3606 hash_type (const void *val)
3607 {
3608   return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val));
3609 }
3610
3611 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
3612
3613 static int
3614 compare_type (const void *val1, const void *val2)
3615 {
3616   return TREE_TYPE ((const_tree) val1) == (const_tree) val2;
3617 }
3618
3619 /* Return an identifier for the mangled unqualified name for a
3620    conversion operator to TYPE.  This mangling is not specified by the
3621    ABI spec; it is only used internally.  */
3622
3623 tree
3624 mangle_conv_op_name_for_type (const tree type)
3625 {
3626   void **slot;
3627   tree identifier;
3628
3629   if (type == error_mark_node)
3630     return error_mark_node;
3631
3632   if (conv_type_names == NULL)
3633     conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
3634
3635   slot = htab_find_slot_with_hash (conv_type_names, type,
3636                                    (hashval_t) TYPE_UID (type), INSERT);
3637   identifier = (tree)*slot;
3638   if (!identifier)
3639     {
3640       char buffer[64];
3641
3642        /* Create a unique name corresponding to TYPE.  */
3643       sprintf (buffer, "operator %lu",
3644                (unsigned long) htab_elements (conv_type_names));
3645       identifier = get_identifier (buffer);
3646       *slot = identifier;
3647
3648       /* Hang TYPE off the identifier so it can be found easily later
3649          when performing conversions.  */
3650       TREE_TYPE (identifier) = type;
3651
3652       /* Set bits on the identifier so we know later it's a conversion.  */
3653       IDENTIFIER_OPNAME_P (identifier) = 1;
3654       IDENTIFIER_TYPENAME_P (identifier) = 1;
3655     }
3656
3657   return identifier;
3658 }
3659
3660 /* Return an identifier for the name of an initialization guard
3661    variable for indicated VARIABLE.  */
3662
3663 tree
3664 mangle_guard_variable (const tree variable)
3665 {
3666   start_mangling (variable);
3667   write_string ("_ZGV");
3668   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
3669     /* The name of a guard variable for a reference temporary should refer
3670        to the reference, not the temporary.  */
3671     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
3672   else
3673     write_name (variable, /*ignore_local_scope=*/0);
3674   return finish_mangling_get_identifier (/*warn=*/false);
3675 }
3676
3677 /* Return an identifier for the name of a temporary variable used to
3678    initialize a static reference.  This isn't part of the ABI, but we might
3679    as well call them something readable.  */
3680
3681 static GTY(()) int temp_count;
3682
3683 tree
3684 mangle_ref_init_variable (const tree variable)
3685 {
3686   start_mangling (variable);
3687   write_string ("_ZGR");
3688   write_name (variable, /*ignore_local_scope=*/0);
3689   /* Avoid name clashes with aggregate initialization of multiple
3690      references at once.  */
3691   write_unsigned_number (temp_count++);
3692   return finish_mangling_get_identifier (/*warn=*/false);
3693 }
3694 \f
3695
3696 /* Foreign language type mangling section.  */
3697
3698 /* How to write the type codes for the integer Java type.  */
3699
3700 static void
3701 write_java_integer_type_codes (const tree type)
3702 {
3703   if (type == java_int_type_node)
3704     write_char ('i');
3705   else if (type == java_short_type_node)
3706     write_char ('s');
3707   else if (type == java_byte_type_node)
3708     write_char ('c');
3709   else if (type == java_char_type_node)
3710     write_char ('w');
3711   else if (type == java_long_type_node)
3712     write_char ('x');
3713   else if (type == java_boolean_type_node)
3714     write_char ('b');
3715   else
3716     gcc_unreachable ();
3717 }
3718
3719 #include "gt-cp-mangle.h"