1 /* Name mangling for the new standard C++ ABI.
2 Copyright (C) 2000 Free Software Foundation, Inc.
3 Written by Alex Samuel <sameul@codesourcery.com>
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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
58 /* Debugging support. */
60 /* Define DEBUG_MANGLE to enable very verbose trace messages. */
62 #define DEBUG_MANGLE 0
65 /* Macros for tracing the write_* functions. */
67 # define MANGLE_TRACE(FN, INPUT) \
68 fprintf (stderr, " %-24s: %-24s\n", FN, INPUT)
69 # define MANGLE_TRACE_TREE(FN, NODE) \
70 fprintf (stderr, " %-24s: %-24s (%p)\n", \
71 FN, tree_code_name[TREE_CODE (NODE)], (void *) NODE)
73 # define MANGLE_TRACE(FN, INPUT)
74 # define MANGLE_TRACE_TREE(FN, NODE)
77 /* Non-zero if NODE is a class template-id. We can't rely on
78 CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
79 that hard to distinguish A<T> from A, where A<T> is the type as
80 instantiated outside of the template, and A is the type used
81 without parameters inside the template. */
82 #define CLASSTYPE_TEMPLATE_ID_P(NODE) \
83 (TYPE_LANG_SPECIFIC (NODE) != NULL \
84 && CLASSTYPE_TEMPLATE_INFO (NODE) != NULL \
85 && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))
87 /* Things we only need one of. This module is not reentrant. */
90 /* The name in which we're building the mangled name. */
91 struct obstack name_obstack;
93 /* An array of the current substitution candidates, in the order
95 varray_type substitutions;
98 /* Indices into subst_identifiers. These are identifiers used in
99 special substitution rules. */
107 SUBID_BASIC_IOSTREAM,
110 substitution_identifier_index_t;
112 /* For quick substitution checks, look up these common identifiers
114 static tree subst_identifiers[SUBID_MAX];
116 /* Single-letter codes for builtin integer types, defined in
117 <builtin-type>. These are indexed by integer_type_kind values. */
119 integer_type_codes[itk_none] =
122 'a', /* itk_signed_char */
123 'h', /* itk_unsigned_char */
125 't', /* itk_unsigned_short */
127 'j', /* itk_unsigned_int */
129 'm', /* itk_unsigned_long */
130 'x', /* itk_long_long */
131 'y' /* itk_unsigned_long_long */
134 static int decl_is_template_id PARAMS ((tree, tree*));
136 /* Functions for handling substitutions. */
138 static inline tree canonicalize_for_substitution PARAMS ((tree));
139 static void add_substitution PARAMS ((tree));
140 static inline int is_std_substitution PARAMS ((tree, substitution_identifier_index_t));
141 static inline int is_std_substitution_char PARAMS ((tree, substitution_identifier_index_t));
142 static int find_substitution PARAMS ((tree));
144 /* Functions for emitting mangled representations of things. */
146 static void write_mangled_name PARAMS ((tree));
147 static void write_encoding PARAMS ((tree));
148 static void write_name PARAMS ((tree, int));
149 static void write_unscoped_name PARAMS ((tree));
150 static void write_unscoped_template_name PARAMS ((tree));
151 static void write_nested_name PARAMS ((tree));
152 static void write_prefix PARAMS ((tree));
153 static void write_template_prefix PARAMS ((tree));
154 static void write_unqualified_name PARAMS ((tree));
155 static void write_source_name PARAMS ((tree));
156 static void write_number PARAMS ((unsigned HOST_WIDE_INT, int,
158 static void write_integer_cst PARAMS ((tree));
159 static void write_identifier PARAMS ((const char *));
160 static void write_special_name_constructor PARAMS ((tree));
161 static void write_special_name_destructor PARAMS ((tree));
162 static void write_type PARAMS ((tree));
163 static int write_CV_qualifiers_for_type PARAMS ((tree));
164 static void write_builtin_type PARAMS ((tree));
165 static void write_function_type PARAMS ((tree));
166 static void write_bare_function_type PARAMS ((tree, int));
167 static void write_method_parms PARAMS ((tree, int));
168 static void write_class_enum_type PARAMS ((tree));
169 static void write_template_args PARAMS ((tree));
170 static void write_expression PARAMS ((tree));
171 static void write_template_arg_literal PARAMS ((tree));
172 static void write_template_arg PARAMS ((tree));
173 static void write_template_template_arg PARAMS ((tree));
174 static void write_array_type PARAMS ((tree));
175 static void write_pointer_to_member_type PARAMS ((tree));
176 static void write_template_param PARAMS ((tree));
177 static void write_template_template_param PARAMS ((tree));
178 static void write_substitution PARAMS ((int));
179 static int discriminator_for_local_entity PARAMS ((tree));
180 static int discriminator_for_string_literal PARAMS ((tree, tree));
181 static void write_discriminator PARAMS ((int));
182 static void write_local_name PARAMS ((tree, tree, tree));
183 static void dump_substitution_candidates PARAMS ((void));
184 static const char *mangle_decl_string PARAMS ((tree));
186 /* Control functions. */
188 static inline void start_mangling PARAMS ((void));
189 static inline const char *finish_mangling PARAMS ((void));
190 static tree mangle_special_for_type PARAMS ((tree, const char *));
192 /* Append a single character to the end of the mangled
194 #define write_char(CHAR) \
195 obstack_1grow (&G.name_obstack, (CHAR))
197 /* Append a NUL-terminated string to the end of the mangled
199 #define write_string(STRING) \
200 obstack_grow (&G.name_obstack, (STRING), strlen (STRING))
202 /* Return the position at which the next character will be appended to
203 the mangled representation. */
204 #define mangled_position() \
205 obstack_object_size (&G.name_obstack)
207 /* Non-zero if NODE1 and NODE2 are both TREE_LIST nodes and have the
208 same purpose (context, which may be a type) and value (template
209 decl). See write_template_prefix for more information on what this
211 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \
212 (TREE_CODE (NODE1) == TREE_LIST \
213 && TREE_CODE (NODE2) == TREE_LIST \
214 && ((TYPE_P (TREE_PURPOSE (NODE1)) \
215 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2)))\
216 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \
217 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
219 /* Write out a signed quantity in base 10. */
220 #define write_signed_number(NUMBER) \
221 write_number (NUMBER, /*unsigned_p=*/0, 10)
223 /* Write out an unsigned quantity in base 10. */
224 #define write_unsigned_number(NUMBER) \
225 write_number (NUMBER, /*unsigned_p=*/1, 10)
227 /* If DECL is a template instance, return non-zero and, if
228 TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
229 Otherwise return zero. */
232 decl_is_template_id (decl, template_info)
236 if (TREE_CODE (decl) == TYPE_DECL)
238 /* TYPE_DECLs are handled specially. Look at its type to decide
239 if this is a template instantiation. */
240 tree type = TREE_TYPE (decl);
242 if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
244 if (template_info != NULL)
245 /* For a templated TYPE_DECL, the template info is hanging
247 *template_info = CLASSTYPE_TEMPLATE_INFO (type);
253 /* Check if this is a primary template. */
254 if (DECL_LANG_SPECIFIC (decl) != NULL
255 && DECL_USE_TEMPLATE (decl)
256 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
257 && TREE_CODE (decl) != TEMPLATE_DECL)
259 if (template_info != NULL)
260 /* For most templated decls, the template info is hanging
262 *template_info = DECL_TEMPLATE_INFO (decl);
267 /* It's not a template id. */
271 /* Produce debugging output of current substitution candidates. */
274 dump_substitution_candidates ()
278 fprintf (stderr, " ++ substitutions ");
279 for (i = 0; i < VARRAY_ACTIVE_SIZE (G.substitutions); ++i)
281 tree el = VARRAY_TREE (G.substitutions, i);
282 const char *name = "???";
285 fprintf (stderr, " ");
287 name = IDENTIFIER_POINTER (DECL_NAME (el));
288 else if (TREE_CODE (el) == TREE_LIST)
289 name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
290 else if (TYPE_NAME (el))
291 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el)));
292 fprintf (stderr, " S%d_ = ", i - 1);
294 (CP_TYPE_RESTRICT_P (el)
295 || CP_TYPE_VOLATILE_P (el)
296 || CP_TYPE_CONST_P (el)))
297 fprintf (stderr, "CV-");
298 fprintf (stderr, "%s (%s at %p)\n",
299 name, tree_code_name[TREE_CODE (el)], (void *) el);
303 /* Both decls and types can be substitution candidates, but sometimes
304 they refer to the same thing. For instance, a TYPE_DECL and
305 RECORD_TYPE for the same class refer to the same thing, and should
306 be treated accordinginly in substitutions. This function returns a
307 canonicalized tree node representing NODE that is used when adding
308 and substitution candidates and finding matches. */
311 canonicalize_for_substitution (node)
314 /* For a TYPE_DECL, use the type instead. */
315 if (TREE_CODE (node) == TYPE_DECL)
316 node = TREE_TYPE (node);
318 node = canonical_type_variant (node);
323 /* Add NODE as a substitution candidate. NODE must not already be on
324 the list of candidates. */
327 add_substitution (node)
333 fprintf (stderr, " ++ add_substitution (%s at %10p)\n",
334 tree_code_name[TREE_CODE (node)], (void *) node);
336 /* Get the canonicalized substitution candidate for NODE. */
337 c = canonicalize_for_substitution (node);
338 if (DEBUG_MANGLE && c != node)
339 fprintf (stderr, " ++ using candidate (%s at %10p)\n",
340 tree_code_name[TREE_CODE (node)], (void *) node);
344 /* Make sure NODE isn't already a candidate. */
347 for (i = VARRAY_ACTIVE_SIZE (G.substitutions); --i >= 0; )
349 tree candidate = VARRAY_TREE (G.substitutions, i);
351 && node == candidate)
353 && TYPE_P (candidate)
354 && same_type_p (node, candidate)))
355 my_friendly_abort (20000524);
358 #endif /* ENABLE_CHECKING */
360 /* Put the decl onto the varray of substitution candidates. */
361 VARRAY_PUSH_TREE (G.substitutions, node);
364 dump_substitution_candidates ();
367 /* Helper function for find_substitution. Returns non-zero if NODE,
368 which may be a decl or a CLASS_TYPE, is a template-id with template
369 name of substitution_index[INDEX] in the ::std namespace. */
372 is_std_substitution (node, index)
374 substitution_identifier_index_t index;
381 type = TREE_TYPE (node);
384 else if (CLASS_TYPE_P (node))
387 decl = TYPE_NAME (node);
390 /* These are not the droids you're looking for. */
393 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
394 && TYPE_LANG_SPECIFIC (type)
395 && CLASSTYPE_TEMPLATE_INFO (type)
396 && (DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
397 == subst_identifiers[index]));
400 /* Helper function for find_substitution. Returns non-zero if NODE,
401 which may be a decl or a CLASS_TYPE, is the template-id
402 ::std::identifier<char>, where identifier is
403 substitution_index[INDEX]. */
406 is_std_substitution_char (node, index)
408 substitution_identifier_index_t index;
411 /* Check NODE's name is ::std::identifier. */
412 if (!is_std_substitution (node, index))
414 /* Figure out its template args. */
416 args = DECL_TI_ARGS (node);
417 else if (CLASS_TYPE_P (node))
418 args = CLASSTYPE_TI_ARGS (node);
420 /* Oops, not a template. */
422 /* NODE's template arg list should be <char>. */
424 TREE_VEC_LENGTH (args) == 1
425 && TREE_VEC_ELT (args, 0) == char_type_node;
428 /* Check whether a substitution should be used to represent NODE in
431 First, check standard special-case substitutions.
433 <substitution> ::= St
440 # ::std::basic_string
443 # ::std::basic_string<char,
444 ::std::char_traits<char>,
445 ::std::allocator<char> >
448 # ::std::basic_istream<char, ::std::char_traits<char> >
451 # ::std::basic_ostream<char, ::std::char_traits<char> >
454 # ::std::basic_iostream<char, ::std::char_traits<char> >
456 Then examine the stack of currently available substitution
457 candidates for entities appearing earlier in the same mangling
459 If a substitution is found, write its mangled representation and
460 return non-zero. If none is found, just return zero. */
463 find_substitution (node)
467 int size = VARRAY_ACTIVE_SIZE (G.substitutions);
472 fprintf (stderr, " ++ find_substitution (%s at %p)\n",
473 tree_code_name[TREE_CODE (node)], (void *) node);
475 /* Obtain the canonicalized substitution representation for NODE.
476 This is what we'll compare against. */
477 node = canonicalize_for_substitution (node);
479 /* Check for builtin substitutions. */
481 decl = TYPE_P (node) ? TYPE_NAME (node) : node;
482 type = TYPE_P (node) ? node : TREE_TYPE (node);
484 /* Check for std::allocator. */
486 && is_std_substitution (decl, SUBID_ALLOCATOR)
487 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
493 /* Check for std::basic_string. */
494 if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
498 /* If this is a type (i.e. a fully-qualified template-id),
500 std::basic_string <char,
501 std::char_traits<char>,
502 std::allocator<char> > . */
503 if (CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED
504 && CLASSTYPE_USE_TEMPLATE (type))
506 tree args = CLASSTYPE_TI_ARGS (type);
507 if (TREE_VEC_LENGTH (args) == 3
508 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
509 && is_std_substitution_char (TREE_VEC_ELT (args, 1),
511 && is_std_substitution_char (TREE_VEC_ELT (args, 2),
520 /* Substitute for the template name only if this isn't a type. */
527 /* Check for basic_{i,o,io}stream. */
529 && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED
530 && CLASS_TYPE_P (type)
531 && CLASSTYPE_USE_TEMPLATE (type)
532 && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
534 /* First, check for the template
535 args <char, std::char_traits<char> > . */
536 tree args = CLASSTYPE_TI_ARGS (type);
537 if (TREE_VEC_LENGTH (args) == 2
538 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
539 && is_std_substitution_char (TREE_VEC_ELT (args, 1),
542 /* Got them. Is this basic_istream? */
543 tree name = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type));
544 if (name == subst_identifiers[SUBID_BASIC_ISTREAM])
549 /* Or basic_ostream? */
550 else if (name == subst_identifiers[SUBID_BASIC_OSTREAM])
555 /* Or basic_iostream? */
556 else if (name == subst_identifiers[SUBID_BASIC_IOSTREAM])
564 /* Check for namespace std. */
565 if (decl && DECL_NAMESPACE_STD_P (decl))
571 /* Now check the list of available substitutions for this mangling
573 for (i = 0; i < size; ++i)
575 tree candidate = VARRAY_TREE (G.substitutions, i);
576 /* NODE is a matched to a candidate if it's the same decl node or
577 if it's the same type. */
578 if (decl == candidate
579 || (TYPE_P (candidate) && type && TYPE_P (type)
580 && same_type_p (type, candidate))
581 || NESTED_TEMPLATE_MATCH (node, candidate))
583 write_substitution (i);
588 /* No substitution found. */
593 /* <mangled-name> ::= _Z <encoding> */
596 write_mangled_name (decl)
599 MANGLE_TRACE_TREE ("mangled-name", decl);
601 if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
602 /* The standard notes:
603 "The <encoding> of an extern "C" function is treated like
604 global-scope data, i.e. as its <source-name> without a type." */
605 write_source_name (DECL_NAME (decl));
607 /* C++ name; needs to be mangled. */
610 write_encoding (decl);
614 /* <encoding> ::= <function name> <bare-function-type>
618 write_encoding (decl)
621 MANGLE_TRACE_TREE ("encoding", decl);
623 if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
625 write_source_name (DECL_NAME (decl));
629 write_name (decl, /*ignore_local_scope=*/0);
630 if (TREE_CODE (decl) == FUNCTION_DECL)
634 if (decl_is_template_id (decl, NULL))
635 fn_type = get_mostly_instantiated_function_type (decl, NULL, NULL);
637 fn_type = TREE_TYPE (decl);
639 write_bare_function_type (fn_type,
640 (!DECL_CONSTRUCTOR_P (decl)
641 && !DECL_DESTRUCTOR_P (decl)
642 && !DECL_CONV_FN_P (decl)
643 && decl_is_template_id (decl, NULL)));
647 /* <name> ::= <unscoped-name>
648 ::= <unscoped-template-name> <template-args>
652 If IGNORE_LOCAL_SCOPE is non-zero, this production of <name> is
653 called from <local-name>, which mangles the enclosing scope
654 elsewhere and then uses this function to mangle just the part
655 underneath the function scope. So don't use the <local-name>
656 production, to avoid an infinite recursion. */
659 write_name (decl, ignore_local_scope)
661 int ignore_local_scope;
665 MANGLE_TRACE_TREE ("name", decl);
667 if (TREE_CODE (decl) == TYPE_DECL)
669 /* In case this is a typedef, fish out the corresponding
670 TYPE_DECL for the main variant. */
671 decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
672 context = TYPE_CONTEXT (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
675 context = (DECL_CONTEXT (decl) == NULL) ? NULL : CP_DECL_CONTEXT (decl);
677 /* Decls in :: or ::std scope are treated specially. */
679 || context == global_namespace
680 || DECL_NAMESPACE_STD_P (context))
683 /* Is this a template instance? */
684 if (decl_is_template_id (decl, &template_info))
686 /* Yes: use <unscoped-template-name>. */
687 write_unscoped_template_name (TI_TEMPLATE (template_info));
688 write_template_args (TI_ARGS (template_info));
691 /* Everything else gets an <unqualified-name>. */
692 write_unscoped_name (decl);
696 /* Handle local names, unless we asked not to (that is, invoked
697 under <local-name>, to handle only the part of the name under
699 if (!ignore_local_scope)
701 /* Scan up the list of scope context, looking for a
702 function. If we find one, this entity is in local
703 function scope. local_entity tracks context one scope
704 level down, so it will contain the element that's
705 directly in that function's scope, either decl or one of
706 its enclosing scopes. */
707 tree local_entity = decl;
708 while (context != NULL && context != global_namespace)
710 /* Make sure we're always dealing with decls. */
711 if (context != NULL && TYPE_P (context))
712 context = TYPE_NAME (context);
713 /* Is this a function? */
714 if (TREE_CODE (context) == FUNCTION_DECL)
716 /* Yes, we have local scope. Use the <local-name>
717 production for the innermost function scope. */
718 write_local_name (context, local_entity, decl);
721 /* Up one scope level. */
722 local_entity = context;
723 context = CP_DECL_CONTEXT (context);
726 /* No local scope found? Fall through to <nested-name>. */
729 /* Other decls get a <nested-name> to encode their scope. */
730 write_nested_name (decl);
734 /* <unscoped-name> ::= <unqualified-name>
735 ::= St <unqualified-name> # ::std:: */
738 write_unscoped_name (decl)
741 tree context = CP_DECL_CONTEXT (decl);
743 MANGLE_TRACE_TREE ("unscoped-name", decl);
745 /* Is DECL in ::std? */
746 if (DECL_NAMESPACE_STD_P (context))
749 write_unqualified_name (decl);
751 /* If not, it should be in the global namespace. */
752 else if (context == global_namespace || context == NULL)
753 write_unqualified_name (decl);
755 my_friendly_abort (20000521);
758 /* <unscoped-template-name> ::= <unscoped-name>
759 ::= <substitution> */
762 write_unscoped_template_name (decl)
765 MANGLE_TRACE_TREE ("unscoped-template-name", decl);
767 if (find_substitution (decl))
769 write_unscoped_name (decl);
770 add_substitution (decl);
773 /* Write the nested name, including CV-qualifiers, of DECL.
775 <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
776 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
778 <CV-qualifiers> ::= [r] [V] [K] */
781 write_nested_name (decl)
786 MANGLE_TRACE_TREE ("nested-name", decl);
790 /* Write CV-qualifiers, if this is a member function. */
791 if (TREE_CODE (decl) == FUNCTION_DECL
792 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
794 if (DECL_VOLATILE_MEMFUNC_P (decl))
796 if (DECL_CONST_MEMFUNC_P (decl))
800 /* Is this a template instance? */
801 if (decl_is_template_id (decl, &template_info))
803 /* Yes, use <template-prefix>. */
804 write_template_prefix (decl);
805 write_template_args (TI_ARGS (template_info));
809 /* No, just use <prefix> */
810 write_prefix (DECL_CONTEXT (decl));
811 write_unqualified_name (decl);
816 /* <prefix> ::= <prefix> <unqualified-name>>
817 ::= <template-prefix> <template-args>
819 ::= <substitution> */
826 /* Non-NULL if NODE represents a template-id. */
827 tree template_info = NULL;
829 MANGLE_TRACE_TREE ("prefix", node);
832 || node == global_namespace)
835 if (find_substitution (node))
839 /* Node is a decl. */
841 /* If this is a function decl, that means we've hit function
842 scope, so this prefix must be for a local name. In this
843 case, we're under the <local-name> production, which encodes
844 the enclosing function scope elsewhere. So don't continue
846 if (TREE_CODE (node) == FUNCTION_DECL)
850 decl_is_template_id (decl, &template_info);
853 /* Node is a type. */
855 decl = TYPE_NAME (node);
856 if (CLASSTYPE_TEMPLATE_ID_P (node))
857 template_info = CLASSTYPE_TEMPLATE_INFO (node);
860 if (template_info != NULL)
863 write_template_prefix (decl);
864 write_template_args (TI_ARGS (template_info));
869 write_prefix (CP_DECL_CONTEXT (decl));
870 write_unqualified_name (decl);
873 add_substitution (node);
876 /* <template-prefix> ::= <prefix> <template component>
877 ::= <substitution> */
880 write_template_prefix (node)
883 tree decl = DECL_P (node) ? node : TYPE_NAME (node);
884 tree type = DECL_P (node) ? TREE_TYPE (node) : node;
885 tree context = CP_DECL_CONTEXT (decl);
890 MANGLE_TRACE_TREE ("template-prefix", node);
892 /* Find the template decl. */
893 if (decl_is_template_id (decl, &template_info))
894 template = TI_TEMPLATE (template_info);
895 else if (CLASSTYPE_TEMPLATE_ID_P (type))
896 template = CLASSTYPE_TI_TEMPLATE (type);
898 /* Oops, not a template. */
899 my_friendly_abort (20000524);
901 /* For a member template, though, the template name for the
902 innermost name must have all the outer template levels
903 instantiated. For instance, consider
905 template<typename T> struct Outer {
906 template<typename U> struct Inner {};
909 The template name for `Inner' in `Outer<int>::Inner<float>' is
910 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
911 levels separately, so there's no TEMPLATE_DECL available for this
912 (there's only `Outer<T>::Inner<U>').
914 In order to get the substitutions right, we create a special
915 TREE_LIST to represent the substitution candidate for a nested
916 template. The TREE_PURPOSE is the template's context, fully
917 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
920 So, for the example above, `Outer<int>::Inner' is represented as a
921 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
922 and whose value is `Outer<T>::Inner<U>'. */
923 if (TYPE_P (context))
924 substitution = build_tree_list (context, template);
926 substitution = template;
928 if (find_substitution (substitution))
931 write_prefix (context);
932 write_unqualified_name (decl);
934 add_substitution (substitution);
937 /* We don't need to handle thunks, vtables, or VTTs here. Those are
938 mangled through special entry points.
940 <unqualified-name> ::= <operator-name>
945 write_unqualified_name (decl)
948 MANGLE_TRACE_TREE ("unqualified-name", decl);
950 if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_CONSTRUCTOR_P (decl))
951 write_special_name_constructor (decl);
952 else if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_DESTRUCTOR_P (decl))
953 write_special_name_destructor (decl);
954 else if (DECL_CONV_FN_P (decl))
956 /* Conversion operator. Handle it right here.
957 <operator> ::= cv <type> */
959 write_type (TREE_TYPE (DECL_NAME (decl)));
961 else if (DECL_OVERLOADED_OPERATOR_P (decl))
963 operator_name_info_t *oni;
964 if (DECL_ASSIGNMENT_OPERATOR_P (decl))
965 oni = assignment_operator_name_info;
967 oni = operator_name_info;
969 write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
972 write_source_name (DECL_NAME (decl));
975 /* Non-termial <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
977 <source-name> ::= </length/ number> <identifier> */
980 write_source_name (identifier)
983 MANGLE_TRACE_TREE ("source-name", identifier);
985 /* Never write the whole template-id name including the template
986 arguments; we only want the template name. */
987 if (IDENTIFIER_TEMPLATE (identifier))
988 identifier = IDENTIFIER_TEMPLATE (identifier);
990 write_unsigned_number (IDENTIFIER_LENGTH (identifier));
991 write_identifier (IDENTIFIER_POINTER (identifier));
994 /* Non-terminal <number>.
996 <number> ::= [n] </decimal integer/> */
999 write_number (number, unsigned_p, base)
1000 unsigned HOST_WIDE_INT number;
1004 static const char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1005 unsigned HOST_WIDE_INT n;
1006 unsigned HOST_WIDE_INT m = 1;
1008 if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1011 number = -((HOST_WIDE_INT) number);
1014 /* Figure out how many digits there are. */
1022 /* Write them out. */
1025 int digit = number / m;
1026 write_char (digits[digit]);
1027 number -= digit * m;
1031 my_friendly_assert (number == 0, 20000407);
1034 /* Write out an integeral CST in decimal. */
1037 write_integer_cst (cst)
1040 if (tree_int_cst_sgn (cst) >= 0)
1042 if (TREE_INT_CST_HIGH (cst) != 0)
1043 sorry ("mangling very large integers");
1044 write_unsigned_number (TREE_INT_CST_LOW (cst));
1047 write_signed_number (tree_low_cst (cst, 0));
1050 /* Non-terminal <identifier>.
1052 <identifier> ::= </unqualified source code identifier> */
1055 write_identifier (identifier)
1056 const char *identifier;
1058 MANGLE_TRACE ("identifier", identifier);
1059 write_string (identifier);
1062 /* Handle constructor productions of non-terminal <special-name>.
1063 CTOR is a constructor FUNCTION_DECL.
1065 <special-name> ::= C1 # complete object constructor
1066 ::= C2 # base object constructor
1067 ::= C3 # complete object allocating constructor
1069 Currently, allocating constructors are never used.
1071 We also need to provide unique mangled names (which should never be
1072 exported) for the constructor that takes an in-charge parameter,
1073 and for a constructor whose name is the same as its class's name.
1074 We use "C*INTERNAL*" for these. */
1077 write_special_name_constructor (ctor)
1080 if (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1081 /* Even though we don't ever emit a definition of the
1082 old-style destructor, we still have to consider entities
1083 (like static variables) nested inside it. */
1084 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
1085 write_string ("C1");
1086 else if (DECL_BASE_CONSTRUCTOR_P (ctor))
1087 write_string ("C2");
1089 my_friendly_abort (20001115);
1092 /* Handle destructor productions of non-terminal <special-name>.
1093 DTOR is a denstructor FUNCTION_DECL.
1095 <special-name> ::= D0 # deleting (in-charge) destructor
1096 ::= D1 # complete object (in-charge) destructor
1097 ::= D2 # base object (not-in-charge) destructor
1099 We also need to provide unique mngled names for old-ABI
1100 destructors, sometimes. These should only be used internally. We
1101 use "D*INTERNAL*" for these. */
1104 write_special_name_destructor (dtor)
1107 if (DECL_DELETING_DESTRUCTOR_P (dtor))
1108 write_string ("D0");
1109 else if (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1110 /* Even though we don't ever emit a definition of the
1111 old-style destructor, we still have to consider entities
1112 (like static variables) nested inside it. */
1113 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
1114 write_string ("D1");
1115 else if (DECL_BASE_DESTRUCTOR_P (dtor))
1116 write_string ("D2");
1118 my_friendly_abort (20001115);
1121 /* Return the discriminator for ENTITY appearing inside
1122 FUNCTION. The discriminator is the lexical ordinal of VAR among
1123 entities with the same name in the same FUNCTION. */
1126 discriminator_for_local_entity (entity)
1132 /* Assume this is the only local entity with this name. */
1135 /* For now, we don't discriminate amongst local variables. */
1136 if (TREE_CODE (entity) != TYPE_DECL)
1139 /* Scan the list of local classes. */
1140 entity = TREE_TYPE (entity);
1141 for (type = &VARRAY_TREE (local_classes, 0); *type != entity; ++type)
1142 if (TYPE_IDENTIFIER (*type) == TYPE_IDENTIFIER (entity)
1143 && TYPE_CONTEXT (*type) == TYPE_CONTEXT (entity))
1146 return discriminator;
1149 /* Return the discriminator for STRING, a string literal used inside
1150 FUNCTION. The disciminator is the lexical ordinal of STRING among
1151 string literals used in FUNCTION. */
1154 discriminator_for_string_literal (function, string)
1155 tree function ATTRIBUTE_UNUSED;
1156 tree string ATTRIBUTE_UNUSED;
1158 /* For now, we don't discriminate amongst string literals. */
1162 /* <discriminator> := _ <number>
1164 The discriminator is used only for the second and later occurrences
1165 of the same name within a single function. In this case <number> is
1166 n - 2, if this is the nth occurrence, in lexical order. */
1169 write_discriminator (discriminator)
1172 /* If discriminator is zero, don't write anything. Otherwise... */
1173 if (discriminator > 0)
1176 /* The number is omitted for discriminator == 1. Beyond 1, the
1177 numbering starts at 0. */
1178 if (discriminator > 1)
1179 write_unsigned_number (discriminator - 2);
1183 /* Mangle the name of a function-scope entity. FUNCTION is the
1184 FUNCTION_DECL for the enclosing function. ENTITY is the decl for
1185 the entity itself. LOCAL_ENTITY is the entity that's directly
1186 scoped in FUNCTION_DECL, either ENTITY itself or an enclosing scope
1189 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1190 := Z <function encoding> E s [<discriminator>] */
1193 write_local_name (function, local_entity, entity)
1198 MANGLE_TRACE_TREE ("local-name", entity);
1201 write_encoding (function);
1203 if (TREE_CODE (entity) == STRING_CST)
1206 write_discriminator (discriminator_for_string_literal (function,
1211 /* Now the <entity name>. Let write_name know its being called
1212 from <local-name>, so it doesn't try to process the enclosing
1213 function scope again. */
1214 write_name (entity, /*ignore_local_scope=*/1);
1215 write_discriminator (discriminator_for_local_entity (local_entity));
1219 /* Non-terminals <type> and <CV-qualifier>.
1221 <type> ::= <builtin-type>
1223 ::= <class-enum-type>
1225 ::= <pointer-to-member-type>
1226 ::= <template-param>
1229 ::= P <type> # pointer-to
1230 ::= R <type> # reference-to
1231 ::= C <type> # complex pair (C 2000) [not supported]
1232 ::= G <type> # imaginary (C 2000) [not supported]
1233 ::= U <source-name> <type> # vendor extended type qualifier
1236 TYPE is a type node. */
1242 /* This gets set to non-zero if TYPE turns out to be a (possibly
1243 CV-qualified) builtin type. */
1244 int is_builtin_type = 0;
1246 MANGLE_TRACE_TREE ("type", type);
1248 if (type == error_mark_node)
1251 if (find_substitution (type))
1254 if (write_CV_qualifiers_for_type (type) > 0)
1255 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1256 mangle the unqualified type. The recursive call is needed here
1257 since both the qualified and uqualified types are substitution
1259 write_type (TYPE_MAIN_VARIANT (type));
1262 /* See through any typedefs. */
1263 type = TYPE_MAIN_VARIANT (type);
1265 switch (TREE_CODE (type))
1269 case INTEGER_TYPE: /* Includes wchar_t. */
1271 /* If this is a typedef, TYPE may not be one of
1272 the standard builtin type nodes, but an alias of one. Use
1273 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
1274 write_builtin_type (TYPE_MAIN_VARIANT (type));
1280 write_type (TREE_TYPE (type));
1285 write_function_type (type);
1291 /* A pointer-to-member function is represented as a special
1292 RECORD_TYPE, so check for this first. */
1293 if (TYPE_PTRMEMFUNC_P (type))
1294 write_pointer_to_member_type (type);
1296 write_class_enum_type (type);
1300 /* We handle TYPENAME_TYPEs like ordinary nested names. */
1301 write_nested_name (TYPE_STUB_DECL (type));
1305 write_array_type (type);
1309 /* A pointer-to-member variable is represented by a POINTER_TYPE
1310 to an OFFSET_TYPE, so check for this first. */
1311 if (TYPE_PTRMEM_P (type))
1312 write_pointer_to_member_type (type);
1316 write_type (TREE_TYPE (type));
1320 case REFERENCE_TYPE:
1322 write_type (TREE_TYPE (type));
1325 case TEMPLATE_TYPE_PARM:
1326 case TEMPLATE_PARM_INDEX:
1327 write_template_param (type);
1330 case TEMPLATE_TEMPLATE_PARM:
1331 write_template_template_param (type);
1334 case BOUND_TEMPLATE_TEMPLATE_PARM:
1335 write_template_template_param (type);
1337 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1341 write_pointer_to_member_type (build_pointer_type (type));
1345 my_friendly_abort (20000409);
1349 /* Types other than builtin types are substitution candidates. */
1350 if (!is_builtin_type)
1351 add_substitution (type);
1354 /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
1355 CV-qualifiers written for TYPE.
1357 <CV-qualifiers> ::= [r] [V] [K] */
1360 write_CV_qualifiers_for_type (type)
1363 int num_qualifiers = 0;
1365 /* The order is specified by:
1367 "In cases where multiple order-insensitive qualifiers are
1368 present, they should be ordered 'K' (closest to the base type),
1369 'V', 'r', and 'U' (farthest from the base type) ..." */
1371 if (CP_TYPE_RESTRICT_P (type))
1376 if (CP_TYPE_VOLATILE_P (type))
1381 if (CP_TYPE_CONST_P (type))
1387 return num_qualifiers;
1390 /* Non-terminal <builtin-type>.
1392 <builtin-type> ::= v # void
1397 ::= h # unsigned char
1399 ::= t # unsigned short
1401 ::= j # unsigned int
1403 ::= m # unsigned long
1404 ::= x # long long, __int64
1405 ::= y # unsigned long long, __int64
1406 ::= n # __int128 [not supported]
1407 ::= o # unsigned __int128 [not supported]
1410 ::= e # long double, __float80
1411 ::= g # __float128 [not supported] */
1414 write_builtin_type (type)
1417 switch (TREE_CODE (type))
1428 /* If this is size_t, get the underlying int type. */
1429 if (TYPE_IS_SIZETYPE (type))
1430 type = TYPE_DOMAIN (type);
1432 /* TYPE may still be wchar_t, since that isn't in
1433 integer_type_nodes. */
1434 if (type == wchar_type_node)
1439 /* Assume TYPE is one of the shared integer type nodes. Find
1440 it in the array of these nodes. */
1441 for (itk = 0; itk < itk_none; ++itk)
1442 if (type == integer_types[itk])
1444 /* Print the corresponding single-letter code. */
1445 write_char (integer_type_codes[itk]);
1449 if (itk == itk_none)
1450 /* Couldn't find this type. */
1451 my_friendly_abort (20000408);
1456 if (type == float_type_node)
1458 else if (type == double_type_node)
1460 else if (type == long_double_type_node)
1463 my_friendly_abort (20000409);
1467 my_friendly_abort (20000509);
1471 /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
1472 METHOD_TYPE. The return type is mangled before the parameter
1475 <function-type> ::= F [Y] <bare-function-type> E */
1478 write_function_type (type)
1481 MANGLE_TRACE_TREE ("function-type", type);
1484 /* We don't track whether or not a type is `extern "C"'. Note that
1485 you can have an `extern "C"' function that does not have
1486 `extern "C"' type, and vice versa:
1488 extern "C" typedef void function_t();
1489 function_t f; // f has C++ linkage, but its type is
1492 typedef void function_t();
1493 extern "C" function_t f; // Vice versa.
1496 write_bare_function_type (type, /*include_return_type_p=*/1);
1500 /* Non-terminal <bare-function-type>. NODE is a FUNCTION_DECL or a
1501 METHOD_TYPE. If INCLUDE_RETURN_TYPE is non-zero, the return value
1502 is mangled before the parameter types.
1504 <bare-function-type> ::= </signature/ type>+ */
1507 write_bare_function_type (type, include_return_type_p)
1509 int include_return_type_p;
1511 MANGLE_TRACE_TREE ("bare-function-type", type);
1513 /* Mangle the return type, if requested. */
1514 if (include_return_type_p)
1515 write_type (TREE_TYPE (type));
1517 /* Now mangle the types of the arguments. */
1518 write_method_parms (TYPE_ARG_TYPES (type),
1519 TREE_CODE (type) == METHOD_TYPE);
1522 /* Write the mangled representation of a method parameter list of
1523 types given in PARM_LIST. If METHOD_P is non-zero, the function is
1524 considered a non-static method, and the this parameter is omitted. */
1527 write_method_parms (parm_list, method_p)
1532 /* Assume this parameter type list is variable-length. If it ends
1533 with a void type, then it's not. */
1536 /* If this is a member function, skip the first arg, which is the
1538 "Member functions do not encode the type of their implicit this
1541 parm_list = TREE_CHAIN (parm_list);
1543 for (first_parm = parm_list;
1545 parm_list = TREE_CHAIN (parm_list))
1547 tree parm = TREE_VALUE (parm_list);
1549 if (parm == void_type_node)
1551 /* "Empty parameter lists, whether declared as () or
1552 conventionally as (void), are encoded with a void parameter
1554 if (parm_list == first_parm)
1556 /* If the parm list is terminated with a void type, it's
1559 /* A void type better be the last one. */
1560 my_friendly_assert (TREE_CHAIN (parm_list) == NULL, 20000523);
1567 /* <builtin-type> ::= z # ellipsis */
1571 /* <class-enum-type> ::= <name> */
1574 write_class_enum_type (type)
1577 write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
1580 /* Non-terminal <template-args>. ARGS is a TREE_VEC of template
1583 <template-args> ::= I <template-arg>+ E */
1586 write_template_args (args)
1590 int length = TREE_VEC_LENGTH (args);
1592 MANGLE_TRACE_TREE ("template-args", args);
1594 my_friendly_assert (length > 0, 20000422);
1596 if (TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
1598 /* We have nested template args. We want the innermost template
1600 args = TREE_VEC_ELT (args, length - 1);
1601 length = TREE_VEC_LENGTH (args);
1605 for (i = 0; i < length; ++i)
1606 write_template_arg (TREE_VEC_ELT (args, i));
1610 /* <expression> ::= <unary operator-name> <expression>
1611 ::= <binary operator-name> <expression> <expression>
1614 <expr-primary> ::= <template-param>
1615 ::= L <type> <value number> E # literal
1616 ::= L <mangled-name> E # external name */
1619 write_expression (expr)
1622 enum tree_code code;
1624 code = TREE_CODE (expr);
1626 /* Handle pointers-to-members by making them look like expression
1628 if (code == PTRMEM_CST)
1630 expr = build_nt (ADDR_EXPR,
1631 build_nt (SCOPE_REF,
1632 PTRMEM_CST_CLASS (expr),
1633 PTRMEM_CST_MEMBER (expr)));
1634 code = TREE_CODE (expr);
1637 /* Handle template parameters. */
1638 if (code == TEMPLATE_TYPE_PARM
1639 || code == TEMPLATE_TEMPLATE_PARM
1640 || code == BOUND_TEMPLATE_TEMPLATE_PARM
1641 || code == TEMPLATE_PARM_INDEX)
1642 write_template_param (expr);
1643 /* Handle literals. */
1644 else if (TREE_CODE_CLASS (code) == 'c')
1645 write_template_arg_literal (expr);
1646 else if (DECL_P (expr))
1649 write_mangled_name (expr);
1656 /* Skip NOP_EXPRs. They can occur when (say) a pointer argument
1657 is converted (via qualification conversions) to another
1659 while (TREE_CODE (expr) == NOP_EXPR)
1661 expr = TREE_OPERAND (expr, 0);
1662 code = TREE_CODE (expr);
1665 /* When we bind a variable or function to a non-type template
1666 argument with reference type, we create an ADDR_EXPR to show
1667 the fact that the entity's address has been taken. But, we
1668 don't actually want to output a mangling code for the `&'. */
1669 if (TREE_CODE (expr) == ADDR_EXPR
1671 && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
1673 expr = TREE_OPERAND (expr, 0);
1676 write_expression (expr);
1680 code = TREE_CODE (expr);
1683 /* If it wasn't any of those, recursively expand the expression. */
1684 write_string (operator_name_info[(int) code].mangled_name);
1686 /* Handle pointers-to-members specially. */
1687 if (code == SCOPE_REF)
1689 write_type (TREE_OPERAND (expr, 0));
1690 if (TREE_CODE (TREE_OPERAND (expr, 1)) == IDENTIFIER_NODE)
1691 write_source_name (TREE_OPERAND (expr, 1));
1693 write_encoding (TREE_OPERAND (expr, 1));
1696 for (i = 0; i < TREE_CODE_LENGTH (code); ++i)
1697 write_expression (TREE_OPERAND (expr, i));
1701 /* Literal subcase of non-terminal <template-arg>.
1703 "Literal arguments, e.g. "A<42L>", are encoded with their type
1704 and value. Negative integer values are preceded with "n"; for
1705 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
1706 encoded as 0, true as 1. If floating-point arguments are accepted
1707 as an extension, their values should be encoded using a
1708 fixed-length lowercase hexadecimal string corresponding to the
1709 internal representation (IEEE on IA-64), high-order bytes first,
1710 without leading zeroes. For example: "Lfbff000000E" is -1.0f." */
1713 write_template_arg_literal (value)
1716 tree type = TREE_TYPE (value);
1720 if (TREE_CODE (value) == CONST_DECL)
1721 write_integer_cst (DECL_INITIAL (value));
1722 else if (TREE_CODE (value) == INTEGER_CST)
1724 if (same_type_p (type, boolean_type_node))
1726 if (value == boolean_false_node || integer_zerop (value))
1727 write_unsigned_number (0);
1728 else if (value == boolean_true_node)
1729 write_unsigned_number (1);
1731 my_friendly_abort (20000412);
1734 write_integer_cst (value);
1736 else if (TREE_CODE (value) == REAL_CST)
1738 #ifdef CROSS_COMPILE
1739 static int explained;
1743 sorry ("real-valued template parameters when cross-compiling");
1748 for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1749 write_number (((unsigned char *)
1750 &TREE_REAL_CST (value))[i],
1756 my_friendly_abort (20000412);
1761 /* Non-terminal <tempalate-arg>.
1763 <template-arg> ::= <type> # type
1764 ::= L <type> </value/ number> E # literal
1765 ::= LZ <name> E # external name
1766 ::= X <expression> E # expression */
1769 write_template_arg (node)
1772 enum tree_code code = TREE_CODE (node);
1774 MANGLE_TRACE_TREE ("template-arg", node);
1776 /* A template template paramter's argument list contains TREE_LIST
1777 nodes of which the value field is the the actual argument. */
1778 if (code == TREE_LIST)
1780 node = TREE_VALUE (node);
1781 /* If it's a decl, deal with its type instead. */
1784 node = TREE_TYPE (node);
1785 code = TREE_CODE (node);
1791 else if (code == TEMPLATE_DECL)
1792 /* A template appearing as a template arg is a template template arg. */
1793 write_template_template_arg (node);
1794 else if (DECL_P (node))
1798 write_encoding (node);
1801 else if (TREE_CODE_CLASS (code) == 'c' && code != PTRMEM_CST)
1802 write_template_arg_literal (node);
1805 /* Template arguments may be expressions. */
1807 write_expression (node);
1812 /* <template-template-arg>
1814 ::= <substitution> */
1817 write_template_template_arg (tree decl)
1819 MANGLE_TRACE_TREE ("template-template-arg", decl);
1821 if (find_substitution (decl))
1823 write_name (decl, /*ignore_local_scope=*/0);
1824 add_substitution (decl);
1828 /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
1830 <array-type> ::= A [</dimension/ number>] _ </element/ type>
1831 ::= A <expression> _ </element/ type>
1833 "Array types encode the dimension (number of elements) and the
1834 element type. For variable length arrays, the dimension (but not
1835 the '_' separator) is omitted." */
1838 write_array_type (type)
1842 if (TYPE_DOMAIN (type))
1847 index_type = TYPE_DOMAIN (type);
1848 /* The INDEX_TYPE gives the upper and lower bounds of the
1850 max = TYPE_MAX_VALUE (index_type);
1851 if (TREE_CODE (max) == INTEGER_CST)
1853 /* The ABI specifies that we should mangle the number of
1854 elements in the array, not the largest allowed index. */
1855 max = size_binop (PLUS_EXPR, max, size_one_node);
1856 write_unsigned_number (tree_low_cst (max, 1));
1859 write_expression (TREE_OPERAND (max, 0));
1862 write_type (TREE_TYPE (type));
1865 /* Non-terminal <pointer-to-member-type> for pointer-to-member
1866 variables. TYPE is a pointer-to-member POINTER_TYPE.
1868 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
1871 write_pointer_to_member_type (type)
1875 write_type (TYPE_PTRMEM_CLASS_TYPE (type));
1876 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
1879 /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
1880 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
1881 TEMPLATE_PARM_INDEX.
1883 <template-param> ::= T </parameter/ number> _ */
1886 write_template_param (parm)
1891 MANGLE_TRACE_TREE ("template-parm", parm);
1893 switch (TREE_CODE (parm))
1895 case TEMPLATE_TYPE_PARM:
1896 case TEMPLATE_TEMPLATE_PARM:
1897 case BOUND_TEMPLATE_TEMPLATE_PARM:
1898 parm_index = TEMPLATE_TYPE_IDX (parm);
1901 case TEMPLATE_PARM_INDEX:
1902 parm_index = TEMPLATE_PARM_IDX (parm);
1906 my_friendly_abort (20000523);
1910 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
1911 earliest template param denoted by `_'. */
1913 write_unsigned_number (parm_index - 1);
1917 /* <template-template-param>
1918 ::= <template-param>
1919 ::= <substitution> */
1922 write_template_template_param (parm)
1925 tree template = NULL_TREE;
1927 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
1928 template template parameter. The substitution candidate here is
1929 only the template. */
1930 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
1933 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
1934 if (find_substitution (template))
1938 /* <template-param> encodes only the template parameter position,
1939 not its template arguments, which is fine here. */
1940 write_template_param (parm);
1942 add_substitution (template);
1945 /* Non-terminal <substitution>.
1947 <substitution> ::= S <seq-id> _
1951 write_substitution (seq_id)
1954 MANGLE_TRACE ("substitution", "");
1958 write_number (seq_id - 1, /*unsigned=*/1, 36);
1962 /* Start mangling a new name or type. */
1967 obstack_free (&G.name_obstack, obstack_base (&G.name_obstack));
1970 /* Done with mangling. Return the generated mangled name. */
1972 static inline const char *
1975 /* Clear all the substitutions. */
1976 VARRAY_POP_ALL (G.substitutions);
1978 /* Null-terminate the string. */
1981 return (const char *) obstack_base (&G.name_obstack);
1984 /* Initialize data structures for mangling. */
1989 gcc_obstack_init (&G.name_obstack);
1990 VARRAY_TREE_INIT (G.substitutions, 1, "mangling substitutions");
1992 /* Cache these identifiers for quick comparison when checking for
1993 standard substitutions. */
1994 subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
1995 subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
1996 subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
1997 subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
1998 subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
1999 subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2002 /* Generate the mangled name of DECL. */
2005 mangle_decl_string (decl)
2012 if (TREE_CODE (decl) == TYPE_DECL)
2013 write_type (TREE_TYPE (decl));
2016 write_mangled_name (decl);
2017 if (DECL_LANG_SPECIFIC (decl)
2018 && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
2019 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
2020 /* We need a distinct mangled name for these entities, but
2021 we should never actually output it. So, we append some
2022 characters the assembler won't like. */
2023 write_string (" *INTERNAL* ");
2026 result = finish_mangling ();
2028 fprintf (stderr, "mangle_decl_string = '%s'\n\n", result);
2032 /* Create an identifier for the external mangled name of DECL. */
2038 return get_identifier (mangle_decl_string (decl));
2041 /* Generate the mangled representation of TYPE. */
2044 mangle_type_string (type)
2051 result = finish_mangling ();
2053 fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2057 /* Create an identifier for the mangled representation of TYPE. */
2063 return get_identifier (mangle_type_string (type));
2066 /* Create an identifier for the mangled name of a special component
2067 for belonging to TYPE. CODE is the ABI-specified code for this
2071 mangle_special_for_type (type, code)
2077 /* We don't have an actual decl here for the special component, so
2078 we can't just process the <encoded-name>. Instead, fake it. */
2081 /* Start the mangling. */
2082 write_string ("_Z");
2083 write_string (code);
2087 result = finish_mangling ();
2090 fprintf (stderr, "mangle_special_for_type = %s\n\n", result);
2092 return get_identifier (result);
2095 /* Create an identifier for the mangled representation of the typeinfo
2096 structure for TYPE. */
2099 mangle_typeinfo_for_type (type)
2102 return mangle_special_for_type (type, "TI");
2105 /* Create an identifier for the mangled name of the NTBS containing
2106 the mangled name of TYPE. */
2109 mangle_typeinfo_string_for_type (type)
2112 return mangle_special_for_type (type, "TS");
2115 /* Create an identifier for the mangled name of the vtable for TYPE. */
2118 mangle_vtbl_for_type (type)
2121 return mangle_special_for_type (type, "TV");
2124 /* Returns an identifier for the mangled name of the VTT for TYPE. */
2127 mangle_vtt_for_type (type)
2130 return mangle_special_for_type (type, "TT");
2133 /* Return an identifier for a construction vtable group. TYPE is
2134 the most derived class in the hierarchy; BINFO is the base
2135 subobject for which this construction vtable group will be used.
2137 This mangling isn't part of the ABI specification; in the ABI
2138 specification, the vtable group is dumped in the same COMDAT as the
2139 main vtable, and is referenced only from that vtable, so it doesn't
2140 need an external name. For binary formats without COMDAT sections,
2141 though, we need external names for the vtable groups.
2143 We use the production
2145 <special-name> ::= CT <type> <offset number> _ <base type> */
2148 mangle_ctor_vtbl_for_type (type, binfo)
2156 write_string ("_Z");
2157 write_string ("TC");
2159 write_integer_cst (BINFO_OFFSET (binfo));
2161 write_type (BINFO_TYPE (binfo));
2163 result = finish_mangling ();
2165 fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n", result);
2166 return get_identifier (result);
2169 /* Return an identifier for the mangled name of a thunk to FN_DECL.
2170 OFFSET is the initial adjustment to this used to find the vptr. If
2171 VCALL_OFFSET is non-NULL, this is a virtual thunk, and it is the
2172 vtbl offset in bytes.
2174 <special-name> ::= Th <offset number> _ <base encoding>
2175 ::= Tv <offset number> _ <vcall offset number> _
2180 mangle_thunk (fn_decl, offset, vcall_offset)
2189 write_string ("_Z");
2190 /* The <special-name> for virtual thunks is Tv, for non-virtual
2193 if (vcall_offset != 0)
2198 /* For either flavor, write the offset to this. */
2199 write_integer_cst (offset);
2202 /* For a virtual thunk, add the vcall offset. */
2205 /* Virtual thunk. Write the vcall offset and base type name. */
2206 write_integer_cst (vcall_offset);
2211 write_encoding (fn_decl);
2213 result = finish_mangling ();
2215 fprintf (stderr, "mangle_thunk = %s\n\n", result);
2216 return get_identifier (result);
2219 /* Return an identifier for the mangled unqualified name for a
2220 conversion operator to TYPE. This mangling is not specified by the
2221 ABI spec; it is only used internally.
2223 For compatibility with existing conversion operator mechanisms,
2224 the mangled form is `__op<type>' where <type> is the mangled
2225 representation of TYPE.
2227 FIXME: Though identifiers with starting with __op are reserved for
2228 the implementation, it would eventually be nice to use inaccessible
2229 names for these operators. */
2232 mangle_conv_op_name_for_type (type)
2237 /* Build the mangling for TYPE. */
2238 const char *mangled_type = mangle_type_string (type);
2239 /* Allocate a temporary buffer for the complete name. */
2240 char *op_name = (char *) xmalloc (strlen (OPERATOR_TYPENAME_FORMAT)
2241 + strlen (mangled_type) + 1);
2242 /* Assemble the mangling. */
2243 strcpy (op_name, OPERATOR_TYPENAME_FORMAT);
2244 strcat (op_name, mangled_type);
2245 /* Find or create an identifier. */
2246 identifier = get_identifier (op_name);
2247 /* Done with the temporary buffer. */
2249 /* Set bits on the identifier so we know later it's a conversion. */
2250 IDENTIFIER_OPNAME_P (identifier) = 1;
2251 IDENTIFIER_TYPENAME_P (identifier) = 1;
2252 /* Hang TYPE off the identifier so it can be found easily later when
2253 performing conversions. */
2254 TREE_TYPE (identifier) = type;
2259 /* Return an identifier for the name of an initialization guard
2260 variable for indicated VARIABLE. */
2263 mangle_guard_variable (variable)
2267 write_string ("_ZGV");
2268 write_name (variable, /*ignore_local_scope=*/0);
2269 return get_identifier (finish_mangling ());