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>
6 This file is part of GCC.
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)
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.
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/>. */
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 */
50 #include "coretypes.h"
62 /* Debugging support. */
64 /* Define DEBUG_MANGLE to enable very verbose trace messages. */
66 #define DEBUG_MANGLE 0
69 /* Macros for tracing the write_* functions. */
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))
77 # define MANGLE_TRACE(FN, INPUT)
78 # define MANGLE_TRACE_TREE(FN, NODE)
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))))))
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
96 VEC(tree,gc) *substitutions;
98 /* The entity that is being mangled. */
99 tree GTY ((skip)) entity;
101 /* True if the mangling will be different in a future version of the
103 bool need_abi_warning;
106 static GTY (()) globals G;
108 /* Whether or not to pretend that a static function is in an anonymous
110 static bool fake_anon_scope;
112 /* The obstack on which we build mangled names. */
113 static struct obstack *mangle_obstack;
115 /* The obstack on which we build mangled names that are not going to
116 be IDENTIFIER_NODEs. */
117 static struct obstack name_obstack;
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;
123 /* Indices into subst_identifiers. These are identifiers used in
124 special substitution rules. */
132 SUBID_BASIC_IOSTREAM,
135 substitution_identifier_index_t;
137 /* For quick substitution checks, look up these common identifiers
139 static GTY(()) tree subst_identifiers[SUBID_MAX];
141 /* Single-letter codes for builtin integer types, defined in
142 <builtin-type>. These are indexed by integer_type_kind values. */
144 integer_type_codes[itk_none] =
147 'a', /* itk_signed_char */
148 'h', /* itk_unsigned_char */
150 't', /* itk_unsigned_short */
152 'j', /* itk_unsigned_int */
154 'm', /* itk_unsigned_long */
155 'x', /* itk_long_long */
156 'y' /* itk_unsigned_long_long */
159 static int decl_is_template_id (const tree, tree* const);
161 /* Functions for handling substitutions. */
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);
172 /* Functions for emitting mangled representations of things. */
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 int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
187 static void write_number (unsigned HOST_WIDE_INT, const int,
189 static void write_integer_cst (const tree);
190 static void write_real_cst (const tree);
191 static void write_identifier (const char *);
192 static void write_special_name_constructor (const tree);
193 static void write_special_name_destructor (const tree);
194 static void write_type (tree);
195 static int write_CV_qualifiers_for_type (const tree);
196 static void write_builtin_type (tree);
197 static void write_function_type (const tree);
198 static void write_bare_function_type (const tree, const int, const tree);
199 static void write_method_parms (tree, const int, const tree);
200 static void write_class_enum_type (const tree);
201 static void write_template_args (tree);
202 static void write_expression (tree);
203 static void write_template_arg_literal (const tree);
204 static void write_template_arg (tree);
205 static void write_template_template_arg (const tree);
206 static void write_array_type (const tree);
207 static void write_pointer_to_member_type (const tree);
208 static void write_template_param (const tree);
209 static void write_template_template_param (const tree);
210 static void write_substitution (const int);
211 static int discriminator_for_local_entity (tree);
212 static int discriminator_for_string_literal (tree, tree);
213 static void write_discriminator (const int);
214 static void write_local_name (const tree, const tree, const tree);
215 static void dump_substitution_candidates (void);
216 static tree mangle_decl_string (const tree);
218 /* Control functions. */
220 static inline void start_mangling (const tree);
221 static inline const char *finish_mangling (const bool);
222 static tree mangle_special_for_type (const tree, const char *);
224 /* Foreign language functions. */
226 static void write_java_integer_type_codes (const tree);
228 /* Append a single character to the end of the mangled
230 #define write_char(CHAR) \
231 obstack_1grow (mangle_obstack, (CHAR))
233 /* Append a sized buffer to the end of the mangled representation. */
234 #define write_chars(CHAR, LEN) \
235 obstack_grow (mangle_obstack, (CHAR), (LEN))
237 /* Append a NUL-terminated string to the end of the mangled
239 #define write_string(STRING) \
240 obstack_grow (mangle_obstack, (STRING), strlen (STRING))
242 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
243 same purpose (context, which may be a type) and value (template
244 decl). See write_template_prefix for more information on what this
246 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \
247 (TREE_CODE (NODE1) == TREE_LIST \
248 && TREE_CODE (NODE2) == TREE_LIST \
249 && ((TYPE_P (TREE_PURPOSE (NODE1)) \
250 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))) \
251 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \
252 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
254 /* Write out an unsigned quantity in base 10. */
255 #define write_unsigned_number(NUMBER) \
256 write_number ((NUMBER), /*unsigned_p=*/1, 10)
258 /* If DECL is a template instance, return nonzero and, if
259 TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
260 Otherwise return zero. */
263 decl_is_template_id (const tree decl, tree* const template_info)
265 if (TREE_CODE (decl) == TYPE_DECL)
267 /* TYPE_DECLs are handled specially. Look at its type to decide
268 if this is a template instantiation. */
269 const tree type = TREE_TYPE (decl);
271 if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
273 if (template_info != NULL)
274 /* For a templated TYPE_DECL, the template info is hanging
276 *template_info = TYPE_TEMPLATE_INFO (type);
282 /* Check if this is a primary template. */
283 if (DECL_LANG_SPECIFIC (decl) != NULL
284 && DECL_USE_TEMPLATE (decl)
285 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
286 && TREE_CODE (decl) != TEMPLATE_DECL)
288 if (template_info != NULL)
289 /* For most templated decls, the template info is hanging
291 *template_info = DECL_TEMPLATE_INFO (decl);
296 /* It's not a template id. */
300 /* Produce debugging output of current substitution candidates. */
303 dump_substitution_candidates (void)
308 fprintf (stderr, " ++ substitutions ");
309 for (i = 0; VEC_iterate (tree, G.substitutions, i, el); ++i)
311 const char *name = "???";
314 fprintf (stderr, " ");
316 name = IDENTIFIER_POINTER (DECL_NAME (el));
317 else if (TREE_CODE (el) == TREE_LIST)
318 name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
319 else if (TYPE_NAME (el))
320 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el)));
321 fprintf (stderr, " S%d_ = ", i - 1);
323 (CP_TYPE_RESTRICT_P (el)
324 || CP_TYPE_VOLATILE_P (el)
325 || CP_TYPE_CONST_P (el)))
326 fprintf (stderr, "CV-");
327 fprintf (stderr, "%s (%s at %p)\n",
328 name, tree_code_name[TREE_CODE (el)], (void *) el);
332 /* Both decls and types can be substitution candidates, but sometimes
333 they refer to the same thing. For instance, a TYPE_DECL and
334 RECORD_TYPE for the same class refer to the same thing, and should
335 be treated accordingly in substitutions. This function returns a
336 canonicalized tree node representing NODE that is used when adding
337 and substitution candidates and finding matches. */
340 canonicalize_for_substitution (tree node)
342 /* For a TYPE_DECL, use the type instead. */
343 if (TREE_CODE (node) == TYPE_DECL)
344 node = TREE_TYPE (node);
346 && TYPE_CANONICAL (node) != node
347 && TYPE_MAIN_VARIANT (node) != node)
348 /* Here we want to strip the topmost typedef only.
349 We need to do that so is_std_substitution can do proper
351 node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node),
352 cp_type_quals (node));
356 /* Add NODE as a substitution candidate. NODE must not already be on
357 the list of candidates. */
360 add_substitution (tree node)
365 fprintf (stderr, " ++ add_substitution (%s at %10p)\n",
366 tree_code_name[TREE_CODE (node)], (void *) node);
368 /* Get the canonicalized substitution candidate for NODE. */
369 c = canonicalize_for_substitution (node);
370 if (DEBUG_MANGLE && c != node)
371 fprintf (stderr, " ++ using candidate (%s at %10p)\n",
372 tree_code_name[TREE_CODE (node)], (void *) node);
376 /* Make sure NODE isn't already a candidate. */
381 for (i = 0; VEC_iterate (tree, G.substitutions, i, candidate); i++)
383 gcc_assert (!(DECL_P (node) && node == candidate));
384 gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
385 && same_type_p (node, candidate)));
388 #endif /* ENABLE_CHECKING */
390 /* Put the decl onto the varray of substitution candidates. */
391 VEC_safe_push (tree, gc, G.substitutions, node);
394 dump_substitution_candidates ();
397 /* Helper function for find_substitution. Returns nonzero if NODE,
398 which may be a decl or a CLASS_TYPE, is a template-id with template
399 name of substitution_index[INDEX] in the ::std namespace. */
402 is_std_substitution (const tree node,
403 const substitution_identifier_index_t index)
410 type = TREE_TYPE (node);
413 else if (CLASS_TYPE_P (node))
416 decl = TYPE_NAME (node);
419 /* These are not the droids you're looking for. */
422 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
423 && TYPE_LANG_SPECIFIC (type)
424 && TYPE_TEMPLATE_INFO (type)
425 && (DECL_NAME (TYPE_TI_TEMPLATE (type))
426 == subst_identifiers[index]));
429 /* Helper function for find_substitution. Returns nonzero if NODE,
430 which may be a decl or a CLASS_TYPE, is the template-id
431 ::std::identifier<char>, where identifier is
432 substitution_index[INDEX]. */
435 is_std_substitution_char (const tree node,
436 const substitution_identifier_index_t index)
439 /* Check NODE's name is ::std::identifier. */
440 if (!is_std_substitution (node, index))
442 /* Figure out its template args. */
444 args = DECL_TI_ARGS (node);
445 else if (CLASS_TYPE_P (node))
446 args = CLASSTYPE_TI_ARGS (node);
448 /* Oops, not a template. */
450 /* NODE's template arg list should be <char>. */
452 TREE_VEC_LENGTH (args) == 1
453 && TREE_VEC_ELT (args, 0) == char_type_node;
456 /* Check whether a substitution should be used to represent NODE in
459 First, check standard special-case substitutions.
461 <substitution> ::= St
468 # ::std::basic_string
471 # ::std::basic_string<char,
472 ::std::char_traits<char>,
473 ::std::allocator<char> >
476 # ::std::basic_istream<char, ::std::char_traits<char> >
479 # ::std::basic_ostream<char, ::std::char_traits<char> >
482 # ::std::basic_iostream<char, ::std::char_traits<char> >
484 Then examine the stack of currently available substitution
485 candidates for entities appearing earlier in the same mangling
487 If a substitution is found, write its mangled representation and
488 return nonzero. If none is found, just return zero. */
491 find_substitution (tree node)
494 const int size = VEC_length (tree, G.substitutions);
499 fprintf (stderr, " ++ find_substitution (%s at %p)\n",
500 tree_code_name[TREE_CODE (node)], (void *) node);
502 /* Obtain the canonicalized substitution representation for NODE.
503 This is what we'll compare against. */
504 node = canonicalize_for_substitution (node);
506 /* Check for builtin substitutions. */
508 decl = TYPE_P (node) ? TYPE_NAME (node) : node;
509 type = TYPE_P (node) ? node : TREE_TYPE (node);
511 /* Check for std::allocator. */
513 && is_std_substitution (decl, SUBID_ALLOCATOR)
514 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
520 /* Check for std::basic_string. */
521 if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
525 /* If this is a type (i.e. a fully-qualified template-id),
527 std::basic_string <char,
528 std::char_traits<char>,
529 std::allocator<char> > . */
530 if (cp_type_quals (type) == TYPE_UNQUALIFIED
531 && CLASSTYPE_USE_TEMPLATE (type))
533 tree args = CLASSTYPE_TI_ARGS (type);
534 if (TREE_VEC_LENGTH (args) == 3
535 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
536 && is_std_substitution_char (TREE_VEC_ELT (args, 1),
538 && is_std_substitution_char (TREE_VEC_ELT (args, 2),
547 /* Substitute for the template name only if this isn't a type. */
554 /* Check for basic_{i,o,io}stream. */
556 && cp_type_quals (type) == TYPE_UNQUALIFIED
557 && CLASS_TYPE_P (type)
558 && CLASSTYPE_USE_TEMPLATE (type)
559 && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
561 /* First, check for the template
562 args <char, std::char_traits<char> > . */
563 tree args = CLASSTYPE_TI_ARGS (type);
564 if (TREE_VEC_LENGTH (args) == 2
565 && TYPE_P (TREE_VEC_ELT (args, 0))
566 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
567 && is_std_substitution_char (TREE_VEC_ELT (args, 1),
570 /* Got them. Is this basic_istream? */
571 if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
576 /* Or basic_ostream? */
577 else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
582 /* Or basic_iostream? */
583 else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
591 /* Check for namespace std. */
592 if (decl && DECL_NAMESPACE_STD_P (decl))
598 /* Now check the list of available substitutions for this mangling
600 for (i = 0; i < size; ++i)
602 tree candidate = VEC_index (tree, G.substitutions, i);
603 /* NODE is a matched to a candidate if it's the same decl node or
604 if it's the same type. */
605 if (decl == candidate
606 || (TYPE_P (candidate) && type && TYPE_P (type)
607 && same_type_p (type, candidate))
608 || NESTED_TEMPLATE_MATCH (node, candidate))
610 write_substitution (i);
615 /* No substitution found. */
620 /* TOP_LEVEL is true, if this is being called at outermost level of
621 mangling. It should be false when mangling a decl appearing in an
622 expression within some other mangling.
624 <mangled-name> ::= _Z <encoding> */
627 write_mangled_name (const tree decl, bool top_level)
629 MANGLE_TRACE_TREE ("mangled-name", decl);
631 if (/* The names of `extern "C"' functions are not mangled. */
632 DECL_EXTERN_C_FUNCTION_P (decl)
633 /* But overloaded operator names *are* mangled. */
634 && !DECL_OVERLOADED_OPERATOR_P (decl))
639 write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
642 /* The standard notes: "The <encoding> of an extern "C"
643 function is treated like global-scope data, i.e. as its
644 <source-name> without a type." We cannot write
645 overloaded operators that way though, because it contains
646 characters invalid in assembler. */
647 if (abi_version_at_least (2))
650 G.need_abi_warning = true;
651 write_source_name (DECL_NAME (decl));
654 else if (TREE_CODE (decl) == VAR_DECL
655 /* The names of non-static global variables aren't mangled. */
656 && DECL_EXTERNAL_LINKAGE_P (decl)
657 && (CP_DECL_CONTEXT (decl) == global_namespace
658 /* And neither are `extern "C"' variables. */
659 || DECL_EXTERN_C_P (decl)))
661 if (top_level || abi_version_at_least (2))
665 G.need_abi_warning = true;
673 write_encoding (decl);
674 if (DECL_LANG_SPECIFIC (decl)
675 && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
676 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
677 /* We need a distinct mangled name for these entities, but
678 we should never actually output it. So, we append some
679 characters the assembler won't like. */
680 write_string (" *INTERNAL* ");
684 /* <encoding> ::= <function name> <bare-function-type>
688 write_encoding (const tree decl)
690 MANGLE_TRACE_TREE ("encoding", decl);
692 if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
694 /* For overloaded operators write just the mangled name
695 without arguments. */
696 if (DECL_OVERLOADED_OPERATOR_P (decl))
697 write_name (decl, /*ignore_local_scope=*/0);
699 write_source_name (DECL_NAME (decl));
703 write_name (decl, /*ignore_local_scope=*/0);
704 if (TREE_CODE (decl) == FUNCTION_DECL)
709 if (decl_is_template_id (decl, NULL))
711 fn_type = get_mostly_instantiated_function_type (decl);
712 /* FN_TYPE will not have parameter types for in-charge or
713 VTT parameters. Therefore, we pass NULL_TREE to
714 write_bare_function_type -- otherwise, it will get
715 confused about which artificial parameters to skip. */
720 fn_type = TREE_TYPE (decl);
724 write_bare_function_type (fn_type,
725 (!DECL_CONSTRUCTOR_P (decl)
726 && !DECL_DESTRUCTOR_P (decl)
727 && !DECL_CONV_FN_P (decl)
728 && decl_is_template_id (decl, NULL)),
733 /* Since we now use strcmp to compare typeinfos on all targets because of
734 the RTLD_LOCAL problem, we need to munge the typeinfo name used for
735 local classes of static functions to fix g++.dg/abi/local1.C. We do
736 that by pretending that the function is in an anonymous namespace. */
739 needs_fake_anon (const_tree decl)
741 /* Pretend there's an anonymous namespace right around a static
742 function if we're mangling for RTTI. */
743 return (fake_anon_scope && !TREE_PUBLIC (decl)
744 && TREE_CODE (decl) == FUNCTION_DECL);
747 /* <name> ::= <unscoped-name>
748 ::= <unscoped-template-name> <template-args>
752 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
753 called from <local-name>, which mangles the enclosing scope
754 elsewhere and then uses this function to mangle just the part
755 underneath the function scope. So don't use the <local-name>
756 production, to avoid an infinite recursion. */
759 write_name (tree decl, const int ignore_local_scope)
763 MANGLE_TRACE_TREE ("name", decl);
765 if (TREE_CODE (decl) == TYPE_DECL)
767 /* In case this is a typedef, fish out the corresponding
768 TYPE_DECL for the main variant. */
769 decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
770 context = CP_TYPE_CONTEXT (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
773 context = CP_DECL_CONTEXT (decl);
775 gcc_assert (context != NULL_TREE);
777 /* If we need a fake anonymous namespace, force the nested name path. */
778 if (needs_fake_anon (decl) && context == global_namespace)
779 context = error_mark_node;
781 /* A decl in :: or ::std scope is treated specially. The former is
782 mangled using <unscoped-name> or <unscoped-template-name>, the
783 latter with a special substitution. Also, a name that is
784 directly in a local function scope is also mangled with
785 <unscoped-name> rather than a full <nested-name>. */
786 if (context == global_namespace
787 || DECL_NAMESPACE_STD_P (context)
788 || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL))
791 /* Is this a template instance? */
792 if (decl_is_template_id (decl, &template_info))
794 /* Yes: use <unscoped-template-name>. */
795 write_unscoped_template_name (TI_TEMPLATE (template_info));
796 write_template_args (TI_ARGS (template_info));
799 /* Everything else gets an <unqualified-name>. */
800 write_unscoped_name (decl);
804 if (context == error_mark_node)
805 context = global_namespace;
807 /* Handle local names, unless we asked not to (that is, invoked
808 under <local-name>, to handle only the part of the name under
810 if (!ignore_local_scope)
812 /* Scan up the list of scope context, looking for a
813 function. If we find one, this entity is in local
814 function scope. local_entity tracks context one scope
815 level down, so it will contain the element that's
816 directly in that function's scope, either decl or one of
817 its enclosing scopes. */
818 tree local_entity = decl;
819 while (context != global_namespace)
821 /* Make sure we're always dealing with decls. */
822 if (TYPE_P (context))
823 context = TYPE_NAME (context);
824 /* Is this a function? */
825 if (TREE_CODE (context) == FUNCTION_DECL)
827 /* Yes, we have local scope. Use the <local-name>
828 production for the innermost function scope. */
829 write_local_name (context, local_entity, decl);
832 /* Up one scope level. */
833 local_entity = context;
834 context = CP_DECL_CONTEXT (context);
837 /* No local scope found? Fall through to <nested-name>. */
840 /* Other decls get a <nested-name> to encode their scope. */
841 write_nested_name (decl);
845 /* <unscoped-name> ::= <unqualified-name>
846 ::= St <unqualified-name> # ::std:: */
849 write_unscoped_name (const tree decl)
851 tree context = CP_DECL_CONTEXT (decl);
853 MANGLE_TRACE_TREE ("unscoped-name", decl);
855 /* Is DECL in ::std? */
856 if (DECL_NAMESPACE_STD_P (context))
859 write_unqualified_name (decl);
863 /* If not, it should be either in the global namespace, or directly
864 in a local function scope. */
865 gcc_assert (context == global_namespace
866 || TREE_CODE (context) == FUNCTION_DECL);
868 write_unqualified_name (decl);
872 /* <unscoped-template-name> ::= <unscoped-name>
873 ::= <substitution> */
876 write_unscoped_template_name (const tree decl)
878 MANGLE_TRACE_TREE ("unscoped-template-name", decl);
880 if (find_substitution (decl))
882 write_unscoped_name (decl);
883 add_substitution (decl);
886 /* Write the nested name, including CV-qualifiers, of DECL.
888 <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
889 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
891 <CV-qualifiers> ::= [r] [V] [K] */
894 write_nested_name (const tree decl)
898 MANGLE_TRACE_TREE ("nested-name", decl);
902 /* Write CV-qualifiers, if this is a member function. */
903 if (TREE_CODE (decl) == FUNCTION_DECL
904 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
906 if (DECL_VOLATILE_MEMFUNC_P (decl))
908 if (DECL_CONST_MEMFUNC_P (decl))
912 /* Is this a template instance? */
913 if (decl_is_template_id (decl, &template_info))
915 /* Yes, use <template-prefix>. */
916 write_template_prefix (decl);
917 write_template_args (TI_ARGS (template_info));
919 else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
921 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
922 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
924 write_template_prefix (decl);
925 write_template_args (TREE_OPERAND (name, 1));
929 write_prefix (CP_DECL_CONTEXT (decl));
930 write_unqualified_name (decl);
935 /* No, just use <prefix> */
936 write_prefix (DECL_CONTEXT (decl));
937 if (needs_fake_anon (decl))
938 /* Pretend this static function is in an anonymous namespace. */
939 write_source_name (get_anonymous_namespace_name ());
940 write_unqualified_name (decl);
945 /* <prefix> ::= <prefix> <unqualified-name>
947 ::= <template-prefix> <template-args>
949 ::= <substitution> */
952 write_prefix (const tree node)
955 /* Non-NULL if NODE represents a template-id. */
956 tree template_info = NULL;
958 MANGLE_TRACE_TREE ("prefix", node);
961 || node == global_namespace)
964 if (find_substitution (node))
969 /* If this is a function decl, that means we've hit function
970 scope, so this prefix must be for a local name. In this
971 case, we're under the <local-name> production, which encodes
972 the enclosing function scope elsewhere. So don't continue
974 if (TREE_CODE (node) == FUNCTION_DECL)
978 decl_is_template_id (decl, &template_info);
982 /* Node is a type. */
983 decl = TYPE_NAME (node);
984 if (CLASSTYPE_TEMPLATE_ID_P (node))
985 template_info = TYPE_TEMPLATE_INFO (node);
988 /* In G++ 3.2, the name of the template parameter was used. */
989 if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
990 && !abi_version_at_least (2))
991 G.need_abi_warning = true;
993 if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
994 && abi_version_at_least (2))
995 write_template_param (node);
996 else if (template_info != NULL)
999 write_template_prefix (decl);
1000 write_template_args (TI_ARGS (template_info));
1002 else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
1004 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
1005 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1007 write_template_prefix (decl);
1008 write_template_args (TREE_OPERAND (name, 1));
1012 write_prefix (CP_DECL_CONTEXT (decl));
1013 write_unqualified_name (decl);
1017 /* Not templated. */
1019 write_prefix (CP_DECL_CONTEXT (decl));
1020 write_unqualified_name (decl);
1023 add_substitution (node);
1026 /* <template-prefix> ::= <prefix> <template component>
1027 ::= <template-param>
1028 ::= <substitution> */
1031 write_template_prefix (const tree node)
1033 tree decl = DECL_P (node) ? node : TYPE_NAME (node);
1034 tree type = DECL_P (node) ? TREE_TYPE (node) : node;
1035 tree context = CP_DECL_CONTEXT (decl);
1040 MANGLE_TRACE_TREE ("template-prefix", node);
1042 /* Find the template decl. */
1043 if (decl_is_template_id (decl, &template_info))
1044 templ = TI_TEMPLATE (template_info);
1045 else if (TREE_CODE (type) == TYPENAME_TYPE)
1046 /* For a typename type, all we have is the name. */
1047 templ = DECL_NAME (decl);
1050 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
1052 templ = TYPE_TI_TEMPLATE (type);
1055 /* For a member template, though, the template name for the
1056 innermost name must have all the outer template levels
1057 instantiated. For instance, consider
1059 template<typename T> struct Outer {
1060 template<typename U> struct Inner {};
1063 The template name for `Inner' in `Outer<int>::Inner<float>' is
1064 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1065 levels separately, so there's no TEMPLATE_DECL available for this
1066 (there's only `Outer<T>::Inner<U>').
1068 In order to get the substitutions right, we create a special
1069 TREE_LIST to represent the substitution candidate for a nested
1070 template. The TREE_PURPOSE is the template's context, fully
1071 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1074 So, for the example above, `Outer<int>::Inner' is represented as a
1075 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1076 and whose value is `Outer<T>::Inner<U>'. */
1077 if (TYPE_P (context))
1078 substitution = build_tree_list (context, templ);
1080 substitution = templ;
1082 if (find_substitution (substitution))
1085 /* In G++ 3.2, the name of the template template parameter was used. */
1086 if (TREE_TYPE (templ)
1087 && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
1088 && !abi_version_at_least (2))
1089 G.need_abi_warning = true;
1091 if (TREE_TYPE (templ)
1092 && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
1093 && abi_version_at_least (2))
1094 write_template_param (TREE_TYPE (templ));
1097 write_prefix (context);
1098 write_unqualified_name (decl);
1101 add_substitution (substitution);
1104 /* We don't need to handle thunks, vtables, or VTTs here. Those are
1105 mangled through special entry points.
1107 <unqualified-name> ::= <operator-name>
1110 ::= <local-source-name>
1112 <local-source-name> ::= L <source-name> <discriminator> */
1115 write_unqualified_name (const tree decl)
1117 MANGLE_TRACE_TREE ("unqualified-name", decl);
1119 if (DECL_NAME (decl) == NULL_TREE)
1121 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
1122 write_source_name (DECL_ASSEMBLER_NAME (decl));
1125 else if (DECL_DECLARES_FUNCTION_P (decl))
1128 if (DECL_CONSTRUCTOR_P (decl))
1129 write_special_name_constructor (decl);
1130 else if (DECL_DESTRUCTOR_P (decl))
1131 write_special_name_destructor (decl);
1132 else if (DECL_CONV_FN_P (decl))
1134 /* Conversion operator. Handle it right here.
1135 <operator> ::= cv <type> */
1137 if (decl_is_template_id (decl, NULL))
1140 fn_type = get_mostly_instantiated_function_type (decl);
1141 type = TREE_TYPE (fn_type);
1144 type = DECL_CONV_FN_TYPE (decl);
1145 write_conversion_operator_name (type);
1147 else if (DECL_OVERLOADED_OPERATOR_P (decl))
1149 operator_name_info_t *oni;
1150 if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1151 oni = assignment_operator_name_info;
1153 oni = operator_name_info;
1155 write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1164 if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
1165 && DECL_NAMESPACE_SCOPE_P (decl)
1166 && decl_linkage (decl) == lk_internal)
1168 MANGLE_TRACE_TREE ("local-source-name", decl);
1170 write_source_name (DECL_NAME (decl));
1171 /* The default discriminator is 1, and that's all we ever use,
1172 so there's no code to output one here. */
1175 write_source_name (DECL_NAME (decl));
1178 /* Write the unqualified-name for a conversion operator to TYPE. */
1181 write_conversion_operator_name (const tree type)
1183 write_string ("cv");
1187 /* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1189 <source-name> ::= </length/ number> <identifier> */
1192 write_source_name (tree identifier)
1194 MANGLE_TRACE_TREE ("source-name", identifier);
1196 /* Never write the whole template-id name including the template
1197 arguments; we only want the template name. */
1198 if (IDENTIFIER_TEMPLATE (identifier))
1199 identifier = IDENTIFIER_TEMPLATE (identifier);
1201 write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1202 write_identifier (IDENTIFIER_POINTER (identifier));
1205 /* Convert NUMBER to ascii using base BASE and generating at least
1206 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1207 into which to store the characters. Returns the number of
1208 characters generated (these will be layed out in advance of where
1212 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1213 char *buffer, const unsigned int min_digits)
1215 static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1216 unsigned digits = 0;
1220 unsigned HOST_WIDE_INT d = number / base;
1222 *--buffer = base_digits[number - d * base];
1226 while (digits < min_digits)
1228 *--buffer = base_digits[0];
1234 /* Non-terminal <number>.
1236 <number> ::= [n] </decimal integer/> */
1239 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1240 const unsigned int base)
1242 char buffer[sizeof (HOST_WIDE_INT) * 8];
1245 if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1248 number = -((HOST_WIDE_INT) number);
1250 count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1251 write_chars (buffer + sizeof (buffer) - count, count);
1254 /* Write out an integral CST in decimal. Most numbers are small, and
1255 representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1256 bigger than that, which we must deal with. */
1259 write_integer_cst (const tree cst)
1261 int sign = tree_int_cst_sgn (cst);
1263 if (TREE_INT_CST_HIGH (cst) + (sign < 0))
1265 /* A bignum. We do this in chunks, each of which fits in a
1267 char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1268 unsigned HOST_WIDE_INT chunk;
1269 unsigned chunk_digits;
1270 char *ptr = buffer + sizeof (buffer);
1275 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1280 if (sizeof (HOST_WIDE_INT) >= 8)
1282 /* It is at least 64 bits, so 10^18 is representable. */
1287 type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1288 base = build_int_cstu (type, chunk);
1289 n = build_int_cst_wide (type,
1290 TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
1295 n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
1299 tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
1300 tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
1303 done = integer_zerop (d);
1304 tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
1305 c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1306 done ? 1 : chunk_digits);
1312 write_chars (ptr, count);
1317 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
1324 write_unsigned_number (low);
1328 /* Write out a floating-point literal.
1330 "Floating-point literals are encoded using the bit pattern of the
1331 target processor's internal representation of that number, as a
1332 fixed-length lowercase hexadecimal string, high-order bytes first
1333 (even if the target processor would store low-order bytes first).
1334 The "n" prefix is not used for floating-point literals; the sign
1335 bit is encoded with the rest of the number.
1337 Here are some examples, assuming the IEEE standard representation
1338 for floating point numbers. (Spaces are for readability, not
1339 part of the encoding.)
1342 -1.0f Lf bf80 0000 E
1343 1.17549435e-38f Lf 0080 0000 E
1344 1.40129846e-45f Lf 0000 0001 E
1345 0.0f Lf 0000 0000 E"
1347 Caller is responsible for the Lx and the E. */
1349 write_real_cst (const tree value)
1351 if (abi_version_at_least (2))
1353 long target_real[4]; /* largest supported float */
1354 char buffer[9]; /* eight hex digits in a 32-bit number */
1357 tree type = TREE_TYPE (value);
1358 int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1360 real_to_target (target_real, &TREE_REAL_CST (value),
1363 /* The value in target_real is in the target word order,
1364 so we must write it out backward if that happens to be
1365 little-endian. write_number cannot be used, it will
1366 produce uppercase. */
1367 if (FLOAT_WORDS_BIG_ENDIAN)
1368 i = 0, limit = words, dir = 1;
1370 i = words - 1, limit = -1, dir = -1;
1372 for (; i != limit; i += dir)
1374 sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1375 write_chars (buffer, 8);
1380 /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out
1381 literally. Note that compatibility with 3.2 is impossible,
1382 because the old floating-point emulator used a different
1383 format for REAL_VALUE_TYPE. */
1385 for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1386 write_number (((unsigned char *) &TREE_REAL_CST (value))[i],
1389 G.need_abi_warning = 1;
1393 /* Non-terminal <identifier>.
1395 <identifier> ::= </unqualified source code identifier> */
1398 write_identifier (const char *identifier)
1400 MANGLE_TRACE ("identifier", identifier);
1401 write_string (identifier);
1404 /* Handle constructor productions of non-terminal <special-name>.
1405 CTOR is a constructor FUNCTION_DECL.
1407 <special-name> ::= C1 # complete object constructor
1408 ::= C2 # base object constructor
1409 ::= C3 # complete object allocating constructor
1411 Currently, allocating constructors are never used.
1413 We also need to provide mangled names for the maybe-in-charge
1414 constructor, so we treat it here too. mangle_decl_string will
1415 append *INTERNAL* to that, to make sure we never emit it. */
1418 write_special_name_constructor (const tree ctor)
1420 if (DECL_BASE_CONSTRUCTOR_P (ctor))
1421 write_string ("C2");
1424 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1425 /* Even though we don't ever emit a definition of
1426 the old-style destructor, we still have to
1427 consider entities (like static variables) nested
1429 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor));
1430 write_string ("C1");
1434 /* Handle destructor productions of non-terminal <special-name>.
1435 DTOR is a destructor FUNCTION_DECL.
1437 <special-name> ::= D0 # deleting (in-charge) destructor
1438 ::= D1 # complete object (in-charge) destructor
1439 ::= D2 # base object (not-in-charge) destructor
1441 We also need to provide mangled names for the maybe-incharge
1442 destructor, so we treat it here too. mangle_decl_string will
1443 append *INTERNAL* to that, to make sure we never emit it. */
1446 write_special_name_destructor (const tree dtor)
1448 if (DECL_DELETING_DESTRUCTOR_P (dtor))
1449 write_string ("D0");
1450 else if (DECL_BASE_DESTRUCTOR_P (dtor))
1451 write_string ("D2");
1454 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1455 /* Even though we don't ever emit a definition of
1456 the old-style destructor, we still have to
1457 consider entities (like static variables) nested
1459 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor));
1460 write_string ("D1");
1464 /* Return the discriminator for ENTITY appearing inside
1465 FUNCTION. The discriminator is the lexical ordinal of VAR among
1466 entities with the same name in the same FUNCTION. */
1469 discriminator_for_local_entity (tree entity)
1471 /* Assume this is the only local entity with this name. */
1472 int discriminator = 0;
1474 if (DECL_DISCRIMINATOR_P (entity) && DECL_LANG_SPECIFIC (entity))
1475 discriminator = DECL_DISCRIMINATOR (entity);
1476 else if (TREE_CODE (entity) == TYPE_DECL)
1480 /* Scan the list of local classes. */
1481 entity = TREE_TYPE (entity);
1482 for (ix = 0; ; ix++)
1484 tree type = VEC_index (tree, local_classes, ix);
1487 if (TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (entity)
1488 && TYPE_CONTEXT (type) == TYPE_CONTEXT (entity))
1493 return discriminator;
1496 /* Return the discriminator for STRING, a string literal used inside
1497 FUNCTION. The discriminator is the lexical ordinal of STRING among
1498 string literals used in FUNCTION. */
1501 discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED,
1502 tree string ATTRIBUTE_UNUSED)
1504 /* For now, we don't discriminate amongst string literals. */
1508 /* <discriminator> := _ <number>
1510 The discriminator is used only for the second and later occurrences
1511 of the same name within a single function. In this case <number> is
1512 n - 2, if this is the nth occurrence, in lexical order. */
1515 write_discriminator (const int discriminator)
1517 /* If discriminator is zero, don't write anything. Otherwise... */
1518 if (discriminator > 0)
1521 write_unsigned_number (discriminator - 1);
1525 /* Mangle the name of a function-scope entity. FUNCTION is the
1526 FUNCTION_DECL for the enclosing function. ENTITY is the decl for
1527 the entity itself. LOCAL_ENTITY is the entity that's directly
1528 scoped in FUNCTION_DECL, either ENTITY itself or an enclosing scope
1531 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1532 := Z <function encoding> E s [<discriminator>] */
1535 write_local_name (const tree function, const tree local_entity,
1538 MANGLE_TRACE_TREE ("local-name", entity);
1541 write_encoding (function);
1543 if (TREE_CODE (entity) == STRING_CST)
1546 write_discriminator (discriminator_for_string_literal (function,
1551 /* Now the <entity name>. Let write_name know its being called
1552 from <local-name>, so it doesn't try to process the enclosing
1553 function scope again. */
1554 write_name (entity, /*ignore_local_scope=*/1);
1555 write_discriminator (discriminator_for_local_entity (local_entity));
1559 /* Non-terminals <type> and <CV-qualifier>.
1561 <type> ::= <builtin-type>
1563 ::= <class-enum-type>
1565 ::= <pointer-to-member-type>
1566 ::= <template-param>
1569 ::= P <type> # pointer-to
1570 ::= R <type> # reference-to
1571 ::= C <type> # complex pair (C 2000)
1572 ::= G <type> # imaginary (C 2000) [not supported]
1573 ::= U <source-name> <type> # vendor extended type qualifier
1577 <type> ::= RR <type> # rvalue reference-to
1578 <type> ::= Dt <expression> # decltype of an id-expression or
1579 # class member access
1580 <type> ::= DT <expression> # decltype of an expression
1582 TYPE is a type node. */
1585 write_type (tree type)
1587 /* This gets set to nonzero if TYPE turns out to be a (possibly
1588 CV-qualified) builtin type. */
1589 int is_builtin_type = 0;
1591 MANGLE_TRACE_TREE ("type", type);
1593 if (type == error_mark_node)
1596 if (find_substitution (type))
1599 if (write_CV_qualifiers_for_type (type) > 0)
1600 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1601 mangle the unqualified type. The recursive call is needed here
1602 since both the qualified and unqualified types are substitution
1604 write_type (TYPE_MAIN_VARIANT (type));
1605 else if (TREE_CODE (type) == ARRAY_TYPE)
1606 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1607 so that the cv-qualification of the element type is available
1608 in write_array_type. */
1609 write_array_type (type);
1612 tree type_orig = type;
1614 /* See through any typedefs. */
1615 type = TYPE_MAIN_VARIANT (type);
1617 if (TYPE_PTRMEM_P (type))
1618 write_pointer_to_member_type (type);
1621 /* Handle any target-specific fundamental types. */
1622 const char *target_mangling
1623 = targetm.mangle_type (type_orig);
1625 if (target_mangling)
1627 write_string (target_mangling);
1628 /* Add substitutions for types other than fundamental
1630 if (TREE_CODE (type) != VOID_TYPE
1631 && TREE_CODE (type) != INTEGER_TYPE
1632 && TREE_CODE (type) != REAL_TYPE
1633 && TREE_CODE (type) != BOOLEAN_TYPE)
1634 add_substitution (type);
1638 switch (TREE_CODE (type))
1642 case INTEGER_TYPE: /* Includes wchar_t. */
1644 case FIXED_POINT_TYPE:
1646 /* If this is a typedef, TYPE may not be one of
1647 the standard builtin type nodes, but an alias of one. Use
1648 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
1649 write_builtin_type (TYPE_MAIN_VARIANT (type));
1656 write_type (TREE_TYPE (type));
1661 write_function_type (type);
1667 /* A pointer-to-member function is represented as a special
1668 RECORD_TYPE, so check for this first. */
1669 if (TYPE_PTRMEMFUNC_P (type))
1670 write_pointer_to_member_type (type);
1672 write_class_enum_type (type);
1676 case UNBOUND_CLASS_TEMPLATE:
1677 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1678 ordinary nested names. */
1679 write_nested_name (TYPE_STUB_DECL (type));
1684 write_type (TREE_TYPE (type));
1687 case REFERENCE_TYPE:
1688 if (TYPE_REF_IS_RVALUE (type))
1692 write_type (TREE_TYPE (type));
1695 case TEMPLATE_TYPE_PARM:
1696 case TEMPLATE_PARM_INDEX:
1697 write_template_param (type);
1700 case TEMPLATE_TEMPLATE_PARM:
1701 write_template_template_param (type);
1704 case BOUND_TEMPLATE_TEMPLATE_PARM:
1705 write_template_template_param (type);
1707 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1711 write_string ("U8__vector");
1712 write_type (TREE_TYPE (type));
1715 case TYPE_PACK_EXPANSION:
1716 write_string ("Dp");
1717 write_type (PACK_EXPANSION_PATTERN (type));
1722 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
1726 ++cp_unevaluated_operand;
1727 write_expression (DECLTYPE_TYPE_EXPR (type));
1728 --cp_unevaluated_operand;
1733 sorry ("mangling typeof, use decltype instead");
1742 /* Types other than builtin types are substitution candidates. */
1743 if (!is_builtin_type)
1744 add_substitution (type);
1747 /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
1748 CV-qualifiers written for TYPE.
1750 <CV-qualifiers> ::= [r] [V] [K] */
1753 write_CV_qualifiers_for_type (const tree type)
1755 int num_qualifiers = 0;
1757 /* The order is specified by:
1759 "In cases where multiple order-insensitive qualifiers are
1760 present, they should be ordered 'K' (closest to the base type),
1761 'V', 'r', and 'U' (farthest from the base type) ..."
1763 Note that we do not use cp_type_quals below; given "const
1764 int[3]", the "const" is emitted with the "int", not with the
1767 if (TYPE_QUALS (type) & TYPE_QUAL_RESTRICT)
1772 if (TYPE_QUALS (type) & TYPE_QUAL_VOLATILE)
1777 if (TYPE_QUALS (type) & TYPE_QUAL_CONST)
1783 return num_qualifiers;
1786 /* Non-terminal <builtin-type>.
1788 <builtin-type> ::= v # void
1793 ::= h # unsigned char
1795 ::= t # unsigned short
1797 ::= j # unsigned int
1799 ::= m # unsigned long
1800 ::= x # long long, __int64
1801 ::= y # unsigned long long, __int64
1803 ::= o # unsigned __int128
1806 ::= e # long double, __float80
1807 ::= g # __float128 [not supported]
1808 ::= u <source-name> # vendor extended type */
1811 write_builtin_type (tree type)
1813 if (TYPE_CANONICAL (type))
1814 type = TYPE_CANONICAL (type);
1816 switch (TREE_CODE (type))
1827 /* TYPE may still be wchar_t, char16_t, or char32_t, since that
1828 isn't in integer_type_nodes. */
1829 if (type == wchar_type_node)
1831 else if (type == char16_type_node)
1832 write_string ("Ds");
1833 else if (type == char32_type_node)
1834 write_string ("Di");
1835 else if (TYPE_FOR_JAVA (type))
1836 write_java_integer_type_codes (type);
1840 /* Assume TYPE is one of the shared integer type nodes. Find
1841 it in the array of these nodes. */
1843 for (itk = 0; itk < itk_none; ++itk)
1844 if (type == integer_types[itk])
1846 /* Print the corresponding single-letter code. */
1847 write_char (integer_type_codes[itk]);
1851 if (itk == itk_none)
1853 tree t = c_common_type_for_mode (TYPE_MODE (type),
1854 TYPE_UNSIGNED (type));
1861 if (TYPE_PRECISION (type) == 128)
1862 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
1865 /* Allow for cases where TYPE is not one of the shared
1866 integer type nodes and write a "vendor extended builtin
1867 type" with a name the form intN or uintN, respectively.
1868 Situations like this can happen if you have an
1869 __attribute__((__mode__(__SI__))) type and use exotic
1870 switches like '-mint8' on AVR. Of course, this is
1871 undefined by the C++ ABI (and '-mint8' is not even
1872 Standard C conforming), but when using such special
1873 options you're pretty much in nowhere land anyway. */
1875 char prec[11]; /* up to ten digits for an unsigned */
1877 prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
1878 sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
1879 write_char ('u'); /* "vendor extended builtin type" */
1880 write_unsigned_number (strlen (prefix) + strlen (prec));
1881 write_string (prefix);
1882 write_string (prec);
1889 if (type == float_type_node
1890 || type == java_float_type_node)
1892 else if (type == double_type_node
1893 || type == java_double_type_node)
1895 else if (type == long_double_type_node)
1901 case FIXED_POINT_TYPE:
1902 write_string ("DF");
1903 if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
1904 write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
1905 if (type == fract_type_node
1906 || type == sat_fract_type_node
1907 || type == accum_type_node
1908 || type == sat_accum_type_node)
1910 else if (type == unsigned_fract_type_node
1911 || type == sat_unsigned_fract_type_node
1912 || type == unsigned_accum_type_node
1913 || type == sat_unsigned_accum_type_node)
1915 else if (type == short_fract_type_node
1916 || type == sat_short_fract_type_node
1917 || type == short_accum_type_node
1918 || type == sat_short_accum_type_node)
1920 else if (type == unsigned_short_fract_type_node
1921 || type == sat_unsigned_short_fract_type_node
1922 || type == unsigned_short_accum_type_node
1923 || type == sat_unsigned_short_accum_type_node)
1925 else if (type == long_fract_type_node
1926 || type == sat_long_fract_type_node
1927 || type == long_accum_type_node
1928 || type == sat_long_accum_type_node)
1930 else if (type == unsigned_long_fract_type_node
1931 || type == sat_unsigned_long_fract_type_node
1932 || type == unsigned_long_accum_type_node
1933 || type == sat_unsigned_long_accum_type_node)
1935 else if (type == long_long_fract_type_node
1936 || type == sat_long_long_fract_type_node
1937 || type == long_long_accum_type_node
1938 || type == sat_long_long_accum_type_node)
1940 else if (type == unsigned_long_long_fract_type_node
1941 || type == sat_unsigned_long_long_fract_type_node
1942 || type == unsigned_long_long_accum_type_node
1943 || type == sat_unsigned_long_long_accum_type_node)
1946 sorry ("mangling unknown fixed point type");
1947 write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
1948 if (TYPE_SATURATING (type))
1959 /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
1960 METHOD_TYPE. The return type is mangled before the parameter
1963 <function-type> ::= F [Y] <bare-function-type> E */
1966 write_function_type (const tree type)
1968 MANGLE_TRACE_TREE ("function-type", type);
1970 /* For a pointer to member function, the function type may have
1971 cv-qualifiers, indicating the quals for the artificial 'this'
1973 if (TREE_CODE (type) == METHOD_TYPE)
1975 /* The first parameter must be a POINTER_TYPE pointing to the
1976 `this' parameter. */
1977 tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
1978 write_CV_qualifiers_for_type (this_type);
1982 /* We don't track whether or not a type is `extern "C"'. Note that
1983 you can have an `extern "C"' function that does not have
1984 `extern "C"' type, and vice versa:
1986 extern "C" typedef void function_t();
1987 function_t f; // f has C++ linkage, but its type is
1990 typedef void function_t();
1991 extern "C" function_t f; // Vice versa.
1994 write_bare_function_type (type, /*include_return_type_p=*/1,
1999 /* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
2000 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
2001 is mangled before the parameter types. If non-NULL, DECL is
2002 FUNCTION_DECL for the function whose type is being emitted.
2004 If DECL is a member of a Java type, then a literal 'J'
2005 is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2008 <bare-function-type> ::= [J]</signature/ type>+ */
2011 write_bare_function_type (const tree type, const int include_return_type_p,
2016 MANGLE_TRACE_TREE ("bare-function-type", type);
2018 /* Detect Java methods and emit special encoding. */
2020 && DECL_FUNCTION_MEMBER_P (decl)
2021 && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
2022 && !DECL_CONSTRUCTOR_P (decl)
2023 && !DECL_DESTRUCTOR_P (decl)
2024 && !DECL_CONV_FN_P (decl))
2034 /* Mangle the return type, if requested. */
2035 if (include_return_type_p || java_method_p)
2036 write_type (TREE_TYPE (type));
2038 /* Now mangle the types of the arguments. */
2039 write_method_parms (TYPE_ARG_TYPES (type),
2040 TREE_CODE (type) == METHOD_TYPE,
2044 /* Write the mangled representation of a method parameter list of
2045 types given in PARM_TYPES. If METHOD_P is nonzero, the function is
2046 considered a non-static method, and the this parameter is omitted.
2047 If non-NULL, DECL is the FUNCTION_DECL for the function whose
2048 parameters are being emitted. */
2051 write_method_parms (tree parm_types, const int method_p, const tree decl)
2053 tree first_parm_type;
2054 tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2056 /* Assume this parameter type list is variable-length. If it ends
2057 with a void type, then it's not. */
2060 /* If this is a member function, skip the first arg, which is the
2062 "Member functions do not encode the type of their implicit this
2065 Similarly, there's no need to mangle artificial parameters, like
2066 the VTT parameters for constructors and destructors. */
2069 parm_types = TREE_CHAIN (parm_types);
2070 parm_decl = parm_decl ? TREE_CHAIN (parm_decl) : NULL_TREE;
2072 while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2074 parm_types = TREE_CHAIN (parm_types);
2075 parm_decl = TREE_CHAIN (parm_decl);
2079 for (first_parm_type = parm_types;
2081 parm_types = TREE_CHAIN (parm_types))
2083 tree parm = TREE_VALUE (parm_types);
2084 if (parm == void_type_node)
2086 /* "Empty parameter lists, whether declared as () or
2087 conventionally as (void), are encoded with a void parameter
2089 if (parm_types == first_parm_type)
2091 /* If the parm list is terminated with a void type, it's
2094 /* A void type better be the last one. */
2095 gcc_assert (TREE_CHAIN (parm_types) == NULL);
2102 /* <builtin-type> ::= z # ellipsis */
2106 /* <class-enum-type> ::= <name> */
2109 write_class_enum_type (const tree type)
2111 write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2114 /* Non-terminal <template-args>. ARGS is a TREE_VEC of template
2117 <template-args> ::= I <template-arg>+ E */
2120 write_template_args (tree args)
2123 int length = TREE_VEC_LENGTH (args);
2125 MANGLE_TRACE_TREE ("template-args", args);
2129 gcc_assert (length > 0);
2131 if (TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
2133 /* We have nested template args. We want the innermost template
2135 args = TREE_VEC_ELT (args, length - 1);
2136 length = TREE_VEC_LENGTH (args);
2138 for (i = 0; i < length; ++i)
2139 write_template_arg (TREE_VEC_ELT (args, i));
2146 <unqualified-name> <template-args>
2147 part of SCOPE_REF or COMPONENT_REF mangling. */
2150 write_member_name (tree member)
2152 if (TREE_CODE (member) == IDENTIFIER_NODE)
2153 write_source_name (member);
2154 else if (DECL_P (member))
2156 /* G++ 3.2 incorrectly put out both the "sr" code and
2157 the nested name of the qualified name. */
2158 G.need_abi_warning = 1;
2159 write_unqualified_name (member);
2161 else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2163 tree name = TREE_OPERAND (member, 0);
2164 if (TREE_CODE (name) == OVERLOAD)
2165 name = OVL_FUNCTION (name);
2166 write_member_name (name);
2167 write_template_args (TREE_OPERAND (member, 1));
2170 write_expression (member);
2173 /* <expression> ::= <unary operator-name> <expression>
2174 ::= <binary operator-name> <expression> <expression>
2177 <expr-primary> ::= <template-param>
2178 ::= L <type> <value number> E # literal
2179 ::= L <mangled-name> E # external name
2180 ::= st <type> # sizeof
2181 ::= sr <type> <unqualified-name> # dependent name
2182 ::= sr <type> <unqualified-name> <template-args> */
2185 write_expression (tree expr)
2187 enum tree_code code = TREE_CODE (expr);
2189 /* Skip NOP_EXPRs. They can occur when (say) a pointer argument
2190 is converted (via qualification conversions) to another
2192 while (TREE_CODE (expr) == NOP_EXPR
2193 || TREE_CODE (expr) == NON_LVALUE_EXPR)
2195 expr = TREE_OPERAND (expr, 0);
2196 code = TREE_CODE (expr);
2199 if (code == BASELINK)
2201 expr = BASELINK_FUNCTIONS (expr);
2202 code = TREE_CODE (expr);
2205 /* Handle pointers-to-members by making them look like expression
2207 if (code == PTRMEM_CST)
2209 expr = build_nt (ADDR_EXPR,
2210 build_qualified_name (/*type=*/NULL_TREE,
2211 PTRMEM_CST_CLASS (expr),
2212 PTRMEM_CST_MEMBER (expr),
2213 /*template_p=*/false));
2214 code = TREE_CODE (expr);
2217 /* Handle template parameters. */
2218 if (code == TEMPLATE_TYPE_PARM
2219 || code == TEMPLATE_TEMPLATE_PARM
2220 || code == BOUND_TEMPLATE_TEMPLATE_PARM
2221 || code == TEMPLATE_PARM_INDEX)
2222 write_template_param (expr);
2223 /* Handle literals. */
2224 else if (TREE_CODE_CLASS (code) == tcc_constant
2225 || (abi_version_at_least (2) && code == CONST_DECL))
2226 write_template_arg_literal (expr);
2227 else if (code == PARM_DECL)
2229 /* A function parameter used in a late-specified return type. */
2230 int index = DECL_PARM_INDEX (expr);
2231 gcc_assert (index >= 1);
2232 write_string ("fp");
2234 write_unsigned_number (index - 2);
2237 else if (DECL_P (expr))
2239 /* G++ 3.2 incorrectly mangled non-type template arguments of
2240 enumeration type using their names. */
2241 if (code == CONST_DECL)
2242 G.need_abi_warning = 1;
2244 write_mangled_name (expr, false);
2247 else if (TREE_CODE (expr) == SIZEOF_EXPR
2248 && TYPE_P (TREE_OPERAND (expr, 0)))
2250 write_string ("st");
2251 write_type (TREE_OPERAND (expr, 0));
2253 else if (TREE_CODE (expr) == ALIGNOF_EXPR
2254 && TYPE_P (TREE_OPERAND (expr, 0)))
2256 write_string ("at");
2257 write_type (TREE_OPERAND (expr, 0));
2259 else if (abi_version_at_least (2) && TREE_CODE (expr) == SCOPE_REF)
2261 tree scope = TREE_OPERAND (expr, 0);
2262 tree member = TREE_OPERAND (expr, 1);
2264 /* If the MEMBER is a real declaration, then the qualifying
2265 scope was not dependent. Ideally, we would not have a
2266 SCOPE_REF in those cases, but sometimes we do. If the second
2267 argument is a DECL, then the name must not have been
2269 if (DECL_P (member))
2270 write_expression (member);
2275 write_string ("sr");
2277 /* If MEMBER is a template-id, separate the template
2278 from the arguments. */
2279 if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2281 template_args = TREE_OPERAND (member, 1);
2282 member = TREE_OPERAND (member, 0);
2285 template_args = NULL_TREE;
2286 /* Write out the name of the MEMBER. */
2287 if (IDENTIFIER_TYPENAME_P (member))
2288 write_conversion_operator_name (TREE_TYPE (member));
2289 else if (IDENTIFIER_OPNAME_P (member))
2292 const char *mangled_name = NULL;
2294 /* Unfortunately, there is no easy way to go from the
2295 name of the operator back to the corresponding tree
2297 for (i = 0; i < MAX_TREE_CODES; ++i)
2298 if (operator_name_info[i].identifier == member)
2300 /* The ABI says that we prefer binary operator
2301 names to unary operator names. */
2302 if (operator_name_info[i].arity == 2)
2304 mangled_name = operator_name_info[i].mangled_name;
2307 else if (!mangled_name)
2308 mangled_name = operator_name_info[i].mangled_name;
2310 else if (assignment_operator_name_info[i].identifier
2314 = assignment_operator_name_info[i].mangled_name;
2317 write_string (mangled_name);
2320 write_source_name (member);
2321 /* Write out the template arguments. */
2323 write_template_args (template_args);
2326 else if (TREE_CODE (expr) == INDIRECT_REF
2327 && TREE_TYPE (TREE_OPERAND (expr, 0))
2328 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2330 write_expression (TREE_OPERAND (expr, 0));
2337 /* When we bind a variable or function to a non-type template
2338 argument with reference type, we create an ADDR_EXPR to show
2339 the fact that the entity's address has been taken. But, we
2340 don't actually want to output a mangling code for the `&'. */
2341 if (TREE_CODE (expr) == ADDR_EXPR
2343 && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2345 expr = TREE_OPERAND (expr, 0);
2348 write_expression (expr);
2352 code = TREE_CODE (expr);
2355 if (code == COMPONENT_REF)
2357 tree ob = TREE_OPERAND (expr, 0);
2359 if (TREE_CODE (ob) == ARROW_EXPR)
2361 write_string (operator_name_info[(int)code].mangled_name);
2362 ob = TREE_OPERAND (ob, 0);
2365 write_string ("dt");
2367 write_expression (ob);
2368 write_member_name (TREE_OPERAND (expr, 1));
2372 /* If it wasn't any of those, recursively expand the expression. */
2373 name = operator_name_info[(int) code].mangled_name;
2376 sorry ("mangling %C", code);
2380 write_string (name);
2386 tree fn = CALL_EXPR_FN (expr);
2388 if (TREE_CODE (fn) == ADDR_EXPR)
2389 fn = TREE_OPERAND (fn, 0);
2391 /* Mangle a dependent name as the name, not whatever happens to
2392 be the first function in the overload set. */
2393 if ((TREE_CODE (fn) == FUNCTION_DECL
2394 || TREE_CODE (fn) == OVERLOAD)
2395 && type_dependent_expression_p_push (expr))
2396 fn = DECL_NAME (get_first_fn (fn));
2398 if (TREE_CODE (fn) == IDENTIFIER_NODE)
2399 write_source_name (fn);
2401 write_expression (fn);
2404 for (i = 0; i < call_expr_nargs (expr); ++i)
2405 write_expression (CALL_EXPR_ARG (expr, i));
2410 write_type (TREE_TYPE (expr));
2411 if (list_length (TREE_OPERAND (expr, 0)) == 1)
2412 write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2415 tree args = TREE_OPERAND (expr, 0);
2417 for (; args; args = TREE_CHAIN (args))
2418 write_expression (TREE_VALUE (args));
2423 /* FIXME these should have a distinct mangling. */
2424 case STATIC_CAST_EXPR:
2425 case CONST_CAST_EXPR:
2426 write_type (TREE_TYPE (expr));
2427 write_expression (TREE_OPERAND (expr, 0));
2431 sorry ("mangling new-expression");
2434 /* Handle pointers-to-members specially. */
2436 write_type (TREE_OPERAND (expr, 0));
2437 write_member_name (TREE_OPERAND (expr, 1));
2441 for (i = 0; i < TREE_OPERAND_LENGTH (expr); ++i)
2443 tree operand = TREE_OPERAND (expr, i);
2444 /* As a GNU extension, the middle operand of a
2445 conditional may be omitted. Since expression
2446 manglings are supposed to represent the input token
2447 stream, there's no good way to mangle such an
2448 expression without extending the C++ ABI. */
2449 if (code == COND_EXPR && i == 1 && !operand)
2451 error ("omitted middle operand to %<?:%> operand "
2452 "cannot be mangled");
2455 write_expression (operand);
2461 /* Literal subcase of non-terminal <template-arg>.
2463 "Literal arguments, e.g. "A<42L>", are encoded with their type
2464 and value. Negative integer values are preceded with "n"; for
2465 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2466 encoded as 0, true as 1." */
2469 write_template_arg_literal (const tree value)
2472 write_type (TREE_TYPE (value));
2474 switch (TREE_CODE (value))
2477 write_integer_cst (DECL_INITIAL (value));
2481 gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2482 || integer_zerop (value) || integer_onep (value));
2483 write_integer_cst (value);
2487 write_real_cst (value);
2497 /* Non-terminal <template-arg>.
2499 <template-arg> ::= <type> # type
2500 ::= L <type> </value/ number> E # literal
2501 ::= LZ <name> E # external name
2502 ::= X <expression> E # expression */
2505 write_template_arg (tree node)
2507 enum tree_code code = TREE_CODE (node);
2509 MANGLE_TRACE_TREE ("template-arg", node);
2511 /* A template template parameter's argument list contains TREE_LIST
2512 nodes of which the value field is the actual argument. */
2513 if (code == TREE_LIST)
2515 node = TREE_VALUE (node);
2516 /* If it's a decl, deal with its type instead. */
2519 node = TREE_TYPE (node);
2520 code = TREE_CODE (node);
2524 if (TREE_CODE (node) == NOP_EXPR
2525 && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2527 /* Template parameters can be of reference type. To maintain
2528 internal consistency, such arguments use a conversion from
2529 address of object to reference type. */
2530 gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2531 if (abi_version_at_least (2))
2532 node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2534 G.need_abi_warning = 1;
2537 if (ARGUMENT_PACK_P (node))
2539 /* Expand the template argument pack. */
2540 tree args = ARGUMENT_PACK_ARGS (node);
2541 int i, length = TREE_VEC_LENGTH (args);
2543 for (i = 0; i < length; ++i)
2544 write_template_arg (TREE_VEC_ELT (args, i));
2547 else if (TYPE_P (node))
2549 else if (code == TEMPLATE_DECL)
2550 /* A template appearing as a template arg is a template template arg. */
2551 write_template_template_arg (node);
2552 else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
2553 || (abi_version_at_least (2) && code == CONST_DECL))
2554 write_template_arg_literal (node);
2555 else if (DECL_P (node))
2557 /* Until ABI version 2, non-type template arguments of
2558 enumeration type were mangled using their names. */
2559 if (code == CONST_DECL && !abi_version_at_least (2))
2560 G.need_abi_warning = 1;
2562 /* Until ABI version 3, the underscore before the mangled name
2563 was incorrectly omitted. */
2564 if (!abi_version_at_least (3))
2566 G.need_abi_warning = 1;
2570 write_string ("_Z");
2571 write_encoding (node);
2576 /* Template arguments may be expressions. */
2578 write_expression (node);
2583 /* <template-template-arg>
2585 ::= <substitution> */
2588 write_template_template_arg (const tree decl)
2590 MANGLE_TRACE_TREE ("template-template-arg", decl);
2592 if (find_substitution (decl))
2594 write_name (decl, /*ignore_local_scope=*/0);
2595 add_substitution (decl);
2599 /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
2601 <array-type> ::= A [</dimension/ number>] _ </element/ type>
2602 ::= A <expression> _ </element/ type>
2604 "Array types encode the dimension (number of elements) and the
2605 element type. For variable length arrays, the dimension (but not
2606 the '_' separator) is omitted." */
2609 write_array_type (const tree type)
2612 if (TYPE_DOMAIN (type))
2617 index_type = TYPE_DOMAIN (type);
2618 /* The INDEX_TYPE gives the upper and lower bounds of the
2620 max = TYPE_MAX_VALUE (index_type);
2621 if (TREE_CODE (max) == INTEGER_CST)
2623 /* The ABI specifies that we should mangle the number of
2624 elements in the array, not the largest allowed index. */
2625 max = size_binop (PLUS_EXPR, max, size_one_node);
2626 write_unsigned_number (tree_low_cst (max, 1));
2630 max = TREE_OPERAND (max, 0);
2631 if (!abi_version_at_least (2))
2633 /* value_dependent_expression_p presumes nothing is
2634 dependent when PROCESSING_TEMPLATE_DECL is zero. */
2635 ++processing_template_decl;
2636 if (!value_dependent_expression_p (max))
2637 G.need_abi_warning = 1;
2638 --processing_template_decl;
2640 write_expression (max);
2645 write_type (TREE_TYPE (type));
2648 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2649 variables. TYPE is a pointer-to-member POINTER_TYPE.
2651 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
2654 write_pointer_to_member_type (const tree type)
2657 write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2658 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2661 /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
2662 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2663 TEMPLATE_PARM_INDEX.
2665 <template-param> ::= T </parameter/ number> _ */
2668 write_template_param (const tree parm)
2672 tree parm_type = NULL_TREE;
2674 MANGLE_TRACE_TREE ("template-parm", parm);
2676 switch (TREE_CODE (parm))
2678 case TEMPLATE_TYPE_PARM:
2679 case TEMPLATE_TEMPLATE_PARM:
2680 case BOUND_TEMPLATE_TEMPLATE_PARM:
2681 parm_index = TEMPLATE_TYPE_IDX (parm);
2682 parm_level = TEMPLATE_TYPE_LEVEL (parm);
2685 case TEMPLATE_PARM_INDEX:
2686 parm_index = TEMPLATE_PARM_IDX (parm);
2687 parm_level = TEMPLATE_PARM_LEVEL (parm);
2688 parm_type = TREE_TYPE (TEMPLATE_PARM_DECL (parm));
2696 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2697 earliest template param denoted by `_'. */
2699 write_unsigned_number (parm_index - 1);
2703 /* <template-template-param>
2704 ::= <template-param>
2705 ::= <substitution> */
2708 write_template_template_param (const tree parm)
2710 tree templ = NULL_TREE;
2712 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2713 template template parameter. The substitution candidate here is
2714 only the template. */
2715 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2718 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2719 if (find_substitution (templ))
2723 /* <template-param> encodes only the template parameter position,
2724 not its template arguments, which is fine here. */
2725 write_template_param (parm);
2727 add_substitution (templ);
2730 /* Non-terminal <substitution>.
2732 <substitution> ::= S <seq-id> _
2736 write_substitution (const int seq_id)
2738 MANGLE_TRACE ("substitution", "");
2742 write_number (seq_id - 1, /*unsigned=*/1, 36);
2746 /* Start mangling ENTITY. */
2749 start_mangling (const tree entity)
2752 G.need_abi_warning = false;
2753 obstack_free (&name_obstack, name_base);
2754 mangle_obstack = &name_obstack;
2755 name_base = obstack_alloc (&name_obstack, 0);
2758 /* Done with mangling. If WARN is true, and the name of G.entity will
2759 be mangled differently in a future version of the ABI, issue a
2763 finish_mangling_internal (const bool warn)
2765 if (warn_abi && warn && G.need_abi_warning)
2766 warning (OPT_Wabi, "the mangled name of %qD will change in a future "
2770 /* Clear all the substitutions. */
2771 VEC_truncate (tree, G.substitutions, 0);
2773 /* Null-terminate the string. */
2778 /* Like finish_mangling_internal, but return the mangled string. */
2780 static inline const char *
2781 finish_mangling (const bool warn)
2783 finish_mangling_internal (warn);
2784 return (const char *) obstack_finish (mangle_obstack);
2787 /* Like finish_mangling_internal, but return an identifier. */
2790 finish_mangling_get_identifier (const bool warn)
2792 finish_mangling_internal (warn);
2793 /* Don't obstack_finish here, and the next start_mangling will
2794 remove the identifier. */
2795 return get_identifier ((const char *) name_base);
2798 /* Initialize data structures for mangling. */
2803 gcc_obstack_init (&name_obstack);
2804 name_base = obstack_alloc (&name_obstack, 0);
2805 G.substitutions = NULL;
2807 /* Cache these identifiers for quick comparison when checking for
2808 standard substitutions. */
2809 subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2810 subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
2811 subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
2812 subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
2813 subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
2814 subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2817 /* Generate the mangled name of DECL. */
2820 mangle_decl_string (const tree decl)
2824 start_mangling (decl);
2826 if (TREE_CODE (decl) == TYPE_DECL)
2827 write_type (TREE_TYPE (decl));
2829 write_mangled_name (decl, true);
2831 result = finish_mangling_get_identifier (/*warn=*/true);
2833 fprintf (stderr, "mangle_decl_string = '%s'\n\n",
2834 IDENTIFIER_POINTER (result));
2838 /* Create an identifier for the external mangled name of DECL. */
2841 mangle_decl (const tree decl)
2843 tree id = mangle_decl_string (decl);
2844 id = targetm.mangle_decl_assembler_name (decl, id);
2845 SET_DECL_ASSEMBLER_NAME (decl, id);
2848 /* Generate the mangled representation of TYPE for the typeinfo name. */
2851 mangle_type_string_for_rtti (const tree type)
2855 start_mangling (type);
2856 /* Mangle in a fake anonymous namespace if necessary. */
2857 fake_anon_scope = true;
2859 fake_anon_scope = false;
2860 result = finish_mangling (/*warn=*/false);
2862 fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2866 /* Create an identifier for the mangled name of a special component
2867 for belonging to TYPE. CODE is the ABI-specified code for this
2871 mangle_special_for_type (const tree type, const char *code)
2875 /* We don't have an actual decl here for the special component, so
2876 we can't just process the <encoded-name>. Instead, fake it. */
2877 start_mangling (type);
2879 /* Start the mangling. */
2880 write_string ("_Z");
2881 write_string (code);
2885 result = finish_mangling_get_identifier (/*warn=*/false);
2888 fprintf (stderr, "mangle_special_for_type = %s\n\n",
2889 IDENTIFIER_POINTER (result));
2894 /* Create an identifier for the mangled representation of the typeinfo
2895 structure for TYPE. */
2898 mangle_typeinfo_for_type (const tree type)
2900 return mangle_special_for_type (type, "TI");
2903 /* Create an identifier for the mangled name of the NTBS containing
2904 the mangled name of TYPE. */
2907 mangle_typeinfo_string_for_type (const tree type)
2909 return mangle_special_for_type (type, "TS");
2912 /* Create an identifier for the mangled name of the vtable for TYPE. */
2915 mangle_vtbl_for_type (const tree type)
2917 return mangle_special_for_type (type, "TV");
2920 /* Returns an identifier for the mangled name of the VTT for TYPE. */
2923 mangle_vtt_for_type (const tree type)
2925 return mangle_special_for_type (type, "TT");
2928 /* Return an identifier for a construction vtable group. TYPE is
2929 the most derived class in the hierarchy; BINFO is the base
2930 subobject for which this construction vtable group will be used.
2932 This mangling isn't part of the ABI specification; in the ABI
2933 specification, the vtable group is dumped in the same COMDAT as the
2934 main vtable, and is referenced only from that vtable, so it doesn't
2935 need an external name. For binary formats without COMDAT sections,
2936 though, we need external names for the vtable groups.
2938 We use the production
2940 <special-name> ::= CT <type> <offset number> _ <base type> */
2943 mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
2947 start_mangling (type);
2949 write_string ("_Z");
2950 write_string ("TC");
2952 write_integer_cst (BINFO_OFFSET (binfo));
2954 write_type (BINFO_TYPE (binfo));
2956 result = finish_mangling_get_identifier (/*warn=*/false);
2958 fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
2959 IDENTIFIER_POINTER (result));
2963 /* Mangle a this pointer or result pointer adjustment.
2965 <call-offset> ::= h <fixed offset number> _
2966 ::= v <fixed offset number> _ <virtual offset number> _ */
2969 mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
2971 write_char (virtual_offset ? 'v' : 'h');
2973 /* For either flavor, write the fixed offset. */
2974 write_integer_cst (fixed_offset);
2977 /* For a virtual thunk, add the virtual offset. */
2980 write_integer_cst (virtual_offset);
2985 /* Return an identifier for the mangled name of a this-adjusting or
2986 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment
2987 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this
2988 is a virtual thunk, and it is the vtbl offset in
2989 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
2990 zero for a covariant thunk. Note, that FN_DECL might be a covariant
2991 thunk itself. A covariant thunk name always includes the adjustment
2992 for the this pointer, even if there is none.
2994 <special-name> ::= T <call-offset> <base encoding>
2995 ::= Tc <this_adjust call-offset> <result_adjust call-offset>
2999 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
3000 tree virtual_offset)
3004 start_mangling (fn_decl);
3006 write_string ("_Z");
3009 if (!this_adjusting)
3011 /* Covariant thunk with no this adjustment */
3013 mangle_call_offset (integer_zero_node, NULL_TREE);
3014 mangle_call_offset (fixed_offset, virtual_offset);
3016 else if (!DECL_THUNK_P (fn_decl))
3017 /* Plain this adjusting thunk. */
3018 mangle_call_offset (fixed_offset, virtual_offset);
3021 /* This adjusting thunk to covariant thunk. */
3023 mangle_call_offset (fixed_offset, virtual_offset);
3024 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
3025 virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
3027 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
3028 mangle_call_offset (fixed_offset, virtual_offset);
3029 fn_decl = THUNK_TARGET (fn_decl);
3033 write_encoding (fn_decl);
3035 result = finish_mangling_get_identifier (/*warn=*/false);
3037 fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
3041 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3042 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
3045 static GTY ((param_is (union tree_node))) htab_t conv_type_names;
3047 /* Hash a node (VAL1) in the table. */
3050 hash_type (const void *val)
3052 return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val));
3055 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */
3058 compare_type (const void *val1, const void *val2)
3060 return TREE_TYPE ((const_tree) val1) == (const_tree) val2;
3063 /* Return an identifier for the mangled unqualified name for a
3064 conversion operator to TYPE. This mangling is not specified by the
3065 ABI spec; it is only used internally. */
3068 mangle_conv_op_name_for_type (const tree type)
3073 if (type == error_mark_node)
3074 return error_mark_node;
3076 if (conv_type_names == NULL)
3077 conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
3079 slot = htab_find_slot_with_hash (conv_type_names, type,
3080 (hashval_t) TYPE_UID (type), INSERT);
3081 identifier = (tree)*slot;
3086 /* Create a unique name corresponding to TYPE. */
3087 sprintf (buffer, "operator %lu",
3088 (unsigned long) htab_elements (conv_type_names));
3089 identifier = get_identifier (buffer);
3092 /* Hang TYPE off the identifier so it can be found easily later
3093 when performing conversions. */
3094 TREE_TYPE (identifier) = type;
3096 /* Set bits on the identifier so we know later it's a conversion. */
3097 IDENTIFIER_OPNAME_P (identifier) = 1;
3098 IDENTIFIER_TYPENAME_P (identifier) = 1;
3104 /* Return an identifier for the name of an initialization guard
3105 variable for indicated VARIABLE. */
3108 mangle_guard_variable (const tree variable)
3110 start_mangling (variable);
3111 write_string ("_ZGV");
3112 if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
3113 /* The name of a guard variable for a reference temporary should refer
3114 to the reference, not the temporary. */
3115 write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
3117 write_name (variable, /*ignore_local_scope=*/0);
3118 return finish_mangling_get_identifier (/*warn=*/false);
3121 /* Return an identifier for the name of a temporary variable used to
3122 initialize a static reference. This isn't part of the ABI, but we might
3123 as well call them something readable. */
3126 mangle_ref_init_variable (const tree variable)
3128 start_mangling (variable);
3129 write_string ("_ZGR");
3130 write_name (variable, /*ignore_local_scope=*/0);
3131 return finish_mangling_get_identifier (/*warn=*/false);
3135 /* Foreign language type mangling section. */
3137 /* How to write the type codes for the integer Java type. */
3140 write_java_integer_type_codes (const tree type)
3142 if (type == java_int_type_node)
3144 else if (type == java_short_type_node)
3146 else if (type == java_byte_type_node)
3148 else if (type == java_char_type_node)
3150 else if (type == java_long_type_node)
3152 else if (type == java_boolean_type_node)
3158 #include "gt-cp-mangle.h"