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 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
1838     {
1839       int i;
1840
1841       /* When we bind a variable or function to a non-type template
1842          argument with reference type, we create an ADDR_EXPR to show
1843          the fact that the entity's address has been taken.  But, we
1844          don't actually want to output a mangling code for the `&'.  */
1845       if (TREE_CODE (expr) == ADDR_EXPR
1846           && TREE_TYPE (expr)
1847           && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
1848         {
1849           expr = TREE_OPERAND (expr, 0);
1850           if (DECL_P (expr))
1851             {
1852               write_expression (expr);
1853               return;
1854             }
1855
1856           code = TREE_CODE (expr);
1857         }
1858
1859       /* If it wasn't any of those, recursively expand the expression.  */
1860       write_string (operator_name_info[(int) code].mangled_name);
1861
1862       switch (code)
1863         {
1864         case CAST_EXPR:
1865           write_type (TREE_TYPE (expr));
1866           write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
1867           break;
1868
1869         case STATIC_CAST_EXPR:
1870         case CONST_CAST_EXPR:
1871           write_type (TREE_TYPE (expr));
1872           write_expression (TREE_OPERAND (expr, 0));
1873           break;
1874
1875         /* Handle pointers-to-members specially.  */
1876         case SCOPE_REF:
1877           write_type (TREE_OPERAND (expr, 0));
1878           if (TREE_CODE (TREE_OPERAND (expr, 1)) == IDENTIFIER_NODE)
1879             write_source_name (TREE_OPERAND (expr, 1));
1880           else
1881             write_encoding (TREE_OPERAND (expr, 1));
1882           break;
1883
1884         default:
1885           for (i = 0; i < TREE_CODE_LENGTH (code); ++i)
1886             write_expression (TREE_OPERAND (expr, i));
1887         }
1888     }
1889 }
1890
1891 /* Literal subcase of non-terminal <template-arg>.
1892
1893      "Literal arguments, e.g. "A<42L>", are encoded with their type
1894      and value. Negative integer values are preceded with "n"; for
1895      example, "A<-42L>" becomes "1AILln42EE". The bool value false is
1896      encoded as 0, true as 1. If floating-point arguments are accepted
1897      as an extension, their values should be encoded using a
1898      fixed-length lowercase hexadecimal string corresponding to the
1899      internal representation (IEEE on IA-64), high-order bytes first,
1900      without leading zeroes. For example: "Lfbff000000E" is -1.0f."  */
1901
1902 static void
1903 write_template_arg_literal (value)
1904      tree value;
1905 {
1906   tree type = TREE_TYPE (value);
1907   write_char ('L');
1908   write_type (type);
1909
1910   if (TREE_CODE (value) == CONST_DECL)
1911     write_integer_cst (DECL_INITIAL (value));
1912   else if (TREE_CODE (value) == INTEGER_CST)
1913     {
1914       if (same_type_p (type, boolean_type_node))
1915         {
1916           if (value == boolean_false_node || integer_zerop (value))
1917             write_unsigned_number (0);
1918           else if (value == boolean_true_node)
1919             write_unsigned_number (1);
1920           else
1921             abort ();
1922         }
1923       else
1924         write_integer_cst (value);
1925     }
1926   else if (TREE_CODE (value) == REAL_CST)
1927     {
1928 #ifdef CROSS_COMPILE
1929       static int explained;
1930
1931       if (!explained)
1932         {
1933           sorry ("real-valued template parameters when cross-compiling");
1934           explained = 1;
1935         }
1936 #else
1937       size_t i;
1938       for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1939         write_number (((unsigned char *)
1940                        &TREE_REAL_CST (value))[i],
1941                       /*unsigned_p=*/1,
1942                       16);
1943 #endif
1944     }
1945   else
1946     abort ();
1947
1948   write_char ('E');
1949 }
1950
1951 /* Non-terminal <tempalate-arg>.
1952
1953      <template-arg> ::= <type>                        # type
1954                     ::= L <type> </value/ number> E   # literal
1955                     ::= LZ <name> E                   # external name
1956                     ::= X <expression> E              # expression  */
1957
1958 static void
1959 write_template_arg (node)
1960      tree node;
1961 {
1962   enum tree_code code = TREE_CODE (node);
1963
1964   MANGLE_TRACE_TREE ("template-arg", node);
1965
1966   /* A template template paramter's argument list contains TREE_LIST
1967      nodes of which the value field is the the actual argument.  */
1968   if (code == TREE_LIST)
1969     {
1970       node = TREE_VALUE (node);
1971       /* If it's a decl, deal with its type instead.  */
1972       if (DECL_P (node))
1973         {
1974           node = TREE_TYPE (node);
1975           code = TREE_CODE (node);
1976         }
1977     }
1978
1979   if (TYPE_P (node))
1980     write_type (node);
1981   else if (code == TEMPLATE_DECL)
1982     /* A template appearing as a template arg is a template template arg.  */
1983     write_template_template_arg (node);
1984   else if (DECL_P (node))
1985     {
1986       write_char ('L');
1987       write_char ('Z');
1988       write_encoding (node);
1989       write_char ('E');
1990     }
1991   else if (TREE_CODE_CLASS (code) == 'c' && code != PTRMEM_CST)
1992     write_template_arg_literal (node);
1993   else
1994     {
1995       /* Template arguments may be expressions.  */
1996       write_char ('X');
1997       write_expression (node);
1998       write_char ('E');
1999     }
2000 }
2001
2002 /*  <template-template-arg>
2003                         ::= <name>
2004                         ::= <substitution>  */
2005
2006 void
2007 write_template_template_arg (tree decl)
2008 {
2009   MANGLE_TRACE_TREE ("template-template-arg", decl);
2010
2011   if (find_substitution (decl))
2012     return;
2013   write_name (decl, /*ignore_local_scope=*/0);
2014   add_substitution (decl);
2015 }
2016
2017
2018 /* Non-terminal <array-type>.  TYPE is an ARRAY_TYPE.
2019
2020      <array-type> ::= A [</dimension/ number>] _ </element/ type>
2021                   ::= A <expression> _ </element/ type>
2022
2023      "Array types encode the dimension (number of elements) and the
2024      element type. For variable length arrays, the dimension (but not
2025      the '_' separator) is omitted."  */
2026
2027 static void
2028 write_array_type (type)
2029   tree type;
2030 {
2031   write_char ('A');
2032   if (TYPE_DOMAIN (type))
2033     {
2034       tree index_type;
2035       tree max;
2036
2037       index_type = TYPE_DOMAIN (type);
2038       /* The INDEX_TYPE gives the upper and lower bounds of the
2039          array.  */
2040       max = TYPE_MAX_VALUE (index_type);
2041       if (TREE_CODE (max) == INTEGER_CST)
2042         {
2043           /* The ABI specifies that we should mangle the number of
2044              elements in the array, not the largest allowed index.  */
2045           max = size_binop (PLUS_EXPR, max, size_one_node);
2046           write_unsigned_number (tree_low_cst (max, 1));
2047         }
2048       else
2049         write_expression (TREE_OPERAND (max, 0));
2050     }
2051   write_char ('_');
2052   write_type (TREE_TYPE (type));
2053 }
2054
2055 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2056    variables.  TYPE is a pointer-to-member POINTER_TYPE.
2057
2058      <pointer-to-member-type> ::= M </class/ type> </member/ type>  */
2059
2060 static void
2061 write_pointer_to_member_type (type)
2062      tree type;
2063 {
2064   write_char ('M');
2065   write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2066   write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2067 }
2068
2069 /* Non-terminal <template-param>.  PARM is a TEMPLATE_TYPE_PARM,
2070    TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2071    TEMPLATE_PARM_INDEX.
2072
2073      <template-param> ::= T </parameter/ number> _
2074
2075    If we are internally mangling then we distinguish level and, for
2076    non-type parms, type too. The mangling appends
2077
2078      </level/ number> _ </non-type type/ type> _
2079
2080    This is used by mangle_conv_op_name_for_type.  */
2081
2082 static void
2083 write_template_param (parm)
2084      tree parm;
2085 {
2086   int parm_index;
2087   int parm_level;
2088   tree parm_type = NULL_TREE;
2089
2090   MANGLE_TRACE_TREE ("template-parm", parm);
2091
2092   switch (TREE_CODE (parm))
2093     {
2094     case TEMPLATE_TYPE_PARM:
2095     case TEMPLATE_TEMPLATE_PARM:
2096     case BOUND_TEMPLATE_TEMPLATE_PARM:
2097       parm_index = TEMPLATE_TYPE_IDX (parm);
2098       parm_level = TEMPLATE_TYPE_LEVEL (parm);
2099       break;
2100
2101     case TEMPLATE_PARM_INDEX:
2102       parm_index = TEMPLATE_PARM_IDX (parm);
2103       parm_level = TEMPLATE_PARM_LEVEL (parm);
2104       parm_type = TREE_TYPE (TEMPLATE_PARM_DECL (parm));
2105       break;
2106
2107     default:
2108       abort ();
2109     }
2110
2111   write_char ('T');
2112   /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2113      earliest template param denoted by `_'.  */
2114   if (parm_index > 0)
2115     write_unsigned_number (parm_index - 1);
2116   write_char ('_');
2117   if (G.internal_mangling_p)
2118     {
2119       if (parm_level > 0)
2120         write_unsigned_number (parm_level - 1);
2121       write_char ('_');
2122       if (parm_type)
2123         write_type (parm_type);
2124       write_char ('_');
2125     }
2126 }
2127
2128 /*  <template-template-param>
2129                         ::= <template-param>
2130                         ::= <substitution>  */
2131
2132 static void
2133 write_template_template_param (parm)
2134      tree parm;
2135 {
2136   tree template = NULL_TREE;
2137
2138   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2139      template template parameter.  The substitution candidate here is
2140      only the template.  */
2141   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2142     {
2143       template
2144         = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2145       if (find_substitution (template))
2146         return;
2147     }
2148
2149   /* <template-param> encodes only the template parameter position,
2150      not its template arguments, which is fine here.  */
2151   write_template_param (parm);
2152   if (template)
2153     add_substitution (template);
2154 }
2155
2156 /* Non-terminal <substitution>.
2157
2158       <substitution> ::= S <seq-id> _
2159                      ::= S_  */
2160
2161 static void
2162 write_substitution (seq_id)
2163      int seq_id;
2164 {
2165   MANGLE_TRACE ("substitution", "");
2166
2167   write_char ('S');
2168   if (seq_id > 0)
2169     write_number (seq_id - 1, /*unsigned=*/1, 36);
2170   write_char ('_');
2171 }
2172
2173 /* Start mangling a new name or type.  */
2174
2175 static inline void
2176 start_mangling ()
2177 {
2178   VARRAY_TREE_INIT (G.substitutions, 1, "mangling substitutions");
2179   obstack_free (&G.name_obstack, obstack_base (&G.name_obstack));
2180 }
2181
2182 /* Done with mangling.  Return the generated mangled name.  */
2183
2184 static inline const char *
2185 finish_mangling ()
2186 {
2187   /* Clear all the substitutions.  */
2188   G.substitutions = 0;
2189
2190   /* Null-terminate the string.  */
2191   write_char ('\0');
2192
2193   return (const char *) obstack_base (&G.name_obstack);
2194 }
2195
2196 /* Initialize data structures for mangling.  */
2197
2198 void
2199 init_mangle ()
2200 {
2201   gcc_obstack_init (&G.name_obstack);
2202
2203   /* Cache these identifiers for quick comparison when checking for
2204      standard substitutions.  */
2205   subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2206   subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
2207   subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
2208   subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
2209   subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
2210   subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2211 }
2212
2213 /* Generate the mangled name of DECL.  */
2214
2215 static const char *
2216 mangle_decl_string (decl)
2217      tree decl;
2218 {
2219   const char *result;
2220
2221   start_mangling ();
2222
2223   if (TREE_CODE (decl) == TYPE_DECL)
2224     write_type (TREE_TYPE (decl));
2225   else if (/* The names of `extern "C"' functions are not mangled.  */
2226            (DECL_EXTERN_C_FUNCTION_P (decl)
2227             /* But overloaded operator names *are* mangled.  */
2228             && !DECL_OVERLOADED_OPERATOR_P (decl))
2229            /* The names of global variables aren't mangled either.  */
2230            || (TREE_CODE (decl) == VAR_DECL
2231                && CP_DECL_CONTEXT (decl) == global_namespace)
2232            /* And neither are `extern "C"' variables.  */
2233            || (TREE_CODE (decl) == VAR_DECL
2234                && DECL_EXTERN_C_P (decl)))
2235     write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
2236   else
2237     {
2238       write_mangled_name (decl);
2239       if (DECL_LANG_SPECIFIC (decl)
2240           && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
2241               || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
2242         /* We need a distinct mangled name for these entities, but
2243            we should never actually output it.  So, we append some
2244            characters the assembler won't like.  */
2245         write_string (" *INTERNAL* ");
2246     }
2247
2248   result = finish_mangling ();
2249   if (DEBUG_MANGLE)
2250     fprintf (stderr, "mangle_decl_string = '%s'\n\n", result);
2251   return result;
2252 }
2253
2254 /* Create an identifier for the external mangled name of DECL.  */
2255
2256 void
2257 mangle_decl (decl)
2258      tree decl;
2259 {
2260   tree id = get_identifier (mangle_decl_string (decl));
2261
2262   SET_DECL_ASSEMBLER_NAME (decl, id);
2263 }
2264
2265 /* Generate the mangled representation of TYPE.  */
2266
2267 const char *
2268 mangle_type_string (type)
2269      tree type;
2270 {
2271   const char *result;
2272
2273   start_mangling ();
2274   write_type (type);
2275   result = finish_mangling ();
2276   if (DEBUG_MANGLE)
2277     fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2278   return result;
2279 }
2280
2281 /* Create an identifier for the mangled representation of TYPE.  */
2282
2283 tree
2284 mangle_type (type)
2285      tree type;
2286 {
2287   return get_identifier (mangle_type_string (type));
2288 }
2289
2290 /* Create an identifier for the mangled name of a special component
2291    for belonging to TYPE.  CODE is the ABI-specified code for this
2292    component.  */
2293
2294 static tree
2295 mangle_special_for_type (type, code)
2296      tree type;
2297      const char *code;
2298 {
2299   const char *result;
2300
2301   /* We don't have an actual decl here for the special component, so
2302      we can't just process the <encoded-name>.  Instead, fake it.  */
2303   start_mangling ();
2304
2305   /* Start the mangling.  */
2306   write_string ("_Z");
2307   write_string (code);
2308
2309   /* Add the type.  */
2310   write_type (type);
2311   result = finish_mangling ();
2312
2313   if (DEBUG_MANGLE)
2314     fprintf (stderr, "mangle_special_for_type = %s\n\n", result);
2315
2316   return get_identifier (result);
2317 }
2318
2319 /* Create an identifier for the mangled representation of the typeinfo
2320    structure for TYPE.  */
2321
2322 tree
2323 mangle_typeinfo_for_type (type)
2324      tree type;
2325 {
2326   return mangle_special_for_type (type, "TI");
2327 }
2328
2329 /* Create an identifier for the mangled name of the NTBS containing
2330    the mangled name of TYPE.  */
2331
2332 tree
2333 mangle_typeinfo_string_for_type (type)
2334      tree type;
2335 {
2336   return mangle_special_for_type (type, "TS");
2337 }
2338
2339 /* Create an identifier for the mangled name of the vtable for TYPE.  */
2340
2341 tree
2342 mangle_vtbl_for_type (type)
2343      tree type;
2344 {
2345   return mangle_special_for_type (type, "TV");
2346 }
2347
2348 /* Returns an identifier for the mangled name of the VTT for TYPE.  */
2349
2350 tree
2351 mangle_vtt_for_type (type)
2352      tree type;
2353 {
2354   return mangle_special_for_type (type, "TT");
2355 }
2356
2357 /* Return an identifier for a construction vtable group.  TYPE is
2358    the most derived class in the hierarchy; BINFO is the base
2359    subobject for which this construction vtable group will be used.
2360
2361    This mangling isn't part of the ABI specification; in the ABI
2362    specification, the vtable group is dumped in the same COMDAT as the
2363    main vtable, and is referenced only from that vtable, so it doesn't
2364    need an external name.  For binary formats without COMDAT sections,
2365    though, we need external names for the vtable groups.
2366
2367    We use the production
2368
2369     <special-name> ::= CT <type> <offset number> _ <base type>  */
2370
2371 tree
2372 mangle_ctor_vtbl_for_type (type, binfo)
2373      tree type;
2374      tree binfo;
2375 {
2376   const char *result;
2377
2378   start_mangling ();
2379
2380   write_string ("_Z");
2381   write_string ("TC");
2382   write_type (type);
2383   write_integer_cst (BINFO_OFFSET (binfo));
2384   write_char ('_');
2385   write_type (BINFO_TYPE (binfo));
2386
2387   result = finish_mangling ();
2388   if (DEBUG_MANGLE)
2389     fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n", result);
2390   return get_identifier (result);
2391 }
2392
2393 /* Return an identifier for the mangled name of a thunk to FN_DECL.
2394    OFFSET is the initial adjustment to this used to find the vptr.  If
2395    VCALL_OFFSET is non-NULL, this is a virtual thunk, and it is the
2396    vtbl offset in bytes.
2397
2398     <special-name> ::= Th <offset number> _ <base encoding>
2399                    ::= Tv <offset number> _ <vcall offset number> _
2400                                                             <base encoding>
2401 */
2402
2403 tree
2404 mangle_thunk (fn_decl, offset, vcall_offset)
2405      tree fn_decl;
2406      tree offset;
2407      tree vcall_offset;
2408 {
2409   const char *result;
2410
2411   start_mangling ();
2412
2413   write_string ("_Z");
2414   /* The <special-name> for virtual thunks is Tv, for non-virtual
2415      thunks Th.  */
2416   write_char ('T');
2417   if (vcall_offset != 0)
2418     write_char ('v');
2419   else
2420     write_char ('h');
2421
2422   /* For either flavor, write the offset to this.  */
2423   write_integer_cst (offset);
2424   write_char ('_');
2425
2426   /* For a virtual thunk, add the vcall offset.  */
2427   if (vcall_offset)
2428     {
2429       /* Virtual thunk.  Write the vcall offset and base type name.  */
2430       write_integer_cst (vcall_offset);
2431       write_char ('_');
2432     }
2433
2434   /* Scoped name.  */
2435   write_encoding (fn_decl);
2436
2437   result = finish_mangling ();
2438   if (DEBUG_MANGLE)
2439     fprintf (stderr, "mangle_thunk = %s\n\n", result);
2440   return get_identifier (result);
2441 }
2442
2443 /* Return an identifier for the mangled unqualified name for a
2444    conversion operator to TYPE.  This mangling is not specified by the
2445    ABI spec; it is only used internally.  */
2446
2447 tree
2448 mangle_conv_op_name_for_type (type)
2449      tree type;
2450 {
2451   tree identifier;
2452   const char *mangled_type;
2453   char *op_name;
2454
2455   /* Build the internal mangling for TYPE.  */
2456   G.internal_mangling_p = true;
2457   mangled_type = mangle_type_string (type);
2458   G.internal_mangling_p = false;
2459
2460   /* Allocate a temporary buffer for the complete name.  */
2461   op_name = concat ("operator ", mangled_type, NULL);
2462   /* Find or create an identifier.  */
2463   identifier = get_identifier (op_name);
2464   /* Done with the temporary buffer.  */
2465   free (op_name);
2466
2467   /* It had better be a unique mangling for the type.  */
2468   my_friendly_assert (!IDENTIFIER_TYPENAME_P (identifier)
2469                       || same_type_p (type, TREE_TYPE (identifier)),
2470                       20011230);
2471
2472   /* Set bits on the identifier so we know later it's a conversion.  */
2473   IDENTIFIER_OPNAME_P (identifier) = 1;
2474   IDENTIFIER_TYPENAME_P (identifier) = 1;
2475   /* Hang TYPE off the identifier so it can be found easily later when
2476      performing conversions.  */
2477   TREE_TYPE (identifier) = type;
2478
2479   return identifier;
2480 }
2481
2482 /* Return an identifier for the name of an initialization guard
2483    variable for indicated VARIABLE.  */
2484
2485 tree
2486 mangle_guard_variable (variable)
2487      tree variable;
2488 {
2489   start_mangling ();
2490   write_string ("_ZGV");
2491   if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
2492     /* The name of a guard variable for a reference temporary should refer
2493        to the reference, not the temporary.  */
2494     write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
2495   else
2496     write_name (variable, /*ignore_local_scope=*/0);
2497   return get_identifier (finish_mangling ());
2498 }
2499
2500 /* Return an identifier for the name of a temporary variable used to
2501    initialize a static reference.  This isn't part of the ABI, but we might
2502    as well call them something readable.  */
2503
2504 tree
2505 mangle_ref_init_variable (variable)
2506      tree variable;
2507 {
2508   start_mangling ();
2509   write_string ("_ZGR");
2510   write_name (variable, /*ignore_local_scope=*/0);
2511   return get_identifier (finish_mangling ());
2512 }
2513 \f
2514
2515 /* Foreign language type mangling section.  */
2516
2517 /* How to write the type codes for the integer Java type.  */
2518
2519 static void
2520 write_java_integer_type_codes (type)
2521      tree type;
2522 {
2523   if (type == java_int_type_node)
2524     write_char ('i');
2525   else if (type == java_short_type_node)
2526     write_char ('s');
2527   else if (type == java_byte_type_node)
2528     write_char ('c');
2529   else if (type == java_char_type_node)
2530     write_char ('w');
2531   else if (type == java_long_type_node)
2532     write_char ('x');
2533   else if (type == java_boolean_type_node)
2534     write_char ('b');
2535   else
2536     abort ();
2537 }
2538