1 /* Name mangling for the 3.0 C++ ABI.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3 Written by Alex Samuel <sameul@codesourcery.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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
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.
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:
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
52 #include "coretypes.h"
64 /* Debugging support. */
66 /* Define DEBUG_MANGLE to enable very verbose trace messages. */
68 #define DEBUG_MANGLE 0
71 /* Macros for tracing the write_* functions. */
73 # define MANGLE_TRACE(FN, INPUT) \
74 fprintf (stderr, " %-24s: %-24s\n", (FN), (INPUT))
75 # define MANGLE_TRACE_TREE(FN, NODE) \
76 fprintf (stderr, " %-24s: %-24s (%p)\n", \
77 (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE))
79 # define MANGLE_TRACE(FN, INPUT)
80 # define MANGLE_TRACE_TREE(FN, NODE)
83 /* Nonzero if NODE is a class template-id. We can't rely on
84 CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
85 that hard to distinguish A<T> from A, where A<T> is the type as
86 instantiated outside of the template, and A is the type used
87 without parameters inside the template. */
88 #define CLASSTYPE_TEMPLATE_ID_P(NODE) \
89 (TYPE_LANG_SPECIFIC (NODE) != NULL \
90 && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \
91 || (CLASSTYPE_TEMPLATE_INFO (NODE) != NULL \
92 && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))))
94 /* Things we only need one of. This module is not reentrant. */
95 typedef struct globals GTY(())
97 /* An array of the current substitution candidates, in the order
99 varray_type substitutions;
101 /* The entity that is being mangled. */
102 tree GTY ((skip)) entity;
104 /* True if the mangling will be different in a future version of the
106 bool need_abi_warning;
109 static GTY (()) globals G;
111 /* The obstack on which we build mangled names. */
112 static struct obstack *mangle_obstack;
114 /* The obstack on which we build mangled names that are not going to
115 be IDENTIFIER_NODEs. */
116 static struct obstack name_obstack;
118 /* The first object on the name_obstack; we use this to free memory
119 allocated on the name_obstack. */
120 static void *name_base;
122 /* Indices into subst_identifiers. These are identifiers used in
123 special substitution rules. */
131 SUBID_BASIC_IOSTREAM,
134 substitution_identifier_index_t;
136 /* For quick substitution checks, look up these common identifiers
138 static GTY(()) tree subst_identifiers[SUBID_MAX];
140 /* Single-letter codes for builtin integer types, defined in
141 <builtin-type>. These are indexed by integer_type_kind values. */
143 integer_type_codes[itk_none] =
146 'a', /* itk_signed_char */
147 'h', /* itk_unsigned_char */
149 't', /* itk_unsigned_short */
151 'j', /* itk_unsigned_int */
153 'm', /* itk_unsigned_long */
154 'x', /* itk_long_long */
155 'y' /* itk_unsigned_long_long */
158 static int decl_is_template_id (const tree, tree* const);
160 /* Functions for handling substitutions. */
162 static inline tree canonicalize_for_substitution (tree);
163 static void add_substitution (tree);
164 static inline int is_std_substitution (const tree,
165 const substitution_identifier_index_t);
166 static inline int is_std_substitution_char (const tree,
167 const substitution_identifier_index_t);
168 static int find_substitution (tree);
169 static void mangle_call_offset (const tree, const tree);
171 /* Functions for emitting mangled representations of things. */
173 static void write_mangled_name (const tree, bool);
174 static void write_encoding (const tree);
175 static void write_name (tree, const int);
176 static void write_unscoped_name (const tree);
177 static void write_unscoped_template_name (const tree);
178 static void write_nested_name (const tree);
179 static void write_prefix (const tree);
180 static void write_template_prefix (const tree);
181 static void write_unqualified_name (const tree);
182 static void write_conversion_operator_name (const tree);
183 static void write_source_name (tree);
184 static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
186 static void write_number (unsigned HOST_WIDE_INT, const int,
188 static void write_integer_cst (const tree);
189 static void write_real_cst (const tree);
190 static void write_identifier (const char *);
191 static void write_special_name_constructor (const tree);
192 static void write_special_name_destructor (const tree);
193 static void write_type (tree);
194 static int write_CV_qualifiers_for_type (const tree);
195 static void write_builtin_type (tree);
196 static void write_function_type (const tree);
197 static void write_bare_function_type (const tree, const int, const tree);
198 static void write_method_parms (tree, const int, const tree);
199 static void write_class_enum_type (const tree);
200 static void write_template_args (tree);
201 static void write_expression (tree);
202 static void write_template_arg_literal (const tree);
203 static void write_template_arg (tree);
204 static void write_template_template_arg (const tree);
205 static void write_array_type (const tree);
206 static void write_pointer_to_member_type (const tree);
207 static void write_template_param (const tree);
208 static void write_template_template_param (const tree);
209 static void write_substitution (const int);
210 static int discriminator_for_local_entity (tree);
211 static int discriminator_for_string_literal (tree, tree);
212 static void write_discriminator (const int);
213 static void write_local_name (const tree, const tree, const tree);
214 static void dump_substitution_candidates (void);
215 static const char *mangle_decl_string (const tree);
217 /* Control functions. */
219 static inline void start_mangling (const tree, bool);
220 static inline const char *finish_mangling (const bool);
221 static tree mangle_special_for_type (const tree, const char *);
223 /* Foreign language functions. */
225 static void write_java_integer_type_codes (const tree);
227 /* Append a single character to the end of the mangled
229 #define write_char(CHAR) \
230 obstack_1grow (mangle_obstack, (CHAR))
232 /* Append a sized buffer to the end of the mangled representation. */
233 #define write_chars(CHAR, LEN) \
234 obstack_grow (mangle_obstack, (CHAR), (LEN))
236 /* Append a NUL-terminated string to the end of the mangled
238 #define write_string(STRING) \
239 obstack_grow (mangle_obstack, (STRING), strlen (STRING))
241 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
242 same purpose (context, which may be a type) and value (template
243 decl). See write_template_prefix for more information on what this
245 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \
246 (TREE_CODE (NODE1) == TREE_LIST \
247 && TREE_CODE (NODE2) == TREE_LIST \
248 && ((TYPE_P (TREE_PURPOSE (NODE1)) \
249 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2)))\
250 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \
251 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
253 /* Write out an unsigned quantity in base 10. */
254 #define write_unsigned_number(NUMBER) \
255 write_number ((NUMBER), /*unsigned_p=*/1, 10)
257 /* If DECL is a template instance, return nonzero and, if
258 TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
259 Otherwise return zero. */
262 decl_is_template_id (const tree decl, tree* const template_info)
264 if (TREE_CODE (decl) == TYPE_DECL)
266 /* TYPE_DECLs are handled specially. Look at its type to decide
267 if this is a template instantiation. */
268 const tree type = TREE_TYPE (decl);
270 if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
272 if (template_info != NULL)
273 /* For a templated TYPE_DECL, the template info is hanging
275 *template_info = TYPE_TEMPLATE_INFO (type);
281 /* Check if this is a primary template. */
282 if (DECL_LANG_SPECIFIC (decl) != NULL
283 && DECL_USE_TEMPLATE (decl)
284 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
285 && TREE_CODE (decl) != TEMPLATE_DECL)
287 if (template_info != NULL)
288 /* For most templated decls, the template info is hanging
290 *template_info = DECL_TEMPLATE_INFO (decl);
295 /* It's not a template id. */
299 /* Produce debugging output of current substitution candidates. */
302 dump_substitution_candidates (void)
306 fprintf (stderr, " ++ substitutions ");
307 for (i = 0; i < VARRAY_ACTIVE_SIZE (G.substitutions); ++i)
309 tree el = VARRAY_TREE (G.substitutions, i);
310 const char *name = "???";
313 fprintf (stderr, " ");
315 name = IDENTIFIER_POINTER (DECL_NAME (el));
316 else if (TREE_CODE (el) == TREE_LIST)
317 name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
318 else if (TYPE_NAME (el))
319 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el)));
320 fprintf (stderr, " S%d_ = ", i - 1);
322 (CP_TYPE_RESTRICT_P (el)
323 || CP_TYPE_VOLATILE_P (el)
324 || CP_TYPE_CONST_P (el)))
325 fprintf (stderr, "CV-");
326 fprintf (stderr, "%s (%s at %p)\n",
327 name, tree_code_name[TREE_CODE (el)], (void *) el);
331 /* Both decls and types can be substitution candidates, but sometimes
332 they refer to the same thing. For instance, a TYPE_DECL and
333 RECORD_TYPE for the same class refer to the same thing, and should
334 be treated accordingly in substitutions. This function returns a
335 canonicalized tree node representing NODE that is used when adding
336 and substitution candidates and finding matches. */
339 canonicalize_for_substitution (tree node)
341 /* For a TYPE_DECL, use the type instead. */
342 if (TREE_CODE (node) == TYPE_DECL)
343 node = TREE_TYPE (node);
345 node = canonical_type_variant (node);
350 /* Add NODE as a substitution candidate. NODE must not already be on
351 the list of candidates. */
354 add_substitution (tree node)
359 fprintf (stderr, " ++ add_substitution (%s at %10p)\n",
360 tree_code_name[TREE_CODE (node)], (void *) node);
362 /* Get the canonicalized substitution candidate for NODE. */
363 c = canonicalize_for_substitution (node);
364 if (DEBUG_MANGLE && c != node)
365 fprintf (stderr, " ++ using candidate (%s at %10p)\n",
366 tree_code_name[TREE_CODE (node)], (void *) node);
370 /* Make sure NODE isn't already a candidate. */
373 for (i = VARRAY_ACTIVE_SIZE (G.substitutions); --i >= 0; )
375 const tree candidate = VARRAY_TREE (G.substitutions, i);
377 gcc_assert (!(DECL_P (node) && node == candidate));
378 gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
379 && same_type_p (node, candidate)));
382 #endif /* ENABLE_CHECKING */
384 /* Put the decl onto the varray of substitution candidates. */
385 VARRAY_PUSH_TREE (G.substitutions, node);
388 dump_substitution_candidates ();
391 /* Helper function for find_substitution. Returns nonzero if NODE,
392 which may be a decl or a CLASS_TYPE, is a template-id with template
393 name of substitution_index[INDEX] in the ::std namespace. */
396 is_std_substitution (const tree node,
397 const substitution_identifier_index_t index)
404 type = TREE_TYPE (node);
407 else if (CLASS_TYPE_P (node))
410 decl = TYPE_NAME (node);
413 /* These are not the droids you're looking for. */
416 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
417 && TYPE_LANG_SPECIFIC (type)
418 && TYPE_TEMPLATE_INFO (type)
419 && (DECL_NAME (TYPE_TI_TEMPLATE (type))
420 == subst_identifiers[index]));
423 /* Helper function for find_substitution. Returns nonzero if NODE,
424 which may be a decl or a CLASS_TYPE, is the template-id
425 ::std::identifier<char>, where identifier is
426 substitution_index[INDEX]. */
429 is_std_substitution_char (const tree node,
430 const substitution_identifier_index_t index)
433 /* Check NODE's name is ::std::identifier. */
434 if (!is_std_substitution (node, index))
436 /* Figure out its template args. */
438 args = DECL_TI_ARGS (node);
439 else if (CLASS_TYPE_P (node))
440 args = CLASSTYPE_TI_ARGS (node);
442 /* Oops, not a template. */
444 /* NODE's template arg list should be <char>. */
446 TREE_VEC_LENGTH (args) == 1
447 && TREE_VEC_ELT (args, 0) == char_type_node;
450 /* Check whether a substitution should be used to represent NODE in
453 First, check standard special-case substitutions.
455 <substitution> ::= St
462 # ::std::basic_string
465 # ::std::basic_string<char,
466 ::std::char_traits<char>,
467 ::std::allocator<char> >
470 # ::std::basic_istream<char, ::std::char_traits<char> >
473 # ::std::basic_ostream<char, ::std::char_traits<char> >
476 # ::std::basic_iostream<char, ::std::char_traits<char> >
478 Then examine the stack of currently available substitution
479 candidates for entities appearing earlier in the same mangling
481 If a substitution is found, write its mangled representation and
482 return nonzero. If none is found, just return zero. */
485 find_substitution (tree node)
488 const int size = VARRAY_ACTIVE_SIZE (G.substitutions);
493 fprintf (stderr, " ++ find_substitution (%s at %p)\n",
494 tree_code_name[TREE_CODE (node)], (void *) node);
496 /* Obtain the canonicalized substitution representation for NODE.
497 This is what we'll compare against. */
498 node = canonicalize_for_substitution (node);
500 /* Check for builtin substitutions. */
502 decl = TYPE_P (node) ? TYPE_NAME (node) : node;
503 type = TYPE_P (node) ? node : TREE_TYPE (node);
505 /* Check for std::allocator. */
507 && is_std_substitution (decl, SUBID_ALLOCATOR)
508 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
514 /* Check for std::basic_string. */
515 if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
519 /* If this is a type (i.e. a fully-qualified template-id),
521 std::basic_string <char,
522 std::char_traits<char>,
523 std::allocator<char> > . */
524 if (cp_type_quals (type) == TYPE_UNQUALIFIED
525 && CLASSTYPE_USE_TEMPLATE (type))
527 tree args = CLASSTYPE_TI_ARGS (type);
528 if (TREE_VEC_LENGTH (args) == 3
529 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
530 && is_std_substitution_char (TREE_VEC_ELT (args, 1),
532 && is_std_substitution_char (TREE_VEC_ELT (args, 2),
541 /* Substitute for the template name only if this isn't a type. */
548 /* Check for basic_{i,o,io}stream. */
550 && cp_type_quals (type) == TYPE_UNQUALIFIED
551 && CLASS_TYPE_P (type)
552 && CLASSTYPE_USE_TEMPLATE (type)
553 && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
555 /* First, check for the template
556 args <char, std::char_traits<char> > . */
557 tree args = CLASSTYPE_TI_ARGS (type);
558 if (TREE_VEC_LENGTH (args) == 2
559 && TYPE_P (TREE_VEC_ELT (args, 0))
560 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
561 && is_std_substitution_char (TREE_VEC_ELT (args, 1),
564 /* Got them. Is this basic_istream? */
565 tree name = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type));
566 if (name == subst_identifiers[SUBID_BASIC_ISTREAM])
571 /* Or basic_ostream? */
572 else if (name == subst_identifiers[SUBID_BASIC_OSTREAM])
577 /* Or basic_iostream? */
578 else if (name == subst_identifiers[SUBID_BASIC_IOSTREAM])
586 /* Check for namespace std. */
587 if (decl && DECL_NAMESPACE_STD_P (decl))
593 /* Now check the list of available substitutions for this mangling
595 for (i = 0; i < size; ++i)
597 tree candidate = VARRAY_TREE (G.substitutions, i);
598 /* NODE is a matched to a candidate if it's the same decl node or
599 if it's the same type. */
600 if (decl == candidate
601 || (TYPE_P (candidate) && type && TYPE_P (type)
602 && same_type_p (type, candidate))
603 || NESTED_TEMPLATE_MATCH (node, candidate))
605 write_substitution (i);
610 /* No substitution found. */
615 /* TOP_LEVEL is true, if this is being called at outermost level of
616 mangling. It should be false when mangling a decl appearing in an
617 expression within some other mangling.
619 <mangled-name> ::= _Z <encoding> */
622 write_mangled_name (const tree decl, bool top_level)
624 MANGLE_TRACE_TREE ("mangled-name", decl);
626 if (/* The names of `extern "C"' functions are not mangled. */
627 DECL_EXTERN_C_FUNCTION_P (decl)
628 /* But overloaded operator names *are* mangled. */
629 && !DECL_OVERLOADED_OPERATOR_P (decl))
634 write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
637 /* The standard notes: "The <encoding> of an extern "C"
638 function is treated like global-scope data, i.e. as its
639 <source-name> without a type." We cannot write
640 overloaded operators that way though, because it contains
641 characters invalid in assembler. */
642 if (abi_version_at_least (2))
645 G.need_abi_warning = true;
646 write_source_name (DECL_NAME (decl));
649 else if (TREE_CODE (decl) == VAR_DECL
650 /* The names of global variables aren't mangled. */
651 && (CP_DECL_CONTEXT (decl) == global_namespace
652 /* And neither are `extern "C"' variables. */
653 || DECL_EXTERN_C_P (decl)))
655 if (top_level || abi_version_at_least (2))
659 G.need_abi_warning = true;
667 write_encoding (decl);
668 if (DECL_LANG_SPECIFIC (decl)
669 && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
670 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
671 /* We need a distinct mangled name for these entities, but
672 we should never actually output it. So, we append some
673 characters the assembler won't like. */
674 write_string (" *INTERNAL* ");
678 /* <encoding> ::= <function name> <bare-function-type>
682 write_encoding (const tree decl)
684 MANGLE_TRACE_TREE ("encoding", decl);
686 if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
688 /* For overloaded operators write just the mangled name
689 without arguments. */
690 if (DECL_OVERLOADED_OPERATOR_P (decl))
691 write_name (decl, /*ignore_local_scope=*/0);
693 write_source_name (DECL_NAME (decl));
697 write_name (decl, /*ignore_local_scope=*/0);
698 if (TREE_CODE (decl) == FUNCTION_DECL)
703 if (decl_is_template_id (decl, NULL))
705 fn_type = get_mostly_instantiated_function_type (decl);
706 /* FN_TYPE will not have parameter types for in-charge or
707 VTT parameters. Therefore, we pass NULL_TREE to
708 write_bare_function_type -- otherwise, it will get
709 confused about which artificial parameters to skip. */
714 fn_type = TREE_TYPE (decl);
718 write_bare_function_type (fn_type,
719 (!DECL_CONSTRUCTOR_P (decl)
720 && !DECL_DESTRUCTOR_P (decl)
721 && !DECL_CONV_FN_P (decl)
722 && decl_is_template_id (decl, NULL)),
727 /* <name> ::= <unscoped-name>
728 ::= <unscoped-template-name> <template-args>
732 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
733 called from <local-name>, which mangles the enclosing scope
734 elsewhere and then uses this function to mangle just the part
735 underneath the function scope. So don't use the <local-name>
736 production, to avoid an infinite recursion. */
739 write_name (tree decl, const int ignore_local_scope)
743 MANGLE_TRACE_TREE ("name", decl);
745 if (TREE_CODE (decl) == TYPE_DECL)
747 /* In case this is a typedef, fish out the corresponding
748 TYPE_DECL for the main variant. */
749 decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
750 context = TYPE_CONTEXT (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
753 context = (DECL_CONTEXT (decl) == NULL) ? NULL : CP_DECL_CONTEXT (decl);
755 /* A decl in :: or ::std scope is treated specially. The former is
756 mangled using <unscoped-name> or <unscoped-template-name>, the
757 latter with a special substitution. Also, a name that is
758 directly in a local function scope is also mangled with
759 <unscoped-name> rather than a full <nested-name>. */
761 || context == global_namespace
762 || DECL_NAMESPACE_STD_P (context)
763 || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL))
766 /* Is this a template instance? */
767 if (decl_is_template_id (decl, &template_info))
769 /* Yes: use <unscoped-template-name>. */
770 write_unscoped_template_name (TI_TEMPLATE (template_info));
771 write_template_args (TI_ARGS (template_info));
774 /* Everything else gets an <unqualified-name>. */
775 write_unscoped_name (decl);
779 /* Handle local names, unless we asked not to (that is, invoked
780 under <local-name>, to handle only the part of the name under
782 if (!ignore_local_scope)
784 /* Scan up the list of scope context, looking for a
785 function. If we find one, this entity is in local
786 function scope. local_entity tracks context one scope
787 level down, so it will contain the element that's
788 directly in that function's scope, either decl or one of
789 its enclosing scopes. */
790 tree local_entity = decl;
791 while (context != NULL && context != global_namespace)
793 /* Make sure we're always dealing with decls. */
794 if (context != NULL && TYPE_P (context))
795 context = TYPE_NAME (context);
796 /* Is this a function? */
797 if (TREE_CODE (context) == FUNCTION_DECL)
799 /* Yes, we have local scope. Use the <local-name>
800 production for the innermost function scope. */
801 write_local_name (context, local_entity, decl);
804 /* Up one scope level. */
805 local_entity = context;
806 context = CP_DECL_CONTEXT (context);
809 /* No local scope found? Fall through to <nested-name>. */
812 /* Other decls get a <nested-name> to encode their scope. */
813 write_nested_name (decl);
817 /* <unscoped-name> ::= <unqualified-name>
818 ::= St <unqualified-name> # ::std:: */
821 write_unscoped_name (const tree decl)
823 tree context = CP_DECL_CONTEXT (decl);
825 MANGLE_TRACE_TREE ("unscoped-name", decl);
827 /* Is DECL in ::std? */
828 if (DECL_NAMESPACE_STD_P (context))
831 write_unqualified_name (decl);
835 /* If not, it should be either in the global namespace, or directly
836 in a local function scope. */
837 gcc_assert (context == global_namespace
839 || TREE_CODE (context) == FUNCTION_DECL);
841 write_unqualified_name (decl);
845 /* <unscoped-template-name> ::= <unscoped-name>
846 ::= <substitution> */
849 write_unscoped_template_name (const tree decl)
851 MANGLE_TRACE_TREE ("unscoped-template-name", decl);
853 if (find_substitution (decl))
855 write_unscoped_name (decl);
856 add_substitution (decl);
859 /* Write the nested name, including CV-qualifiers, of DECL.
861 <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
862 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
864 <CV-qualifiers> ::= [r] [V] [K] */
867 write_nested_name (const tree decl)
871 MANGLE_TRACE_TREE ("nested-name", decl);
875 /* Write CV-qualifiers, if this is a member function. */
876 if (TREE_CODE (decl) == FUNCTION_DECL
877 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
879 if (DECL_VOLATILE_MEMFUNC_P (decl))
881 if (DECL_CONST_MEMFUNC_P (decl))
885 /* Is this a template instance? */
886 if (decl_is_template_id (decl, &template_info))
888 /* Yes, use <template-prefix>. */
889 write_template_prefix (decl);
890 write_template_args (TI_ARGS (template_info));
894 /* No, just use <prefix> */
895 write_prefix (DECL_CONTEXT (decl));
896 write_unqualified_name (decl);
901 /* <prefix> ::= <prefix> <unqualified-name>
903 ::= <template-prefix> <template-args>
905 ::= <substitution> */
908 write_prefix (const tree node)
911 /* Non-NULL if NODE represents a template-id. */
912 tree template_info = NULL;
914 MANGLE_TRACE_TREE ("prefix", node);
917 || node == global_namespace)
920 if (find_substitution (node))
925 /* If this is a function decl, that means we've hit function
926 scope, so this prefix must be for a local name. In this
927 case, we're under the <local-name> production, which encodes
928 the enclosing function scope elsewhere. So don't continue
930 if (TREE_CODE (node) == FUNCTION_DECL)
934 decl_is_template_id (decl, &template_info);
938 /* Node is a type. */
939 decl = TYPE_NAME (node);
940 if (CLASSTYPE_TEMPLATE_ID_P (node))
941 template_info = TYPE_TEMPLATE_INFO (node);
944 /* In G++ 3.2, the name of the template parameter was used. */
945 if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
946 && !abi_version_at_least (2))
947 G.need_abi_warning = true;
949 if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
950 && abi_version_at_least (2))
951 write_template_param (node);
952 else if (template_info != NULL)
955 write_template_prefix (decl);
956 write_template_args (TI_ARGS (template_info));
961 write_prefix (CP_DECL_CONTEXT (decl));
962 write_unqualified_name (decl);
965 add_substitution (node);
968 /* <template-prefix> ::= <prefix> <template component>
970 ::= <substitution> */
973 write_template_prefix (const tree node)
975 tree decl = DECL_P (node) ? node : TYPE_NAME (node);
976 tree type = DECL_P (node) ? TREE_TYPE (node) : node;
977 tree context = CP_DECL_CONTEXT (decl);
982 MANGLE_TRACE_TREE ("template-prefix", node);
984 /* Find the template decl. */
985 if (decl_is_template_id (decl, &template_info))
986 template = TI_TEMPLATE (template_info);
989 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
991 template = TYPE_TI_TEMPLATE (type);
994 /* For a member template, though, the template name for the
995 innermost name must have all the outer template levels
996 instantiated. For instance, consider
998 template<typename T> struct Outer {
999 template<typename U> struct Inner {};
1002 The template name for `Inner' in `Outer<int>::Inner<float>' is
1003 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1004 levels separately, so there's no TEMPLATE_DECL available for this
1005 (there's only `Outer<T>::Inner<U>').
1007 In order to get the substitutions right, we create a special
1008 TREE_LIST to represent the substitution candidate for a nested
1009 template. The TREE_PURPOSE is the template's context, fully
1010 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1013 So, for the example above, `Outer<int>::Inner' is represented as a
1014 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1015 and whose value is `Outer<T>::Inner<U>'. */
1016 if (TYPE_P (context))
1017 substitution = build_tree_list (context, template);
1019 substitution = template;
1021 if (find_substitution (substitution))
1024 /* In G++ 3.2, the name of the template template parameter was used. */
1025 if (TREE_CODE (TREE_TYPE (template)) == TEMPLATE_TEMPLATE_PARM
1026 && !abi_version_at_least (2))
1027 G.need_abi_warning = true;
1029 if (TREE_CODE (TREE_TYPE (template)) == TEMPLATE_TEMPLATE_PARM
1030 && abi_version_at_least (2))
1031 write_template_param (TREE_TYPE (template));
1034 write_prefix (context);
1035 write_unqualified_name (decl);
1038 add_substitution (substitution);
1041 /* We don't need to handle thunks, vtables, or VTTs here. Those are
1042 mangled through special entry points.
1044 <unqualified-name> ::= <operator-name>
1046 ::= <source-name> */
1049 write_unqualified_name (const tree decl)
1051 MANGLE_TRACE_TREE ("unqualified-name", decl);
1053 if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_CONSTRUCTOR_P (decl))
1054 write_special_name_constructor (decl);
1055 else if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_DESTRUCTOR_P (decl))
1056 write_special_name_destructor (decl);
1057 else if (DECL_NAME (decl) == NULL_TREE)
1058 write_source_name (DECL_ASSEMBLER_NAME (decl));
1059 else if (DECL_CONV_FN_P (decl))
1061 /* Conversion operator. Handle it right here.
1062 <operator> ::= cv <type> */
1064 if (decl_is_template_id (decl, NULL))
1066 tree fn_type = get_mostly_instantiated_function_type (decl);
1067 type = TREE_TYPE (fn_type);
1070 type = DECL_CONV_FN_TYPE (decl);
1071 write_conversion_operator_name (type);
1073 else if (DECL_OVERLOADED_OPERATOR_P (decl))
1075 operator_name_info_t *oni;
1076 if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1077 oni = assignment_operator_name_info;
1079 oni = operator_name_info;
1081 write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1084 write_source_name (DECL_NAME (decl));
1087 /* Write the unqualified-name for a conversion operator to TYPE. */
1090 write_conversion_operator_name (const tree type)
1092 write_string ("cv");
1096 /* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1098 <source-name> ::= </length/ number> <identifier> */
1101 write_source_name (tree identifier)
1103 MANGLE_TRACE_TREE ("source-name", identifier);
1105 /* Never write the whole template-id name including the template
1106 arguments; we only want the template name. */
1107 if (IDENTIFIER_TEMPLATE (identifier))
1108 identifier = IDENTIFIER_TEMPLATE (identifier);
1110 write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1111 write_identifier (IDENTIFIER_POINTER (identifier));
1114 /* Convert NUMBER to ascii using base BASE and generating at least
1115 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1116 into which to store the characters. Returns the number of
1117 characters generated (these will be layed out in advance of where
1121 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1122 char *buffer, const unsigned int min_digits)
1124 static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1125 unsigned digits = 0;
1129 unsigned HOST_WIDE_INT d = number / base;
1131 *--buffer = base_digits[number - d * base];
1135 while (digits < min_digits)
1137 *--buffer = base_digits[0];
1143 /* Non-terminal <number>.
1145 <number> ::= [n] </decimal integer/> */
1148 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1149 const unsigned int base)
1151 char buffer[sizeof (HOST_WIDE_INT) * 8];
1154 if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1157 number = -((HOST_WIDE_INT) number);
1159 count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1160 write_chars (buffer + sizeof (buffer) - count, count);
1163 /* Write out an integral CST in decimal. Most numbers are small, and
1164 representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1165 bigger than that, which we must deal with. */
1168 write_integer_cst (const tree cst)
1170 int sign = tree_int_cst_sgn (cst);
1172 if (TREE_INT_CST_HIGH (cst) + (sign < 0))
1174 /* A bignum. We do this in chunks, each of which fits in a
1176 char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1177 unsigned HOST_WIDE_INT chunk;
1178 unsigned chunk_digits;
1179 char *ptr = buffer + sizeof (buffer);
1184 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1189 if (sizeof (HOST_WIDE_INT) >= 8)
1191 /* It is at least 64 bits, so 10^18 is representable. */
1196 type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1197 base = build_int_cstu (type, chunk);
1198 n = build_int_cst_wide (type,
1199 TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
1204 n = fold (build1 (NEGATE_EXPR, type, n));
1208 tree d = fold (build2 (FLOOR_DIV_EXPR, type, n, base));
1209 tree tmp = fold (build2 (MULT_EXPR, type, d, base));
1212 done = integer_zerop (d);
1213 tmp = fold (build2 (MINUS_EXPR, type, n, tmp));
1214 c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1215 done ? 1 : chunk_digits);
1221 write_chars (ptr, count);
1226 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
1233 write_unsigned_number (low);
1237 /* Write out a floating-point literal.
1239 "Floating-point literals are encoded using the bit pattern of the
1240 target processor's internal representation of that number, as a
1241 fixed-length lowercase hexadecimal string, high-order bytes first
1242 (even if the target processor would store low-order bytes first).
1243 The "n" prefix is not used for floating-point literals; the sign
1244 bit is encoded with the rest of the number.
1246 Here are some examples, assuming the IEEE standard representation
1247 for floating point numbers. (Spaces are for readability, not
1248 part of the encoding.)
1251 -1.0f Lf bf80 0000 E
1252 1.17549435e-38f Lf 0080 0000 E
1253 1.40129846e-45f Lf 0000 0001 E
1254 0.0f Lf 0000 0000 E"
1256 Caller is responsible for the Lx and the E. */
1258 write_real_cst (const tree value)
1260 if (abi_version_at_least (2))
1262 long target_real[4]; /* largest supported float */
1263 char buffer[9]; /* eight hex digits in a 32-bit number */
1266 tree type = TREE_TYPE (value);
1267 int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1269 real_to_target (target_real, &TREE_REAL_CST (value),
1272 /* The value in target_real is in the target word order,
1273 so we must write it out backward if that happens to be
1274 little-endian. write_number cannot be used, it will
1275 produce uppercase. */
1276 if (FLOAT_WORDS_BIG_ENDIAN)
1277 i = 0, limit = words, dir = 1;
1279 i = words - 1, limit = -1, dir = -1;
1281 for (; i != limit; i += dir)
1283 sprintf (buffer, "%08lx", target_real[i]);
1284 write_chars (buffer, 8);
1289 /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out
1290 literally. Note that compatibility with 3.2 is impossible,
1291 because the old floating-point emulator used a different
1292 format for REAL_VALUE_TYPE. */
1294 for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1295 write_number (((unsigned char *) &TREE_REAL_CST (value))[i],
1298 G.need_abi_warning = 1;
1302 /* Non-terminal <identifier>.
1304 <identifier> ::= </unqualified source code identifier> */
1307 write_identifier (const char *identifier)
1309 MANGLE_TRACE ("identifier", identifier);
1310 write_string (identifier);
1313 /* Handle constructor productions of non-terminal <special-name>.
1314 CTOR is a constructor FUNCTION_DECL.
1316 <special-name> ::= C1 # complete object constructor
1317 ::= C2 # base object constructor
1318 ::= C3 # complete object allocating constructor
1320 Currently, allocating constructors are never used.
1322 We also need to provide mangled names for the maybe-in-charge
1323 constructor, so we treat it here too. mangle_decl_string will
1324 append *INTERNAL* to that, to make sure we never emit it. */
1327 write_special_name_constructor (const tree ctor)
1329 if (DECL_BASE_CONSTRUCTOR_P (ctor))
1330 write_string ("C2");
1333 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1334 /* Even though we don't ever emit a definition of
1335 the old-style destructor, we still have to
1336 consider entities (like static variables) nested
1338 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor));
1339 write_string ("C1");
1343 /* Handle destructor productions of non-terminal <special-name>.
1344 DTOR is a destructor FUNCTION_DECL.
1346 <special-name> ::= D0 # deleting (in-charge) destructor
1347 ::= D1 # complete object (in-charge) destructor
1348 ::= D2 # base object (not-in-charge) destructor
1350 We also need to provide mangled names for the maybe-incharge
1351 destructor, so we treat it here too. mangle_decl_string will
1352 append *INTERNAL* to that, to make sure we never emit it. */
1355 write_special_name_destructor (const tree dtor)
1357 if (DECL_DELETING_DESTRUCTOR_P (dtor))
1358 write_string ("D0");
1359 else if (DECL_BASE_DESTRUCTOR_P (dtor))
1360 write_string ("D2");
1363 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1364 /* Even though we don't ever emit a definition of
1365 the old-style destructor, we still have to
1366 consider entities (like static variables) nested
1368 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor));
1369 write_string ("D1");
1373 /* Return the discriminator for ENTITY appearing inside
1374 FUNCTION. The discriminator is the lexical ordinal of VAR among
1375 entities with the same name in the same FUNCTION. */
1378 discriminator_for_local_entity (tree entity)
1382 /* Assume this is the only local entity with this name. */
1383 int discriminator = 0;
1385 if (DECL_DISCRIMINATOR_P (entity) && DECL_LANG_SPECIFIC (entity))
1386 discriminator = DECL_DISCRIMINATOR (entity);
1387 else if (TREE_CODE (entity) == TYPE_DECL)
1389 /* Scan the list of local classes. */
1390 entity = TREE_TYPE (entity);
1391 for (type = &VARRAY_TREE (local_classes, 0); *type != entity; ++type)
1392 if (TYPE_IDENTIFIER (*type) == TYPE_IDENTIFIER (entity)
1393 && TYPE_CONTEXT (*type) == TYPE_CONTEXT (entity))
1397 return discriminator;
1400 /* Return the discriminator for STRING, a string literal used inside
1401 FUNCTION. The discriminator is the lexical ordinal of STRING among
1402 string literals used in FUNCTION. */
1405 discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED,
1406 tree string ATTRIBUTE_UNUSED)
1408 /* For now, we don't discriminate amongst string literals. */
1412 /* <discriminator> := _ <number>
1414 The discriminator is used only for the second and later occurrences
1415 of the same name within a single function. In this case <number> is
1416 n - 2, if this is the nth occurrence, in lexical order. */
1419 write_discriminator (const int discriminator)
1421 /* If discriminator is zero, don't write anything. Otherwise... */
1422 if (discriminator > 0)
1425 write_unsigned_number (discriminator - 1);
1429 /* Mangle the name of a function-scope entity. FUNCTION is the
1430 FUNCTION_DECL for the enclosing function. ENTITY is the decl for
1431 the entity itself. LOCAL_ENTITY is the entity that's directly
1432 scoped in FUNCTION_DECL, either ENTITY itself or an enclosing scope
1435 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1436 := Z <function encoding> E s [<discriminator>] */
1439 write_local_name (const tree function, const tree local_entity,
1442 MANGLE_TRACE_TREE ("local-name", entity);
1445 write_encoding (function);
1447 if (TREE_CODE (entity) == STRING_CST)
1450 write_discriminator (discriminator_for_string_literal (function,
1455 /* Now the <entity name>. Let write_name know its being called
1456 from <local-name>, so it doesn't try to process the enclosing
1457 function scope again. */
1458 write_name (entity, /*ignore_local_scope=*/1);
1459 write_discriminator (discriminator_for_local_entity (local_entity));
1463 /* Non-terminals <type> and <CV-qualifier>.
1465 <type> ::= <builtin-type>
1467 ::= <class-enum-type>
1469 ::= <pointer-to-member-type>
1470 ::= <template-param>
1473 ::= P <type> # pointer-to
1474 ::= R <type> # reference-to
1475 ::= C <type> # complex pair (C 2000)
1476 ::= G <type> # imaginary (C 2000) [not supported]
1477 ::= U <source-name> <type> # vendor extended type qualifier
1479 TYPE is a type node. */
1482 write_type (tree type)
1484 /* This gets set to nonzero if TYPE turns out to be a (possibly
1485 CV-qualified) builtin type. */
1486 int is_builtin_type = 0;
1488 MANGLE_TRACE_TREE ("type", type);
1490 if (type == error_mark_node)
1493 if (find_substitution (type))
1496 if (write_CV_qualifiers_for_type (type) > 0)
1497 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1498 mangle the unqualified type. The recursive call is needed here
1499 since both the qualified and unqualified types are substitution
1501 write_type (TYPE_MAIN_VARIANT (type));
1502 else if (TREE_CODE (type) == ARRAY_TYPE)
1503 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1504 so that the cv-qualification of the element type is available
1505 in write_array_type. */
1506 write_array_type (type);
1509 /* See through any typedefs. */
1510 type = TYPE_MAIN_VARIANT (type);
1512 if (TYPE_PTRMEM_P (type))
1513 write_pointer_to_member_type (type);
1514 else switch (TREE_CODE (type))
1518 case INTEGER_TYPE: /* Includes wchar_t. */
1521 /* Handle any target-specific fundamental types. */
1522 const char *target_mangling
1523 = targetm.mangle_fundamental_type (type);
1525 if (target_mangling)
1527 write_string (target_mangling);
1531 /* If this is a typedef, TYPE may not be one of
1532 the standard builtin type nodes, but an alias of one. Use
1533 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
1534 write_builtin_type (TYPE_MAIN_VARIANT (type));
1541 write_type (TREE_TYPE (type));
1546 write_function_type (type);
1552 /* A pointer-to-member function is represented as a special
1553 RECORD_TYPE, so check for this first. */
1554 if (TYPE_PTRMEMFUNC_P (type))
1555 write_pointer_to_member_type (type);
1557 write_class_enum_type (type);
1561 case UNBOUND_CLASS_TEMPLATE:
1562 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1563 ordinary nested names. */
1564 write_nested_name (TYPE_STUB_DECL (type));
1569 write_type (TREE_TYPE (type));
1572 case REFERENCE_TYPE:
1574 write_type (TREE_TYPE (type));
1577 case TEMPLATE_TYPE_PARM:
1578 case TEMPLATE_PARM_INDEX:
1579 write_template_param (type);
1582 case TEMPLATE_TEMPLATE_PARM:
1583 write_template_template_param (type);
1586 case BOUND_TEMPLATE_TEMPLATE_PARM:
1587 write_template_template_param (type);
1589 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1593 write_string ("U8__vector");
1594 write_type (TREE_TYPE (type));
1602 /* Types other than builtin types are substitution candidates. */
1603 if (!is_builtin_type)
1604 add_substitution (type);
1607 /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
1608 CV-qualifiers written for TYPE.
1610 <CV-qualifiers> ::= [r] [V] [K] */
1613 write_CV_qualifiers_for_type (const tree type)
1615 int num_qualifiers = 0;
1617 /* The order is specified by:
1619 "In cases where multiple order-insensitive qualifiers are
1620 present, they should be ordered 'K' (closest to the base type),
1621 'V', 'r', and 'U' (farthest from the base type) ..."
1623 Note that we do not use cp_type_quals below; given "const
1624 int[3]", the "const" is emitted with the "int", not with the
1627 if (TYPE_QUALS (type) & TYPE_QUAL_RESTRICT)
1632 if (TYPE_QUALS (type) & TYPE_QUAL_VOLATILE)
1637 if (TYPE_QUALS (type) & TYPE_QUAL_CONST)
1643 return num_qualifiers;
1646 /* Non-terminal <builtin-type>.
1648 <builtin-type> ::= v # void
1653 ::= h # unsigned char
1655 ::= t # unsigned short
1657 ::= j # unsigned int
1659 ::= m # unsigned long
1660 ::= x # long long, __int64
1661 ::= y # unsigned long long, __int64
1663 ::= o # unsigned __int128
1666 ::= e # long double, __float80
1667 ::= g # __float128 [not supported]
1668 ::= u <source-name> # vendor extended type */
1671 write_builtin_type (tree type)
1673 switch (TREE_CODE (type))
1684 /* If this is size_t, get the underlying int type. */
1685 if (TYPE_IS_SIZETYPE (type))
1686 type = TYPE_DOMAIN (type);
1688 /* TYPE may still be wchar_t, since that isn't in
1689 integer_type_nodes. */
1690 if (type == wchar_type_node)
1692 else if (TYPE_FOR_JAVA (type))
1693 write_java_integer_type_codes (type);
1697 /* Assume TYPE is one of the shared integer type nodes. Find
1698 it in the array of these nodes. */
1700 for (itk = 0; itk < itk_none; ++itk)
1701 if (type == integer_types[itk])
1703 /* Print the corresponding single-letter code. */
1704 write_char (integer_type_codes[itk]);
1708 if (itk == itk_none)
1710 tree t = c_common_type_for_mode (TYPE_MODE (type),
1711 TYPE_UNSIGNED (type));
1714 gcc_assert (TYPE_PRECISION (type) == 128);
1715 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
1727 if (type == float_type_node
1728 || type == java_float_type_node)
1730 else if (type == double_type_node
1731 || type == java_double_type_node)
1733 else if (type == long_double_type_node)
1744 /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
1745 METHOD_TYPE. The return type is mangled before the parameter
1748 <function-type> ::= F [Y] <bare-function-type> E */
1751 write_function_type (const tree type)
1753 MANGLE_TRACE_TREE ("function-type", type);
1755 /* For a pointer to member function, the function type may have
1756 cv-qualifiers, indicating the quals for the artificial 'this'
1758 if (TREE_CODE (type) == METHOD_TYPE)
1760 /* The first parameter must be a POINTER_TYPE pointing to the
1761 `this' parameter. */
1762 tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
1763 write_CV_qualifiers_for_type (this_type);
1767 /* We don't track whether or not a type is `extern "C"'. Note that
1768 you can have an `extern "C"' function that does not have
1769 `extern "C"' type, and vice versa:
1771 extern "C" typedef void function_t();
1772 function_t f; // f has C++ linkage, but its type is
1775 typedef void function_t();
1776 extern "C" function_t f; // Vice versa.
1779 write_bare_function_type (type, /*include_return_type_p=*/1,
1784 /* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
1785 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
1786 is mangled before the parameter types. If non-NULL, DECL is
1787 FUNCTION_DECL for the function whose type is being emitted.
1789 <bare-function-type> ::= </signature/ type>+ */
1792 write_bare_function_type (const tree type, const int include_return_type_p,
1795 MANGLE_TRACE_TREE ("bare-function-type", type);
1797 /* Mangle the return type, if requested. */
1798 if (include_return_type_p)
1799 write_type (TREE_TYPE (type));
1801 /* Now mangle the types of the arguments. */
1802 write_method_parms (TYPE_ARG_TYPES (type),
1803 TREE_CODE (type) == METHOD_TYPE,
1807 /* Write the mangled representation of a method parameter list of
1808 types given in PARM_TYPES. If METHOD_P is nonzero, the function is
1809 considered a non-static method, and the this parameter is omitted.
1810 If non-NULL, DECL is the FUNCTION_DECL for the function whose
1811 parameters are being emitted. */
1814 write_method_parms (tree parm_types, const int method_p, const tree decl)
1816 tree first_parm_type;
1817 tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
1819 /* Assume this parameter type list is variable-length. If it ends
1820 with a void type, then it's not. */
1823 /* If this is a member function, skip the first arg, which is the
1825 "Member functions do not encode the type of their implicit this
1828 Similarly, there's no need to mangle artificial parameters, like
1829 the VTT parameters for constructors and destructors. */
1832 parm_types = TREE_CHAIN (parm_types);
1833 parm_decl = parm_decl ? TREE_CHAIN (parm_decl) : NULL_TREE;
1835 while (parm_decl && DECL_ARTIFICIAL (parm_decl))
1837 parm_types = TREE_CHAIN (parm_types);
1838 parm_decl = TREE_CHAIN (parm_decl);
1842 for (first_parm_type = parm_types;
1844 parm_types = TREE_CHAIN (parm_types))
1846 tree parm = TREE_VALUE (parm_types);
1847 if (parm == void_type_node)
1849 /* "Empty parameter lists, whether declared as () or
1850 conventionally as (void), are encoded with a void parameter
1852 if (parm_types == first_parm_type)
1854 /* If the parm list is terminated with a void type, it's
1857 /* A void type better be the last one. */
1858 gcc_assert (TREE_CHAIN (parm_types) == NULL);
1865 /* <builtin-type> ::= z # ellipsis */
1869 /* <class-enum-type> ::= <name> */
1872 write_class_enum_type (const tree type)
1874 write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
1877 /* Non-terminal <template-args>. ARGS is a TREE_VEC of template
1880 <template-args> ::= I <template-arg>+ E */
1883 write_template_args (tree args)
1886 int length = TREE_VEC_LENGTH (args);
1888 MANGLE_TRACE_TREE ("template-args", args);
1892 gcc_assert (length > 0);
1894 if (TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
1896 /* We have nested template args. We want the innermost template
1898 args = TREE_VEC_ELT (args, length - 1);
1899 length = TREE_VEC_LENGTH (args);
1901 for (i = 0; i < length; ++i)
1902 write_template_arg (TREE_VEC_ELT (args, i));
1907 /* <expression> ::= <unary operator-name> <expression>
1908 ::= <binary operator-name> <expression> <expression>
1911 <expr-primary> ::= <template-param>
1912 ::= L <type> <value number> E # literal
1913 ::= L <mangled-name> E # external name
1914 ::= sr <type> <unqualified-name>
1915 ::= sr <type> <unqualified-name> <template-args> */
1918 write_expression (tree expr)
1920 enum tree_code code;
1922 code = TREE_CODE (expr);
1924 /* Handle pointers-to-members by making them look like expression
1926 if (code == PTRMEM_CST)
1928 expr = build_nt (ADDR_EXPR,
1929 build_nt (SCOPE_REF,
1930 PTRMEM_CST_CLASS (expr),
1931 PTRMEM_CST_MEMBER (expr)));
1932 code = TREE_CODE (expr);
1935 /* Skip NOP_EXPRs. They can occur when (say) a pointer argument
1936 is converted (via qualification conversions) to another
1938 while (TREE_CODE (expr) == NOP_EXPR
1939 || TREE_CODE (expr) == NON_LVALUE_EXPR)
1941 expr = TREE_OPERAND (expr, 0);
1942 code = TREE_CODE (expr);
1945 /* Handle template parameters. */
1946 if (code == TEMPLATE_TYPE_PARM
1947 || code == TEMPLATE_TEMPLATE_PARM
1948 || code == BOUND_TEMPLATE_TEMPLATE_PARM
1949 || code == TEMPLATE_PARM_INDEX)
1950 write_template_param (expr);
1951 /* Handle literals. */
1952 else if (TREE_CODE_CLASS (code) == 'c'
1953 || (abi_version_at_least (2) && code == CONST_DECL))
1954 write_template_arg_literal (expr);
1955 else if (DECL_P (expr))
1957 /* G++ 3.2 incorrectly mangled non-type template arguments of
1958 enumeration type using their names. */
1959 if (code == CONST_DECL)
1960 G.need_abi_warning = 1;
1962 write_mangled_name (expr, false);
1965 else if (TREE_CODE (expr) == SIZEOF_EXPR
1966 && TYPE_P (TREE_OPERAND (expr, 0)))
1968 write_string ("st");
1969 write_type (TREE_OPERAND (expr, 0));
1971 else if (abi_version_at_least (2) && TREE_CODE (expr) == SCOPE_REF)
1973 tree scope = TREE_OPERAND (expr, 0);
1974 tree member = TREE_OPERAND (expr, 1);
1976 /* If the MEMBER is a real declaration, then the qualifying
1977 scope was not dependent. Ideally, we would not have a
1978 SCOPE_REF in those cases, but sometimes we do. If the second
1979 argument is a DECL, then the name must not have been
1981 if (DECL_P (member))
1982 write_expression (member);
1987 write_string ("sr");
1989 /* If MEMBER is a template-id, separate the template
1990 from the arguments. */
1991 if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
1993 template_args = TREE_OPERAND (member, 1);
1994 member = TREE_OPERAND (member, 0);
1997 template_args = NULL_TREE;
1998 /* Write out the name of the MEMBER. */
1999 if (IDENTIFIER_TYPENAME_P (member))
2000 write_conversion_operator_name (TREE_TYPE (member));
2001 else if (IDENTIFIER_OPNAME_P (member))
2004 const char *mangled_name = NULL;
2006 /* Unfortunately, there is no easy way to go from the
2007 name of the operator back to the corresponding tree
2009 for (i = 0; i < LAST_CPLUS_TREE_CODE; ++i)
2010 if (operator_name_info[i].identifier == member)
2012 /* The ABI says that we prefer binary operator
2013 names to unary operator names. */
2014 if (operator_name_info[i].arity == 2)
2016 mangled_name = operator_name_info[i].mangled_name;
2019 else if (!mangled_name)
2020 mangled_name = operator_name_info[i].mangled_name;
2022 else if (assignment_operator_name_info[i].identifier
2026 = assignment_operator_name_info[i].mangled_name;
2029 write_string (mangled_name);
2032 write_source_name (member);
2033 /* Write out the template arguments. */
2035 write_template_args (template_args);
2042 /* When we bind a variable or function to a non-type template
2043 argument with reference type, we create an ADDR_EXPR to show
2044 the fact that the entity's address has been taken. But, we
2045 don't actually want to output a mangling code for the `&'. */
2046 if (TREE_CODE (expr) == ADDR_EXPR
2048 && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2050 expr = TREE_OPERAND (expr, 0);
2053 write_expression (expr);
2057 code = TREE_CODE (expr);
2060 /* If it wasn't any of those, recursively expand the expression. */
2061 write_string (operator_name_info[(int) code].mangled_name);
2066 sorry ("call_expr cannot be mangled due to a defect in the C++ ABI");
2070 write_type (TREE_TYPE (expr));
2071 /* There is no way to mangle a zero-operand cast like
2073 if (!TREE_OPERAND (expr, 0))
2074 sorry ("zero-operand casts cannot be mangled due to a defect "
2077 write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2080 case STATIC_CAST_EXPR:
2081 case CONST_CAST_EXPR:
2082 write_type (TREE_TYPE (expr));
2083 write_expression (TREE_OPERAND (expr, 0));
2087 /* Handle pointers-to-members specially. */
2089 write_type (TREE_OPERAND (expr, 0));
2090 if (TREE_CODE (TREE_OPERAND (expr, 1)) == IDENTIFIER_NODE)
2091 write_source_name (TREE_OPERAND (expr, 1));
2092 else if (TREE_CODE (TREE_OPERAND (expr, 1)) == TEMPLATE_ID_EXPR)
2097 template_id = TREE_OPERAND (expr, 1);
2098 name = TREE_OPERAND (template_id, 0);
2099 /* FIXME: What about operators? */
2100 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2101 write_source_name (TREE_OPERAND (template_id, 0));
2102 write_template_args (TREE_OPERAND (template_id, 1));
2106 /* G++ 3.2 incorrectly put out both the "sr" code and
2107 the nested name of the qualified name. */
2108 G.need_abi_warning = 1;
2109 write_encoding (TREE_OPERAND (expr, 1));
2114 for (i = 0; i < TREE_CODE_LENGTH (code); ++i)
2116 tree operand = TREE_OPERAND (expr, i);
2117 /* As a GNU expression, the middle operand of a
2118 conditional may be omitted. Since expression
2119 manglings are supposed to represent the input token
2120 stream, there's no good way to mangle such an
2121 expression without extending the C++ ABI. */
2122 if (code == COND_EXPR && i == 1 && !operand)
2124 error ("omitted middle operand to `?:' operand "
2125 "cannot be mangled");
2128 write_expression (operand);
2134 /* Literal subcase of non-terminal <template-arg>.
2136 "Literal arguments, e.g. "A<42L>", are encoded with their type
2137 and value. Negative integer values are preceded with "n"; for
2138 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2139 encoded as 0, true as 1." */
2142 write_template_arg_literal (const tree value)
2145 write_type (TREE_TYPE (value));
2147 switch (TREE_CODE (value))
2150 write_integer_cst (DECL_INITIAL (value));
2154 gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2155 || integer_zerop (value) || integer_onep (value));
2156 write_integer_cst (value);
2160 write_real_cst (value);
2170 /* Non-terminal <template-arg>.
2172 <template-arg> ::= <type> # type
2173 ::= L <type> </value/ number> E # literal
2174 ::= LZ <name> E # external name
2175 ::= X <expression> E # expression */
2178 write_template_arg (tree node)
2180 enum tree_code code = TREE_CODE (node);
2182 MANGLE_TRACE_TREE ("template-arg", node);
2184 /* A template template parameter's argument list contains TREE_LIST
2185 nodes of which the value field is the the actual argument. */
2186 if (code == TREE_LIST)
2188 node = TREE_VALUE (node);
2189 /* If it's a decl, deal with its type instead. */
2192 node = TREE_TYPE (node);
2193 code = TREE_CODE (node);
2197 if (TREE_CODE (node) == NOP_EXPR
2198 && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2200 /* Template parameters can be of reference type. To maintain
2201 internal consistency, such arguments use a conversion from
2202 address of object to reference type. */
2203 gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2204 if (abi_version_at_least (2))
2205 node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2207 G.need_abi_warning = 1;
2212 else if (code == TEMPLATE_DECL)
2213 /* A template appearing as a template arg is a template template arg. */
2214 write_template_template_arg (node);
2215 else if ((TREE_CODE_CLASS (code) == 'c' && code != PTRMEM_CST)
2216 || (abi_version_at_least (2) && code == CONST_DECL))
2217 write_template_arg_literal (node);
2218 else if (DECL_P (node))
2220 /* Until ABI version 2, non-type template arguments of
2221 enumeration type were mangled using their names. */
2222 if (code == CONST_DECL && !abi_version_at_least (2))
2223 G.need_abi_warning = 1;
2225 /* Until ABI version 3, the underscore before the mangled name
2226 was incorrectly omitted. */
2227 if (!abi_version_at_least (3))
2229 G.need_abi_warning = 1;
2233 write_string ("_Z");
2234 write_encoding (node);
2239 /* Template arguments may be expressions. */
2241 write_expression (node);
2246 /* <template-template-arg>
2248 ::= <substitution> */
2251 write_template_template_arg (const tree decl)
2253 MANGLE_TRACE_TREE ("template-template-arg", decl);
2255 if (find_substitution (decl))
2257 write_name (decl, /*ignore_local_scope=*/0);
2258 add_substitution (decl);
2262 /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
2264 <array-type> ::= A [</dimension/ number>] _ </element/ type>
2265 ::= A <expression> _ </element/ type>
2267 "Array types encode the dimension (number of elements) and the
2268 element type. For variable length arrays, the dimension (but not
2269 the '_' separator) is omitted." */
2272 write_array_type (const tree type)
2275 if (TYPE_DOMAIN (type))
2280 index_type = TYPE_DOMAIN (type);
2281 /* The INDEX_TYPE gives the upper and lower bounds of the
2283 max = TYPE_MAX_VALUE (index_type);
2284 if (TREE_CODE (max) == INTEGER_CST)
2286 /* The ABI specifies that we should mangle the number of
2287 elements in the array, not the largest allowed index. */
2288 max = size_binop (PLUS_EXPR, max, size_one_node);
2289 write_unsigned_number (tree_low_cst (max, 1));
2293 max = TREE_OPERAND (max, 0);
2294 if (!abi_version_at_least (2))
2296 /* value_dependent_expression_p presumes nothing is
2297 dependent when PROCESSING_TEMPLATE_DECL is zero. */
2298 ++processing_template_decl;
2299 if (!value_dependent_expression_p (max))
2300 G.need_abi_warning = 1;
2301 --processing_template_decl;
2303 write_expression (max);
2308 write_type (TREE_TYPE (type));
2311 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2312 variables. TYPE is a pointer-to-member POINTER_TYPE.
2314 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
2317 write_pointer_to_member_type (const tree type)
2320 write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2321 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2324 /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
2325 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2326 TEMPLATE_PARM_INDEX.
2328 <template-param> ::= T </parameter/ number> _ */
2331 write_template_param (const tree parm)
2335 tree parm_type = NULL_TREE;
2337 MANGLE_TRACE_TREE ("template-parm", parm);
2339 switch (TREE_CODE (parm))
2341 case TEMPLATE_TYPE_PARM:
2342 case TEMPLATE_TEMPLATE_PARM:
2343 case BOUND_TEMPLATE_TEMPLATE_PARM:
2344 parm_index = TEMPLATE_TYPE_IDX (parm);
2345 parm_level = TEMPLATE_TYPE_LEVEL (parm);
2348 case TEMPLATE_PARM_INDEX:
2349 parm_index = TEMPLATE_PARM_IDX (parm);
2350 parm_level = TEMPLATE_PARM_LEVEL (parm);
2351 parm_type = TREE_TYPE (TEMPLATE_PARM_DECL (parm));
2359 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2360 earliest template param denoted by `_'. */
2362 write_unsigned_number (parm_index - 1);
2366 /* <template-template-param>
2367 ::= <template-param>
2368 ::= <substitution> */
2371 write_template_template_param (const tree parm)
2373 tree template = NULL_TREE;
2375 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2376 template template parameter. The substitution candidate here is
2377 only the template. */
2378 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2381 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2382 if (find_substitution (template))
2386 /* <template-param> encodes only the template parameter position,
2387 not its template arguments, which is fine here. */
2388 write_template_param (parm);
2390 add_substitution (template);
2393 /* Non-terminal <substitution>.
2395 <substitution> ::= S <seq-id> _
2399 write_substitution (const int seq_id)
2401 MANGLE_TRACE ("substitution", "");
2405 write_number (seq_id - 1, /*unsigned=*/1, 36);
2409 /* Start mangling ENTITY. */
2412 start_mangling (const tree entity, const bool ident_p)
2415 G.need_abi_warning = false;
2418 obstack_free (&name_obstack, name_base);
2419 mangle_obstack = &name_obstack;
2420 name_base = obstack_alloc (&name_obstack, 0);
2423 mangle_obstack = &ident_hash->stack;
2426 /* Done with mangling. Return the generated mangled name. If WARN is
2427 true, and the name of G.entity will be mangled differently in a
2428 future version of the ABI, issue a warning. */
2430 static inline const char *
2431 finish_mangling (const bool warn)
2433 if (warn_abi && warn && G.need_abi_warning)
2434 warning ("the mangled name of `%D' will change in a future "
2438 /* Clear all the substitutions. */
2439 VARRAY_CLEAR (G.substitutions);
2441 /* Null-terminate the string. */
2444 return (const char *) obstack_finish (mangle_obstack);
2447 /* Initialize data structures for mangling. */
2452 gcc_obstack_init (&name_obstack);
2453 name_base = obstack_alloc (&name_obstack, 0);
2454 VARRAY_TREE_INIT (G.substitutions, 1, "mangling substitutions");
2456 /* Cache these identifiers for quick comparison when checking for
2457 standard substitutions. */
2458 subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2459 subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
2460 subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
2461 subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
2462 subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
2463 subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2466 /* Generate the mangled name of DECL. */
2469 mangle_decl_string (const tree decl)
2473 start_mangling (decl, /*ident_p=*/true);
2475 if (TREE_CODE (decl) == TYPE_DECL)
2476 write_type (TREE_TYPE (decl));
2478 write_mangled_name (decl, true);
2480 result = finish_mangling (/*warn=*/true);
2482 fprintf (stderr, "mangle_decl_string = '%s'\n\n", result);
2486 /* Like get_identifier, except that NAME is assumed to have been
2487 allocated on the obstack used by the identifier hash table. */
2490 get_identifier_nocopy (const char *name)
2492 hashnode ht_node = ht_lookup (ident_hash, (const unsigned char *) name,
2493 strlen (name), HT_ALLOCED);
2494 return HT_IDENT_TO_GCC_IDENT (ht_node);
2497 /* Create an identifier for the external mangled name of DECL. */
2500 mangle_decl (const tree decl)
2502 SET_DECL_ASSEMBLER_NAME (decl,
2503 get_identifier_nocopy (mangle_decl_string (decl)));
2506 /* Generate the mangled representation of TYPE. */
2509 mangle_type_string (const tree type)
2513 start_mangling (type, /*ident_p=*/false);
2515 result = finish_mangling (/*warn=*/false);
2517 fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2521 /* Create an identifier for the mangled name of a special component
2522 for belonging to TYPE. CODE is the ABI-specified code for this
2526 mangle_special_for_type (const tree type, const char *code)
2530 /* We don't have an actual decl here for the special component, so
2531 we can't just process the <encoded-name>. Instead, fake it. */
2532 start_mangling (type, /*ident_p=*/true);
2534 /* Start the mangling. */
2535 write_string ("_Z");
2536 write_string (code);
2540 result = finish_mangling (/*warn=*/false);
2543 fprintf (stderr, "mangle_special_for_type = %s\n\n", result);
2545 return get_identifier_nocopy (result);
2548 /* Create an identifier for the mangled representation of the typeinfo
2549 structure for TYPE. */
2552 mangle_typeinfo_for_type (const tree type)
2554 return mangle_special_for_type (type, "TI");
2557 /* Create an identifier for the mangled name of the NTBS containing
2558 the mangled name of TYPE. */
2561 mangle_typeinfo_string_for_type (const tree type)
2563 return mangle_special_for_type (type, "TS");
2566 /* Create an identifier for the mangled name of the vtable for TYPE. */
2569 mangle_vtbl_for_type (const tree type)
2571 return mangle_special_for_type (type, "TV");
2574 /* Returns an identifier for the mangled name of the VTT for TYPE. */
2577 mangle_vtt_for_type (const tree type)
2579 return mangle_special_for_type (type, "TT");
2582 /* Return an identifier for a construction vtable group. TYPE is
2583 the most derived class in the hierarchy; BINFO is the base
2584 subobject for which this construction vtable group will be used.
2586 This mangling isn't part of the ABI specification; in the ABI
2587 specification, the vtable group is dumped in the same COMDAT as the
2588 main vtable, and is referenced only from that vtable, so it doesn't
2589 need an external name. For binary formats without COMDAT sections,
2590 though, we need external names for the vtable groups.
2592 We use the production
2594 <special-name> ::= CT <type> <offset number> _ <base type> */
2597 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
2601 start_mangling (type, /*ident_p=*/true);
2603 write_string ("_Z");
2604 write_string ("TC");
2606 write_integer_cst (BINFO_OFFSET (binfo));
2608 write_type (BINFO_TYPE (binfo));
2610 result = finish_mangling (/*warn=*/false);
2612 fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n", result);
2613 return get_identifier_nocopy (result);
2616 /* Mangle a this pointer or result pointer adjustment.
2618 <call-offset> ::= h <fixed offset number> _
2619 ::= v <fixed offset number> _ <virtual offset number> _ */
2622 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
2624 write_char (virtual_offset ? 'v' : 'h');
2626 /* For either flavor, write the fixed offset. */
2627 write_integer_cst (fixed_offset);
2630 /* For a virtual thunk, add the virtual offset. */
2633 write_integer_cst (virtual_offset);
2638 /* Return an identifier for the mangled name of a this-adjusting or
2639 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment
2640 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this
2641 is a virtual thunk, and it is the vtbl offset in
2642 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
2643 zero for a covariant thunk. Note, that FN_DECL might be a covariant
2644 thunk itself. A covariant thunk name always includes the adjustment
2645 for the this pointer, even if there is none.
2647 <special-name> ::= T <call-offset> <base encoding>
2648 ::= Tc <this_adjust call-offset> <result_adjust call-offset>
2653 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
2654 tree virtual_offset)
2658 start_mangling (fn_decl, /*ident_p=*/true);
2660 write_string ("_Z");
2663 if (!this_adjusting)
2665 /* Covariant thunk with no this adjustment */
2667 mangle_call_offset (integer_zero_node, NULL_TREE);
2668 mangle_call_offset (fixed_offset, virtual_offset);
2670 else if (!DECL_THUNK_P (fn_decl))
2671 /* Plain this adjusting thunk. */
2672 mangle_call_offset (fixed_offset, virtual_offset);
2675 /* This adjusting thunk to covariant thunk. */
2677 mangle_call_offset (fixed_offset, virtual_offset);
2678 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
2679 virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
2681 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
2682 mangle_call_offset (fixed_offset, virtual_offset);
2683 fn_decl = THUNK_TARGET (fn_decl);
2687 write_encoding (fn_decl);
2689 result = finish_mangling (/*warn=*/false);
2691 fprintf (stderr, "mangle_thunk = %s\n\n", result);
2692 return get_identifier_nocopy (result);
2695 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
2696 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
2699 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
2701 /* Hash a node (VAL1) in the table. */
2704 hash_type (const void *val)
2706 return (hashval_t) TYPE_UID (TREE_TYPE ((tree) val));
2709 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */
2712 compare_type (const void *val1, const void *val2)
2714 return TREE_TYPE ((tree) val1) == (tree) val2;
2717 /* Return an identifier for the mangled unqualified name for a
2718 conversion operator to TYPE. This mangling is not specified by the
2719 ABI spec; it is only used internally. */
2722 mangle_conv_op_name_for_type (const tree type)
2727 if (conv_type_names == NULL)
2728 conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
2730 slot = htab_find_slot_with_hash (conv_type_names, type,
2731 (hashval_t) TYPE_UID (type), INSERT);
2732 identifier = (tree)*slot;
2737 /* Create a unique name corresponding to TYPE. */
2738 sprintf (buffer, "operator %lu",
2739 (unsigned long) htab_elements (conv_type_names));
2740 identifier = get_identifier (buffer);
2743 /* Hang TYPE off the identifier so it can be found easily later
2744 when performing conversions. */
2745 TREE_TYPE (identifier) = type;
2747 /* Set bits on the identifier so we know later it's a conversion. */
2748 IDENTIFIER_OPNAME_P (identifier) = 1;
2749 IDENTIFIER_TYPENAME_P (identifier) = 1;
2755 /* Return an identifier for the name of an initialization guard
2756 variable for indicated VARIABLE. */
2759 mangle_guard_variable (const tree variable)
2761 start_mangling (variable, /*ident_p=*/true);
2762 write_string ("_ZGV");
2763 if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
2764 /* The name of a guard variable for a reference temporary should refer
2765 to the reference, not the temporary. */
2766 write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
2768 write_name (variable, /*ignore_local_scope=*/0);
2769 return get_identifier_nocopy (finish_mangling (/*warn=*/false));
2772 /* Return an identifier for the name of a temporary variable used to
2773 initialize a static reference. This isn't part of the ABI, but we might
2774 as well call them something readable. */
2777 mangle_ref_init_variable (const tree variable)
2779 start_mangling (variable, /*ident_p=*/true);
2780 write_string ("_ZGR");
2781 write_name (variable, /*ignore_local_scope=*/0);
2782 return get_identifier_nocopy (finish_mangling (/*warn=*/false));
2786 /* Foreign language type mangling section. */
2788 /* How to write the type codes for the integer Java type. */
2791 write_java_integer_type_codes (const tree type)
2793 if (type == java_int_type_node)
2795 else if (type == java_short_type_node)
2797 else if (type == java_byte_type_node)
2799 else if (type == java_char_type_node)
2801 else if (type == java_long_type_node)
2803 else if (type == java_boolean_type_node)
2809 #include "gt-cp-mangle.h"