gcc/cp/mangle.c

   1 /* Name mangling for the 3.0 C++ ABI.
   2    Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
   3    Written by Alex Samuel <sameul@codesourcery.com>
   4
   5    This file is part of GNU CC.
   6
   7    GNU CC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GNU CC is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GNU CC; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  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 */
  49
  50 #include "config.h"
  51 #include "system.h"
  52 #include "tree.h"
  53 #include "cp-tree.h"
  54 #include "real.h"
  55 #include "obstack.h"
  56 #include "toplev.h"
  57 #include "varray.h"
  58
  59 /* Debugging support.  */
  60
  61 /* Define DEBUG_MANGLE to enable very verbose trace messages.  */
  62 #ifndef DEBUG_MANGLE
  63 #define DEBUG_MANGLE 0
  64 #endif
  65
  66 /* Macros for tracing the write_* functions.  */
  67 #if DEBUG_MANGLE
  68 # define MANGLE_TRACE(FN, INPUT) \
  69   fprintf (stderr, "  %-24s: %-24s\n", (FN), (INPUT))
  70 # define MANGLE_TRACE_TREE(FN, NODE) \
  71   fprintf (stderr, "  %-24s: %-24s (%p)\n", \
  72            (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE))
  73 #else
  74 # define MANGLE_TRACE(FN, INPUT)
  75 # define MANGLE_TRACE_TREE(FN, NODE)
  76 #endif
  77
  78 /* Non-zero if NODE is a class template-id.  We can't rely on
  79    CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
  80    that hard to distinguish A<T> from A, where A<T> is the type as
  81    instantiated outside of the template, and A is the type used
  82    without parameters inside the template.  */
  83 #define CLASSTYPE_TEMPLATE_ID_P(NODE)                                 \
  84   (TYPE_LANG_SPECIFIC (NODE) != NULL                                  \
  85    && CLASSTYPE_TEMPLATE_INFO (NODE) != NULL                          \
  86    && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))
  87
  88 /* Things we only need one of.  This module is not reentrant.  */
  89 static struct globals
  90 {
  91   /* The name in which we're building the mangled name.  */
  92   struct obstack name_obstack;
  93
  94   /* An array of the current substitution candidates, in the order
  95      we've seen them.  */
  96   varray_type substitutions;
  97
  98   /* We are mangling an internal symbol. It is important to keep those
  99      involving template parmeters distinct by distinguishing their level
 100      and, for non-type parms, their type.  */
 101   bool internal_mangling_p;
 102 } G;
 103
 104 /* Indices into subst_identifiers.  These are identifiers used in
 105    special substitution rules.  */
 106 typedef enum
 107 {
 108   SUBID_ALLOCATOR,
 109   SUBID_BASIC_STRING,
 110   SUBID_CHAR_TRAITS,
 111   SUBID_BASIC_ISTREAM,
 112   SUBID_BASIC_OSTREAM,
 113   SUBID_BASIC_IOSTREAM,
 114   SUBID_MAX
 115 }
 116 substitution_identifier_index_t;
 117
 118 /* For quick substitution checks, look up these common identifiers
 119    once only.  */
 120 static tree subst_identifiers[SUBID_MAX];
 121
 122 /* Single-letter codes for builtin integer types, defined in
 123    <builtin-type>.  These are indexed by integer_type_kind values.  */
 124 static const char
 125 integer_type_codes[itk_none] =
 126 {
 127   'c',  /* itk_char */
 128   'a',  /* itk_signed_char */
 129   'h',  /* itk_unsigned_char */
 130   's',  /* itk_short */
 131   't',  /* itk_unsigned_short */
 132   'i',  /* itk_int */
 133   'j',  /* itk_unsigned_int */
 134   'l',  /* itk_long */
 135   'm',  /* itk_unsigned_long */
 136   'x',  /* itk_long_long */
 137   'y'   /* itk_unsigned_long_long */
 138 };
 139
 140 static int decl_is_template_id PARAMS ((tree, tree*));
 141
 142 /* Functions for handling substitutions.  */
 143
 144 static inline tree canonicalize_for_substitution PARAMS ((tree));
 145 static void add_substitution PARAMS ((tree));
 146 static inline int is_std_substitution PARAMS ((tree, substitution_identifier_index_t));
 147 static inline int is_std_substitution_char PARAMS ((tree, substitution_identifier_index_t));
 148 static int find_substitution PARAMS ((tree));
 149
 150 /* Functions for emitting mangled representations of things.  */
 151
 152 static void write_mangled_name PARAMS ((tree));
 153 static void write_encoding PARAMS ((tree));
 154 static void write_name PARAMS ((tree, int));
 155 static void write_unscoped_name PARAMS ((tree));
 156 static void write_unscoped_template_name PARAMS ((tree));
 157 static void write_nested_name PARAMS ((tree));
 158 static void write_prefix PARAMS ((tree));
 159 static void write_template_prefix PARAMS ((tree));
 160 static void write_unqualified_name PARAMS ((tree));
 161 static void write_source_name PARAMS ((tree));
 162 static int hwint_to_ascii PARAMS ((unsigned HOST_WIDE_INT, unsigned int, char *, unsigned));
 163 static void write_number PARAMS ((unsigned HOST_WIDE_INT, int,
 164                                   unsigned int));
 165 static void write_integer_cst PARAMS ((tree));
 166 static void write_identifier PARAMS ((const char *));
 167 static void write_special_name_constructor PARAMS ((tree));
 168 static void write_special_name_destructor PARAMS ((tree));
 169 static void write_type PARAMS ((tree));
 170 static int write_CV_qualifiers_for_type PARAMS ((tree));
 171 static void write_builtin_type PARAMS ((tree));
 172 static void write_function_type PARAMS ((tree));
 173 static void write_bare_function_type PARAMS ((tree, int, tree));
 174 static void write_method_parms PARAMS ((tree, int, tree));
 175 static void write_class_enum_type PARAMS ((tree));
 176 static void write_template_args PARAMS ((tree));
 177 static void write_expression PARAMS ((tree));
 178 static void write_template_arg_literal PARAMS ((tree));
 179 static void write_template_arg PARAMS ((tree));
 180 static void write_template_template_arg PARAMS ((tree));
 181 static void write_array_type PARAMS ((tree));
 182 static void write_pointer_to_member_type PARAMS ((tree));
 183 static void write_template_param PARAMS ((tree));
 184 static void write_template_template_param PARAMS ((tree));
 185 static void write_substitution PARAMS ((int));
 186 static int discriminator_for_local_entity PARAMS ((tree));
 187 static int discriminator_for_string_literal PARAMS ((tree, tree));
 188 static void write_discriminator PARAMS ((int));
 189 static void write_local_name PARAMS ((tree, tree, tree));
 190 static void dump_substitution_candidates PARAMS ((void));
 191 static const char *mangle_decl_string PARAMS ((tree));
 192
 193 /* Control functions.  */
 194
 195 static inline void start_mangling PARAMS ((void));
 196 static inline const char *finish_mangling PARAMS ((void));
 197 static tree mangle_special_for_type PARAMS ((tree, const char *));
 198
 199 /* Foreign language functions. */
 200
 201 static void write_java_integer_type_codes PARAMS ((tree));
 202
 203 /* Append a single character to the end of the mangled
 204    representation.  */
 205 #define write_char(CHAR)                                              \
 206   obstack_1grow (&G.name_obstack, (CHAR))
 207
 208 /* Append a sized buffer to the end of the mangled representation. */
 209 #define write_chars(CHAR, LEN)                                        \
 210   obstack_grow (&G.name_obstack, (CHAR), (LEN))
 211
 212 /* Append a NUL-terminated string to the end of the mangled
 213    representation.  */
 214 #define write_string(STRING)                                          \
 215   obstack_grow (&G.name_obstack, (STRING), strlen (STRING))
 216
 217 /* Return the position at which the next character will be appended to
 218    the mangled representation.  */
 219 #define mangled_position()                                              \
 220   obstack_object_size (&G.name_obstack)
 221
 222 /* Non-zero if NODE1 and NODE2 are both TREE_LIST nodes and have the
 223    same purpose (context, which may be a type) and value (template
 224    decl).  See write_template_prefix for more information on what this
 225    is used for.  */
 226 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2)                         \
 227   (TREE_CODE (NODE1) == TREE_LIST                                     \
 228    && TREE_CODE (NODE2) == TREE_LIST                                  \
 229    && ((TYPE_P (TREE_PURPOSE (NODE1))                                 \
 230         && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2)))\
 231        || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2))             \
 232    && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
 233
 234 /* Write out a signed quantity in base 10.  */
 235 #define write_signed_number(NUMBER) \
 236   write_number ((NUMBER), /*unsigned_p=*/0, 10)
 237
 238 /* Write out an unsigned quantity in base 10.  */
 239 #define write_unsigned_number(NUMBER) \
 240   write_number ((NUMBER), /*unsigned_p=*/1, 10)
 241
 242 /* If DECL is a template instance, return non-zero and, if
 243    TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
 244    Otherwise return zero.  */
 245
 246 static int
 247 decl_is_template_id (decl, template_info)
 248      tree decl;
 249      tree* template_info;
 250 {
 251   if (TREE_CODE (decl) == TYPE_DECL)
 252     {
 253       /* TYPE_DECLs are handled specially.  Look at its type to decide
 254          if this is a template instantiation.  */
 255       tree type = TREE_TYPE (decl);
 256
 257       if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
 258         {
 259           if (template_info != NULL)
 260             /* For a templated TYPE_DECL, the template info is hanging
 261                off the type.  */
 262             *template_info = CLASSTYPE_TEMPLATE_INFO (type);
 263           return 1;
 264         }
 265     }
 266   else
 267     {
 268       /* Check if this is a primary template.  */
 269       if (DECL_LANG_SPECIFIC (decl) != NULL
 270           && DECL_USE_TEMPLATE (decl)
 271           && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
 272           && TREE_CODE (decl) != TEMPLATE_DECL)
 273         {
 274           if (template_info != NULL)
 275             /* For most templated decls, the template info is hanging
 276                off the decl.  */
 277             *template_info = DECL_TEMPLATE_INFO (decl);
 278           return 1;
 279         }
 280     }
 281
 282   /* It's not a template id.  */
 283   return 0;
 284 }
 285
 286 /* Produce debugging output of current substitution candidates.  */
 287
 288 static void
 289 dump_substitution_candidates ()
 290 {
 291   unsigned i;
 292
 293   fprintf (stderr, "  ++ substitutions  ");
 294   for (i = 0; i < VARRAY_ACTIVE_SIZE (G.substitutions); ++i)
 295     {
 296       tree el = VARRAY_TREE (G.substitutions, i);
 297       const char *name = "???";
 298
 299       if (i > 0)
 300         fprintf (stderr, "                    ");
 301       if (DECL_P (el))
 302         name = IDENTIFIER_POINTER (DECL_NAME (el));
 303       else if (TREE_CODE (el) == TREE_LIST)
 304         name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
 305       else if (TYPE_NAME (el))
 306         name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el)));
 307       fprintf (stderr, " S%d_ = ", i - 1);
 308       if (TYPE_P (el) &&
 309           (CP_TYPE_RESTRICT_P (el)
 310            || CP_TYPE_VOLATILE_P (el)
 311            || CP_TYPE_CONST_P (el)))
 312         fprintf (stderr, "CV-");
 313       fprintf (stderr, "%s (%s at %p)\n",
 314                name, tree_code_name[TREE_CODE (el)], (void *) el);
 315     }
 316 }
 317
 318 /* Both decls and types can be substitution candidates, but sometimes
 319    they refer to the same thing.  For instance, a TYPE_DECL and
 320    RECORD_TYPE for the same class refer to the same thing, and should
 321    be treated accordinginly in substitutions.  This function returns a
 322    canonicalized tree node representing NODE that is used when adding
 323    and substitution candidates and finding matches.  */
 324
 325 static inline tree
 326 canonicalize_for_substitution (node)
 327      tree node;
 328 {
 329   /* For a TYPE_DECL, use the type instead.  */
 330   if (TREE_CODE (node) == TYPE_DECL)
 331     node = TREE_TYPE (node);
 332   if (TYPE_P (node))
 333     node = canonical_type_variant (node);
 334
 335   return node;
 336 }
 337
 338 /* Add NODE as a substitution candidate.  NODE must not already be on
 339    the list of candidates.  */
 340
 341 static void
 342 add_substitution (node)
 343      tree node;
 344 {
 345   tree c;
 346
 347   if (DEBUG_MANGLE)
 348     fprintf (stderr, "  ++ add_substitution (%s at %10p)\n",
 349              tree_code_name[TREE_CODE (node)], (void *) node);
 350
 351   /* Get the canonicalized substitution candidate for NODE.  */
 352   c = canonicalize_for_substitution (node);
 353   if (DEBUG_MANGLE && c != node)
 354     fprintf (stderr, "  ++ using candidate (%s at %10p)\n",
 355              tree_code_name[TREE_CODE (node)], (void *) node);
 356   node = c;
 357
 358 #if ENABLE_CHECKING
 359   /* Make sure NODE isn't already a candidate.  */
 360   {
 361     int i;
 362     for (i = VARRAY_ACTIVE_SIZE (G.substitutions); --i >= 0; )
 363       {
 364         tree candidate = VARRAY_TREE (G.substitutions, i);
 365         if ((DECL_P (node)
 366              && node == candidate)
 367             || (TYPE_P (node)
 368                 && TYPE_P (candidate)
 369                 && same_type_p (node, candidate)))
 370           abort ();
 371       }
 372   }
 373 #endif /* ENABLE_CHECKING */
 374
 375   /* Put the decl onto the varray of substitution candidates.  */
 376   VARRAY_PUSH_TREE (G.substitutions, node);
 377
 378   if (DEBUG_MANGLE)
 379     dump_substitution_candidates ();
 380 }
 381
 382 /* Helper function for find_substitution.  Returns non-zero if NODE,
 383    which may be a decl or a CLASS_TYPE, is a template-id with template
 384    name of substitution_index[INDEX] in the ::std namespace.  */
 385
 386 static inline int
 387 is_std_substitution (node, index)
 388      tree node;
 389      substitution_identifier_index_t index;
 390 {
 391   tree type = NULL;
 392   tree decl = NULL;
 393
 394   if (DECL_P (node))
 395     {
 396       type = TREE_TYPE (node);
 397       decl = node;
 398     }
 399   else if (CLASS_TYPE_P (node))
 400     {
 401       type = node;
 402       decl = TYPE_NAME (node);
 403     }
 404   else
 405     /* These are not the droids you're looking for.  */
 406     return 0;
 407
 408   return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
 409           && TYPE_LANG_SPECIFIC (type)
 410           && CLASSTYPE_TEMPLATE_INFO (type)
 411           && (DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
 412               == subst_identifiers[index]));
 413 }
 414
 415 /* Helper function for find_substitution.  Returns non-zero if NODE,
 416    which may be a decl or a CLASS_TYPE, is the template-id
 417    ::std::identifier<char>, where identifier is
 418    substitution_index[INDEX].  */
 419
 420 static inline int
 421 is_std_substitution_char (node, index)
 422      tree node;
 423      substitution_identifier_index_t index;
 424 {
 425   tree args;
 426   /* Check NODE's name is ::std::identifier.  */
 427   if (!is_std_substitution (node, index))
 428     return 0;
 429   /* Figure out its template args.  */
 430   if (DECL_P (node))
 431     args = DECL_TI_ARGS (node);
 432   else if (CLASS_TYPE_P (node))
 433     args = CLASSTYPE_TI_ARGS (node);
 434   else
 435     /* Oops, not a template.  */
 436     return 0;
 437   /* NODE's template arg list should be <char>.  */
 438   return
 439     TREE_VEC_LENGTH (args) == 1
 440     && TREE_VEC_ELT (args, 0) == char_type_node;
 441 }
 442
 443 /* Check whether a substitution should be used to represent NODE in
 444    the mangling.
 445
 446    First, check standard special-case substitutions.
 447
 448      <substitution> ::= St
 449          # ::std
 450
 451                     ::= Sa
 452          # ::std::allocator
 453
 454                     ::= Sb
 455          # ::std::basic_string
 456
 457                     ::= Ss
 458          # ::std::basic_string<char,
 459                                ::std::char_traits<char>,
 460                                ::std::allocator<char> >
 461
 462                     ::= Si
 463          # ::std::basic_istream<char, ::std::char_traits<char> >
 464
 465                     ::= So
 466          # ::std::basic_ostream<char, ::std::char_traits<char> >
 467
 468                     ::= Sd
 469          # ::std::basic_iostream<char, ::std::char_traits<char> >
 470
 471    Then examine the stack of currently available substitution
 472    candidates for entities appearing earlier in the same mangling
 473
 474    If a substitution is found, write its mangled representation and
 475    return non-zero.  If none is found, just return zero.  */
 476
 477 static int
 478 find_substitution (node)
 479      tree node;
 480 {
 481   int i;
 482   int size = VARRAY_ACTIVE_SIZE (G.substitutions);
 483   tree decl;
 484   tree type;
 485
 486   if (DEBUG_MANGLE)
 487     fprintf (stderr, "  ++ find_substitution (%s at %p)\n",
 488              tree_code_name[TREE_CODE (node)], (void *) node);
 489
 490   /* Obtain the canonicalized substitution representation for NODE.
 491      This is what we'll compare against.  */
 492   node = canonicalize_for_substitution (node);
 493
 494   /* Check for builtin substitutions.  */
 495
 496   decl = TYPE_P (node) ? TYPE_NAME (node) : node;
 497   type = TYPE_P (node) ? node : TREE_TYPE (node);
 498
 499   /* Check for std::allocator.  */
 500   if (decl
 501       && is_std_substitution (decl, SUBID_ALLOCATOR)
 502       && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
 503     {
 504       write_string ("Sa");
 505       return 1;
 506     }
 507
 508   /* Check for std::basic_string.  */
 509   if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
 510     {
 511       if (TYPE_P (node))
 512         {
 513           /* If this is a type (i.e. a fully-qualified template-id),
 514              check for
 515                  std::basic_string <char,
 516                                     std::char_traits<char>,
 517                                     std::allocator<char> > .  */
 518           if (cp_type_quals (type) == TYPE_UNQUALIFIED
 519               && CLASSTYPE_USE_TEMPLATE (type))
 520             {
 521               tree args = CLASSTYPE_TI_ARGS (type);
 522               if (TREE_VEC_LENGTH (args) == 3
 523                   && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 524                   && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 525                                                SUBID_CHAR_TRAITS)
 526                   && is_std_substitution_char (TREE_VEC_ELT (args, 2),
 527                                                SUBID_ALLOCATOR))
 528                 {
 529                   write_string ("Ss");
 530                   return 1;
 531                 }
 532             }
 533         }
 534       else
 535         /* Substitute for the template name only if this isn't a type.  */
 536         {
 537           write_string ("Sb");
 538           return 1;
 539         }
 540     }
 541
 542   /* Check for basic_{i,o,io}stream.  */
 543   if (TYPE_P (node)
 544       && cp_type_quals (type) == TYPE_UNQUALIFIED
 545       && CLASS_TYPE_P (type)
 546       && CLASSTYPE_USE_TEMPLATE (type)
 547       && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
 548     {
 549       /* First, check for the template
 550          args <char, std::char_traits<char> > .  */
 551       tree args = CLASSTYPE_TI_ARGS (type);
 552       if (TREE_VEC_LENGTH (args) == 2
 553           && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
 554           && is_std_substitution_char (TREE_VEC_ELT (args, 1),
 555                                        SUBID_CHAR_TRAITS))
 556         {
 557           /* Got them.  Is this basic_istream?  */
 558           tree name = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type));
 559           if (name == subst_identifiers[SUBID_BASIC_ISTREAM])
 560             {
 561               write_string ("Si");
 562               return 1;
 563             }
 564           /* Or basic_ostream?  */
 565           else if (name == subst_identifiers[SUBID_BASIC_OSTREAM])
 566             {
 567               write_string ("So");
 568               return 1;
 569             }
 570           /* Or basic_iostream?  */
 571           else if (name == subst_identifiers[SUBID_BASIC_IOSTREAM])
 572             {
 573               write_string ("Sd");
 574               return 1;
 575             }
 576         }
 577     }
 578
 579   /* Check for namespace std.  */
 580   if (decl && DECL_NAMESPACE_STD_P (decl))
 581     {
 582       write_string ("St");
 583       return 1;
 584     }
 585
 586   /* Now check the list of available substitutions for this mangling
 587      operation.    */
 588   for (i = 0; i < size; ++i)
 589     {
 590       tree candidate = VARRAY_TREE (G.substitutions, i);
 591       /* NODE is a matched to a candidate if it's the same decl node or
 592          if it's the same type.  */
 593       if (decl == candidate
 594           || (TYPE_P (candidate) && type && TYPE_P (type)
 595               && same_type_p (type, candidate))
 596           || NESTED_TEMPLATE_MATCH (node, candidate))
 597         {
 598           write_substitution (i);
 599           return 1;
 600         }
 601     }
 602
 603   /* No substitution found.  */
 604   return 0;
 605 }
 606
 607
 608 /*  <mangled-name>      ::= _Z <encoding>  */
 609
 610 static inline void
 611 write_mangled_name (decl)
 612      tree decl;
 613 {
 614   MANGLE_TRACE_TREE ("mangled-name", decl);
 615
 616   if (DECL_LANG_SPECIFIC (decl)
 617       && DECL_EXTERN_C_FUNCTION_P (decl)
 618       && ! DECL_OVERLOADED_OPERATOR_P (decl))
 619     /* The standard notes:
 620          "The <encoding> of an extern "C" function is treated like
 621          global-scope data, i.e. as its <source-name> without a type."
 622        We cannot write overloaded operators that way though,
 623        because it contains characters invalid in assembler.  */
 624     write_source_name (DECL_NAME (decl));
 625   else
 626     /* C++ name; needs to be mangled.  */
 627     {
 628       write_string ("_Z");
 629       write_encoding (decl);
 630     }
 631 }
 632
 633 /*   <encoding>         ::= <function name> <bare-function-type>
 634                         ::= <data name>  */
 635
 636 static void
 637 write_encoding (decl)
 638      tree decl;
 639 {
 640   MANGLE_TRACE_TREE ("encoding", decl);
 641
 642   if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
 643     {
 644       /* For overloaded operators write just the mangled name
 645          without arguments.  */
 646       if (DECL_OVERLOADED_OPERATOR_P (decl))
 647         write_name (decl, /*ignore_local_scope=*/0);
 648       else
 649         write_source_name (DECL_NAME (decl));
 650       return;
 651     }
 652
 653   write_name (decl, /*ignore_local_scope=*/0);
 654   if (TREE_CODE (decl) == FUNCTION_DECL)
 655     {
 656       tree fn_type;
 657
 658       if (decl_is_template_id (decl, NULL))
 659         fn_type = get_mostly_instantiated_function_type (decl, NULL, NULL);
 660       else
 661         fn_type = TREE_TYPE (decl);
 662
 663       write_bare_function_type (fn_type,
 664                                 (!DECL_CONSTRUCTOR_P (decl)
 665                                  && !DECL_DESTRUCTOR_P (decl)
 666                                  && !DECL_CONV_FN_P (decl)
 667                                  && decl_is_template_id (decl, NULL)),
 668                                 decl);
 669     }
 670 }
 671
 672 /* <name> ::= <unscoped-name>
 673           ::= <unscoped-template-name> <template-args>
 674           ::= <nested-name>
 675           ::= <local-name>
 676
 677    If IGNORE_LOCAL_SCOPE is non-zero, this production of <name> is
 678    called from <local-name>, which mangles the enclosing scope
 679    elsewhere and then uses this function to mangle just the part
 680    underneath the function scope.  So don't use the <local-name>
 681    production, to avoid an infinite recursion.  */
 682
 683 static void
 684 write_name (decl, ignore_local_scope)
 685      tree decl;
 686      int ignore_local_scope;
 687 {
 688   tree context;
 689
 690   MANGLE_TRACE_TREE ("name", decl);
 691
 692   if (TREE_CODE (decl) == TYPE_DECL)
 693     {
 694       /* In case this is a typedef, fish out the corresponding
 695          TYPE_DECL for the main variant.  */
 696       decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
 697       context = TYPE_CONTEXT (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
 698     }
 699   else
 700     context = (DECL_CONTEXT (decl) == NULL) ? NULL : CP_DECL_CONTEXT (decl);
 701
 702   /* A decl in :: or ::std scope is treated specially.  The former is
 703      mangled using <unscoped-name> or <unscoped-template-name>, the
 704      latter with a special substitution.  Also, a name that is
 705      directly in a local function scope is also mangled with
 706      <unscoped-name> rather than a full <nested-name>.  */
 707   if (context == NULL
 708       || context == global_namespace
 709       || DECL_NAMESPACE_STD_P (context)
 710       || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL))
 711     {
 712       tree template_info;
 713       /* Is this a template instance?  */
 714       if (decl_is_template_id (decl, &template_info))
 715         {
 716           /* Yes: use <unscoped-template-name>.  */
 717           write_unscoped_template_name (TI_TEMPLATE (template_info));
 718           write_template_args (TI_ARGS (template_info));
 719         }
 720       else
 721         /* Everything else gets an <unqualified-name>.  */
 722         write_unscoped_name (decl);
 723     }
 724   else
 725     {
 726       /* Handle local names, unless we asked not to (that is, invoked
 727          under <local-name>, to handle only the part of the name under
 728          the local scope).  */
 729       if (!ignore_local_scope)
 730         {
 731           /* Scan up the list of scope context, looking for a
 732              function.  If we find one, this entity is in local
 733              function scope.  local_entity tracks context one scope
 734              level down, so it will contain the element that's
 735              directly in that function's scope, either decl or one of
 736              its enclosing scopes.  */
 737           tree local_entity = decl;
 738           while (context != NULL && context != global_namespace)
 739             {
 740               /* Make sure we're always dealing with decls.  */
 741               if (context != NULL && TYPE_P (context))
 742                 context = TYPE_NAME (context);
 743               /* Is this a function?  */
 744               if (TREE_CODE (context) == FUNCTION_DECL)
 745                 {
 746                   /* Yes, we have local scope.  Use the <local-name>
 747                      production for the innermost function scope.  */
 748                   write_local_name (context, local_entity, decl);
 749                   return;
 750                 }
 751               /* Up one scope level.  */
 752               local_entity = context;
 753               context = CP_DECL_CONTEXT (context);
 754             }
 755
 756           /* No local scope found?  Fall through to <nested-name>.  */
 757         }
 758
 759       /* Other decls get a <nested-name> to encode their scope.  */
 760       write_nested_name (decl);
 761     }
 762 }
 763
 764 /* <unscoped-name> ::= <unqualified-name>
 765                    ::= St <unqualified-name>   # ::std::  */
 766
 767 static void
 768 write_unscoped_name (decl)
 769      tree decl;
 770 {
 771   tree context = CP_DECL_CONTEXT (decl);
 772
 773   MANGLE_TRACE_TREE ("unscoped-name", decl);
 774
 775   /* Is DECL in ::std?  */
 776   if (DECL_NAMESPACE_STD_P (context))
 777     {
 778       write_string ("St");
 779       write_unqualified_name (decl);
 780     }
 781   /* If not, it should be either in the global namespace, or directly
 782      in a local function scope.  */
 783   else if (context == global_namespace
 784            || context == NULL
 785            || TREE_CODE (context) == FUNCTION_DECL)
 786     write_unqualified_name (decl);
 787   else
 788     abort ();
 789 }
 790
 791 /* <unscoped-template-name> ::= <unscoped-name>
 792                             ::= <substitution>  */
 793
 794 static void
 795 write_unscoped_template_name (decl)
 796      tree decl;
 797 {
 798   MANGLE_TRACE_TREE ("unscoped-template-name", decl);
 799
 800   if (find_substitution (decl))
 801     return;
 802   write_unscoped_name (decl);
 803   add_substitution (decl);
 804 }
 805
 806 /* Write the nested name, including CV-qualifiers, of DECL.
 807
 808    <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
 809                  ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
 810
 811    <CV-qualifiers> ::= [r] [V] [K]  */
 812
 813 static void
 814 write_nested_name (decl)
 815      tree decl;
 816 {
 817   tree template_info;
 818
 819   MANGLE_TRACE_TREE ("nested-name", decl);
 820
 821   write_char ('N');
 822
 823   /* Write CV-qualifiers, if this is a member function.  */
 824   if (TREE_CODE (decl) == FUNCTION_DECL
 825       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
 826     {
 827       if (DECL_VOLATILE_MEMFUNC_P (decl))
 828         write_char ('V');
 829       if (DECL_CONST_MEMFUNC_P (decl))
 830         write_char ('K');
 831     }
 832
 833   /* Is this a template instance?  */
 834   if (decl_is_template_id (decl, &template_info))
 835     {
 836       /* Yes, use <template-prefix>.  */
 837       write_template_prefix (decl);
 838       write_template_args (TI_ARGS (template_info));
 839     }
 840   else
 841     {
 842       /* No, just use <prefix>  */
 843       write_prefix (DECL_CONTEXT (decl));
 844       write_unqualified_name (decl);
 845     }
 846   write_char ('E');
 847 }
 848
 849 /* <prefix> ::= <prefix> <unqualified-name>>
 850             ::= <template-prefix> <template-args>
 851             ::= # empty
 852             ::= <substitution>  */
 853
 854 static void
 855 write_prefix (node)
 856      tree node;
 857 {
 858   tree decl;
 859   /* Non-NULL if NODE represents a template-id.  */
 860   tree template_info = NULL;
 861
 862   MANGLE_TRACE_TREE ("prefix", node);
 863
 864   if (node == NULL
 865       || node == global_namespace)
 866     return;
 867
 868   if (find_substitution (node))
 869     return;
 870
 871   if (DECL_P (node))
 872     /* Node is a decl.  */
 873     {
 874       /* If this is a function decl, that means we've hit function
 875          scope, so this prefix must be for a local name.  In this
 876          case, we're under the <local-name> production, which encodes
 877          the enclosing function scope elsewhere.  So don't continue
 878          here.  */
 879       if (TREE_CODE (node) == FUNCTION_DECL)
 880         return;
 881
 882       decl = node;
 883       decl_is_template_id (decl, &template_info);
 884     }
 885   else
 886     /* Node is a type.  */
 887     {
 888       decl = TYPE_NAME (node);
 889       if (CLASSTYPE_TEMPLATE_ID_P (node))
 890         template_info = CLASSTYPE_TEMPLATE_INFO (node);
 891     }
 892
 893   if (template_info != NULL)
 894     /* Templated.  */
 895     {
 896       write_template_prefix (decl);
 897       write_template_args (TI_ARGS (template_info));
 898     }
 899   else
 900     /* Not templated.  */
 901     {
 902       write_prefix (CP_DECL_CONTEXT (decl));
 903       write_unqualified_name (decl);
 904     }
 905
 906   add_substitution (node);
 907 }
 908
 909 /* <template-prefix> ::= <prefix> <template component>
 910                      ::= <substitution>  */
 911
 912 static void
 913 write_template_prefix (node)
 914      tree node;
 915 {
 916   tree decl = DECL_P (node) ? node : TYPE_NAME (node);
 917   tree type = DECL_P (node) ? TREE_TYPE (node) : node;
 918   tree context = CP_DECL_CONTEXT (decl);
 919   tree template_info;
 920   tree template;
 921   tree substitution;
 922
 923   MANGLE_TRACE_TREE ("template-prefix", node);
 924
 925   /* Find the template decl.  */
 926   if (decl_is_template_id (decl, &template_info))
 927     template = TI_TEMPLATE (template_info);
 928   else if (CLASSTYPE_TEMPLATE_ID_P (type))
 929     template = CLASSTYPE_TI_TEMPLATE (type);
 930   else
 931     /* Oops, not a template.  */
 932     abort ();
 933
 934   /* For a member template, though, the template name for the
 935      innermost name must have all the outer template levels
 936      instantiated.  For instance, consider
 937
 938        template<typename T> struct Outer {
 939          template<typename U> struct Inner {};
 940        };
 941
 942      The template name for `Inner' in `Outer<int>::Inner<float>' is
 943      `Outer<int>::Inner<U>'.  In g++, we don't instantiate the template
 944      levels separately, so there's no TEMPLATE_DECL available for this
 945      (there's only `Outer<T>::Inner<U>').
 946
 947      In order to get the substitutions right, we create a special
 948      TREE_LIST to represent the substitution candidate for a nested
 949      template.  The TREE_PURPOSE is the template's context, fully
 950      instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
 951      template.
 952
 953      So, for the example above, `Outer<int>::Inner' is represented as a
 954      substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
 955      and whose value is `Outer<T>::Inner<U>'.  */
 956   if (TYPE_P (context))
 957     substitution = build_tree_list (context, template);
 958   else
 959     substitution = template;
 960
 961   if (find_substitution (substitution))
 962     return;
 963
 964   write_prefix (context);
 965   write_unqualified_name (decl);
 966
 967   add_substitution (substitution);
 968 }
 969
 970 /* We don't need to handle thunks, vtables, or VTTs here.  Those are
 971    mangled through special entry points.
 972
 973     <unqualified-name>  ::= <operator-name>
 974                         ::= <special-name>
 975                         ::= <source-name>  */
 976
 977 static void
 978 write_unqualified_name (decl)
 979      tree decl;
 980 {
 981   MANGLE_TRACE_TREE ("unqualified-name", decl);
 982
 983   if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_CONSTRUCTOR_P (decl))
 984     write_special_name_constructor (decl);
 985   else if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_DESTRUCTOR_P (decl))
 986     write_special_name_destructor (decl);
 987   else if (DECL_CONV_FN_P (decl))
 988     {
 989       /* Conversion operator. Handle it right here.
 990            <operator> ::= cv <type>  */
 991       tree type;
 992       if (decl_is_template_id (decl, NULL))
 993         {
 994           tree fn_type = get_mostly_instantiated_function_type (decl, NULL,
 995                                                                 NULL);
 996           type = TREE_TYPE (fn_type);
 997         }
 998       else
 999         type = TREE_TYPE (DECL_NAME (decl));
1000       write_string ("cv");
1001       write_type (type);
1002     }
1003   else if (DECL_OVERLOADED_OPERATOR_P (decl))
1004     {
1005       operator_name_info_t *oni;
1006       if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1007         oni = assignment_operator_name_info;
1008       else
1009         oni = operator_name_info;
1010
1011       write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1012     }
1013   else
1014     write_source_name (DECL_NAME (decl));
1015 }
1016
1017 /* Non-termial <source-name>.  IDENTIFIER is an IDENTIFIER_NODE.
1018
1019      <source-name> ::= </length/ number> <identifier>  */
1020
1021 static void
1022 write_source_name (identifier)
1023      tree identifier;
1024 {
1025   MANGLE_TRACE_TREE ("source-name", identifier);
1026
1027   /* Never write the whole template-id name including the template
1028      arguments; we only want the template name.  */
1029   if (IDENTIFIER_TEMPLATE (identifier))
1030     identifier = IDENTIFIER_TEMPLATE (identifier);
1031
1032   write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1033   write_identifier (IDENTIFIER_POINTER (identifier));
1034 }
1035
1036 /* Convert NUMBER to ascii using base BASE and generating at least
1037    MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1038    into which to store the characters. Returns the number of
1039    characters generated (these will be layed out in advance of where
1040    BUFFER points).  */
1041
1042 static int
1043 hwint_to_ascii (number, base, buffer, min_digits)
1044      unsigned HOST_WIDE_INT number;
1045      unsigned int base;
1046      char *buffer;
1047      unsigned min_digits;
1048 {
1049   static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1050   unsigned digits = 0;
1051
1052   while (number)
1053     {
1054       unsigned HOST_WIDE_INT d = number / base;
1055
1056       *--buffer = base_digits[number - d * base];
1057       digits++;
1058       number = d;
1059     }
1060   while (digits < min_digits)
1061     {
1062       *--buffer = base_digits[0];
1063       digits++;
1064     }
1065   return digits;
1066 }
1067
1068 /* Non-terminal <number>.
1069
1070      <number> ::= [n] </decimal integer/>  */
1071
1072 static void
1073 write_number (number, unsigned_p, base)
1074      unsigned HOST_WIDE_INT number;
1075      int unsigned_p;
1076      unsigned int base;
1077 {
1078   char buffer[sizeof (HOST_WIDE_INT) * 8];
1079   unsigned count = 0;
1080
1081   if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1082     {
1083       write_char ('n');
1084       number = -((HOST_WIDE_INT) number);
1085     }
1086   count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1087   write_chars (buffer + sizeof (buffer) - count, count);
1088 }
1089
1090 /* Write out an integral CST in decimal. Most numbers are small, and
1091    representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1092    bigger than that, which we must deal with. */
1093
1094 static inline void
1095 write_integer_cst (cst)
1096      tree cst;
1097 {
1098   int sign = tree_int_cst_sgn (cst);
1099
1100   if (TREE_INT_CST_HIGH (cst) + (sign < 0))
1101     {
1102       /* A bignum. We do this in chunks, each of which fits in a
1103          HOST_WIDE_INT. */
1104       char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1105       unsigned HOST_WIDE_INT chunk;
1106       unsigned chunk_digits;
1107       char *ptr = buffer + sizeof (buffer);
1108       unsigned count = 0;
1109       tree n, base, type;
1110       int done;
1111
1112       /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1113          representable. */
1114       chunk = 1000000000;
1115       chunk_digits = 9;
1116
1117       if (sizeof (HOST_WIDE_INT) >= 8)
1118         {
1119           /* It is at least 64 bits, so 10^18 is representable. */
1120           chunk_digits = 18;
1121           chunk *= chunk;
1122         }
1123
1124       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1125       base = build_int_2 (chunk, 0);
1126       n = build_int_2 (TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
1127       TREE_TYPE (n) = TREE_TYPE (base) = type;
1128
1129       if (sign < 0)
1130         {
1131           write_char ('n');
1132           n = fold (build1 (NEGATE_EXPR, type, n));
1133         }
1134       do
1135         {
1136           tree d = fold (build (FLOOR_DIV_EXPR, type, n, base));
1137           tree tmp = fold (build (MULT_EXPR, type, d, base));
1138           unsigned c;
1139
1140           done = integer_zerop (d);
1141           tmp = fold (build (MINUS_EXPR, type, n, tmp));
1142           c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1143                                 done ? 1 : chunk_digits);
1144           ptr -= c;
1145           count += c;
1146           n = d;
1147         }
1148       while (!done);
1149       write_chars (ptr, count);
1150     }
1151   else
1152     {
1153       /* A small num.  */
1154       unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
1155
1156       if (sign < 0)
1157         {
1158           write_char ('n');
1159           low = -low;
1160         }
1161       write_unsigned_number (low);
1162     }
1163 }
1164
1165 /* Non-terminal <identifier>.
1166
1167      <identifier> ::= </unqualified source code identifier>  */
1168
1169 static void
1170 write_identifier (identifier)
1171      const char *identifier;
1172 {
1173   MANGLE_TRACE ("identifier", identifier);
1174   write_string (identifier);
1175 }
1176
1177 /* Handle constructor productions of non-terminal <special-name>.
1178    CTOR is a constructor FUNCTION_DECL.
1179
1180      <special-name> ::= C1   # complete object constructor
1181                     ::= C2   # base object constructor
1182                     ::= C3   # complete object allocating constructor
1183
1184    Currently, allocating constructors are never used.
1185
1186    We also need to provide mangled names for the maybe-in-charge
1187    constructor, so we treat it here too.  mangle_decl_string will
1188    append *INTERNAL* to that, to make sure we never emit it.  */
1189
1190 static void
1191 write_special_name_constructor (ctor)
1192      tree ctor;
1193 {
1194   if (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1195       /* Even though we don't ever emit a definition of the
1196          old-style destructor, we still have to consider entities
1197          (like static variables) nested inside it.  */
1198       || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
1199     write_string ("C1");
1200   else if (DECL_BASE_CONSTRUCTOR_P (ctor))
1201     write_string ("C2");
1202   else
1203     abort ();
1204 }
1205
1206 /* Handle destructor productions of non-terminal <special-name>.
1207    DTOR is a destructor FUNCTION_DECL.
1208
1209      <special-name> ::= D0 # deleting (in-charge) destructor
1210                     ::= D1 # complete object (in-charge) destructor
1211                     ::= D2 # base object (not-in-charge) destructor
1212
1213    We also need to provide mangled names for the maybe-incharge
1214    destructor, so we treat it here too.  mangle_decl_string will
1215    append *INTERNAL* to that, to make sure we never emit it.  */
1216
1217 static void
1218 write_special_name_destructor (dtor)
1219      tree dtor;
1220 {
1221   if (DECL_DELETING_DESTRUCTOR_P (dtor))
1222     write_string ("D0");
1223   else if (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1224            /* Even though we don't ever emit a definition of the
1225               old-style destructor, we still have to consider entities
1226               (like static variables) nested inside it.  */
1227            || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
1228     write_string ("D1");
1229   else if (DECL_BASE_DESTRUCTOR_P (dtor))
1230     write_string ("D2");
1231   else
1232     abort ();
1233 }
1234
1235 /* Return the discriminator for ENTITY appearing inside
1236    FUNCTION.  The discriminator is the lexical ordinal of VAR among
1237    entities with the same name in the same FUNCTION.  */
1238
1239 static int
1240 discriminator_for_local_entity (entity)
1241      tree entity;
1242 {
1243   tree *type;
1244   int discriminator;
1245
1246   /* Assume this is the only local entity with this name.  */
1247   discriminator = 0;
1248
1249   if (DECL_DISCRIMINATOR_P (entity) && DECL_LANG_SPECIFIC (entity))
1250     discriminator = DECL_DISCRIMINATOR (entity);
1251   else if (TREE_CODE (entity) == TYPE_DECL)
1252     {
1253       /* Scan the list of local classes.  */
1254       entity = TREE_TYPE (entity);
1255       for (type = &VARRAY_TREE (local_classes, 0); *type != entity; ++type)
1256         if (TYPE_IDENTIFIER (*type) == TYPE_IDENTIFIER (entity)
1257             && TYPE_CONTEXT (*type) == TYPE_CONTEXT (entity))
1258           ++discriminator;
1259     }
1260
1261   return discriminator;
1262 }
1263
1264 /* Return the discriminator for STRING, a string literal used inside
1265    FUNCTION.  The disciminator is the lexical ordinal of STRING among
1266    string literals used in FUNCTION.  */
1267
1268 static int
1269 discriminator_for_string_literal (function, string)
1270      tree function ATTRIBUTE_UNUSED;
1271      tree string ATTRIBUTE_UNUSED;
1272 {
1273   /* For now, we don't discriminate amongst string literals.  */
1274   return 0;
1275 }
1276
1277 /*   <discriminator> := _ <number>
1278
1279    The discriminator is used only for the second and later occurrences
1280    of the same name within a single function. In this case <number> is
1281    n - 2, if this is the nth occurrence, in lexical order.  */
1282
1283 static void
1284 write_discriminator (discriminator)
1285      int discriminator;
1286 {
1287   /* If discriminator is zero, don't write anything.  Otherwise... */
1288   if (discriminator > 0)
1289     {
1290       write_char ('_');
1291       write_unsigned_number (discriminator - 1);
1292     }
1293 }
1294
1295 /* Mangle the name of a function-scope entity.  FUNCTION is the
1296    FUNCTION_DECL for the enclosing function.  ENTITY is the decl for
1297    the entity itself.  LOCAL_ENTITY is the entity that's directly
1298    scoped in FUNCTION_DECL, either ENTITY itself or an enclosing scope
1299    of ENTITY.
1300
1301      <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1302                   := Z <function encoding> E s [<discriminator>]  */
1303
1304 static void
1305 write_local_name (function, local_entity, entity)
1306      tree function;
1307      tree local_entity;
1308      tree entity;
1309 {
1310   MANGLE_TRACE_TREE ("local-name", entity);
1311
1312   write_char ('Z');
1313   write_encoding (function);
1314   write_char ('E');
1315   if (TREE_CODE (entity) == STRING_CST)
1316     {
1317       write_char ('s');
1318       write_discriminator (discriminator_for_string_literal (function,
1319                                                              entity));
1320     }
1321   else
1322     {
1323       /* Now the <entity name>.  Let write_name know its being called
1324          from <local-name>, so it doesn't try to process the enclosing
1325          function scope again.  */
1326       write_name (entity, /*ignore_local_scope=*/1);
1327       write_discriminator (discriminator_for_local_entity (local_entity));
1328     }
1329 }
1330
1331 /* Non-terminals <type> and <CV-qualifier>.
1332
1333      <type> ::= <builtin-type>
1334             ::= <function-type>
1335             ::= <class-enum-type>
1336             ::= <array-type>
1337             ::= <pointer-to-member-type>
1338             ::= <template-param>
1339             ::= <substitution>
1340             ::= <CV-qualifier>
1341             ::= P <type>    # pointer-to
1342             ::= R <type>    # reference-to
1343             ::= C <type>    # complex pair (C 2000)
1344             ::= G <type>    # imaginary (C 2000)     [not supported]
1345             ::= U <source-name> <type>   # vendor extended type qualifier
1346
1347    TYPE is a type node.  */
1348
1349 static void
1350 write_type (type)
1351      tree type;
1352 {
1353   /* This gets set to non-zero if TYPE turns out to be a (possibly
1354      CV-qualified) builtin type.  */
1355   int is_builtin_type = 0;
1356
1357   MANGLE_TRACE_TREE ("type", type);
1358
1359   if (type == error_mark_node)
1360     return;
1361
1362   if (find_substitution (type))
1363     return;
1364
1365   if (write_CV_qualifiers_for_type (type) > 0)
1366     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1367        mangle the unqualified type.  The recursive call is needed here
1368        since both the qualified and uqualified types are substitution
1369        candidates.  */
1370     write_type (TYPE_MAIN_VARIANT (type));
1371   else if (TREE_CODE (type) == ARRAY_TYPE)
1372     /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1373        so that the cv-qualification of the element type is available
1374        in write_array_type.  */
1375     write_array_type (type);
1376   else
1377     {
1378       /* See through any typedefs.  */
1379       type = TYPE_MAIN_VARIANT (type);
1380
1381       switch (TREE_CODE (type))
1382         {
1383         case VOID_TYPE:
1384         case BOOLEAN_TYPE:
1385         case INTEGER_TYPE:  /* Includes wchar_t.  */
1386         case REAL_TYPE:
1387           /* If this is a typedef, TYPE may not be one of
1388              the standard builtin type nodes, but an alias of one.  Use
1389              TYPE_MAIN_VARIANT to get to the underlying builtin type.  */
1390           write_builtin_type (TYPE_MAIN_VARIANT (type));
1391           ++is_builtin_type;
1392           break;
1393
1394         case COMPLEX_TYPE:
1395           write_char ('C');
1396           write_type (TREE_TYPE (type));
1397           break;
1398
1399         case FUNCTION_TYPE:
1400         case METHOD_TYPE:
1401           write_function_type (type);
1402           break;
1403
1404         case UNION_TYPE:
1405         case RECORD_TYPE:
1406         case ENUMERAL_TYPE:
1407           /* A pointer-to-member function is represented as a special
1408              RECORD_TYPE, so check for this first.  */
1409           if (TYPE_PTRMEMFUNC_P (type))
1410             write_pointer_to_member_type (type);
1411           else
1412             write_class_enum_type (type);
1413           break;
1414
1415         case TYPENAME_TYPE:
1416         case UNBOUND_CLASS_TEMPLATE:
1417           /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1418              ordinary nested names.  */
1419           write_nested_name (TYPE_STUB_DECL (type));
1420           break;
1421
1422         case POINTER_TYPE:
1423           /* A pointer-to-member variable is represented by a POINTER_TYPE
1424              to an OFFSET_TYPE, so check for this first.  */
1425           if (TYPE_PTRMEM_P (type))
1426             write_pointer_to_member_type (type);
1427           else
1428             {
1429               write_char ('P');
1430               write_type (TREE_TYPE (type));
1431             }
1432           break;
1433
1434         case REFERENCE_TYPE:
1435           write_char ('R');
1436           write_type (TREE_TYPE (type));
1437           break;
1438
1439         case TEMPLATE_TYPE_PARM:
1440         case TEMPLATE_PARM_INDEX:
1441           write_template_param (type);
1442           break;
1443
1444         case TEMPLATE_TEMPLATE_PARM:
1445           write_template_template_param (type);
1446           break;
1447
1448         case BOUND_TEMPLATE_TEMPLATE_PARM:
1449           write_template_template_param (type);
1450           write_template_args
1451             (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1452           break;
1453
1454         case OFFSET_TYPE:
1455           write_pointer_to_member_type (build_pointer_type (type));
1456           break;
1457
1458         case VECTOR_TYPE:
1459           write_string ("U8__vector");
1460           write_type (TREE_TYPE (type));
1461           break;
1462
1463         default:
1464           abort ();
1465         }
1466     }
1467
1468   /* Types other than builtin types are substitution candidates.  */
1469   if (!is_builtin_type)
1470     add_substitution (type);
1471 }
1472
1473 /* Non-terminal <CV-qualifiers> for type nodes.  Returns the number of
1474    CV-qualifiers written for TYPE.
1475
1476      <CV-qualifiers> ::= [r] [V] [K]  */
1477
1478 static int
1479 write_CV_qualifiers_for_type (type)
1480      tree type;
1481 {
1482   int num_qualifiers = 0;
1483
1484   /* The order is specified by:
1485
1486        "In cases where multiple order-insensitive qualifiers are
1487        present, they should be ordered 'K' (closest to the base type),
1488        'V', 'r', and 'U' (farthest from the base type) ..."
1489
1490      Note that we do not use cp_type_quals below; given "const
1491      int[3]", the "const" is emitted with the "int", not with the
1492      array.  */
1493
1494   if (TYPE_QUALS (type) & TYPE_QUAL_RESTRICT)
1495     {
1496       write_char ('r');
1497       ++num_qualifiers;
1498     }
1499   if (TYPE_QUALS (type) & TYPE_QUAL_VOLATILE)
1500     {
1501       write_char ('V');
1502       ++num_qualifiers;
1503     }
1504   if (TYPE_QUALS (type) & TYPE_QUAL_CONST)
1505     {
1506       write_char ('K');
1507       ++num_qualifiers;
1508     }
1509
1510   return num_qualifiers;
1511 }
1512
1513 /* Non-terminal <builtin-type>.
1514
1515      <builtin-type> ::= v   # void
1516                     ::= b   # bool
1517                     ::= w   # wchar_t
1518                     ::= c   # char
1519                     ::= a   # signed char
1520                     ::= h   # unsigned char
1521                     ::= s   # short
1522                     ::= t   # unsigned short
1523                     ::= i   # int
1524                     ::= j   # unsigned int
1525                     ::= l   # long
1526                     ::= m   # unsigned long
1527                     ::= x   # long long, __int64
1528                     ::= y   # unsigned long long, __int64
1529                     ::= n   # __int128
1530                     ::= o   # unsigned __int128
1531                     ::= f   # float
1532                     ::= d   # double
1533                     ::= e   # long double, __float80
1534                     ::= g   # __float128          [not supported]
1535                     ::= u <source-name>  # vendor extended type */
1536
1537 static void
1538 write_builtin_type (type)
1539      tree type;
1540 {
1541   switch (TREE_CODE (type))
1542     {
1543     case VOID_TYPE:
1544       write_char ('v');
1545       break;
1546
1547     case BOOLEAN_TYPE:
1548       write_char ('b');
1549       break;
1550
1551     case INTEGER_TYPE:
1552       /* If this is size_t, get the underlying int type.  */
1553       if (TYPE_IS_SIZETYPE (type))
1554         type = TYPE_DOMAIN (type);
1555
1556       /* TYPE may still be wchar_t, since that isn't in
1557          integer_type_nodes.  */
1558       if (type == wchar_type_node)
1559         write_char ('w');
1560       else if (TYPE_FOR_JAVA (type))
1561         write_java_integer_type_codes (type);
1562       else
1563         {
1564           size_t itk;
1565           /* Assume TYPE is one of the shared integer type nodes.  Find
1566              it in the array of these nodes.  */
1567         iagain:
1568           for (itk = 0; itk < itk_none; ++itk)
1569             if (type == integer_types[itk])
1570               {
1571                 /* Print the corresponding single-letter code.  */
1572                 write_char (integer_type_codes[itk]);
1573                 break;
1574               }
1575
1576           if (itk == itk_none)
1577             {
1578               tree t = c_common_type_for_mode (TYPE_MODE (type),
1579                                                TREE_UNSIGNED (type));
1580               if (type == t)
1581                 {
1582                   if (TYPE_PRECISION (type) == 128)
1583                     write_char (TREE_UNSIGNED (type) ? 'o' : 'n');
1584                   else
1585                     /* Couldn't find this type.  */
1586                     abort ();
1587                 }
1588               else
1589                 {
1590                   type = t;
1591                   goto iagain;
1592                 }
1593             }
1594         }
1595       break;
1596
1597     case REAL_TYPE:
1598       if (type == float_type_node
1599           || type == java_float_type_node)
1600         write_char ('f');
1601       else if (type == double_type_node
1602                || type == java_double_type_node)
1603         write_char ('d');
1604       else if (type == long_double_type_node)
1605         write_char ('e');
1606       else
1607         abort ();
1608       break;
1609
1610     default:
1611       abort ();
1612     }
1613 }
1614
1615 /* Non-terminal <function-type>.  NODE is a FUNCTION_TYPE or
1616    METHOD_TYPE.  The return type is mangled before the parameter
1617    types.
1618
1619      <function-type> ::= F [Y] <bare-function-type> E   */
1620
1621 static void
1622 write_function_type (type)
1623      tree type;
1624 {
1625   MANGLE_TRACE_TREE ("function-type", type);
1626
1627   /* For a pointer to member function, the function type may have
1628      cv-qualifiers, indicating the quals for the artificial 'this'
1629      parameter.  */
1630   if (TREE_CODE (type) == METHOD_TYPE)
1631     {
1632       /* The first parameter must be a POINTER_TYPE pointing to the
1633          `this' parameter.  */
1634       tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
1635       write_CV_qualifiers_for_type (this_type);
1636     }
1637
1638   write_char ('F');
1639   /* We don't track whether or not a type is `extern "C"'.  Note that
1640      you can have an `extern "C"' function that does not have
1641      `extern "C"' type, and vice versa:
1642
1643        extern "C" typedef void function_t();
1644        function_t f; // f has C++ linkage, but its type is
1645                      // `extern "C"'
1646
1647        typedef void function_t();
1648        extern "C" function_t f; // Vice versa.
1649
1650      See [dcl.link].  */
1651   write_bare_function_type (type, /*include_return_type_p=*/1,
1652                             /*decl=*/NULL);
1653   write_char ('E');
1654 }
1655
1656 /* Non-terminal <bare-function-type>.  TYPE is a FUNCTION_TYPE or
1657    METHOD_TYPE.  If INCLUDE_RETURN_TYPE is non-zero, the return value
1658    is mangled before the parameter types.  If non-NULL, DECL is
1659    FUNCTION_DECL for the function whose type is being emitted.
1660
1661      <bare-function-type> ::= </signature/ type>+  */
1662
1663 static void
1664 write_bare_function_type (type, include_return_type_p, decl)
1665      tree type;
1666      int include_return_type_p;
1667      tree decl;
1668 {
1669   MANGLE_TRACE_TREE ("bare-function-type", type);
1670
1671   /* Mangle the return type, if requested.  */
1672   if (include_return_type_p)
1673     write_type (TREE_TYPE (type));
1674
1675   /* Now mangle the types of the arguments.  */
1676   write_method_parms (TYPE_ARG_TYPES (type),
1677                       TREE_CODE (type) == METHOD_TYPE,
1678                       decl);
1679 }
1680
1681 /* Write the mangled representation of a method parameter list of
1682    types given in PARM_TYPES.  If METHOD_P is non-zero, the function is
1683    considered a non-static method, and the this parameter is omitted.
1684    If non-NULL, DECL is the FUNCTION_DECL for the function whose
1685    parameters are being emitted.  */
1686
1687 static void
1688 write_method_parms (parm_types, method_p, decl)
1689      tree decl;
1690      tree parm_types;
1691      int method_p;
1692 {
1693   tree first_parm_type;
1694   tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
1695
1696   /* Assume this parameter type list is variable-length.  If it ends
1697      with a void type, then it's not.  */
1698   int varargs_p = 1;
1699
1700   /* If this is a member function, skip the first arg, which is the
1701      this pointer.
1702        "Member functions do not encode the type of their implicit this
1703        parameter."
1704
1705      Similarly, there's no need to mangle artificial parameters, like
1706      the VTT parameters for constructors and destructors.  */
1707   if (method_p)
1708     {
1709       parm_types = TREE_CHAIN (parm_types);
1710       parm_decl = parm_decl ? TREE_CHAIN (parm_decl) : NULL_TREE;
1711
1712       while (parm_decl && DECL_ARTIFICIAL (parm_decl))
1713         {
1714           parm_types = TREE_CHAIN (parm_types);
1715           parm_decl = TREE_CHAIN (parm_decl);
1716         }
1717     }
1718
1719   for (first_parm_type = parm_types;
1720        parm_types;
1721        parm_types = TREE_CHAIN (parm_types))
1722     {
1723       tree parm = TREE_VALUE (parm_types);
1724       if (parm == void_type_node)
1725         {
1726           /* "Empty parameter lists, whether declared as () or
1727              conventionally as (void), are encoded with a void parameter
1728              (v)."  */
1729           if (parm_types == first_parm_type)
1730             write_type (parm);
1731           /* If the parm list is terminated with a void type, it's
1732              fixed-length.  */
1733           varargs_p = 0;
1734           /* A void type better be the last one.  */
1735           my_friendly_assert (TREE_CHAIN (parm_types) == NULL, 20000523);
1736         }
1737       else
1738         write_type (parm);
1739     }
1740
1741   if (varargs_p)
1742     /* <builtin-type> ::= z  # ellipsis  */
1743     write_char ('z');
1744 }
1745
1746 /* <class-enum-type> ::= <name>  */
1747
1748 static void
1749 write_class_enum_type (type)
1750      tree type;
1751 {
1752   write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
1753 }
1754
1755 /* Non-terminal <template-args>.  ARGS is a TREE_VEC of template
1756    arguments.
1757
1758      <template-args> ::= I <template-arg>+ E  */
1759
1760 static void
1761 write_template_args (args)
1762      tree args;
1763 {
1764   int i;
1765   int length = TREE_VEC_LENGTH (args);
1766
1767   MANGLE_TRACE_TREE ("template-args", args);
1768
1769   my_friendly_assert (length > 0, 20000422);
1770
1771   if (TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
1772     {
1773       /* We have nested template args.  We want the innermost template
1774          argument list.  */
1775       args = TREE_VEC_ELT (args, length - 1);
1776       length = TREE_VEC_LENGTH (args);
1777     }
1778
1779   write_char ('I');
1780   for (i = 0; i < length; ++i)
1781     write_template_arg (TREE_VEC_ELT (args, i));
1782   write_char ('E');
1783 }
1784
1785 /* <expression> ::= <unary operator-name> <expression>
1786                 ::= <binary operator-name> <expression> <expression>
1787                 ::= <expr-primary>
1788
1789    <expr-primary> ::= <template-param>
1790                   ::= L <type> <value number> E  # literal
1791                   ::= L <mangled-name> E         # external name  */
1792
1793 static void
1794 write_expression (expr)
1795      tree expr;
1796 {
1797   enum tree_code code;
1798
1799   code = TREE_CODE (expr);
1800
1801   /* Handle pointers-to-members by making them look like expression
1802      nodes.  */
1803   if (code == PTRMEM_CST)
1804     {
1805       expr = build_nt (ADDR_EXPR,
1806                        build_nt (SCOPE_REF,
1807                                  PTRMEM_CST_CLASS (expr),
1808                                  PTRMEM_CST_MEMBER (expr)));
1809       code = TREE_CODE (expr);
1810     }
1811
1812   /* Skip NOP_EXPRs.  They can occur when (say) a pointer argument
1813      is converted (via qualification conversions) to another
1814      type.  */
1815   while (TREE_CODE (expr) == NOP_EXPR
1816          || TREE_CODE (expr) == NON_LVALUE_EXPR)
1817     {
1818       expr = TREE_OPERAND (expr, 0);
1819       code = TREE_CODE (expr);
1820     }
1821
1822   /* Handle template parameters. */
1823   if (code == TEMPLATE_TYPE_PARM
1824       || code == TEMPLATE_TEMPLATE_PARM
1825       || code == BOUND_TEMPLATE_TEMPLATE_PARM
1826       || code == TEMPLATE_PARM_INDEX)
1827     write_template_param (expr);
1828   /* Handle literals.  */
1829   else if (TREE_CODE_CLASS (code) == 'c')
1830     write_template_arg_literal (expr);
1831   else if (DECL_P (expr))
1832     {
1833       write_char ('L');
1834       write_mangled_name (expr);
1835       write_char ('E');
1836     }
1837   else if (TREE_CODE (expr) == SIZEOF_EXPR
1838            && TYPE_P (TREE_OPERAND (expr, 0)))
1839     {
1840       write_string ("st");
1841       write_type (TREE_OPERAND (expr, 0));
1842     }
1843   else
1844     {
1845       int i;
1846
1847       /* When we bind a variable or function to a non-type template
1848          argument with reference type, we create an ADDR_EXPR to show
1849          the fact that the entity's address has been taken.  But, we
1850          don't actually want to output a mangling code for the `&'.  */
1851       if (TREE_CODE (expr) == ADDR_EXPR
1852           && TREE_TYPE (expr)
1853           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
1854         {
1855           expr = TREE_OPERAND (expr, 0);
1856           if (DECL_P (expr))
1857             {
1858               write_expression (expr);
1859               return;
1860             }
1861
1862           code = TREE_CODE (expr);
1863         }
1864
1865       /* If it wasn't any of those, recursively expand the expression.  */
1866       write_string (operator_name_info[(int) code].mangled_name);
1867
1868       switch (code)
1869         {
1870         case CAST_EXPR:
1871           write_type (TREE_TYPE (expr));
1872           write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
1873           break;
1874
1875         case STATIC_CAST_EXPR:
1876         case CONST_CAST_EXPR:
1877           write_type (TREE_TYPE (expr));
1878           write_expression (TREE_OPERAND (expr, 0));
1879           break;
1880
1881
1882         /* Handle pointers-to-members specially.  */
1883         case SCOPE_REF:
1884           write_type (TREE_OPERAND (expr, 0));
1885           if (TREE_CODE (TREE_OPERAND (expr, 1)) == IDENTIFIER_NODE)
1886             write_source_name (TREE_OPERAND (expr, 1));
1887           else
1888             write_encoding (TREE_OPERAND (expr, 1));
1889           break;
1890
1891         default:
1892           for (i = 0; i < TREE_CODE_LENGTH (code); ++i)
1893             write_expression (TREE_OPERAND (expr, i));
1894         }
1895     }
1896 }
1897
1898 /* Literal subcase of non-terminal <template-arg>.
1899
1900      "Literal arguments, e.g. "A<42L>", are encoded with their type
1901      and value. Negative integer values are preceded with "n"; for
1902      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
1903      encoded as 0, true as 1. If floating-point arguments are accepted
1904      as an extension, their values should be encoded using a
1905      fixed-length lowercase hexadecimal string corresponding to the
1906      internal representation (IEEE on IA-64), high-order bytes first,
1907      without leading zeroes. For example: "Lfbff000000E" is -1.0f."  */
1908
1909 static void
1910 write_template_arg_literal (value)
1911      tree value;
1912 {
1913   tree type = TREE_TYPE (value);
1914   write_char ('L');
1915   write_type (type);
1916
1917   if (TREE_CODE (value) == CONST_DECL)
1918     write_integer_cst (DECL_INITIAL (value));
1919   else if (TREE_CODE (value) == INTEGER_CST)
1920     {
1921       if (same_type_p (type, boolean_type_node))
1922         {
1923           if (value == boolean_false_node || integer_zerop (value))
1924             write_unsigned_number (0);
1925           else if (value == boolean_true_node)
1926             write_unsigned_number (1);
1927           else
1928             abort ();
1929         }
1930       else
1931         write_integer_cst (value);
1932     }
1933   else if (TREE_CODE (value) == REAL_CST)
1934     {
1935 #ifdef CROSS_COMPILE
1936       static int explained;
1937
1938       if (!explained)
1939         {
1940           sorry ("real-valued template parameters when cross-compiling");
1941           explained = 1;
1942         }
1943 #else
1944       size_t i;
1945       for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1946         write_number (((unsigned char *)
1947                        &TREE_REAL_CST (value))[i],
1948                       /*unsigned_p=*/1,
1949                       16);
1950 #endif
1951     }
1952   else
1953     abort ();
1954
1955   write_char ('E');
1956 }
1957
1958 /* Non-terminal <tempalate-arg>.
1959
1960      <template-arg> ::= <type>                        # type
1961                     ::= L <type> </value/ number> E   # literal
1962                     ::= LZ <name> E                   # external name
1963                     ::= X <expression> E              # expression  */
1964
1965 static void
1966 write_template_arg (node)
1967      tree node;
1968 {
1969   enum tree_code code = TREE_CODE (node);
1970
1971   MANGLE_TRACE_TREE ("template-arg", node);
1972
1973   /* A template template paramter's argument list contains TREE_LIST
1974      nodes of which the value field is the the actual argument.  */
1975   if (code == TREE_LIST)
1976     {
1977       node = TREE_VALUE (node);
1978       /* If it's a decl, deal with its type instead.  */
1979       if (DECL_P (node))
1980         {
1981           node = TREE_TYPE (node);
1982           code = TREE_CODE (node);
1983         }
1984     }
1985
1986   if (TYPE_P (node))
1987     write_type (node);
1988   else if (code == TEMPLATE_DECL)
1989     /* A template appearing as a template arg is a template template arg.  */
1990     write_template_template_arg (node);
1991   else if (DECL_P (node))
1992     {
1993       write_char ('L');
1994       write_char ('Z');
1995       write_encoding (node);
1996       write_char ('E');
1997     }
1998   else if (TREE_CODE_CLASS (code) == 'c' && code != PTRMEM_CST)
1999     write_template_arg_literal (node);
2000   else
2001     {
2002       /* Template arguments may be expressions.  */
2003       write_char ('X');
2004       write_expression (node);
2005       write_char ('E');
2006     }
2007 }
2008
2009 /*  <template-template-arg>
2010                         ::= <name>
2011                         ::= <substitution>  */
2012
2013 void
2014 write_template_template_arg (tree decl)
2015 {
2016   MANGLE_TRACE_TREE ("template-template-arg", decl);
2017
2018   if (find_substitution (decl))
2019     return;
2020   write_name (decl, /*ignore_local_scope=*/0);
2021   add_substitution (decl);
2022 }
2023
2024
2025 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2026
2027      <array-type> ::= A [</dimension/ number>] _ </element/ type>
2028                   ::= A <expression> _ </element/ type>
2029
2030      "Array types encode the dimension (number of elements) and the
2031      element type. For variable length arrays, the dimension (but not
2032      the '_' separator) is omitted."  */
2033
2034 static void
2035 write_array_type (type)
2036   tree type;
2037 {
2038   write_char ('A');
2039   if (TYPE_DOMAIN (type))
2040     {
2041       tree index_type;
2042       tree max;
2043
2044       index_type = TYPE_DOMAIN (type);
2045       /* The INDEX_TYPE gives the upper and lower bounds of the
2046          array.  */
2047       max = TYPE_MAX_VALUE (index_type);
2048       if (TREE_CODE (max) == INTEGER_CST)
2049         {
2050           /* The ABI specifies that we should mangle the number of
2051              elements in the array, not the largest allowed index.  */
2052           max = size_binop (PLUS_EXPR, max, size_one_node);
2053           write_unsigned_number (tree_low_cst (max, 1));
2054         }
2055       else
2056         write_expression (TREE_OPERAND (max, 0));
2057     }
2058   write_char ('_');
2059   write_type (TREE_TYPE (type));
2060 }
2061
2062 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2063    variables.  TYPE is a pointer-to-member POINTER_TYPE.
2064
2065      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2066
2067 static void
2068 write_pointer_to_member_type (type)
2069      tree type;
2070 {
2071   write_char ('M');
2072   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2073   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2074 }
2075
2076 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2077    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2078    TEMPLATE_PARM_INDEX.
2079
2080      <template-param> ::= T </parameter/ number> _
2081
2082    If we are internally mangling then we distinguish level and, for
2083    non-type parms, type too. The mangling appends
2084
2085      </level/ number> _ </non-type type/ type> _
2086
2087    This is used by mangle_conv_op_name_for_type.  */
2088
2089 static void
2090 write_template_param (parm)
2091      tree parm;
2092 {
2093   int parm_index;
2094   int parm_level;
2095   tree parm_type = NULL_TREE;
2096
2097   MANGLE_TRACE_TREE ("template-parm", parm);
2098
2099   switch (TREE_CODE (parm))
2100     {
2101     case TEMPLATE_TYPE_PARM:
2102     case TEMPLATE_TEMPLATE_PARM:
2103     case BOUND_TEMPLATE_TEMPLATE_PARM:
2104       parm_index = TEMPLATE_TYPE_IDX (parm);
2105       parm_level = TEMPLATE_TYPE_LEVEL (parm);
2106       break;
2107
2108     case TEMPLATE_PARM_INDEX:
2109       parm_index = TEMPLATE_PARM_IDX (parm);
2110       parm_level = TEMPLATE_PARM_LEVEL (parm);
2111       parm_type = TREE_TYPE (TEMPLATE_PARM_DECL (parm));
2112       break;
2113
2114     default:
2115       abort ();
2116     }
2117
2118   write_char ('T');
2119   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2120      earliest template param denoted by `_'.  */
2121   if (parm_index > 0)
2122     write_unsigned_number (parm_index - 1);
2123   write_char ('_');
2124   if (G.internal_mangling_p)
2125     {
2126       if (parm_level > 0)
2127         write_unsigned_number (parm_level - 1);
2128       write_char ('_');
2129       if (parm_type)
2130         write_type (parm_type);
2131       write_char ('_');
2132     }
2133 }
2134
2135 /*  <template-template-param>
2136                         ::= <template-param>
2137                         ::= <substitution>  */
2138
2139 static void
2140 write_template_template_param (parm)
2141      tree parm;
2142 {
2143   tree template = NULL_TREE;
2144
2145   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2146      template template parameter.  The substitution candidate here is
2147      only the template.  */
2148   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2149     {
2150       template
2151         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2152       if (find_substitution (template))
2153         return;
2154     }
2155
2156   /* <template-param> encodes only the template parameter position,
2157      not its template arguments, which is fine here.  */
2158   write_template_param (parm);
2159   if (template)
2160     add_substitution (template);
2161 }
2162
2163 /* Non-terminal <substitution>.
2164
2165       <substitution> ::= S <seq-id> _
2166                      ::= S_  */
2167
2168 static void
2169 write_substitution (seq_id)
2170      int seq_id;
2171 {
2172   MANGLE_TRACE ("substitution", "");
2173
2174   write_char ('S');
2175   if (seq_id > 0)
2176     write_number (seq_id - 1, /*unsigned=*/1, 36);
2177   write_char ('_');
2178 }
2179
2180 /* Start mangling a new name or type.  */
2181
2182 static inline void
2183 start_mangling ()
2184 {
2185   VARRAY_TREE_INIT (G.substitutions, 1, "mangling substitutions");
2186   obstack_free (&G.name_obstack, obstack_base (&G.name_obstack));
2187 }
2188
2189 /* Done with mangling.  Return the generated mangled name.  */
2190
2191 static inline const char *
2192 finish_mangling ()
2193 {
2194   /* Clear all the substitutions.  */
2195   G.substitutions = 0;
2196
2197   /* Null-terminate the string.  */
2198   write_char ('\0');
2199
2200   return (const char *) obstack_base (&G.name_obstack);
2201 }
2202
2203 /* Initialize data structures for mangling.  */
2204
2205 void
2206 init_mangle ()
2207 {
2208   gcc_obstack_init (&G.name_obstack);
2209
2210   /* Cache these identifiers for quick comparison when checking for
2211      standard substitutions.  */
2212   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2213   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
2214   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
2215   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
2216   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
2217   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2218 }
2219
2220 /* Generate the mangled name of DECL.  */
2221
2222 static const char *
2223 mangle_decl_string (decl)
2224      tree decl;
2225 {
2226   const char *result;
2227
2228   start_mangling ();
2229
2230   if (TREE_CODE (decl) == TYPE_DECL)
2231     write_type (TREE_TYPE (decl));
2232   else if (/* The names of `extern "C"' functions are not mangled.  */
2233            (DECL_EXTERN_C_FUNCTION_P (decl)
2234             /* But overloaded operator names *are* mangled.  */
2235             && !DECL_OVERLOADED_OPERATOR_P (decl))
2236            /* The names of global variables aren't mangled either.  */
2237            || (TREE_CODE (decl) == VAR_DECL
2238                && CP_DECL_CONTEXT (decl) == global_namespace)
2239            /* And neither are `extern "C"' variables.  */
2240            || (TREE_CODE (decl) == VAR_DECL
2241                && DECL_EXTERN_C_P (decl)))
2242     write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
2243   else
2244     {
2245       write_mangled_name (decl);
2246       if (DECL_LANG_SPECIFIC (decl)
2247           && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
2248               || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
2249         /* We need a distinct mangled name for these entities, but
2250            we should never actually output it.  So, we append some
2251            characters the assembler won't like.  */
2252         write_string (" *INTERNAL* ");
2253     }
2254
2255   result = finish_mangling ();
2256   if (DEBUG_MANGLE)
2257     fprintf (stderr, "mangle_decl_string = '%s'\n\n", result);
2258   return result;
2259 }
2260
2261 /* Create an identifier for the external mangled name of DECL.  */
2262
2263 void
2264 mangle_decl (decl)
2265      tree decl;
2266 {
2267   tree id = get_identifier (mangle_decl_string (decl));
2268
2269   SET_DECL_ASSEMBLER_NAME (decl, id);
2270 }
2271
2272 /* Generate the mangled representation of TYPE.  */
2273
2274 const char *
2275 mangle_type_string (type)
2276      tree type;
2277 {
2278   const char *result;
2279
2280   start_mangling ();
2281   write_type (type);
2282   result = finish_mangling ();
2283   if (DEBUG_MANGLE)
2284     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2285   return result;
2286 }
2287
2288 /* Create an identifier for the mangled representation of TYPE.  */
2289
2290 tree
2291 mangle_type (type)
2292      tree type;
2293 {
2294   return get_identifier (mangle_type_string (type));
2295 }
2296
2297 /* Create an identifier for the mangled name of a special component
2298    for belonging to TYPE.  CODE is the ABI-specified code for this
2299    component.  */
2300
2301 static tree
2302 mangle_special_for_type (type, code)
2303      tree type;
2304      const char *code;
2305 {
2306   const char *result;
2307
2308   /* We don't have an actual decl here for the special component, so
2309      we can't just process the <encoded-name>.  Instead, fake it.  */
2310   start_mangling ();
2311
2312   /* Start the mangling.  */
2313   write_string ("_Z");
2314   write_string (code);
2315
2316   /* Add the type.  */
2317   write_type (type);
2318   result = finish_mangling ();
2319
2320   if (DEBUG_MANGLE)
2321     fprintf (stderr, "mangle_special_for_type = %s\n\n", result);
2322
2323   return get_identifier (result);
2324 }
2325
2326 /* Create an identifier for the mangled representation of the typeinfo
2327    structure for TYPE.  */
2328
2329 tree
2330 mangle_typeinfo_for_type (type)
2331      tree type;
2332 {
2333   return mangle_special_for_type (type, "TI");
2334 }
2335
2336 /* Create an identifier for the mangled name of the NTBS containing
2337    the mangled name of TYPE.  */
2338
2339 tree
2340 mangle_typeinfo_string_for_type (type)
2341      tree type;
2342 {
2343   return mangle_special_for_type (type, "TS");
2344 }
2345
2346 /* Create an identifier for the mangled name of the vtable for TYPE.  */
2347
2348 tree
2349 mangle_vtbl_for_type (type)
2350      tree type;
2351 {
2352   return mangle_special_for_type (type, "TV");
2353 }
2354
2355 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
2356
2357 tree
2358 mangle_vtt_for_type (type)
2359      tree type;
2360 {
2361   return mangle_special_for_type (type, "TT");
2362 }
2363
2364 /* Return an identifier for a construction vtable group.  TYPE is
2365    the most derived class in the hierarchy; BINFO is the base
2366    subobject for which this construction vtable group will be used.
2367
2368    This mangling isn't part of the ABI specification; in the ABI
2369    specification, the vtable group is dumped in the same COMDAT as the
2370    main vtable, and is referenced only from that vtable, so it doesn't
2371    need an external name.  For binary formats without COMDAT sections,
2372    though, we need external names for the vtable groups.
2373
2374    We use the production
2375
2376     <special-name> ::= CT <type> <offset number> _ <base type>  */
2377
2378 tree
2379 mangle_ctor_vtbl_for_type (type, binfo)
2380      tree type;
2381      tree binfo;
2382 {
2383   const char *result;
2384
2385   start_mangling ();
2386
2387   write_string ("_Z");
2388   write_string ("TC");
2389   write_type (type);
2390   write_integer_cst (BINFO_OFFSET (binfo));
2391   write_char ('_');
2392   write_type (BINFO_TYPE (binfo));
2393
2394   result = finish_mangling ();
2395   if (DEBUG_MANGLE)
2396     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n", result);
2397   return get_identifier (result);
2398 }
2399
2400 /* Return an identifier for the mangled name of a thunk to FN_DECL.
2401    OFFSET is the initial adjustment to this used to find the vptr.  If
2402    VCALL_OFFSET is non-NULL, this is a virtual thunk, and it is the
2403    vtbl offset in bytes.
2404
2405     <special-name> ::= Th <offset number> _ <base encoding>
2406                    ::= Tv <offset number> _ <vcall offset number> _
2407                                                             <base encoding>
2408 */
2409
2410 tree
2411 mangle_thunk (fn_decl, offset, vcall_offset)
2412      tree fn_decl;
2413      tree offset;
2414      tree vcall_offset;
2415 {
2416   const char *result;
2417
2418   start_mangling ();
2419
2420   write_string ("_Z");
2421   /* The <special-name> for virtual thunks is Tv, for non-virtual
2422      thunks Th.  */
2423   write_char ('T');
2424   if (vcall_offset != 0)
2425     write_char ('v');
2426   else
2427     write_char ('h');
2428
2429   /* For either flavor, write the offset to this.  */
2430   write_integer_cst (offset);
2431   write_char ('_');
2432
2433   /* For a virtual thunk, add the vcall offset.  */
2434   if (vcall_offset)
2435     {
2436       /* Virtual thunk.  Write the vcall offset and base type name.  */
2437       write_integer_cst (vcall_offset);
2438       write_char ('_');
2439     }
2440
2441   /* Scoped name.  */
2442   write_encoding (fn_decl);
2443
2444   result = finish_mangling ();
2445   if (DEBUG_MANGLE)
2446     fprintf (stderr, "mangle_thunk = %s\n\n", result);
2447   return get_identifier (result);
2448 }
2449
2450 /* Return an identifier for the mangled unqualified name for a
2451    conversion operator to TYPE.  This mangling is not specified by the
2452    ABI spec; it is only used internally.  */
2453
2454 tree
2455 mangle_conv_op_name_for_type (type)
2456      tree type;
2457 {
2458   tree identifier;
2459   const char *mangled_type;
2460   char *op_name;
2461
2462   /* Build the internal mangling for TYPE.  */
2463   G.internal_mangling_p = true;
2464   mangled_type = mangle_type_string (type);
2465   G.internal_mangling_p = false;
2466
2467   /* Allocate a temporary buffer for the complete name.  */
2468   op_name = concat ("operator ", mangled_type, NULL);
2469   /* Find or create an identifier.  */
2470   identifier = get_identifier (op_name);
2471   /* Done with the temporary buffer.  */
2472   free (op_name);
2473
2474   /* It had better be a unique mangling for the type.  */
2475   my_friendly_assert (!IDENTIFIER_TYPENAME_P (identifier)
2476                       || same_type_p (type, TREE_TYPE (identifier)),
2477                       20011230);
2478
2479   /* Set bits on the identifier so we know later it's a conversion.  */
2480   IDENTIFIER_OPNAME_P (identifier) = 1;
2481   IDENTIFIER_TYPENAME_P (identifier) = 1;
2482   /* Hang TYPE off the identifier so it can be found easily later when
2483      performing conversions.  */
2484   TREE_TYPE (identifier) = type;
2485
2486   return identifier;
2487 }
2488
2489 /* Return an identifier for the name of an initialization guard
2490    variable for indicated VARIABLE.  */
2491
2492 tree
2493 mangle_guard_variable (variable)
2494      tree variable;
2495 {
2496   start_mangling ();
2497   write_string ("_ZGV");
2498   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
2499     /* The name of a guard variable for a reference temporary should refer
2500        to the reference, not the temporary.  */
2501     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
2502   else
2503     write_name (variable, /*ignore_local_scope=*/0);
2504   return get_identifier (finish_mangling ());
2505 }
2506
2507 /* Return an identifier for the name of a temporary variable used to
2508    initialize a static reference.  This isn't part of the ABI, but we might
2509    as well call them something readable.  */
2510
2511 tree
2512 mangle_ref_init_variable (variable)
2513      tree variable;
2514 {
2515   start_mangling ();
2516   write_string ("_ZGR");
2517   write_name (variable, /*ignore_local_scope=*/0);
2518   return get_identifier (finish_mangling ());
2519 }
2520 \f
2521
2522 /* Foreign language type mangling section.  */
2523
2524 /* How to write the type codes for the integer Java type.  */
2525
2526 static void
2527 write_java_integer_type_codes (type)
2528      tree type;
2529 {
2530   if (type == java_int_type_node)
2531     write_char ('i');
2532   else if (type == java_short_type_node)
2533     write_char ('s');
2534   else if (type == java_byte_type_node)
2535     write_char ('c');
2536   else if (type == java_char_type_node)
2537     write_char ('w');
2538   else if (type == java_long_type_node)
2539     write_char ('x');
2540   else if (type == java_boolean_type_node)
2541     write_char ('b');
2542   else
2543     abort ();
2544 }
2545