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 (type)
 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 (CP_DECL_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     {
2505       expr = BASELINK_FUNCTIONS (expr);
2506       code = TREE_CODE (expr);
2507     }
2508
2509   /* Handle pointers-to-members by making them look like expression
2510      nodes.  */
2511   if (code == PTRMEM_CST)
2512     {
2513       expr = build_nt (ADDR_EXPR,
2514                        build_qualified_name (/*type=*/NULL_TREE,
2515                                              PTRMEM_CST_CLASS (expr),
2516                                              PTRMEM_CST_MEMBER (expr),
2517                                              /*template_p=*/false));
2518       code = TREE_CODE (expr);
2519     }
2520
2521   /* Handle template parameters.  */
2522   if (code == TEMPLATE_TYPE_PARM
2523       || code == TEMPLATE_TEMPLATE_PARM
2524       || code == BOUND_TEMPLATE_TEMPLATE_PARM
2525       || code == TEMPLATE_PARM_INDEX)
2526     write_template_param (expr);
2527   /* Handle literals.  */
2528   else if (TREE_CODE_CLASS (code) == tcc_constant
2529            || (abi_version_at_least (2) && code == CONST_DECL))
2530     write_template_arg_literal (expr);
2531   else if (code == PARM_DECL && DECL_ARTIFICIAL (expr))
2532     {
2533       gcc_assert (!strcmp ("this", IDENTIFIER_POINTER (DECL_NAME (expr))));
2534       write_string ("fpT");
2535     }
2536   else if (code == PARM_DECL)
2537     {
2538       /* A function parameter used in a late-specified return type.  */
2539       int index = DECL_PARM_INDEX (expr);
2540       int level = DECL_PARM_LEVEL (expr);
2541       int delta = G.parm_depth - level + 1;
2542       gcc_assert (index >= 1);
2543       write_char ('f');
2544       if (delta != 0)
2545         {
2546           if (abi_version_at_least (5))
2547             {
2548               /* Let L be the number of function prototype scopes from the
2549                  innermost one (in which the parameter reference occurs) up
2550                  to (and including) the one containing the declaration of
2551                  the referenced parameter.  If the parameter declaration
2552                  clause of the innermost function prototype scope has been
2553                  completely seen, it is not counted (in that case -- which
2554                  is perhaps the most common -- L can be zero).  */
2555               write_char ('L');
2556               write_unsigned_number (delta - 1);
2557             }
2558           else
2559             G.need_abi_warning = true;
2560         }
2561       write_char ('p');
2562       write_compact_number (index - 1);
2563     }
2564   else if (DECL_P (expr))
2565     {
2566       /* G++ 3.2 incorrectly mangled non-type template arguments of
2567          enumeration type using their names.  */
2568       if (code == CONST_DECL)
2569         G.need_abi_warning = 1;
2570       write_char ('L');
2571       write_mangled_name (expr, false);
2572       write_char ('E');
2573     }
2574   else if (TREE_CODE (expr) == SIZEOF_EXPR
2575            && TYPE_P (TREE_OPERAND (expr, 0)))
2576     {
2577       write_string ("st");
2578       write_type (TREE_OPERAND (expr, 0));
2579     }
2580   else if (TREE_CODE (expr) == ALIGNOF_EXPR
2581            && TYPE_P (TREE_OPERAND (expr, 0)))
2582     {
2583       write_string ("at");
2584       write_type (TREE_OPERAND (expr, 0));
2585     }
2586   else if (TREE_CODE (expr) == SCOPE_REF)
2587     {
2588       tree scope = TREE_OPERAND (expr, 0);
2589       tree member = TREE_OPERAND (expr, 1);
2590
2591       if (!abi_version_at_least (2) && DECL_P (member))
2592         {
2593           write_string ("sr");
2594           write_type (scope);
2595           /* G++ 3.2 incorrectly put out both the "sr" code and
2596              the nested name of the qualified name.  */
2597           G.need_abi_warning = 1;
2598           write_encoding (member);
2599         }
2600
2601       /* If the MEMBER is a real declaration, then the qualifying
2602          scope was not dependent.  Ideally, we would not have a
2603          SCOPE_REF in those cases, but sometimes we do.  If the second
2604          argument is a DECL, then the name must not have been
2605          dependent.  */
2606       else if (DECL_P (member))
2607         write_expression (member);
2608       else
2609         {
2610           write_string ("sr");
2611           write_type (scope);
2612           write_member_name (member);
2613         }
2614     }
2615   else if (TREE_CODE (expr) == INDIRECT_REF
2616            && TREE_TYPE (TREE_OPERAND (expr, 0))
2617            && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2618     {
2619       write_expression (TREE_OPERAND (expr, 0));
2620     }
2621   else if (TREE_CODE (expr) == IDENTIFIER_NODE)
2622     {
2623       /* An operator name appearing as a dependent name needs to be
2624          specially marked to disambiguate between a use of the operator
2625          name and a use of the operator in an expression.  */
2626       if (IDENTIFIER_OPNAME_P (expr))
2627         write_string ("on");
2628       write_unqualified_id (expr);
2629     }
2630   else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
2631     {
2632       tree fn = TREE_OPERAND (expr, 0);
2633       if (is_overloaded_fn (fn))
2634         fn = DECL_NAME (get_first_fn (fn));
2635       if (IDENTIFIER_OPNAME_P (fn))
2636         write_string ("on");
2637       write_unqualified_id (fn);
2638       write_template_args (TREE_OPERAND (expr, 1));
2639     }
2640   else if (TREE_CODE (expr) == MODOP_EXPR)
2641     {
2642       enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1));
2643       const char *name = (assignment_operator_name_info[(int) subop]
2644                           .mangled_name);
2645       write_string (name);
2646       write_expression (TREE_OPERAND (expr, 0));
2647       write_expression (TREE_OPERAND (expr, 2));
2648     }
2649   else
2650     {
2651       int i, len;
2652       const char *name;
2653
2654       /* When we bind a variable or function to a non-type template
2655          argument with reference type, we create an ADDR_EXPR to show
2656          the fact that the entity's address has been taken.  But, we
2657          don't actually want to output a mangling code for the `&'.  */
2658       if (TREE_CODE (expr) == ADDR_EXPR
2659           && TREE_TYPE (expr)
2660           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2661         {
2662           expr = TREE_OPERAND (expr, 0);
2663           if (DECL_P (expr))
2664             {
2665               write_expression (expr);
2666               return;
2667             }
2668
2669           code = TREE_CODE (expr);
2670         }
2671
2672       if (code == COMPONENT_REF)
2673         {
2674           tree ob = TREE_OPERAND (expr, 0);
2675
2676           if (TREE_CODE (ob) == ARROW_EXPR)
2677             {
2678               write_string (operator_name_info[(int)code].mangled_name);
2679               ob = TREE_OPERAND (ob, 0);
2680             }
2681           else
2682             write_string ("dt");
2683
2684           write_expression (ob);
2685           write_member_name (TREE_OPERAND (expr, 1));
2686           return;
2687         }
2688
2689       /* If it wasn't any of those, recursively expand the expression.  */
2690       name = operator_name_info[(int) code].mangled_name;
2691       if (name == NULL)
2692         {
2693           sorry ("mangling %C", code);
2694           return;
2695         }
2696       else
2697         write_string (name);
2698
2699       switch (code)
2700         {
2701         case CALL_EXPR:
2702           {
2703             tree fn = CALL_EXPR_FN (expr);
2704
2705             if (TREE_CODE (fn) == ADDR_EXPR)
2706               fn = TREE_OPERAND (fn, 0);
2707
2708             /* Mangle a dependent name as the name, not whatever happens to
2709                be the first function in the overload set.  */
2710             if ((TREE_CODE (fn) == FUNCTION_DECL
2711                  || TREE_CODE (fn) == OVERLOAD)
2712                 && type_dependent_expression_p_push (expr))
2713               fn = DECL_NAME (get_first_fn (fn));
2714
2715             write_expression (fn);
2716           }
2717
2718           for (i = 0; i < call_expr_nargs (expr); ++i)
2719             write_expression (CALL_EXPR_ARG (expr, i));
2720           write_char ('E');
2721           break;
2722
2723         case CAST_EXPR:
2724           write_type (TREE_TYPE (expr));
2725           if (list_length (TREE_OPERAND (expr, 0)) == 1)
2726             write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2727           else
2728             {
2729               tree args = TREE_OPERAND (expr, 0);
2730               write_char ('_');
2731               for (; args; args = TREE_CHAIN (args))
2732                 write_expression (TREE_VALUE (args));
2733               write_char ('E');
2734             }
2735           break;
2736
2737           /* FIXME these should have a distinct mangling.  */
2738         case STATIC_CAST_EXPR:
2739         case CONST_CAST_EXPR:
2740           write_type (TREE_TYPE (expr));
2741           write_expression (TREE_OPERAND (expr, 0));
2742           break;
2743
2744         case NEW_EXPR:
2745           sorry ("mangling new-expression");
2746           break;
2747
2748         default:
2749           /* In the middle-end, some expressions have more operands than
2750              they do in templates (and mangling).  */
2751           len = cp_tree_operand_length (expr);
2752
2753           for (i = 0; i < len; ++i)
2754             {
2755               tree operand = TREE_OPERAND (expr, i);
2756               /* As a GNU extension, the middle operand of a
2757                  conditional may be omitted.  Since expression
2758                  manglings are supposed to represent the input token
2759                  stream, there's no good way to mangle such an
2760                  expression without extending the C++ ABI.  */
2761               if (code == COND_EXPR && i == 1 && !operand)
2762                 {
2763                   error ("omitted middle operand to %<?:%> operand "
2764                          "cannot be mangled");
2765                   continue;
2766                 }
2767               write_expression (operand);
2768             }
2769         }
2770     }
2771 }
2772
2773 /* Literal subcase of non-terminal <template-arg>.
2774
2775      "Literal arguments, e.g. "A<42L>", are encoded with their type
2776      and value. Negative integer values are preceded with "n"; for
2777      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2778      encoded as 0, true as 1."  */
2779
2780 static void
2781 write_template_arg_literal (const tree value)
2782 {
2783   write_char ('L');
2784   write_type (TREE_TYPE (value));
2785
2786   /* Write a null member pointer value as (type)0, regardless of its
2787      real representation.  */
2788   if (null_member_pointer_value_p (value))
2789     write_integer_cst (integer_zero_node);
2790   else
2791     switch (TREE_CODE (value))
2792       {
2793       case CONST_DECL:
2794         write_integer_cst (DECL_INITIAL (value));
2795         break;
2796
2797       case INTEGER_CST:
2798         gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2799                     || integer_zerop (value) || integer_onep (value));
2800         write_integer_cst (value);
2801         break;
2802
2803       case REAL_CST:
2804         write_real_cst (value);
2805         break;
2806
2807       case STRING_CST:
2808         sorry ("string literal in function template signature");
2809         break;
2810
2811       default:
2812         gcc_unreachable ();
2813       }
2814
2815   write_char ('E');
2816 }
2817
2818 /* Non-terminal <template-arg>.
2819
2820      <template-arg> ::= <type>                          # type
2821                     ::= L <type> </value/ number> E     # literal
2822                     ::= LZ <name> E                     # external name
2823                     ::= X <expression> E                # expression  */
2824
2825 static void
2826 write_template_arg (tree node)
2827 {
2828   enum tree_code code = TREE_CODE (node);
2829
2830   MANGLE_TRACE_TREE ("template-arg", node);
2831
2832   /* A template template parameter's argument list contains TREE_LIST
2833      nodes of which the value field is the actual argument.  */
2834   if (code == TREE_LIST)
2835     {
2836       node = TREE_VALUE (node);
2837       /* If it's a decl, deal with its type instead.  */
2838       if (DECL_P (node))
2839         {
2840           node = TREE_TYPE (node);
2841           code = TREE_CODE (node);
2842         }
2843     }
2844
2845   if (TREE_CODE (node) == NOP_EXPR
2846       && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2847     {
2848       /* Template parameters can be of reference type. To maintain
2849          internal consistency, such arguments use a conversion from
2850          address of object to reference type.  */
2851       gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2852       if (abi_version_at_least (2))
2853         node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2854       else
2855         G.need_abi_warning = 1;
2856     }
2857
2858   if (ARGUMENT_PACK_P (node))
2859     {
2860       /* Expand the template argument pack. */
2861       tree args = ARGUMENT_PACK_ARGS (node);
2862       int i, length = TREE_VEC_LENGTH (args);
2863       write_char ('I');
2864       for (i = 0; i < length; ++i)
2865         write_template_arg (TREE_VEC_ELT (args, i));
2866       write_char ('E');
2867     }
2868   else if (TYPE_P (node))
2869     write_type (node);
2870   else if (code == TEMPLATE_DECL)
2871     /* A template appearing as a template arg is a template template arg.  */
2872     write_template_template_arg (node);
2873   else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
2874            || (abi_version_at_least (2) && code == CONST_DECL)
2875            || null_member_pointer_value_p (node))
2876     write_template_arg_literal (node);
2877   else if (DECL_P (node))
2878     {
2879       /* Until ABI version 2, non-type template arguments of
2880          enumeration type were mangled using their names.  */
2881       if (code == CONST_DECL && !abi_version_at_least (2))
2882         G.need_abi_warning = 1;
2883       write_char ('L');
2884       /* Until ABI version 3, the underscore before the mangled name
2885          was incorrectly omitted.  */
2886       if (!abi_version_at_least (3))
2887         {
2888           G.need_abi_warning = 1;
2889           write_char ('Z');
2890         }
2891       else
2892         write_string ("_Z");
2893       write_encoding (node);
2894       write_char ('E');
2895     }
2896   else
2897     {
2898       /* Template arguments may be expressions.  */
2899       write_char ('X');
2900       write_expression (node);
2901       write_char ('E');
2902     }
2903 }
2904
2905 /*  <template-template-arg>
2906                         ::= <name>
2907                         ::= <substitution>  */
2908
2909 static void
2910 write_template_template_arg (const tree decl)
2911 {
2912   MANGLE_TRACE_TREE ("template-template-arg", decl);
2913
2914   if (find_substitution (decl))
2915     return;
2916   write_name (decl, /*ignore_local_scope=*/0);
2917   add_substitution (decl);
2918 }
2919
2920
2921 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2922
2923      <array-type> ::= A [</dimension/ number>] _ </element/ type>
2924                   ::= A <expression> _ </element/ type>
2925
2926      "Array types encode the dimension (number of elements) and the
2927      element type. For variable length arrays, the dimension (but not
2928      the '_' separator) is omitted."  */
2929
2930 static void
2931 write_array_type (const tree type)
2932 {
2933   write_char ('A');
2934   if (TYPE_DOMAIN (type))
2935     {
2936       tree index_type;
2937       tree max;
2938
2939       index_type = TYPE_DOMAIN (type);
2940       /* The INDEX_TYPE gives the upper and lower bounds of the
2941          array.  */
2942       max = TYPE_MAX_VALUE (index_type);
2943       if (TREE_CODE (max) == INTEGER_CST)
2944         {
2945           /* The ABI specifies that we should mangle the number of
2946              elements in the array, not the largest allowed index.  */
2947           max = size_binop (PLUS_EXPR, max, size_one_node);
2948           write_unsigned_number (tree_low_cst (max, 1));
2949         }
2950       else
2951         {
2952           max = TREE_OPERAND (max, 0);
2953           if (!abi_version_at_least (2))
2954             {
2955               /* value_dependent_expression_p presumes nothing is
2956                  dependent when PROCESSING_TEMPLATE_DECL is zero.  */
2957               ++processing_template_decl;
2958               if (!value_dependent_expression_p (max))
2959                 G.need_abi_warning = 1;
2960               --processing_template_decl;
2961             }
2962           write_expression (max);
2963         }
2964
2965     }
2966   write_char ('_');
2967   write_type (TREE_TYPE (type));
2968 }
2969
2970 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2971    variables.  TYPE is a pointer-to-member POINTER_TYPE.
2972
2973      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2974
2975 static void
2976 write_pointer_to_member_type (const tree type)
2977 {
2978   write_char ('M');
2979   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2980   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2981 }
2982
2983 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2984    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2985    TEMPLATE_PARM_INDEX.
2986
2987      <template-param> ::= T </parameter/ number> _  */
2988
2989 static void
2990 write_template_param (const tree parm)
2991 {
2992   int parm_index;
2993
2994   MANGLE_TRACE_TREE ("template-parm", parm);
2995
2996   switch (TREE_CODE (parm))
2997     {
2998     case TEMPLATE_TYPE_PARM:
2999     case TEMPLATE_TEMPLATE_PARM:
3000     case BOUND_TEMPLATE_TEMPLATE_PARM:
3001       parm_index = TEMPLATE_TYPE_IDX (parm);
3002       break;
3003
3004     case TEMPLATE_PARM_INDEX:
3005       parm_index = TEMPLATE_PARM_IDX (parm);
3006       break;
3007
3008     default:
3009       gcc_unreachable ();
3010     }
3011
3012   write_char ('T');
3013   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3014      earliest template param denoted by `_'.  */
3015   write_compact_number (parm_index);
3016 }
3017
3018 /*  <template-template-param>
3019                         ::= <template-param>
3020                         ::= <substitution>  */
3021
3022 static void
3023 write_template_template_param (const tree parm)
3024 {
3025   tree templ = NULL_TREE;
3026
3027   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3028      template template parameter.  The substitution candidate here is
3029      only the template.  */
3030   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
3031     {
3032       templ
3033         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
3034       if (find_substitution (templ))
3035         return;
3036     }
3037
3038   /* <template-param> encodes only the template parameter position,
3039      not its template arguments, which is fine here.  */
3040   write_template_param (parm);
3041   if (templ)
3042     add_substitution (templ);
3043 }
3044
3045 /* Non-terminal <substitution>.
3046
3047       <substitution> ::= S <seq-id> _
3048                      ::= S_  */
3049
3050 static void
3051 write_substitution (const int seq_id)
3052 {
3053   MANGLE_TRACE ("substitution", "");
3054
3055   write_char ('S');
3056   if (seq_id > 0)
3057     write_number (seq_id - 1, /*unsigned=*/1, 36);
3058   write_char ('_');
3059 }
3060
3061 /* Start mangling ENTITY.  */
3062
3063 static inline void
3064 start_mangling (const tree entity)
3065 {
3066   G.entity = entity;
3067   G.need_abi_warning = false;
3068   obstack_free (&name_obstack, name_base);
3069   mangle_obstack = &name_obstack;
3070   name_base = obstack_alloc (&name_obstack, 0);
3071 }
3072
3073 /* Done with mangling. If WARN is true, and the name of G.entity will
3074    be mangled differently in a future version of the ABI, issue a
3075    warning.  */
3076
3077 static void
3078 finish_mangling_internal (const bool warn)
3079 {
3080   if (warn_abi && warn && G.need_abi_warning)
3081     warning (OPT_Wabi, "the mangled name of %qD will change in a future "
3082              "version of GCC",
3083              G.entity);
3084
3085   /* Clear all the substitutions.  */
3086   VEC_truncate (tree, G.substitutions, 0);
3087
3088   /* Null-terminate the string.  */
3089   write_char ('\0');
3090 }
3091
3092
3093 /* Like finish_mangling_internal, but return the mangled string.  */
3094
3095 static inline const char *
3096 finish_mangling (const bool warn)
3097 {
3098   finish_mangling_internal (warn);
3099   return (const char *) obstack_finish (mangle_obstack);
3100 }
3101
3102 /* Like finish_mangling_internal, but return an identifier.  */
3103
3104 static tree
3105 finish_mangling_get_identifier (const bool warn)
3106 {
3107   finish_mangling_internal (warn);
3108   /* Don't obstack_finish here, and the next start_mangling will
3109      remove the identifier.  */
3110   return get_identifier ((const char *) obstack_base (mangle_obstack));
3111 }
3112
3113 /* Initialize data structures for mangling.  */
3114
3115 void
3116 init_mangle (void)
3117 {
3118   gcc_obstack_init (&name_obstack);
3119   name_base = obstack_alloc (&name_obstack, 0);
3120   G.substitutions = NULL;
3121
3122   /* Cache these identifiers for quick comparison when checking for
3123      standard substitutions.  */
3124   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
3125   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
3126   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
3127   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
3128   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
3129   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
3130 }
3131
3132 /* Generate the mangled name of DECL.  */
3133
3134 static tree
3135 mangle_decl_string (const tree decl)
3136 {
3137   tree result;
3138   location_t saved_loc = input_location;
3139   tree saved_fn = NULL_TREE;
3140   bool template_p = false;
3141
3142   /* We shouldn't be trying to mangle an uninstantiated template.  */
3143   gcc_assert (!type_dependent_expression_p (decl));
3144
3145   if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3146     {
3147       struct tinst_level *tl = current_instantiation ();
3148       if ((!tl || tl->decl != decl)
3149           && push_tinst_level (decl))
3150         {
3151           template_p = true;
3152           saved_fn = current_function_decl;
3153           current_function_decl = NULL_TREE;
3154         }
3155     }
3156   input_location = DECL_SOURCE_LOCATION (decl);
3157
3158   start_mangling (decl);
3159
3160   if (TREE_CODE (decl) == TYPE_DECL)
3161     write_type (TREE_TYPE (decl));
3162   else
3163     write_mangled_name (decl, true);
3164
3165   result = finish_mangling_get_identifier (/*warn=*/true);
3166   if (DEBUG_MANGLE)
3167     fprintf (stderr, "mangle_decl_string = '%s'\n\n",
3168              IDENTIFIER_POINTER (result));
3169
3170   if (template_p)
3171     {
3172       pop_tinst_level ();
3173       current_function_decl = saved_fn;
3174     }
3175   input_location = saved_loc;
3176
3177   return result;
3178 }
3179
3180 /* Return an identifier for the external mangled name of DECL.  */
3181
3182 static tree
3183 get_mangled_id (tree decl)
3184 {
3185   tree id = mangle_decl_string (decl);
3186   return targetm.mangle_decl_assembler_name (decl, id);
3187 }
3188
3189 /* Create an identifier for the external mangled name of DECL.  */
3190
3191 void
3192 mangle_decl (const tree decl)
3193 {
3194   tree id = get_mangled_id (decl);
3195   SET_DECL_ASSEMBLER_NAME (decl, id);
3196
3197   if (G.need_abi_warning
3198       /* Don't do this for a fake symbol we aren't going to emit anyway.  */
3199       && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
3200       && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3201     {
3202 #ifdef ASM_OUTPUT_DEF
3203       /* If the mangling will change in the future, emit an alias with the
3204          future mangled name for forward-compatibility.  */
3205       int save_ver;
3206       tree id2, alias;
3207 #endif
3208
3209       SET_IDENTIFIER_GLOBAL_VALUE (id, decl);
3210       if (IDENTIFIER_GLOBAL_VALUE (id) != decl)
3211         inform (DECL_SOURCE_LOCATION (decl), "-fabi-version=4 (or =0) "
3212                 "avoids this error with a change in vector mangling");
3213
3214 #ifdef ASM_OUTPUT_DEF
3215       save_ver = flag_abi_version;
3216       flag_abi_version = 0;
3217       id2 = mangle_decl_string (decl);
3218       id2 = targetm.mangle_decl_assembler_name (decl, id2);
3219       flag_abi_version = save_ver;
3220
3221       alias = make_alias_for (decl, id2);
3222       DECL_IGNORED_P (alias) = 1;
3223       TREE_PUBLIC (alias) = TREE_PUBLIC (decl);
3224       DECL_VISIBILITY (alias) = DECL_VISIBILITY (decl);
3225       if (vague_linkage_p (decl))
3226         DECL_WEAK (alias) = 1;
3227       if (TREE_CODE (decl) == FUNCTION_DECL)
3228         cgraph_same_body_alias (cgraph_get_create_node (decl), alias, decl);
3229       else
3230         varpool_extra_name_alias (alias, decl);
3231 #endif
3232     }
3233 }
3234
3235 /* Generate the mangled representation of TYPE.  */
3236
3237 const char *
3238 mangle_type_string (const tree type)
3239 {
3240   const char *result;
3241
3242   start_mangling (type);
3243   write_type (type);
3244   result = finish_mangling (/*warn=*/false);
3245   if (DEBUG_MANGLE)
3246     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
3247   return result;
3248 }
3249
3250 /* Create an identifier for the mangled name of a special component
3251    for belonging to TYPE.  CODE is the ABI-specified code for this
3252    component.  */
3253
3254 static tree
3255 mangle_special_for_type (const tree type, const char *code)
3256 {
3257   tree result;
3258
3259   /* We don't have an actual decl here for the special component, so
3260      we can't just process the <encoded-name>.  Instead, fake it.  */
3261   start_mangling (type);
3262
3263   /* Start the mangling.  */
3264   write_string ("_Z");
3265   write_string (code);
3266
3267   /* Add the type.  */
3268   write_type (type);
3269   result = finish_mangling_get_identifier (/*warn=*/false);
3270
3271   if (DEBUG_MANGLE)
3272     fprintf (stderr, "mangle_special_for_type = %s\n\n",
3273              IDENTIFIER_POINTER (result));
3274
3275   return result;
3276 }
3277
3278 /* Create an identifier for the mangled representation of the typeinfo
3279    structure for TYPE.  */
3280
3281 tree
3282 mangle_typeinfo_for_type (const tree type)
3283 {
3284   return mangle_special_for_type (type, "TI");
3285 }
3286
3287 /* Create an identifier for the mangled name of the NTBS containing
3288    the mangled name of TYPE.  */
3289
3290 tree
3291 mangle_typeinfo_string_for_type (const tree type)
3292 {
3293   return mangle_special_for_type (type, "TS");
3294 }
3295
3296 /* Create an identifier for the mangled name of the vtable for TYPE.  */
3297
3298 tree
3299 mangle_vtbl_for_type (const tree type)
3300 {
3301   return mangle_special_for_type (type, "TV");
3302 }
3303
3304 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
3305
3306 tree
3307 mangle_vtt_for_type (const tree type)
3308 {
3309   return mangle_special_for_type (type, "TT");
3310 }
3311
3312 /* Return an identifier for a construction vtable group.  TYPE is
3313    the most derived class in the hierarchy; BINFO is the base
3314    subobject for which this construction vtable group will be used.
3315
3316    This mangling isn't part of the ABI specification; in the ABI
3317    specification, the vtable group is dumped in the same COMDAT as the
3318    main vtable, and is referenced only from that vtable, so it doesn't
3319    need an external name.  For binary formats without COMDAT sections,
3320    though, we need external names for the vtable groups.
3321
3322    We use the production
3323
3324     <special-name> ::= CT <type> <offset number> _ <base type>  */
3325
3326 tree
3327 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
3328 {
3329   tree result;
3330
3331   start_mangling (type);
3332
3333   write_string ("_Z");
3334   write_string ("TC");
3335   write_type (type);
3336   write_integer_cst (BINFO_OFFSET (binfo));
3337   write_char ('_');
3338   write_type (BINFO_TYPE (binfo));
3339
3340   result = finish_mangling_get_identifier (/*warn=*/false);
3341   if (DEBUG_MANGLE)
3342     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
3343              IDENTIFIER_POINTER (result));
3344   return result;
3345 }
3346
3347 /* Mangle a this pointer or result pointer adjustment.
3348
3349    <call-offset> ::= h <fixed offset number> _
3350                  ::= v <fixed offset number> _ <virtual offset number> _ */
3351
3352 static void
3353 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
3354 {
3355   write_char (virtual_offset ? 'v' : 'h');
3356
3357   /* For either flavor, write the fixed offset.  */
3358   write_integer_cst (fixed_offset);
3359   write_char ('_');
3360
3361   /* For a virtual thunk, add the virtual offset.  */
3362   if (virtual_offset)
3363     {
3364       write_integer_cst (virtual_offset);
3365       write_char ('_');
3366     }
3367 }
3368
3369 /* Return an identifier for the mangled name of a this-adjusting or
3370    covariant thunk to FN_DECL.  FIXED_OFFSET is the initial adjustment
3371    to this used to find the vptr.  If VIRTUAL_OFFSET is non-NULL, this
3372    is a virtual thunk, and it is the vtbl offset in
3373    bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
3374    zero for a covariant thunk. Note, that FN_DECL might be a covariant
3375    thunk itself. A covariant thunk name always includes the adjustment
3376    for the this pointer, even if there is none.
3377
3378    <special-name> ::= T <call-offset> <base encoding>
3379                   ::= Tc <this_adjust call-offset> <result_adjust call-offset>
3380                                         <base encoding>  */
3381
3382 tree
3383 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
3384               tree virtual_offset)
3385 {
3386   tree result;
3387
3388   start_mangling (fn_decl);
3389
3390   write_string ("_Z");
3391   write_char ('T');
3392
3393   if (!this_adjusting)
3394     {
3395       /* Covariant thunk with no this adjustment */
3396       write_char ('c');
3397       mangle_call_offset (integer_zero_node, NULL_TREE);
3398       mangle_call_offset (fixed_offset, virtual_offset);
3399     }
3400   else if (!DECL_THUNK_P (fn_decl))
3401     /* Plain this adjusting thunk.  */
3402     mangle_call_offset (fixed_offset, virtual_offset);
3403   else
3404     {
3405       /* This adjusting thunk to covariant thunk.  */
3406       write_char ('c');
3407       mangle_call_offset (fixed_offset, virtual_offset);
3408       fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
3409       virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
3410       if (virtual_offset)
3411         virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
3412       mangle_call_offset (fixed_offset, virtual_offset);
3413       fn_decl = THUNK_TARGET (fn_decl);
3414     }
3415
3416   /* Scoped name.  */
3417   write_encoding (fn_decl);
3418
3419   result = finish_mangling_get_identifier (/*warn=*/false);
3420   if (DEBUG_MANGLE)
3421     fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
3422   return result;
3423 }
3424
3425 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3426    operator to TYPE.  The nodes are IDENTIFIERs whose TREE_TYPE is the
3427    TYPE.  */
3428
3429 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
3430
3431 /* Hash a node (VAL1) in the table.  */
3432
3433 static hashval_t
3434 hash_type (const void *val)
3435 {
3436   return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val));
3437 }
3438
3439 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE).  */
3440
3441 static int
3442 compare_type (const void *val1, const void *val2)
3443 {
3444   return TREE_TYPE ((const_tree) val1) == (const_tree) val2;
3445 }
3446
3447 /* Return an identifier for the mangled unqualified name for a
3448    conversion operator to TYPE.  This mangling is not specified by the
3449    ABI spec; it is only used internally.  */
3450
3451 tree
3452 mangle_conv_op_name_for_type (const tree type)
3453 {
3454   void **slot;
3455   tree identifier;
3456
3457   if (type == error_mark_node)
3458     return error_mark_node;
3459
3460   if (conv_type_names == NULL)
3461     conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
3462
3463   slot = htab_find_slot_with_hash (conv_type_names, type,
3464                                    (hashval_t) TYPE_UID (type), INSERT);
3465   identifier = (tree)*slot;
3466   if (!identifier)
3467     {
3468       char buffer[64];
3469
3470        /* Create a unique name corresponding to TYPE.  */
3471       sprintf (buffer, "operator %lu",
3472                (unsigned long) htab_elements (conv_type_names));
3473       identifier = get_identifier (buffer);
3474       *slot = identifier;
3475
3476       /* Hang TYPE off the identifier so it can be found easily later
3477          when performing conversions.  */
3478       TREE_TYPE (identifier) = type;
3479
3480       /* Set bits on the identifier so we know later it's a conversion.  */
3481       IDENTIFIER_OPNAME_P (identifier) = 1;
3482       IDENTIFIER_TYPENAME_P (identifier) = 1;
3483     }
3484
3485   return identifier;
3486 }
3487
3488 /* Return an identifier for the name of an initialization guard
3489    variable for indicated VARIABLE.  */
3490
3491 tree
3492 mangle_guard_variable (const tree variable)
3493 {
3494   start_mangling (variable);
3495   write_string ("_ZGV");
3496   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
3497     /* The name of a guard variable for a reference temporary should refer
3498        to the reference, not the temporary.  */
3499     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
3500   else
3501     write_name (variable, /*ignore_local_scope=*/0);
3502   return finish_mangling_get_identifier (/*warn=*/false);
3503 }
3504
3505 /* Return an identifier for the name of a temporary variable used to
3506    initialize a static reference.  This isn't part of the ABI, but we might
3507    as well call them something readable.  */
3508
3509 static GTY(()) int temp_count;
3510
3511 tree
3512 mangle_ref_init_variable (const tree variable)
3513 {
3514   start_mangling (variable);
3515   write_string ("_ZGR");
3516   write_name (variable, /*ignore_local_scope=*/0);
3517   /* Avoid name clashes with aggregate initialization of multiple
3518      references at once.  */
3519   write_unsigned_number (temp_count++);
3520   return finish_mangling_get_identifier (/*warn=*/false);
3521 }
3522 \f
3523
3524 /* Foreign language type mangling section.  */
3525
3526 /* How to write the type codes for the integer Java type.  */
3527
3528 static void
3529 write_java_integer_type_codes (const tree type)
3530 {
3531   if (type == java_int_type_node)
3532     write_char ('i');
3533   else if (type == java_short_type_node)
3534     write_char ('s');
3535   else if (type == java_byte_type_node)
3536     write_char ('c');
3537   else if (type == java_char_type_node)
3538     write_char ('w');
3539   else if (type == java_long_type_node)
3540     write_char ('x');
3541   else if (type == java_boolean_type_node)
3542     write_char ('b');
3543   else
3544     gcc_unreachable ();
3545 }
3546
3547 #include "gt-cp-mangle.h"