OSDN Git Service

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