gcc/cp/mangle.c

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