1 /* Name mangling for the 3.0 C++ ABI.
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Written by Alex Samuel <samuel@codesourcery.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This file implements mangling of C++ names according to the IA64
22 C++ ABI specification. A mangled name encodes a function or
23 variable's name, scope, type, and/or template arguments into a text
24 identifier. This identifier is used as the function's or
25 variable's linkage name, to preserve compatibility between C++'s
26 language features (templates, scoping, and overloading) and C
29 Additionally, g++ uses mangled names internally. To support this,
30 mangling of types is allowed, even though the mangled name of a
31 type should not appear by itself as an exported name. Ditto for
32 uninstantiated templates.
34 The primary entry point for this module is mangle_decl, which
35 returns an identifier containing the mangled name for a decl.
36 Additional entry points are provided to build mangled names of
37 particular constructs when the appropriate decl for that construct
38 is not available. These are:
40 mangle_typeinfo_for_type: typeinfo data
41 mangle_typeinfo_string_for_type: typeinfo type name
42 mangle_vtbl_for_type: virtual table data
43 mangle_vtt_for_type: VTT data
44 mangle_ctor_vtbl_for_type: `C-in-B' constructor virtual table data
45 mangle_thunk: thunk function or entry */
49 #include "coretypes.h"
51 #include "vtable-verify.h"
53 #include "stringpool.h"
55 #include "stor-layout.h"
59 /* Debugging support. */
61 /* Define DEBUG_MANGLE to enable very verbose trace messages. */
63 #define DEBUG_MANGLE 0
66 /* Macros for tracing the write_* functions. */
68 # define MANGLE_TRACE(FN, INPUT) \
69 fprintf (stderr, " %-24s: %-24s\n", (FN), (INPUT))
70 # define MANGLE_TRACE_TREE(FN, NODE) \
71 fprintf (stderr, " %-24s: %-24s (%p)\n", \
72 (FN), get_tree_code_name (TREE_CODE (NODE)), (void *) (NODE))
74 # define MANGLE_TRACE(FN, INPUT)
75 # define MANGLE_TRACE_TREE(FN, NODE)
78 /* Nonzero if NODE is a class template-id. We can't rely on
79 CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
80 that hard to distinguish A<T> from A, where A<T> is the type as
81 instantiated outside of the template, and A is the type used
82 without parameters inside the template. */
83 #define CLASSTYPE_TEMPLATE_ID_P(NODE) \
84 (TYPE_LANG_SPECIFIC (NODE) != NULL \
85 && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \
86 || (CLASSTYPE_TEMPLATE_INFO (NODE) != NULL \
87 && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))))
89 /* For deciding whether to set G.need_abi_warning, we need to consider both
90 warn_abi_version and flag_abi_compat_version. */
91 #define abi_warn_or_compat_version_crosses(N) \
92 (abi_version_crosses (N) || abi_compat_version_crosses (N))
94 /* Things we only need one of. This module is not reentrant. */
95 struct GTY(()) globals
{
96 /* An array of the current substitution candidates, in the order
98 vec
<tree
, va_gc
> *substitutions
;
100 /* The entity that is being mangled. */
101 tree
GTY ((skip
)) entity
;
103 /* How many parameter scopes we are inside. */
106 /* True if the mangling will be different in a future version of the
108 bool need_abi_warning
;
111 static GTY (()) globals G
;
113 /* The obstack on which we build mangled names. */
114 static struct obstack
*mangle_obstack
;
116 /* The obstack on which we build mangled names that are not going to
117 be IDENTIFIER_NODEs. */
118 static struct obstack name_obstack
;
120 /* The first object on the name_obstack; we use this to free memory
121 allocated on the name_obstack. */
122 static void *name_base
;
124 /* Indices into subst_identifiers. These are identifiers used in
125 special substitution rules. */
133 SUBID_BASIC_IOSTREAM
,
136 substitution_identifier_index_t
;
138 /* For quick substitution checks, look up these common identifiers
140 static GTY(()) tree subst_identifiers
[SUBID_MAX
];
142 /* Single-letter codes for builtin integer types, defined in
143 <builtin-type>. These are indexed by integer_type_kind values. */
145 integer_type_codes
[itk_none
] =
148 'a', /* itk_signed_char */
149 'h', /* itk_unsigned_char */
151 't', /* itk_unsigned_short */
153 'j', /* itk_unsigned_int */
155 'm', /* itk_unsigned_long */
156 'x', /* itk_long_long */
157 'y', /* itk_unsigned_long_long */
158 /* __intN types are handled separately */
159 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
162 static int decl_is_template_id (const tree
, tree
* const);
164 /* Functions for handling substitutions. */
166 static inline tree
canonicalize_for_substitution (tree
);
167 static void add_substitution (tree
);
168 static inline int is_std_substitution (const tree
,
169 const substitution_identifier_index_t
);
170 static inline int is_std_substitution_char (const tree
,
171 const substitution_identifier_index_t
);
172 static int find_substitution (tree
);
173 static void mangle_call_offset (const tree
, const tree
);
175 /* Functions for emitting mangled representations of things. */
177 static void write_mangled_name (const tree
, bool);
178 static void write_encoding (const tree
);
179 static void write_name (tree
, const int);
180 static void write_abi_tags (tree
);
181 static void write_unscoped_name (const tree
);
182 static void write_unscoped_template_name (const tree
);
183 static void write_nested_name (const tree
);
184 static void write_prefix (const tree
);
185 static void write_template_prefix (const tree
);
186 static void write_unqualified_name (tree
);
187 static void write_conversion_operator_name (const tree
);
188 static void write_source_name (tree
);
189 static void write_literal_operator_name (tree
);
190 static void write_unnamed_type_name (const tree
);
191 static void write_closure_type_name (const tree
);
192 static int hwint_to_ascii (unsigned HOST_WIDE_INT
, const unsigned int, char *,
194 static void write_number (unsigned HOST_WIDE_INT
, const int,
196 static void write_compact_number (int num
);
197 static void write_integer_cst (const tree
);
198 static void write_real_cst (const tree
);
199 static void write_identifier (const char *);
200 static void write_special_name_constructor (const tree
);
201 static void write_special_name_destructor (const tree
);
202 static void write_type (tree
);
203 static int write_CV_qualifiers_for_type (const tree
);
204 static void write_builtin_type (tree
);
205 static void write_function_type (const tree
);
206 static void write_bare_function_type (const tree
, const int, const tree
);
207 static void write_method_parms (tree
, const int, const tree
);
208 static void write_class_enum_type (const tree
);
209 static void write_template_args (tree
);
210 static void write_expression (tree
);
211 static void write_template_arg_literal (const tree
);
212 static void write_template_arg (tree
);
213 static void write_template_template_arg (const tree
);
214 static void write_array_type (const tree
);
215 static void write_pointer_to_member_type (const tree
);
216 static void write_template_param (const tree
);
217 static void write_template_template_param (const tree
);
218 static void write_substitution (const int);
219 static int discriminator_for_local_entity (tree
);
220 static int discriminator_for_string_literal (tree
, tree
);
221 static void write_discriminator (const int);
222 static void write_local_name (tree
, const tree
, const tree
);
223 static void dump_substitution_candidates (void);
224 static tree
mangle_decl_string (const tree
);
225 static int local_class_index (tree
);
226 static void maybe_check_abi_tags (tree
, tree
= NULL_TREE
);
228 /* Control functions. */
230 static inline void start_mangling (const tree
);
231 static tree
mangle_special_for_type (const tree
, const char *);
233 /* Foreign language functions. */
235 static void write_java_integer_type_codes (const tree
);
237 /* Append a single character to the end of the mangled
239 #define write_char(CHAR) \
240 obstack_1grow (mangle_obstack, (CHAR))
242 /* Append a sized buffer to the end of the mangled representation. */
243 #define write_chars(CHAR, LEN) \
244 obstack_grow (mangle_obstack, (CHAR), (LEN))
246 /* Append a NUL-terminated string to the end of the mangled
248 #define write_string(STRING) \
249 obstack_grow (mangle_obstack, (STRING), strlen (STRING))
251 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
252 same purpose (context, which may be a type) and value (template
253 decl). See write_template_prefix for more information on what this
255 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \
256 (TREE_CODE (NODE1) == TREE_LIST \
257 && TREE_CODE (NODE2) == TREE_LIST \
258 && ((TYPE_P (TREE_PURPOSE (NODE1)) \
259 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))) \
260 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \
261 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
263 /* Write out an unsigned quantity in base 10. */
264 #define write_unsigned_number(NUMBER) \
265 write_number ((NUMBER), /*unsigned_p=*/1, 10)
267 /* If DECL is a template instance (including the uninstantiated template
268 itself), return nonzero and, if TEMPLATE_INFO is non-NULL, set
269 *TEMPLATE_INFO to its template info. Otherwise return zero. */
272 decl_is_template_id (const tree decl
, tree
* const template_info
)
274 if (TREE_CODE (decl
) == TYPE_DECL
)
276 /* TYPE_DECLs are handled specially. Look at its type to decide
277 if this is a template instantiation. */
278 const tree type
= TREE_TYPE (decl
);
280 if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_ID_P (type
))
282 if (template_info
!= NULL
)
283 /* For a templated TYPE_DECL, the template info is hanging
285 *template_info
= TYPE_TEMPLATE_INFO (type
);
291 /* Check if this is a primary template. */
292 if (DECL_LANG_SPECIFIC (decl
) != NULL
293 && VAR_OR_FUNCTION_DECL_P (decl
)
294 && DECL_TEMPLATE_INFO (decl
)
295 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
))
296 && TREE_CODE (decl
) != TEMPLATE_DECL
)
298 if (template_info
!= NULL
)
299 /* For most templated decls, the template info is hanging
301 *template_info
= DECL_TEMPLATE_INFO (decl
);
306 /* It's not a template id. */
310 /* Produce debugging output of current substitution candidates. */
313 dump_substitution_candidates (void)
318 fprintf (stderr
, " ++ substitutions ");
319 FOR_EACH_VEC_ELT (*G
.substitutions
, i
, el
)
321 const char *name
= "???";
324 fprintf (stderr
, " ");
326 name
= IDENTIFIER_POINTER (DECL_NAME (el
));
327 else if (TREE_CODE (el
) == TREE_LIST
)
328 name
= IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el
)));
329 else if (TYPE_NAME (el
))
330 name
= TYPE_NAME_STRING (el
);
331 fprintf (stderr
, " S%d_ = ", i
- 1);
333 (CP_TYPE_RESTRICT_P (el
)
334 || CP_TYPE_VOLATILE_P (el
)
335 || CP_TYPE_CONST_P (el
)))
336 fprintf (stderr
, "CV-");
337 fprintf (stderr
, "%s (%s at %p)\n",
338 name
, get_tree_code_name (TREE_CODE (el
)), (void *) el
);
342 /* Both decls and types can be substitution candidates, but sometimes
343 they refer to the same thing. For instance, a TYPE_DECL and
344 RECORD_TYPE for the same class refer to the same thing, and should
345 be treated accordingly in substitutions. This function returns a
346 canonicalized tree node representing NODE that is used when adding
347 and substitution candidates and finding matches. */
350 canonicalize_for_substitution (tree node
)
352 /* For a TYPE_DECL, use the type instead. */
353 if (TREE_CODE (node
) == TYPE_DECL
)
354 node
= TREE_TYPE (node
);
356 && TYPE_CANONICAL (node
) != node
357 && TYPE_MAIN_VARIANT (node
) != node
)
360 /* Here we want to strip the topmost typedef only.
361 We need to do that so is_std_substitution can do proper
363 if (TREE_CODE (node
) == FUNCTION_TYPE
)
364 /* Use build_qualified_type and TYPE_QUALS here to preserve
365 the old buggy mangling of attribute noreturn with abi<5. */
366 node
= build_qualified_type (TYPE_MAIN_VARIANT (node
),
369 node
= cp_build_qualified_type (TYPE_MAIN_VARIANT (node
),
370 cp_type_quals (node
));
371 if (TREE_CODE (node
) == FUNCTION_TYPE
372 || TREE_CODE (node
) == METHOD_TYPE
)
373 node
= build_ref_qualified_type (node
, type_memfn_rqual (orig
));
378 /* Add NODE as a substitution candidate. NODE must not already be on
379 the list of candidates. */
382 add_substitution (tree node
)
387 fprintf (stderr
, " ++ add_substitution (%s at %10p)\n",
388 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
390 /* Get the canonicalized substitution candidate for NODE. */
391 c
= canonicalize_for_substitution (node
);
392 if (DEBUG_MANGLE
&& c
!= node
)
393 fprintf (stderr
, " ++ using candidate (%s at %10p)\n",
394 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
397 /* Make sure NODE isn't already a candidate. */
403 FOR_EACH_VEC_SAFE_ELT (G
.substitutions
, i
, candidate
)
405 gcc_assert (!(DECL_P (node
) && node
== candidate
));
406 gcc_assert (!(TYPE_P (node
) && TYPE_P (candidate
)
407 && same_type_p (node
, candidate
)));
411 /* Put the decl onto the varray of substitution candidates. */
412 vec_safe_push (G
.substitutions
, node
);
415 dump_substitution_candidates ();
418 /* Helper function for find_substitution. Returns nonzero if NODE,
419 which may be a decl or a CLASS_TYPE, is a template-id with template
420 name of substitution_index[INDEX] in the ::std namespace. */
423 is_std_substitution (const tree node
,
424 const substitution_identifier_index_t index
)
431 type
= TREE_TYPE (node
);
434 else if (CLASS_TYPE_P (node
))
437 decl
= TYPE_NAME (node
);
440 /* These are not the droids you're looking for. */
443 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl
))
444 && TYPE_LANG_SPECIFIC (type
)
445 && TYPE_TEMPLATE_INFO (type
)
446 && (DECL_NAME (TYPE_TI_TEMPLATE (type
))
447 == subst_identifiers
[index
]));
450 /* Helper function for find_substitution. Returns nonzero if NODE,
451 which may be a decl or a CLASS_TYPE, is the template-id
452 ::std::identifier<char>, where identifier is
453 substitution_index[INDEX]. */
456 is_std_substitution_char (const tree node
,
457 const substitution_identifier_index_t index
)
460 /* Check NODE's name is ::std::identifier. */
461 if (!is_std_substitution (node
, index
))
463 /* Figure out its template args. */
465 args
= DECL_TI_ARGS (node
);
466 else if (CLASS_TYPE_P (node
))
467 args
= CLASSTYPE_TI_ARGS (node
);
469 /* Oops, not a template. */
471 /* NODE's template arg list should be <char>. */
473 TREE_VEC_LENGTH (args
) == 1
474 && TREE_VEC_ELT (args
, 0) == char_type_node
;
477 /* Check whether a substitution should be used to represent NODE in
480 First, check standard special-case substitutions.
482 <substitution> ::= St
489 # ::std::basic_string
492 # ::std::basic_string<char,
493 ::std::char_traits<char>,
494 ::std::allocator<char> >
497 # ::std::basic_istream<char, ::std::char_traits<char> >
500 # ::std::basic_ostream<char, ::std::char_traits<char> >
503 # ::std::basic_iostream<char, ::std::char_traits<char> >
505 Then examine the stack of currently available substitution
506 candidates for entities appearing earlier in the same mangling
508 If a substitution is found, write its mangled representation and
509 return nonzero. If none is found, just return zero. */
512 find_substitution (tree node
)
515 const int size
= vec_safe_length (G
.substitutions
);
518 const char *abbr
= NULL
;
521 fprintf (stderr
, " ++ find_substitution (%s at %p)\n",
522 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
524 /* Obtain the canonicalized substitution representation for NODE.
525 This is what we'll compare against. */
526 node
= canonicalize_for_substitution (node
);
528 /* Check for builtin substitutions. */
530 decl
= TYPE_P (node
) ? TYPE_NAME (node
) : node
;
531 type
= TYPE_P (node
) ? node
: TREE_TYPE (node
);
533 /* Check for std::allocator. */
535 && is_std_substitution (decl
, SUBID_ALLOCATOR
)
536 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl
)))
539 /* Check for std::basic_string. */
540 else if (decl
&& is_std_substitution (decl
, SUBID_BASIC_STRING
))
544 /* If this is a type (i.e. a fully-qualified template-id),
546 std::basic_string <char,
547 std::char_traits<char>,
548 std::allocator<char> > . */
549 if (cp_type_quals (type
) == TYPE_UNQUALIFIED
550 && CLASSTYPE_USE_TEMPLATE (type
))
552 tree args
= CLASSTYPE_TI_ARGS (type
);
553 if (TREE_VEC_LENGTH (args
) == 3
554 && same_type_p (TREE_VEC_ELT (args
, 0), char_type_node
)
555 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
557 && is_std_substitution_char (TREE_VEC_ELT (args
, 2),
563 /* Substitute for the template name only if this isn't a type. */
567 /* Check for basic_{i,o,io}stream. */
568 else if (TYPE_P (node
)
569 && cp_type_quals (type
) == TYPE_UNQUALIFIED
570 && CLASS_TYPE_P (type
)
571 && CLASSTYPE_USE_TEMPLATE (type
)
572 && CLASSTYPE_TEMPLATE_INFO (type
) != NULL
)
574 /* First, check for the template
575 args <char, std::char_traits<char> > . */
576 tree args
= CLASSTYPE_TI_ARGS (type
);
577 if (TREE_VEC_LENGTH (args
) == 2
578 && TYPE_P (TREE_VEC_ELT (args
, 0))
579 && same_type_p (TREE_VEC_ELT (args
, 0), char_type_node
)
580 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
583 /* Got them. Is this basic_istream? */
584 if (is_std_substitution (decl
, SUBID_BASIC_ISTREAM
))
586 /* Or basic_ostream? */
587 else if (is_std_substitution (decl
, SUBID_BASIC_OSTREAM
))
589 /* Or basic_iostream? */
590 else if (is_std_substitution (decl
, SUBID_BASIC_IOSTREAM
))
595 /* Check for namespace std. */
596 else if (decl
&& DECL_NAMESPACE_STD_P (decl
))
602 tree tags
= NULL_TREE
;
603 if (OVERLOAD_TYPE_P (node
) || DECL_CLASS_TEMPLATE_P (node
))
604 tags
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (type
));
605 /* Now check the list of available substitutions for this mangling
607 if (!abbr
|| tags
) for (i
= 0; i
< size
; ++i
)
609 tree candidate
= (*G
.substitutions
)[i
];
610 /* NODE is a matched to a candidate if it's the same decl node or
611 if it's the same type. */
612 if (decl
== candidate
613 || (TYPE_P (candidate
) && type
&& TYPE_P (node
)
614 && same_type_p (type
, candidate
))
615 || NESTED_TEMPLATE_MATCH (node
, candidate
))
617 write_substitution (i
);
623 /* No substitution found. */
629 /* If there are ABI tags on the abbreviation, it becomes
630 a substitution candidate. */
631 write_abi_tags (tags
);
632 add_substitution (node
);
637 /* Returns whether DECL's symbol name should be the plain unqualified-id
638 rather than a more complicated mangled name. */
641 unmangled_name_p (const tree decl
)
643 if (TREE_CODE (decl
) == FUNCTION_DECL
)
645 /* The names of `extern "C"' functions are not mangled. */
646 return (DECL_EXTERN_C_FUNCTION_P (decl
)
647 /* But overloaded operator names *are* mangled. */
648 && !DECL_OVERLOADED_OPERATOR_P (decl
));
650 else if (VAR_P (decl
))
652 /* static variables are mangled. */
653 if (!DECL_EXTERNAL_LINKAGE_P (decl
))
656 /* extern "C" declarations aren't mangled. */
657 if (DECL_EXTERN_C_P (decl
))
660 /* Other variables at non-global scope are mangled. */
661 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
664 /* Variable template instantiations are mangled. */
665 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
666 && variable_template_p (DECL_TI_TEMPLATE (decl
)))
669 /* Declarations with ABI tags are mangled. */
670 if (lookup_attribute ("abi_tag", DECL_ATTRIBUTES (decl
)))
673 /* The names of non-static global variables aren't mangled. */
680 /* TOP_LEVEL is true, if this is being called at outermost level of
681 mangling. It should be false when mangling a decl appearing in an
682 expression within some other mangling.
684 <mangled-name> ::= _Z <encoding> */
687 write_mangled_name (const tree decl
, bool top_level
)
689 MANGLE_TRACE_TREE ("mangled-name", decl
);
691 check_abi_tags (decl
);
693 if (unmangled_name_p (decl
))
696 write_string (IDENTIFIER_POINTER (DECL_NAME (decl
)));
699 /* The standard notes: "The <encoding> of an extern "C"
700 function is treated like global-scope data, i.e. as its
701 <source-name> without a type." We cannot write
702 overloaded operators that way though, because it contains
703 characters invalid in assembler. */
705 write_source_name (DECL_NAME (decl
));
711 write_encoding (decl
);
715 /* Returns true if the return type of DECL is part of its signature, and
716 therefore its mangling. */
719 mangle_return_type_p (tree decl
)
721 return (!DECL_CONSTRUCTOR_P (decl
)
722 && !DECL_DESTRUCTOR_P (decl
)
723 && !DECL_CONV_FN_P (decl
)
724 && decl_is_template_id (decl
, NULL
));
727 /* <encoding> ::= <function name> <bare-function-type>
731 write_encoding (const tree decl
)
733 MANGLE_TRACE_TREE ("encoding", decl
);
735 if (DECL_LANG_SPECIFIC (decl
) && DECL_EXTERN_C_FUNCTION_P (decl
))
737 /* For overloaded operators write just the mangled name
738 without arguments. */
739 if (DECL_OVERLOADED_OPERATOR_P (decl
))
740 write_name (decl
, /*ignore_local_scope=*/0);
742 write_source_name (DECL_NAME (decl
));
746 write_name (decl
, /*ignore_local_scope=*/0);
747 if (TREE_CODE (decl
) == FUNCTION_DECL
)
752 if (decl_is_template_id (decl
, NULL
))
754 fn_type
= get_mostly_instantiated_function_type (decl
);
755 /* FN_TYPE will not have parameter types for in-charge or
756 VTT parameters. Therefore, we pass NULL_TREE to
757 write_bare_function_type -- otherwise, it will get
758 confused about which artificial parameters to skip. */
763 fn_type
= TREE_TYPE (decl
);
767 write_bare_function_type (fn_type
,
768 mangle_return_type_p (decl
),
773 /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
774 or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */
777 decl_mangling_context (tree decl
)
779 tree tcontext
= targetm
.cxx
.decl_mangling_context (decl
);
781 if (tcontext
!= NULL_TREE
)
784 if (TREE_CODE (decl
) == TEMPLATE_DECL
785 && DECL_TEMPLATE_RESULT (decl
))
786 decl
= DECL_TEMPLATE_RESULT (decl
);
788 if (TREE_CODE (decl
) == TYPE_DECL
789 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
791 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl
));
795 else if (template_type_parameter_p (decl
))
796 /* template type parms have no mangling context. */
798 return CP_DECL_CONTEXT (decl
);
801 /* <name> ::= <unscoped-name>
802 ::= <unscoped-template-name> <template-args>
806 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
807 called from <local-name>, which mangles the enclosing scope
808 elsewhere and then uses this function to mangle just the part
809 underneath the function scope. So don't use the <local-name>
810 production, to avoid an infinite recursion. */
813 write_name (tree decl
, const int ignore_local_scope
)
817 MANGLE_TRACE_TREE ("name", decl
);
819 if (TREE_CODE (decl
) == TYPE_DECL
)
821 /* In case this is a typedef, fish out the corresponding
822 TYPE_DECL for the main variant. */
823 decl
= TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
)));
826 context
= decl_mangling_context (decl
);
828 gcc_assert (context
!= NULL_TREE
);
830 if (abi_warn_or_compat_version_crosses (7)
831 && ignore_local_scope
832 && TREE_CODE (context
) == PARM_DECL
)
833 G
.need_abi_warning
= 1;
835 /* A decl in :: or ::std scope is treated specially. The former is
836 mangled using <unscoped-name> or <unscoped-template-name>, the
837 latter with a special substitution. Also, a name that is
838 directly in a local function scope is also mangled with
839 <unscoped-name> rather than a full <nested-name>. */
840 if (context
== global_namespace
841 || DECL_NAMESPACE_STD_P (context
)
842 || (ignore_local_scope
843 && (TREE_CODE (context
) == FUNCTION_DECL
844 || (abi_version_at_least (7)
845 && TREE_CODE (context
) == PARM_DECL
))))
848 /* Is this a template instance? */
849 if (decl_is_template_id (decl
, &template_info
))
851 /* Yes: use <unscoped-template-name>. */
852 write_unscoped_template_name (TI_TEMPLATE (template_info
));
853 write_template_args (TI_ARGS (template_info
));
856 /* Everything else gets an <unqualified-name>. */
857 write_unscoped_name (decl
);
861 /* Handle local names, unless we asked not to (that is, invoked
862 under <local-name>, to handle only the part of the name under
864 if (!ignore_local_scope
)
866 /* Scan up the list of scope context, looking for a
867 function. If we find one, this entity is in local
868 function scope. local_entity tracks context one scope
869 level down, so it will contain the element that's
870 directly in that function's scope, either decl or one of
871 its enclosing scopes. */
872 tree local_entity
= decl
;
873 while (context
!= global_namespace
)
875 /* Make sure we're always dealing with decls. */
876 if (TYPE_P (context
))
877 context
= TYPE_NAME (context
);
878 /* Is this a function? */
879 if (TREE_CODE (context
) == FUNCTION_DECL
880 || TREE_CODE (context
) == PARM_DECL
)
882 /* Yes, we have local scope. Use the <local-name>
883 production for the innermost function scope. */
884 write_local_name (context
, local_entity
, decl
);
887 /* Up one scope level. */
888 local_entity
= context
;
889 context
= decl_mangling_context (context
);
892 /* No local scope found? Fall through to <nested-name>. */
895 /* Other decls get a <nested-name> to encode their scope. */
896 write_nested_name (decl
);
900 /* <unscoped-name> ::= <unqualified-name>
901 ::= St <unqualified-name> # ::std:: */
904 write_unscoped_name (const tree decl
)
906 tree context
= decl_mangling_context (decl
);
908 MANGLE_TRACE_TREE ("unscoped-name", decl
);
910 /* Is DECL in ::std? */
911 if (DECL_NAMESPACE_STD_P (context
))
914 write_unqualified_name (decl
);
918 /* If not, it should be either in the global namespace, or directly
919 in a local function scope. A lambda can also be mangled in the
920 scope of a default argument. */
921 gcc_assert (context
== global_namespace
922 || TREE_CODE (context
) == PARM_DECL
923 || TREE_CODE (context
) == FUNCTION_DECL
);
925 write_unqualified_name (decl
);
929 /* <unscoped-template-name> ::= <unscoped-name>
930 ::= <substitution> */
933 write_unscoped_template_name (const tree decl
)
935 MANGLE_TRACE_TREE ("unscoped-template-name", decl
);
937 if (find_substitution (decl
))
939 write_unscoped_name (decl
);
940 add_substitution (decl
);
943 /* Write the nested name, including CV-qualifiers, of DECL.
945 <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
946 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
948 <ref-qualifier> ::= R # & ref-qualifier
949 ::= O # && ref-qualifier
950 <CV-qualifiers> ::= [r] [V] [K] */
953 write_nested_name (const tree decl
)
957 MANGLE_TRACE_TREE ("nested-name", decl
);
961 /* Write CV-qualifiers, if this is a member function. */
962 if (TREE_CODE (decl
) == FUNCTION_DECL
963 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
965 if (DECL_VOLATILE_MEMFUNC_P (decl
))
967 if (DECL_CONST_MEMFUNC_P (decl
))
969 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl
)))
971 if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl
)))
978 /* Is this a template instance? */
979 if (decl_is_template_id (decl
, &template_info
))
981 /* Yes, use <template-prefix>. */
982 write_template_prefix (decl
);
983 write_template_args (TI_ARGS (template_info
));
985 else if ((!abi_version_at_least (10) || TREE_CODE (decl
) == TYPE_DECL
)
986 && TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
988 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
989 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
991 write_template_prefix (decl
);
992 write_template_args (TREE_OPERAND (name
, 1));
996 write_prefix (decl_mangling_context (decl
));
997 write_unqualified_name (decl
);
1002 /* No, just use <prefix> */
1003 write_prefix (decl_mangling_context (decl
));
1004 write_unqualified_name (decl
);
1009 /* <prefix> ::= <prefix> <unqualified-name>
1010 ::= <template-param>
1011 ::= <template-prefix> <template-args>
1014 ::= <substitution> */
1017 write_prefix (const tree node
)
1020 /* Non-NULL if NODE represents a template-id. */
1021 tree template_info
= NULL
;
1024 || node
== global_namespace
)
1027 MANGLE_TRACE_TREE ("prefix", node
);
1029 if (TREE_CODE (node
) == DECLTYPE_TYPE
)
1035 if (find_substitution (node
))
1040 /* If this is a function or parm decl, that means we've hit function
1041 scope, so this prefix must be for a local name. In this
1042 case, we're under the <local-name> production, which encodes
1043 the enclosing function scope elsewhere. So don't continue
1045 if (TREE_CODE (node
) == FUNCTION_DECL
1046 || TREE_CODE (node
) == PARM_DECL
)
1050 decl_is_template_id (decl
, &template_info
);
1054 /* Node is a type. */
1055 decl
= TYPE_NAME (node
);
1056 if (CLASSTYPE_TEMPLATE_ID_P (node
))
1057 template_info
= TYPE_TEMPLATE_INFO (node
);
1060 if (TREE_CODE (node
) == TEMPLATE_TYPE_PARM
)
1061 write_template_param (node
);
1062 else if (template_info
!= NULL
)
1065 write_template_prefix (decl
);
1066 write_template_args (TI_ARGS (template_info
));
1068 else if (TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
1070 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
1071 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1073 write_template_prefix (decl
);
1074 write_template_args (TREE_OPERAND (name
, 1));
1078 write_prefix (decl_mangling_context (decl
));
1079 write_unqualified_name (decl
);
1083 /* Not templated. */
1085 write_prefix (decl_mangling_context (decl
));
1086 write_unqualified_name (decl
);
1088 || TREE_CODE (decl
) == FIELD_DECL
)
1090 /* <data-member-prefix> := <member source-name> M */
1096 add_substitution (node
);
1099 /* <template-prefix> ::= <prefix> <template component>
1100 ::= <template-param>
1101 ::= <substitution> */
1104 write_template_prefix (const tree node
)
1106 tree decl
= DECL_P (node
) ? node
: TYPE_NAME (node
);
1107 tree type
= DECL_P (node
) ? TREE_TYPE (node
) : node
;
1108 tree context
= decl_mangling_context (decl
);
1113 MANGLE_TRACE_TREE ("template-prefix", node
);
1115 /* Find the template decl. */
1116 if (decl_is_template_id (decl
, &template_info
))
1117 templ
= TI_TEMPLATE (template_info
);
1118 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
1119 /* For a typename type, all we have is the name. */
1120 templ
= DECL_NAME (decl
);
1123 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type
));
1125 templ
= TYPE_TI_TEMPLATE (type
);
1128 /* For a member template, though, the template name for the
1129 innermost name must have all the outer template levels
1130 instantiated. For instance, consider
1132 template<typename T> struct Outer {
1133 template<typename U> struct Inner {};
1136 The template name for `Inner' in `Outer<int>::Inner<float>' is
1137 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1138 levels separately, so there's no TEMPLATE_DECL available for this
1139 (there's only `Outer<T>::Inner<U>').
1141 In order to get the substitutions right, we create a special
1142 TREE_LIST to represent the substitution candidate for a nested
1143 template. The TREE_PURPOSE is the template's context, fully
1144 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1147 So, for the example above, `Outer<int>::Inner' is represented as a
1148 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1149 and whose value is `Outer<T>::Inner<U>'. */
1150 if (context
&& TYPE_P (context
))
1151 substitution
= build_tree_list (context
, templ
);
1153 substitution
= templ
;
1155 if (find_substitution (substitution
))
1158 if (TREE_TYPE (templ
)
1159 && TREE_CODE (TREE_TYPE (templ
)) == TEMPLATE_TEMPLATE_PARM
)
1160 write_template_param (TREE_TYPE (templ
));
1163 write_prefix (context
);
1164 write_unqualified_name (decl
);
1167 add_substitution (substitution
);
1170 /* We don't need to handle thunks, vtables, or VTTs here. Those are
1171 mangled through special entry points.
1173 <unqualified-name> ::= <operator-name>
1176 ::= <unnamed-type-name>
1177 ::= <local-source-name>
1179 <local-source-name> ::= L <source-name> <discriminator> */
1182 write_unqualified_id (tree identifier
)
1184 if (IDENTIFIER_TYPENAME_P (identifier
))
1185 write_conversion_operator_name (TREE_TYPE (identifier
));
1186 else if (IDENTIFIER_OPNAME_P (identifier
))
1189 const char *mangled_name
= NULL
;
1191 /* Unfortunately, there is no easy way to go from the
1192 name of the operator back to the corresponding tree
1194 for (i
= 0; i
< MAX_TREE_CODES
; ++i
)
1195 if (operator_name_info
[i
].identifier
== identifier
)
1197 /* The ABI says that we prefer binary operator
1198 names to unary operator names. */
1199 if (operator_name_info
[i
].arity
== 2)
1201 mangled_name
= operator_name_info
[i
].mangled_name
;
1204 else if (!mangled_name
)
1205 mangled_name
= operator_name_info
[i
].mangled_name
;
1207 else if (assignment_operator_name_info
[i
].identifier
1211 = assignment_operator_name_info
[i
].mangled_name
;
1214 write_string (mangled_name
);
1216 else if (UDLIT_OPER_P (identifier
))
1217 write_literal_operator_name (identifier
);
1219 write_source_name (identifier
);
1223 write_unqualified_name (tree decl
)
1225 MANGLE_TRACE_TREE ("unqualified-name", decl
);
1227 if (identifier_p (decl
))
1229 write_unqualified_id (decl
);
1235 if (DECL_NAME (decl
) == NULL_TREE
)
1238 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl
));
1239 write_source_name (DECL_ASSEMBLER_NAME (decl
));
1241 else if (DECL_DECLARES_FUNCTION_P (decl
))
1244 if (DECL_CONSTRUCTOR_P (decl
))
1245 write_special_name_constructor (decl
);
1246 else if (DECL_DESTRUCTOR_P (decl
))
1247 write_special_name_destructor (decl
);
1248 else if (DECL_CONV_FN_P (decl
))
1250 /* Conversion operator. Handle it right here.
1251 <operator> ::= cv <type> */
1253 if (decl_is_template_id (decl
, NULL
))
1256 fn_type
= get_mostly_instantiated_function_type (decl
);
1257 type
= TREE_TYPE (fn_type
);
1259 else if (FNDECL_USED_AUTO (decl
))
1260 type
= (DECL_STRUCT_FUNCTION (decl
)->language
1261 ->x_auto_return_pattern
);
1263 type
= DECL_CONV_FN_TYPE (decl
);
1264 write_conversion_operator_name (type
);
1266 else if (DECL_OVERLOADED_OPERATOR_P (decl
))
1268 operator_name_info_t
*oni
;
1269 if (DECL_ASSIGNMENT_OPERATOR_P (decl
))
1270 oni
= assignment_operator_name_info
;
1272 oni
= operator_name_info
;
1274 write_string (oni
[DECL_OVERLOADED_OPERATOR_P (decl
)].mangled_name
);
1276 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
1277 write_literal_operator_name (DECL_NAME (decl
));
1284 else if (VAR_OR_FUNCTION_DECL_P (decl
) && ! TREE_PUBLIC (decl
)
1285 && DECL_NAMESPACE_SCOPE_P (decl
)
1286 && decl_linkage (decl
) == lk_internal
)
1288 MANGLE_TRACE_TREE ("local-source-name", decl
);
1290 write_source_name (DECL_NAME (decl
));
1291 /* The default discriminator is 1, and that's all we ever use,
1292 so there's no code to output one here. */
1296 tree type
= TREE_TYPE (decl
);
1298 if (TREE_CODE (decl
) == TYPE_DECL
1299 && TYPE_ANONYMOUS_P (type
))
1300 write_unnamed_type_name (type
);
1301 else if (TREE_CODE (decl
) == TYPE_DECL
1302 && LAMBDA_TYPE_P (type
))
1303 write_closure_type_name (type
);
1305 write_source_name (DECL_NAME (decl
));
1308 /* We use the ABI tags from the primary template, ignoring tags on any
1309 specializations. This is necessary because C++ doesn't require a
1310 specialization to be declared before it is used unless the use
1311 requires a complete type, but we need to get the tags right on
1312 incomplete types as well. */
1313 if (tree tmpl
= most_general_template (decl
))
1314 decl
= DECL_TEMPLATE_RESULT (tmpl
);
1315 /* Don't crash on an unbound class template. */
1316 if (decl
&& TREE_CODE (decl
) != NAMESPACE_DECL
)
1318 tree attrs
= (TREE_CODE (decl
) == TYPE_DECL
1319 ? TYPE_ATTRIBUTES (TREE_TYPE (decl
))
1320 : DECL_ATTRIBUTES (decl
));
1321 write_abi_tags (lookup_attribute ("abi_tag", attrs
));
1325 /* Write the unqualified-name for a conversion operator to TYPE. */
1328 write_conversion_operator_name (const tree type
)
1330 write_string ("cv");
1334 /* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1336 <source-name> ::= </length/ number> <identifier> */
1339 write_source_name (tree identifier
)
1341 MANGLE_TRACE_TREE ("source-name", identifier
);
1343 /* Never write the whole template-id name including the template
1344 arguments; we only want the template name. */
1345 if (IDENTIFIER_TEMPLATE (identifier
))
1346 identifier
= IDENTIFIER_TEMPLATE (identifier
);
1348 write_unsigned_number (IDENTIFIER_LENGTH (identifier
));
1349 write_identifier (IDENTIFIER_POINTER (identifier
));
1352 /* Compare two TREE_STRINGs like strcmp. */
1355 tree_string_cmp (const void *p1
, const void *p2
)
1359 tree s1
= *(const tree
*)p1
;
1360 tree s2
= *(const tree
*)p2
;
1361 return strcmp (TREE_STRING_POINTER (s1
),
1362 TREE_STRING_POINTER (s2
));
1365 /* ID is the name of a function or type with abi_tags attribute TAGS.
1366 Write out the name, suitably decorated. */
1369 write_abi_tags (tree tags
)
1371 if (tags
== NULL_TREE
)
1374 tags
= TREE_VALUE (tags
);
1376 vec
<tree
, va_gc
> * vec
= make_tree_vector();
1378 for (tree t
= tags
; t
; t
= TREE_CHAIN (t
))
1380 if (ABI_TAG_IMPLICIT (t
))
1382 tree str
= TREE_VALUE (t
);
1383 vec_safe_push (vec
, str
);
1386 vec
->qsort (tree_string_cmp
);
1388 unsigned i
; tree str
;
1389 FOR_EACH_VEC_ELT (*vec
, i
, str
)
1392 write_unsigned_number (TREE_STRING_LENGTH (str
) - 1);
1393 write_identifier (TREE_STRING_POINTER (str
));
1396 release_tree_vector (vec
);
1399 /* Write a user-defined literal operator.
1400 ::= li <source-name> # "" <source-name>
1401 IDENTIFIER is an LITERAL_IDENTIFIER_NODE. */
1404 write_literal_operator_name (tree identifier
)
1406 const char* suffix
= UDLIT_OP_SUFFIX (identifier
);
1407 write_identifier (UDLIT_OP_MANGLED_PREFIX
);
1408 write_unsigned_number (strlen (suffix
));
1409 write_identifier (suffix
);
1412 /* Encode 0 as _, and 1+ as n-1_. */
1415 write_compact_number (int num
)
1418 write_unsigned_number (num
- 1);
1422 /* Return how many unnamed types precede TYPE in its enclosing class. */
1425 nested_anon_class_index (tree type
)
1428 tree member
= TYPE_FIELDS (TYPE_CONTEXT (type
));
1429 for (; member
; member
= DECL_CHAIN (member
))
1430 if (DECL_IMPLICIT_TYPEDEF_P (member
))
1432 tree memtype
= TREE_TYPE (member
);
1433 if (memtype
== type
)
1435 else if (TYPE_ANONYMOUS_P (memtype
))
1442 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1445 write_unnamed_type_name (const tree type
)
1448 MANGLE_TRACE_TREE ("unnamed-type-name", type
);
1450 if (TYPE_FUNCTION_SCOPE_P (type
))
1451 discriminator
= local_class_index (type
);
1452 else if (TYPE_CLASS_SCOPE_P (type
))
1453 discriminator
= nested_anon_class_index (type
);
1456 gcc_assert (no_linkage_check (type
, /*relaxed_p=*/true));
1457 /* Just use the old mangling at namespace scope. */
1458 write_source_name (TYPE_IDENTIFIER (type
));
1462 write_string ("Ut");
1463 write_compact_number (discriminator
);
1466 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1467 <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters */
1470 write_closure_type_name (const tree type
)
1472 tree fn
= lambda_function (type
);
1473 tree lambda
= CLASSTYPE_LAMBDA_EXPR (type
);
1474 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1476 MANGLE_TRACE_TREE ("closure-type-name", type
);
1478 write_string ("Ul");
1479 write_method_parms (parms
, /*method_p=*/1, fn
);
1481 write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda
));
1484 /* Convert NUMBER to ascii using base BASE and generating at least
1485 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1486 into which to store the characters. Returns the number of
1487 characters generated (these will be laid out in advance of where
1491 hwint_to_ascii (unsigned HOST_WIDE_INT number
, const unsigned int base
,
1492 char *buffer
, const unsigned int min_digits
)
1494 static const char base_digits
[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1495 unsigned digits
= 0;
1499 unsigned HOST_WIDE_INT d
= number
/ base
;
1501 *--buffer
= base_digits
[number
- d
* base
];
1505 while (digits
< min_digits
)
1507 *--buffer
= base_digits
[0];
1513 /* Non-terminal <number>.
1515 <number> ::= [n] </decimal integer/> */
1518 write_number (unsigned HOST_WIDE_INT number
, const int unsigned_p
,
1519 const unsigned int base
)
1521 char buffer
[sizeof (HOST_WIDE_INT
) * 8];
1524 if (!unsigned_p
&& (HOST_WIDE_INT
) number
< 0)
1527 number
= -((HOST_WIDE_INT
) number
);
1529 count
= hwint_to_ascii (number
, base
, buffer
+ sizeof (buffer
), 1);
1530 write_chars (buffer
+ sizeof (buffer
) - count
, count
);
1533 /* Write out an integral CST in decimal. Most numbers are small, and
1534 representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1535 bigger than that, which we must deal with. */
1538 write_integer_cst (const tree cst
)
1540 int sign
= tree_int_cst_sgn (cst
);
1541 widest_int abs_value
= wi::abs (wi::to_widest (cst
));
1542 if (!wi::fits_uhwi_p (abs_value
))
1544 /* A bignum. We do this in chunks, each of which fits in a
1546 char buffer
[sizeof (HOST_WIDE_INT
) * 8 * 2];
1547 unsigned HOST_WIDE_INT chunk
;
1548 unsigned chunk_digits
;
1549 char *ptr
= buffer
+ sizeof (buffer
);
1554 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1559 if (sizeof (HOST_WIDE_INT
) >= 8)
1561 /* It is at least 64 bits, so 10^18 is representable. */
1566 type
= c_common_signed_or_unsigned_type (1, TREE_TYPE (cst
));
1567 base
= build_int_cstu (type
, chunk
);
1568 n
= wide_int_to_tree (type
, cst
);
1573 n
= fold_build1_loc (input_location
, NEGATE_EXPR
, type
, n
);
1577 tree d
= fold_build2_loc (input_location
, FLOOR_DIV_EXPR
, type
, n
, base
);
1578 tree tmp
= fold_build2_loc (input_location
, MULT_EXPR
, type
, d
, base
);
1581 done
= integer_zerop (d
);
1582 tmp
= fold_build2_loc (input_location
, MINUS_EXPR
, type
, n
, tmp
);
1583 c
= hwint_to_ascii (TREE_INT_CST_LOW (tmp
), 10, ptr
,
1584 done
? 1 : chunk_digits
);
1590 write_chars (ptr
, count
);
1597 write_unsigned_number (abs_value
.to_uhwi ());
1601 /* Write out a floating-point literal.
1603 "Floating-point literals are encoded using the bit pattern of the
1604 target processor's internal representation of that number, as a
1605 fixed-length lowercase hexadecimal string, high-order bytes first
1606 (even if the target processor would store low-order bytes first).
1607 The "n" prefix is not used for floating-point literals; the sign
1608 bit is encoded with the rest of the number.
1610 Here are some examples, assuming the IEEE standard representation
1611 for floating point numbers. (Spaces are for readability, not
1612 part of the encoding.)
1615 -1.0f Lf bf80 0000 E
1616 1.17549435e-38f Lf 0080 0000 E
1617 1.40129846e-45f Lf 0000 0001 E
1618 0.0f Lf 0000 0000 E"
1620 Caller is responsible for the Lx and the E. */
1622 write_real_cst (const tree value
)
1624 long target_real
[4]; /* largest supported float */
1625 char buffer
[9]; /* eight hex digits in a 32-bit number */
1628 tree type
= TREE_TYPE (value
);
1629 int words
= GET_MODE_BITSIZE (TYPE_MODE (type
)) / 32;
1631 real_to_target (target_real
, &TREE_REAL_CST (value
),
1634 /* The value in target_real is in the target word order,
1635 so we must write it out backward if that happens to be
1636 little-endian. write_number cannot be used, it will
1637 produce uppercase. */
1638 if (FLOAT_WORDS_BIG_ENDIAN
)
1639 i
= 0, limit
= words
, dir
= 1;
1641 i
= words
- 1, limit
= -1, dir
= -1;
1643 for (; i
!= limit
; i
+= dir
)
1645 sprintf (buffer
, "%08lx", (unsigned long) target_real
[i
]);
1646 write_chars (buffer
, 8);
1650 /* Non-terminal <identifier>.
1652 <identifier> ::= </unqualified source code identifier> */
1655 write_identifier (const char *identifier
)
1657 MANGLE_TRACE ("identifier", identifier
);
1658 write_string (identifier
);
1661 /* Handle constructor productions of non-terminal <special-name>.
1662 CTOR is a constructor FUNCTION_DECL.
1664 <special-name> ::= C1 # complete object constructor
1665 ::= C2 # base object constructor
1666 ::= C3 # complete object allocating constructor
1668 Currently, allocating constructors are never used. */
1671 write_special_name_constructor (const tree ctor
)
1673 if (DECL_BASE_CONSTRUCTOR_P (ctor
))
1674 write_string ("C2");
1675 /* This is the old-style "[unified]" constructor.
1676 In some cases, we may emit this function and call
1677 it from the clones in order to share code and save space. */
1678 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor
))
1679 write_string ("C4");
1682 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor
));
1683 write_string ("C1");
1687 /* Handle destructor productions of non-terminal <special-name>.
1688 DTOR is a destructor FUNCTION_DECL.
1690 <special-name> ::= D0 # deleting (in-charge) destructor
1691 ::= D1 # complete object (in-charge) destructor
1692 ::= D2 # base object (not-in-charge) destructor */
1695 write_special_name_destructor (const tree dtor
)
1697 if (DECL_DELETING_DESTRUCTOR_P (dtor
))
1698 write_string ("D0");
1699 else if (DECL_BASE_DESTRUCTOR_P (dtor
))
1700 write_string ("D2");
1701 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor
))
1702 /* This is the old-style "[unified]" destructor.
1703 In some cases, we may emit this function and call
1704 it from the clones in order to share code and save space. */
1705 write_string ("D4");
1708 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor
));
1709 write_string ("D1");
1713 /* Scan the vector of local classes and return how many others with the
1714 same name (or same no name) and context precede ENTITY. */
1717 local_class_index (tree entity
)
1719 int ix
, discriminator
= 0;
1720 tree name
= (TYPE_ANONYMOUS_P (entity
) ? NULL_TREE
1721 : TYPE_IDENTIFIER (entity
));
1722 tree ctx
= TYPE_CONTEXT (entity
);
1723 for (ix
= 0; ; ix
++)
1725 tree type
= (*local_classes
)[ix
];
1727 return discriminator
;
1728 if (TYPE_CONTEXT (type
) == ctx
1729 && (name
? TYPE_IDENTIFIER (type
) == name
1730 : TYPE_ANONYMOUS_P (type
)))
1736 /* Return the discriminator for ENTITY appearing inside
1737 FUNCTION. The discriminator is the lexical ordinal of VAR among
1738 entities with the same name in the same FUNCTION. */
1741 discriminator_for_local_entity (tree entity
)
1743 if (DECL_DISCRIMINATOR_P (entity
))
1745 if (DECL_DISCRIMINATOR_SET_P (entity
))
1746 return DECL_DISCRIMINATOR (entity
);
1748 /* The first entity with a particular name doesn't get
1749 DECL_DISCRIMINATOR set up. */
1752 else if (TREE_CODE (entity
) == TYPE_DECL
)
1754 /* Scan the list of local classes. */
1755 entity
= TREE_TYPE (entity
);
1757 /* Lambdas and unnamed types have their own discriminators. */
1758 if (LAMBDA_TYPE_P (entity
) || TYPE_ANONYMOUS_P (entity
))
1761 return local_class_index (entity
);
1767 /* Return the discriminator for STRING, a string literal used inside
1768 FUNCTION. The discriminator is the lexical ordinal of STRING among
1769 string literals used in FUNCTION. */
1772 discriminator_for_string_literal (tree
/*function*/,
1775 /* For now, we don't discriminate amongst string literals. */
1779 /* <discriminator> := _ <number>
1781 The discriminator is used only for the second and later occurrences
1782 of the same name within a single function. In this case <number> is
1783 n - 2, if this is the nth occurrence, in lexical order. */
1786 write_discriminator (const int discriminator
)
1788 /* If discriminator is zero, don't write anything. Otherwise... */
1789 if (discriminator
> 0)
1792 write_unsigned_number (discriminator
- 1);
1796 /* Mangle the name of a function-scope entity. FUNCTION is the
1797 FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1798 default argument scope. ENTITY is the decl for the entity itself.
1799 LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1800 either ENTITY itself or an enclosing scope of ENTITY.
1802 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1803 := Z <function encoding> E s [<discriminator>]
1804 := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1807 write_local_name (tree function
, const tree local_entity
,
1810 tree parm
= NULL_TREE
;
1812 MANGLE_TRACE_TREE ("local-name", entity
);
1814 if (TREE_CODE (function
) == PARM_DECL
)
1817 function
= DECL_CONTEXT (parm
);
1821 write_encoding (function
);
1824 /* For this purpose, parameters are numbered from right-to-left. */
1829 for (t
= DECL_ARGUMENTS (function
); t
; t
= DECL_CHAIN (t
))
1837 write_compact_number (i
- 1);
1840 if (TREE_CODE (entity
) == STRING_CST
)
1843 write_discriminator (discriminator_for_string_literal (function
,
1848 /* Now the <entity name>. Let write_name know its being called
1849 from <local-name>, so it doesn't try to process the enclosing
1850 function scope again. */
1851 write_name (entity
, /*ignore_local_scope=*/1);
1852 write_discriminator (discriminator_for_local_entity (local_entity
));
1856 /* Non-terminals <type> and <CV-qualifier>.
1858 <type> ::= <builtin-type>
1860 ::= <class-enum-type>
1862 ::= <pointer-to-member-type>
1863 ::= <template-param>
1866 ::= P <type> # pointer-to
1867 ::= R <type> # reference-to
1868 ::= C <type> # complex pair (C 2000)
1869 ::= G <type> # imaginary (C 2000) [not supported]
1870 ::= U <source-name> <type> # vendor extended type qualifier
1874 <type> ::= RR <type> # rvalue reference-to
1875 <type> ::= Dt <expression> # decltype of an id-expression or
1876 # class member access
1877 <type> ::= DT <expression> # decltype of an expression
1878 <type> ::= Dn # decltype of nullptr
1880 TYPE is a type node. */
1883 write_type (tree type
)
1885 /* This gets set to nonzero if TYPE turns out to be a (possibly
1886 CV-qualified) builtin type. */
1887 int is_builtin_type
= 0;
1889 MANGLE_TRACE_TREE ("type", type
);
1891 if (type
== error_mark_node
)
1894 type
= canonicalize_for_substitution (type
);
1895 if (find_substitution (type
))
1899 if (write_CV_qualifiers_for_type (type
) > 0)
1900 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1901 mangle the unqualified type. The recursive call is needed here
1902 since both the qualified and unqualified types are substitution
1905 tree t
= TYPE_MAIN_VARIANT (type
);
1906 if (TYPE_ATTRIBUTES (t
) && !OVERLOAD_TYPE_P (t
))
1908 tree attrs
= NULL_TREE
;
1909 if (tx_safe_fn_type_p (type
))
1910 attrs
= tree_cons (get_identifier ("transaction_safe"),
1912 t
= cp_build_type_attribute_variant (t
, attrs
);
1914 gcc_assert (t
!= type
);
1915 if (TREE_CODE (t
) == FUNCTION_TYPE
1916 || TREE_CODE (t
) == METHOD_TYPE
)
1918 t
= build_ref_qualified_type (t
, type_memfn_rqual (type
));
1919 if (abi_version_at_least (8)
1920 || type
== TYPE_MAIN_VARIANT (type
))
1921 /* Avoid adding the unqualified function type as a substitution. */
1922 write_function_type (t
);
1925 if (abi_warn_or_compat_version_crosses (8))
1926 G
.need_abi_warning
= 1;
1931 else if (TREE_CODE (type
) == ARRAY_TYPE
)
1932 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1933 so that the cv-qualification of the element type is available
1934 in write_array_type. */
1935 write_array_type (type
);
1938 tree type_orig
= type
;
1940 /* See through any typedefs. */
1941 type
= TYPE_MAIN_VARIANT (type
);
1942 if (TREE_CODE (type
) == FUNCTION_TYPE
1943 || TREE_CODE (type
) == METHOD_TYPE
)
1944 type
= build_ref_qualified_type (type
, type_memfn_rqual (type_orig
));
1946 /* According to the C++ ABI, some library classes are passed the
1947 same as the scalar type of their single member and use the same
1949 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
1950 type
= TREE_TYPE (first_field (type
));
1952 if (TYPE_PTRDATAMEM_P (type
))
1953 write_pointer_to_member_type (type
);
1956 /* Handle any target-specific fundamental types. */
1957 const char *target_mangling
1958 = targetm
.mangle_type (type_orig
);
1960 if (target_mangling
)
1962 write_string (target_mangling
);
1963 /* Add substitutions for types other than fundamental
1965 if (!VOID_TYPE_P (type
)
1966 && TREE_CODE (type
) != INTEGER_TYPE
1967 && TREE_CODE (type
) != REAL_TYPE
1968 && TREE_CODE (type
) != BOOLEAN_TYPE
)
1969 add_substitution (type
);
1973 switch (TREE_CODE (type
))
1977 case INTEGER_TYPE
: /* Includes wchar_t. */
1979 case FIXED_POINT_TYPE
:
1981 /* If this is a typedef, TYPE may not be one of
1982 the standard builtin type nodes, but an alias of one. Use
1983 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
1984 write_builtin_type (TYPE_MAIN_VARIANT (type
));
1991 write_type (TREE_TYPE (type
));
1996 write_function_type (type
);
2002 /* A pointer-to-member function is represented as a special
2003 RECORD_TYPE, so check for this first. */
2004 if (TYPE_PTRMEMFUNC_P (type
))
2005 write_pointer_to_member_type (type
);
2007 write_class_enum_type (type
);
2011 case UNBOUND_CLASS_TEMPLATE
:
2012 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2013 ordinary nested names. */
2014 write_nested_name (TYPE_STUB_DECL (type
));
2018 case REFERENCE_TYPE
:
2019 if (TYPE_PTR_P (type
))
2021 else if (TYPE_REF_IS_RVALUE (type
))
2026 tree target
= TREE_TYPE (type
);
2027 /* Attribute const/noreturn are not reflected in mangling.
2028 We strip them here rather than at a lower level because
2029 a typedef or template argument can have function type
2030 with function-cv-quals (that use the same representation),
2031 but you can't have a pointer/reference to such a type. */
2032 if (TREE_CODE (target
) == FUNCTION_TYPE
)
2034 if (abi_warn_or_compat_version_crosses (5)
2035 && TYPE_QUALS (target
) != TYPE_UNQUALIFIED
)
2036 G
.need_abi_warning
= 1;
2037 if (abi_version_at_least (5))
2038 target
= build_qualified_type (target
, TYPE_UNQUALIFIED
);
2040 write_type (target
);
2044 case TEMPLATE_TYPE_PARM
:
2047 if (AUTO_IS_DECLTYPE (type
))
2048 write_identifier ("Dc");
2050 write_identifier ("Da");
2054 /* else fall through. */
2055 case TEMPLATE_PARM_INDEX
:
2056 write_template_param (type
);
2059 case TEMPLATE_TEMPLATE_PARM
:
2060 write_template_template_param (type
);
2063 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2064 write_template_template_param (type
);
2066 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type
)));
2070 if (abi_version_at_least (4))
2072 write_string ("Dv");
2073 /* Non-constant vector size would be encoded with
2074 _ expression, but we don't support that yet. */
2075 write_unsigned_number (TYPE_VECTOR_SUBPARTS (type
));
2079 write_string ("U8__vector");
2080 if (abi_warn_or_compat_version_crosses (4))
2081 G
.need_abi_warning
= 1;
2082 write_type (TREE_TYPE (type
));
2085 case TYPE_PACK_EXPANSION
:
2086 write_string ("Dp");
2087 write_type (PACK_EXPANSION_PATTERN (type
));
2091 /* These shouldn't make it into mangling. */
2092 gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type
)
2093 && !DECLTYPE_FOR_LAMBDA_PROXY (type
));
2095 /* In ABI <5, we stripped decltype of a plain decl. */
2096 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
))
2098 tree expr
= DECLTYPE_TYPE_EXPR (type
);
2099 tree etype
= NULL_TREE
;
2100 switch (TREE_CODE (expr
))
2107 case TEMPLATE_PARM_INDEX
:
2108 etype
= TREE_TYPE (expr
);
2115 if (etype
&& !type_uses_auto (etype
))
2117 if (abi_warn_or_compat_version_crosses (5))
2118 G
.need_abi_warning
= 1;
2119 if (!abi_version_at_least (5))
2128 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
))
2132 ++cp_unevaluated_operand
;
2133 write_expression (DECLTYPE_TYPE_EXPR (type
));
2134 --cp_unevaluated_operand
;
2139 write_string ("Dn");
2140 if (abi_version_at_least (7))
2142 if (abi_warn_or_compat_version_crosses (7))
2143 G
.need_abi_warning
= 1;
2147 sorry ("mangling typeof, use decltype instead");
2150 case UNDERLYING_TYPE
:
2151 sorry ("mangling __underlying_type");
2163 /* Types other than builtin types are substitution candidates. */
2164 if (!is_builtin_type
)
2165 add_substitution (type
);
2168 /* qsort callback for sorting a vector of attribute entries. */
2171 attr_strcmp (const void *p1
, const void *p2
)
2173 tree a1
= *(const tree
*)p1
;
2174 tree a2
= *(const tree
*)p2
;
2176 const attribute_spec
*as1
= lookup_attribute_spec (get_attribute_name (a1
));
2177 const attribute_spec
*as2
= lookup_attribute_spec (get_attribute_name (a2
));
2179 return strcmp (as1
->name
, as2
->name
);
2182 /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
2183 CV-qualifiers written for TYPE.
2185 <CV-qualifiers> ::= [r] [V] [K] */
2188 write_CV_qualifiers_for_type (const tree type
)
2190 int num_qualifiers
= 0;
2192 /* The order is specified by:
2194 "In cases where multiple order-insensitive qualifiers are
2195 present, they should be ordered 'K' (closest to the base type),
2196 'V', 'r', and 'U' (farthest from the base type) ..." */
2198 /* Mangle attributes that affect type identity as extended qualifiers.
2200 We don't do this with classes and enums because their attributes
2201 are part of their definitions, not something added on. */
2203 if (!OVERLOAD_TYPE_P (type
))
2206 for (tree a
= TYPE_ATTRIBUTES (type
); a
; a
= TREE_CHAIN (a
))
2208 tree name
= get_attribute_name (a
);
2209 const attribute_spec
*as
= lookup_attribute_spec (name
);
2210 if (as
&& as
->affects_type_identity
2211 && !is_attribute_p ("transaction_safe", name
)
2212 && !is_attribute_p ("abi_tag", name
))
2215 if (abi_warn_or_compat_version_crosses (10) && !vec
.is_empty ())
2216 G
.need_abi_warning
= true;
2217 if (abi_version_at_least (10))
2219 vec
.qsort (attr_strcmp
);
2220 while (!vec
.is_empty())
2223 const attribute_spec
*as
2224 = lookup_attribute_spec (get_attribute_name (a
));
2227 write_unsigned_number (strlen (as
->name
));
2228 write_string (as
->name
);
2232 for (tree args
= TREE_VALUE (a
); args
;
2233 args
= TREE_CHAIN (args
))
2235 tree arg
= TREE_VALUE (args
);
2236 write_template_arg (arg
);
2246 /* Note that we do not use cp_type_quals below; given "const
2247 int[3]", the "const" is emitted with the "int", not with the
2249 cp_cv_quals quals
= TYPE_QUALS (type
);
2251 if (quals
& TYPE_QUAL_RESTRICT
)
2256 if (quals
& TYPE_QUAL_VOLATILE
)
2261 if (quals
& TYPE_QUAL_CONST
)
2267 return num_qualifiers
;
2270 /* Non-terminal <builtin-type>.
2272 <builtin-type> ::= v # void
2277 ::= h # unsigned char
2279 ::= t # unsigned short
2281 ::= j # unsigned int
2283 ::= m # unsigned long
2284 ::= x # long long, __int64
2285 ::= y # unsigned long long, __int64
2287 ::= o # unsigned __int128
2290 ::= e # long double, __float80
2291 ::= g # __float128 [not supported]
2292 ::= u <source-name> # vendor extended type */
2295 write_builtin_type (tree type
)
2297 if (TYPE_CANONICAL (type
))
2298 type
= TYPE_CANONICAL (type
);
2300 switch (TREE_CODE (type
))
2311 /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2312 isn't in integer_type_nodes. */
2313 if (type
== wchar_type_node
)
2315 else if (type
== char16_type_node
)
2316 write_string ("Ds");
2317 else if (type
== char32_type_node
)
2318 write_string ("Di");
2319 else if (TYPE_FOR_JAVA (type
))
2320 write_java_integer_type_codes (type
);
2324 /* Assume TYPE is one of the shared integer type nodes. Find
2325 it in the array of these nodes. */
2327 for (itk
= 0; itk
< itk_none
; ++itk
)
2328 if (integer_types
[itk
] != NULL_TREE
2329 && integer_type_codes
[itk
] != '\0'
2330 && type
== integer_types
[itk
])
2332 /* Print the corresponding single-letter code. */
2333 write_char (integer_type_codes
[itk
]);
2337 if (itk
== itk_none
)
2339 tree t
= c_common_type_for_mode (TYPE_MODE (type
),
2340 TYPE_UNSIGNED (type
));
2347 if (TYPE_PRECISION (type
) == 128)
2348 write_char (TYPE_UNSIGNED (type
) ? 'o' : 'n');
2351 /* Allow for cases where TYPE is not one of the shared
2352 integer type nodes and write a "vendor extended builtin
2353 type" with a name the form intN or uintN, respectively.
2354 Situations like this can happen if you have an
2355 __attribute__((__mode__(__SI__))) type and use exotic
2356 switches like '-mint8' on AVR. Of course, this is
2357 undefined by the C++ ABI (and '-mint8' is not even
2358 Standard C conforming), but when using such special
2359 options you're pretty much in nowhere land anyway. */
2361 char prec
[11]; /* up to ten digits for an unsigned */
2363 prefix
= TYPE_UNSIGNED (type
) ? "uint" : "int";
2364 sprintf (prec
, "%u", (unsigned) TYPE_PRECISION (type
));
2365 write_char ('u'); /* "vendor extended builtin type" */
2366 write_unsigned_number (strlen (prefix
) + strlen (prec
));
2367 write_string (prefix
);
2368 write_string (prec
);
2375 if (type
== float_type_node
2376 || type
== java_float_type_node
)
2378 else if (type
== double_type_node
2379 || type
== java_double_type_node
)
2381 else if (type
== long_double_type_node
)
2383 else if (type
== dfloat32_type_node
)
2384 write_string ("Df");
2385 else if (type
== dfloat64_type_node
)
2386 write_string ("Dd");
2387 else if (type
== dfloat128_type_node
)
2388 write_string ("De");
2393 case FIXED_POINT_TYPE
:
2394 write_string ("DF");
2395 if (GET_MODE_IBIT (TYPE_MODE (type
)) > 0)
2396 write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type
)));
2397 if (type
== fract_type_node
2398 || type
== sat_fract_type_node
2399 || type
== accum_type_node
2400 || type
== sat_accum_type_node
)
2402 else if (type
== unsigned_fract_type_node
2403 || type
== sat_unsigned_fract_type_node
2404 || type
== unsigned_accum_type_node
2405 || type
== sat_unsigned_accum_type_node
)
2407 else if (type
== short_fract_type_node
2408 || type
== sat_short_fract_type_node
2409 || type
== short_accum_type_node
2410 || type
== sat_short_accum_type_node
)
2412 else if (type
== unsigned_short_fract_type_node
2413 || type
== sat_unsigned_short_fract_type_node
2414 || type
== unsigned_short_accum_type_node
2415 || type
== sat_unsigned_short_accum_type_node
)
2417 else if (type
== long_fract_type_node
2418 || type
== sat_long_fract_type_node
2419 || type
== long_accum_type_node
2420 || type
== sat_long_accum_type_node
)
2422 else if (type
== unsigned_long_fract_type_node
2423 || type
== sat_unsigned_long_fract_type_node
2424 || type
== unsigned_long_accum_type_node
2425 || type
== sat_unsigned_long_accum_type_node
)
2427 else if (type
== long_long_fract_type_node
2428 || type
== sat_long_long_fract_type_node
2429 || type
== long_long_accum_type_node
2430 || type
== sat_long_long_accum_type_node
)
2432 else if (type
== unsigned_long_long_fract_type_node
2433 || type
== sat_unsigned_long_long_fract_type_node
2434 || type
== unsigned_long_long_accum_type_node
2435 || type
== sat_unsigned_long_long_accum_type_node
)
2438 sorry ("mangling unknown fixed point type");
2439 write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type
)));
2440 if (TYPE_SATURATING (type
))
2451 /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
2452 METHOD_TYPE. The return type is mangled before the parameter
2455 <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E */
2458 write_function_type (const tree type
)
2460 MANGLE_TRACE_TREE ("function-type", type
);
2462 /* For a pointer to member function, the function type may have
2463 cv-qualifiers, indicating the quals for the artificial 'this'
2465 if (TREE_CODE (type
) == METHOD_TYPE
)
2467 /* The first parameter must be a POINTER_TYPE pointing to the
2468 `this' parameter. */
2469 tree this_type
= class_of_this_parm (type
);
2470 write_CV_qualifiers_for_type (this_type
);
2473 if (tx_safe_fn_type_p (type
))
2474 write_string ("Dx");
2477 /* We don't track whether or not a type is `extern "C"'. Note that
2478 you can have an `extern "C"' function that does not have
2479 `extern "C"' type, and vice versa:
2481 extern "C" typedef void function_t();
2482 function_t f; // f has C++ linkage, but its type is
2485 typedef void function_t();
2486 extern "C" function_t f; // Vice versa.
2489 write_bare_function_type (type
, /*include_return_type_p=*/1,
2491 if (FUNCTION_REF_QUALIFIED (type
))
2493 if (FUNCTION_RVALUE_QUALIFIED (type
))
2501 /* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
2502 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
2503 is mangled before the parameter types. If non-NULL, DECL is
2504 FUNCTION_DECL for the function whose type is being emitted.
2506 If DECL is a member of a Java type, then a literal 'J'
2507 is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2510 <bare-function-type> ::= [J]</signature/ type>+ */
2513 write_bare_function_type (const tree type
, const int include_return_type_p
,
2518 MANGLE_TRACE_TREE ("bare-function-type", type
);
2520 /* Detect Java methods and emit special encoding. */
2522 && DECL_FUNCTION_MEMBER_P (decl
)
2523 && TYPE_FOR_JAVA (DECL_CONTEXT (decl
))
2524 && !DECL_CONSTRUCTOR_P (decl
)
2525 && !DECL_DESTRUCTOR_P (decl
)
2526 && !DECL_CONV_FN_P (decl
))
2536 /* Mangle the return type, if requested. */
2537 if (include_return_type_p
|| java_method_p
)
2538 write_type (TREE_TYPE (type
));
2540 /* Now mangle the types of the arguments. */
2542 write_method_parms (TYPE_ARG_TYPES (type
),
2543 TREE_CODE (type
) == METHOD_TYPE
,
2548 /* Write the mangled representation of a method parameter list of
2549 types given in PARM_TYPES. If METHOD_P is nonzero, the function is
2550 considered a non-static method, and the this parameter is omitted.
2551 If non-NULL, DECL is the FUNCTION_DECL for the function whose
2552 parameters are being emitted. */
2555 write_method_parms (tree parm_types
, const int method_p
, const tree decl
)
2557 tree first_parm_type
;
2558 tree parm_decl
= decl
? DECL_ARGUMENTS (decl
) : NULL_TREE
;
2560 /* Assume this parameter type list is variable-length. If it ends
2561 with a void type, then it's not. */
2564 /* If this is a member function, skip the first arg, which is the
2566 "Member functions do not encode the type of their implicit this
2569 Similarly, there's no need to mangle artificial parameters, like
2570 the VTT parameters for constructors and destructors. */
2573 parm_types
= TREE_CHAIN (parm_types
);
2574 parm_decl
= parm_decl
? DECL_CHAIN (parm_decl
) : NULL_TREE
;
2576 while (parm_decl
&& DECL_ARTIFICIAL (parm_decl
))
2578 parm_types
= TREE_CHAIN (parm_types
);
2579 parm_decl
= DECL_CHAIN (parm_decl
);
2583 for (first_parm_type
= parm_types
;
2585 parm_types
= TREE_CHAIN (parm_types
))
2587 tree parm
= TREE_VALUE (parm_types
);
2588 if (parm
== void_type_node
)
2590 /* "Empty parameter lists, whether declared as () or
2591 conventionally as (void), are encoded with a void parameter
2593 if (parm_types
== first_parm_type
)
2595 /* If the parm list is terminated with a void type, it's
2598 /* A void type better be the last one. */
2599 gcc_assert (TREE_CHAIN (parm_types
) == NULL
);
2606 /* <builtin-type> ::= z # ellipsis */
2610 /* <class-enum-type> ::= <name> */
2613 write_class_enum_type (const tree type
)
2615 write_name (TYPE_NAME (type
), /*ignore_local_scope=*/0);
2618 /* Non-terminal <template-args>. ARGS is a TREE_VEC of template
2621 <template-args> ::= I <template-arg>* E */
2624 write_template_args (tree args
)
2629 MANGLE_TRACE_TREE ("template-args", args
);
2634 length
= TREE_VEC_LENGTH (args
);
2636 if (args
&& length
&& TREE_CODE (TREE_VEC_ELT (args
, 0)) == TREE_VEC
)
2638 /* We have nested template args. We want the innermost template
2640 args
= TREE_VEC_ELT (args
, length
- 1);
2641 length
= TREE_VEC_LENGTH (args
);
2643 for (i
= 0; i
< length
; ++i
)
2644 write_template_arg (TREE_VEC_ELT (args
, i
));
2651 <unqualified-name> <template-args>
2652 part of SCOPE_REF or COMPONENT_REF mangling. */
2655 write_member_name (tree member
)
2657 if (identifier_p (member
))
2658 write_unqualified_id (member
);
2659 else if (DECL_P (member
))
2660 write_unqualified_name (member
);
2661 else if (TREE_CODE (member
) == TEMPLATE_ID_EXPR
)
2663 tree name
= TREE_OPERAND (member
, 0);
2664 if (TREE_CODE (name
) == OVERLOAD
)
2665 name
= OVL_FUNCTION (name
);
2666 write_member_name (name
);
2667 write_template_args (TREE_OPERAND (member
, 1));
2670 write_expression (member
);
2673 /* <expression> ::= <unary operator-name> <expression>
2674 ::= <binary operator-name> <expression> <expression>
2677 <expr-primary> ::= <template-param>
2678 ::= L <type> <value number> E # literal
2679 ::= L <mangled-name> E # external name
2680 ::= st <type> # sizeof
2681 ::= sr <type> <unqualified-name> # dependent name
2682 ::= sr <type> <unqualified-name> <template-args> */
2685 write_expression (tree expr
)
2687 enum tree_code code
= TREE_CODE (expr
);
2689 /* Skip NOP_EXPRs. They can occur when (say) a pointer argument
2690 is converted (via qualification conversions) to another
2692 while (TREE_CODE (expr
) == NOP_EXPR
2693 /* Parentheses aren't mangled. */
2694 || code
== PAREN_EXPR
2695 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
2697 expr
= TREE_OPERAND (expr
, 0);
2698 code
= TREE_CODE (expr
);
2701 if (code
== BASELINK
2702 && (!type_unknown_p (expr
)
2703 || !BASELINK_QUALIFIED_P (expr
)))
2705 expr
= BASELINK_FUNCTIONS (expr
);
2706 code
= TREE_CODE (expr
);
2709 /* Handle pointers-to-members by making them look like expression
2711 if (code
== PTRMEM_CST
)
2713 expr
= build_nt (ADDR_EXPR
,
2714 build_qualified_name (/*type=*/NULL_TREE
,
2715 PTRMEM_CST_CLASS (expr
),
2716 PTRMEM_CST_MEMBER (expr
),
2717 /*template_p=*/false));
2718 code
= TREE_CODE (expr
);
2721 /* Handle template parameters. */
2722 if (code
== TEMPLATE_TYPE_PARM
2723 || code
== TEMPLATE_TEMPLATE_PARM
2724 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
2725 || code
== TEMPLATE_PARM_INDEX
)
2726 write_template_param (expr
);
2727 /* Handle literals. */
2728 else if (TREE_CODE_CLASS (code
) == tcc_constant
2729 || code
== CONST_DECL
)
2730 write_template_arg_literal (expr
);
2731 else if (code
== PARM_DECL
&& DECL_ARTIFICIAL (expr
))
2733 gcc_assert (!strcmp ("this", IDENTIFIER_POINTER (DECL_NAME (expr
))));
2734 write_string ("fpT");
2736 else if (code
== PARM_DECL
)
2738 /* A function parameter used in a late-specified return type. */
2739 int index
= DECL_PARM_INDEX (expr
);
2740 int level
= DECL_PARM_LEVEL (expr
);
2741 int delta
= G
.parm_depth
- level
+ 1;
2742 gcc_assert (index
>= 1);
2746 if (abi_version_at_least (5))
2748 /* Let L be the number of function prototype scopes from the
2749 innermost one (in which the parameter reference occurs) up
2750 to (and including) the one containing the declaration of
2751 the referenced parameter. If the parameter declaration
2752 clause of the innermost function prototype scope has been
2753 completely seen, it is not counted (in that case -- which
2754 is perhaps the most common -- L can be zero). */
2756 write_unsigned_number (delta
- 1);
2758 if (abi_warn_or_compat_version_crosses (5))
2759 G
.need_abi_warning
= true;
2762 write_compact_number (index
- 1);
2764 else if (DECL_P (expr
))
2767 write_mangled_name (expr
, false);
2770 else if (TREE_CODE (expr
) == SIZEOF_EXPR
2771 && SIZEOF_EXPR_TYPE_P (expr
))
2773 write_string ("st");
2774 write_type (TREE_TYPE (TREE_OPERAND (expr
, 0)));
2776 else if (TREE_CODE (expr
) == SIZEOF_EXPR
2777 && TYPE_P (TREE_OPERAND (expr
, 0)))
2779 write_string ("st");
2780 write_type (TREE_OPERAND (expr
, 0));
2782 else if (TREE_CODE (expr
) == ALIGNOF_EXPR
2783 && TYPE_P (TREE_OPERAND (expr
, 0)))
2785 write_string ("at");
2786 write_type (TREE_OPERAND (expr
, 0));
2788 else if (code
== SCOPE_REF
2789 || code
== BASELINK
)
2792 if (code
== SCOPE_REF
)
2794 scope
= TREE_OPERAND (expr
, 0);
2795 member
= TREE_OPERAND (expr
, 1);
2799 scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (expr
));
2800 member
= BASELINK_FUNCTIONS (expr
);
2803 /* If the MEMBER is a real declaration, then the qualifying
2804 scope was not dependent. Ideally, we would not have a
2805 SCOPE_REF in those cases, but sometimes we do. If the second
2806 argument is a DECL, then the name must not have been
2808 if (DECL_P (member
))
2809 write_expression (member
);
2812 write_string ("sr");
2814 write_member_name (member
);
2817 else if (INDIRECT_REF_P (expr
)
2818 && TREE_TYPE (TREE_OPERAND (expr
, 0))
2819 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2821 write_expression (TREE_OPERAND (expr
, 0));
2823 else if (identifier_p (expr
))
2825 /* An operator name appearing as a dependent name needs to be
2826 specially marked to disambiguate between a use of the operator
2827 name and a use of the operator in an expression. */
2828 if (IDENTIFIER_OPNAME_P (expr
))
2829 write_string ("on");
2830 write_unqualified_id (expr
);
2832 else if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
2834 tree fn
= TREE_OPERAND (expr
, 0);
2835 if (is_overloaded_fn (fn
))
2836 fn
= get_first_fn (fn
);
2838 fn
= DECL_NAME (fn
);
2839 if (IDENTIFIER_OPNAME_P (fn
))
2840 write_string ("on");
2841 write_unqualified_id (fn
);
2842 write_template_args (TREE_OPERAND (expr
, 1));
2844 else if (TREE_CODE (expr
) == MODOP_EXPR
)
2846 enum tree_code subop
= TREE_CODE (TREE_OPERAND (expr
, 1));
2847 const char *name
= (assignment_operator_name_info
[(int) subop
]
2849 write_string (name
);
2850 write_expression (TREE_OPERAND (expr
, 0));
2851 write_expression (TREE_OPERAND (expr
, 2));
2853 else if (code
== NEW_EXPR
|| code
== VEC_NEW_EXPR
)
2855 /* ::= [gs] nw <expression>* _ <type> E
2856 ::= [gs] nw <expression>* _ <type> <initializer>
2857 ::= [gs] na <expression>* _ <type> E
2858 ::= [gs] na <expression>* _ <type> <initializer>
2859 <initializer> ::= pi <expression>* E */
2860 tree placement
= TREE_OPERAND (expr
, 0);
2861 tree type
= TREE_OPERAND (expr
, 1);
2862 tree nelts
= TREE_OPERAND (expr
, 2);
2863 tree init
= TREE_OPERAND (expr
, 3);
2866 gcc_assert (code
== NEW_EXPR
);
2867 if (TREE_OPERAND (expr
, 2))
2868 code
= VEC_NEW_EXPR
;
2870 if (NEW_EXPR_USE_GLOBAL (expr
))
2871 write_string ("gs");
2873 write_string (operator_name_info
[(int) code
].mangled_name
);
2875 for (t
= placement
; t
; t
= TREE_CHAIN (t
))
2876 write_expression (TREE_VALUE (t
));
2883 ++processing_template_decl
;
2884 domain
= compute_array_index_type (NULL_TREE
, nelts
,
2885 tf_warning_or_error
);
2886 type
= build_cplus_array_type (type
, domain
);
2887 --processing_template_decl
;
2891 if (init
&& TREE_CODE (init
) == TREE_LIST
2892 && DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
2893 write_expression (TREE_VALUE (init
));
2897 write_string ("pi");
2898 if (init
&& init
!= void_node
)
2899 for (t
= init
; t
; t
= TREE_CHAIN (t
))
2900 write_expression (TREE_VALUE (t
));
2904 else if (code
== DELETE_EXPR
|| code
== VEC_DELETE_EXPR
)
2906 gcc_assert (code
== DELETE_EXPR
);
2907 if (DELETE_EXPR_USE_VEC (expr
))
2908 code
= VEC_DELETE_EXPR
;
2910 if (DELETE_EXPR_USE_GLOBAL (expr
))
2911 write_string ("gs");
2913 write_string (operator_name_info
[(int) code
].mangled_name
);
2915 write_expression (TREE_OPERAND (expr
, 0));
2917 else if (code
== THROW_EXPR
)
2919 tree op
= TREE_OPERAND (expr
, 0);
2922 write_string ("tw");
2923 write_expression (op
);
2926 write_string ("tr");
2928 else if (code
== CONSTRUCTOR
)
2930 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (expr
);
2931 unsigned i
; tree val
;
2933 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
2934 write_string ("il");
2937 write_string ("tl");
2938 write_type (TREE_TYPE (expr
));
2940 FOR_EACH_CONSTRUCTOR_VALUE (elts
, i
, val
)
2941 write_expression (val
);
2944 else if (dependent_name (expr
))
2946 write_unqualified_id (dependent_name (expr
));
2953 /* When we bind a variable or function to a non-type template
2954 argument with reference type, we create an ADDR_EXPR to show
2955 the fact that the entity's address has been taken. But, we
2956 don't actually want to output a mangling code for the `&'. */
2957 if (TREE_CODE (expr
) == ADDR_EXPR
2959 && TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
)
2961 expr
= TREE_OPERAND (expr
, 0);
2964 write_expression (expr
);
2968 code
= TREE_CODE (expr
);
2971 if (code
== COMPONENT_REF
)
2973 tree ob
= TREE_OPERAND (expr
, 0);
2975 if (TREE_CODE (ob
) == ARROW_EXPR
)
2977 write_string (operator_name_info
[(int)code
].mangled_name
);
2978 ob
= TREE_OPERAND (ob
, 0);
2979 write_expression (ob
);
2981 else if (!is_dummy_object (ob
))
2983 write_string ("dt");
2984 write_expression (ob
);
2986 /* else, for a non-static data member with no associated object (in
2987 unevaluated context), use the unresolved-name mangling. */
2989 write_member_name (TREE_OPERAND (expr
, 1));
2993 /* If it wasn't any of those, recursively expand the expression. */
2994 name
= operator_name_info
[(int) code
].mangled_name
;
2996 /* We used to mangle const_cast and static_cast like a C cast. */
2997 if (code
== CONST_CAST_EXPR
2998 || code
== STATIC_CAST_EXPR
)
3000 if (abi_warn_or_compat_version_crosses (6))
3001 G
.need_abi_warning
= 1;
3002 if (!abi_version_at_least (6))
3003 name
= operator_name_info
[CAST_EXPR
].mangled_name
;
3011 error ("use of built-in trait %qE in function signature; "
3012 "use library traits instead", expr
);
3016 sorry ("mangling %C", code
);
3022 write_string (name
);
3028 tree fn
= CALL_EXPR_FN (expr
);
3030 if (TREE_CODE (fn
) == ADDR_EXPR
)
3031 fn
= TREE_OPERAND (fn
, 0);
3033 /* Mangle a dependent name as the name, not whatever happens to
3034 be the first function in the overload set. */
3035 if ((TREE_CODE (fn
) == FUNCTION_DECL
3036 || TREE_CODE (fn
) == OVERLOAD
)
3037 && type_dependent_expression_p_push (expr
))
3038 fn
= DECL_NAME (get_first_fn (fn
));
3040 write_expression (fn
);
3043 for (i
= 0; i
< call_expr_nargs (expr
); ++i
)
3044 write_expression (CALL_EXPR_ARG (expr
, i
));
3049 write_type (TREE_TYPE (expr
));
3050 if (list_length (TREE_OPERAND (expr
, 0)) == 1)
3051 write_expression (TREE_VALUE (TREE_OPERAND (expr
, 0)));
3054 tree args
= TREE_OPERAND (expr
, 0);
3056 for (; args
; args
= TREE_CHAIN (args
))
3057 write_expression (TREE_VALUE (args
));
3062 case DYNAMIC_CAST_EXPR
:
3063 case REINTERPRET_CAST_EXPR
:
3064 case STATIC_CAST_EXPR
:
3065 case CONST_CAST_EXPR
:
3066 write_type (TREE_TYPE (expr
));
3067 write_expression (TREE_OPERAND (expr
, 0));
3070 case PREINCREMENT_EXPR
:
3071 case PREDECREMENT_EXPR
:
3072 if (abi_version_at_least (6))
3074 if (abi_warn_or_compat_version_crosses (6))
3075 G
.need_abi_warning
= 1;
3079 /* In the middle-end, some expressions have more operands than
3080 they do in templates (and mangling). */
3081 len
= cp_tree_operand_length (expr
);
3083 for (i
= 0; i
< len
; ++i
)
3085 tree operand
= TREE_OPERAND (expr
, i
);
3086 /* As a GNU extension, the middle operand of a
3087 conditional may be omitted. Since expression
3088 manglings are supposed to represent the input token
3089 stream, there's no good way to mangle such an
3090 expression without extending the C++ ABI. */
3091 if (code
== COND_EXPR
&& i
== 1 && !operand
)
3093 error ("omitted middle operand to %<?:%> operand "
3094 "cannot be mangled");
3097 write_expression (operand
);
3103 /* Literal subcase of non-terminal <template-arg>.
3105 "Literal arguments, e.g. "A<42L>", are encoded with their type
3106 and value. Negative integer values are preceded with "n"; for
3107 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
3108 encoded as 0, true as 1." */
3111 write_template_arg_literal (const tree value
)
3114 write_type (TREE_TYPE (value
));
3116 /* Write a null member pointer value as (type)0, regardless of its
3117 real representation. */
3118 if (null_member_pointer_value_p (value
))
3119 write_integer_cst (integer_zero_node
);
3121 switch (TREE_CODE (value
))
3124 write_integer_cst (DECL_INITIAL (value
));
3128 gcc_assert (!same_type_p (TREE_TYPE (value
), boolean_type_node
)
3129 || integer_zerop (value
) || integer_onep (value
));
3130 write_integer_cst (value
);
3134 write_real_cst (value
);
3138 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
3139 && TREE_CODE (TREE_IMAGPART (value
)) == INTEGER_CST
)
3141 write_integer_cst (TREE_REALPART (value
));
3143 write_integer_cst (TREE_IMAGPART (value
));
3145 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
3146 && TREE_CODE (TREE_IMAGPART (value
)) == REAL_CST
)
3148 write_real_cst (TREE_REALPART (value
));
3150 write_real_cst (TREE_IMAGPART (value
));
3157 sorry ("string literal in function template signature");
3167 /* Non-terminal <template-arg>.
3169 <template-arg> ::= <type> # type
3170 ::= L <type> </value/ number> E # literal
3171 ::= LZ <name> E # external name
3172 ::= X <expression> E # expression */
3175 write_template_arg (tree node
)
3177 enum tree_code code
= TREE_CODE (node
);
3179 MANGLE_TRACE_TREE ("template-arg", node
);
3181 /* A template template parameter's argument list contains TREE_LIST
3182 nodes of which the value field is the actual argument. */
3183 if (code
== TREE_LIST
)
3185 node
= TREE_VALUE (node
);
3186 /* If it's a decl, deal with its type instead. */
3189 node
= TREE_TYPE (node
);
3190 code
= TREE_CODE (node
);
3194 if (REFERENCE_REF_P (node
))
3195 node
= TREE_OPERAND (node
, 0);
3196 if (TREE_CODE (node
) == NOP_EXPR
3197 && TREE_CODE (TREE_TYPE (node
)) == REFERENCE_TYPE
)
3199 /* Template parameters can be of reference type. To maintain
3200 internal consistency, such arguments use a conversion from
3201 address of object to reference type. */
3202 gcc_assert (TREE_CODE (TREE_OPERAND (node
, 0)) == ADDR_EXPR
);
3203 node
= TREE_OPERAND (TREE_OPERAND (node
, 0), 0);
3206 if (TREE_CODE (node
) == BASELINK
3207 && !type_unknown_p (node
))
3209 if (abi_version_at_least (6))
3210 node
= BASELINK_FUNCTIONS (node
);
3211 if (abi_warn_or_compat_version_crosses (6))
3212 /* We wrongly wrapped a class-scope function in X/E. */
3213 G
.need_abi_warning
= 1;
3216 if (ARGUMENT_PACK_P (node
))
3218 /* Expand the template argument pack. */
3219 tree args
= ARGUMENT_PACK_ARGS (node
);
3220 int i
, length
= TREE_VEC_LENGTH (args
);
3221 if (abi_version_at_least (6))
3225 if (abi_warn_or_compat_version_crosses (6))
3226 G
.need_abi_warning
= 1;
3227 for (i
= 0; i
< length
; ++i
)
3228 write_template_arg (TREE_VEC_ELT (args
, i
));
3231 else if (TYPE_P (node
))
3233 else if (code
== TEMPLATE_DECL
)
3234 /* A template appearing as a template arg is a template template arg. */
3235 write_template_template_arg (node
);
3236 else if ((TREE_CODE_CLASS (code
) == tcc_constant
&& code
!= PTRMEM_CST
)
3237 || code
== CONST_DECL
3238 || null_member_pointer_value_p (node
))
3239 write_template_arg_literal (node
);
3240 else if (DECL_P (node
))
3243 /* Until ABI version 3, the underscore before the mangled name
3244 was incorrectly omitted. */
3245 if (!abi_version_at_least (3))
3248 write_string ("_Z");
3249 if (abi_warn_or_compat_version_crosses (3))
3250 G
.need_abi_warning
= 1;
3251 write_encoding (node
);
3256 /* Template arguments may be expressions. */
3258 write_expression (node
);
3263 /* <template-template-arg>
3265 ::= <substitution> */
3268 write_template_template_arg (const tree decl
)
3270 MANGLE_TRACE_TREE ("template-template-arg", decl
);
3272 if (find_substitution (decl
))
3274 write_name (decl
, /*ignore_local_scope=*/0);
3275 add_substitution (decl
);
3279 /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
3281 <array-type> ::= A [</dimension/ number>] _ </element/ type>
3282 ::= A <expression> _ </element/ type>
3284 "Array types encode the dimension (number of elements) and the
3285 element type. For variable length arrays, the dimension (but not
3286 the '_' separator) is omitted."
3287 Note that for flexible array members, like for other arrays of
3288 unspecified size, the dimension is also omitted. */
3291 write_array_type (const tree type
)
3294 if (TYPE_DOMAIN (type
))
3298 index_type
= TYPE_DOMAIN (type
);
3299 /* The INDEX_TYPE gives the upper and lower bounds of the array.
3300 It's null for flexible array members which have no upper bound
3301 (this is a change from GCC 5 and prior where such members were
3302 incorrectly mangled as zero-length arrays). */
3303 if (tree max
= TYPE_MAX_VALUE (index_type
))
3305 if (TREE_CODE (max
) == INTEGER_CST
)
3307 /* The ABI specifies that we should mangle the number of
3308 elements in the array, not the largest allowed index. */
3309 offset_int wmax
= wi::to_offset (max
) + 1;
3310 /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
3311 number of elements as zero. */
3312 wmax
= wi::zext (wmax
, TYPE_PRECISION (TREE_TYPE (max
)));
3313 gcc_assert (wi::fits_uhwi_p (wmax
));
3314 write_unsigned_number (wmax
.to_uhwi ());
3318 max
= TREE_OPERAND (max
, 0);
3319 write_expression (max
);
3324 write_type (TREE_TYPE (type
));
3327 /* Non-terminal <pointer-to-member-type> for pointer-to-member
3328 variables. TYPE is a pointer-to-member POINTER_TYPE.
3330 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
3333 write_pointer_to_member_type (const tree type
)
3336 write_type (TYPE_PTRMEM_CLASS_TYPE (type
));
3337 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type
));
3340 /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
3341 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3342 TEMPLATE_PARM_INDEX.
3344 <template-param> ::= T </parameter/ number> _ */
3347 write_template_param (const tree parm
)
3351 MANGLE_TRACE_TREE ("template-parm", parm
);
3353 switch (TREE_CODE (parm
))
3355 case TEMPLATE_TYPE_PARM
:
3356 case TEMPLATE_TEMPLATE_PARM
:
3357 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3358 parm_index
= TEMPLATE_TYPE_IDX (parm
);
3361 case TEMPLATE_PARM_INDEX
:
3362 parm_index
= TEMPLATE_PARM_IDX (parm
);
3370 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3371 earliest template param denoted by `_'. */
3372 write_compact_number (parm_index
);
3375 /* <template-template-param>
3376 ::= <template-param>
3377 ::= <substitution> */
3380 write_template_template_param (const tree parm
)
3382 tree templ
= NULL_TREE
;
3384 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3385 template template parameter. The substitution candidate here is
3386 only the template. */
3387 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
3390 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
));
3391 if (find_substitution (templ
))
3395 /* <template-param> encodes only the template parameter position,
3396 not its template arguments, which is fine here. */
3397 write_template_param (parm
);
3399 add_substitution (templ
);
3402 /* Non-terminal <substitution>.
3404 <substitution> ::= S <seq-id> _
3408 write_substitution (const int seq_id
)
3410 MANGLE_TRACE ("substitution", "");
3414 write_number (seq_id
- 1, /*unsigned=*/1, 36);
3418 /* Start mangling ENTITY. */
3421 start_mangling (const tree entity
)
3424 G
.need_abi_warning
= false;
3425 obstack_free (&name_obstack
, name_base
);
3426 mangle_obstack
= &name_obstack
;
3427 name_base
= obstack_alloc (&name_obstack
, 0);
3430 /* Done with mangling. If WARN is true, and the name of G.entity will
3431 be mangled differently in a future version of the ABI, issue a
3435 finish_mangling_internal (void)
3437 /* Clear all the substitutions. */
3438 vec_safe_truncate (G
.substitutions
, 0);
3440 /* Null-terminate the string. */
3445 /* Like finish_mangling_internal, but return the mangled string. */
3447 static inline const char *
3448 finish_mangling (void)
3450 finish_mangling_internal ();
3451 return (const char *) obstack_finish (mangle_obstack
);
3454 /* Like finish_mangling_internal, but return an identifier. */
3457 finish_mangling_get_identifier (void)
3459 finish_mangling_internal ();
3460 /* Don't obstack_finish here, and the next start_mangling will
3461 remove the identifier. */
3462 return get_identifier ((const char *) obstack_base (mangle_obstack
));
3465 /* Initialize data structures for mangling. */
3470 gcc_obstack_init (&name_obstack
);
3471 name_base
= obstack_alloc (&name_obstack
, 0);
3472 vec_alloc (G
.substitutions
, 0);
3474 /* Cache these identifiers for quick comparison when checking for
3475 standard substitutions. */
3476 subst_identifiers
[SUBID_ALLOCATOR
] = get_identifier ("allocator");
3477 subst_identifiers
[SUBID_BASIC_STRING
] = get_identifier ("basic_string");
3478 subst_identifiers
[SUBID_CHAR_TRAITS
] = get_identifier ("char_traits");
3479 subst_identifiers
[SUBID_BASIC_ISTREAM
] = get_identifier ("basic_istream");
3480 subst_identifiers
[SUBID_BASIC_OSTREAM
] = get_identifier ("basic_ostream");
3481 subst_identifiers
[SUBID_BASIC_IOSTREAM
] = get_identifier ("basic_iostream");
3484 /* Generate the mangled name of DECL. */
3487 mangle_decl_string (const tree decl
)
3490 location_t saved_loc
= input_location
;
3491 tree saved_fn
= NULL_TREE
;
3492 bool template_p
= false;
3494 /* We shouldn't be trying to mangle an uninstantiated template. */
3495 gcc_assert (!type_dependent_expression_p (decl
));
3497 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
3499 struct tinst_level
*tl
= current_instantiation ();
3500 if ((!tl
|| tl
->decl
!= decl
)
3501 && push_tinst_level (decl
))
3504 saved_fn
= current_function_decl
;
3505 current_function_decl
= NULL_TREE
;
3508 input_location
= DECL_SOURCE_LOCATION (decl
);
3510 start_mangling (decl
);
3512 if (TREE_CODE (decl
) == TYPE_DECL
)
3513 write_type (TREE_TYPE (decl
));
3515 write_mangled_name (decl
, true);
3517 result
= finish_mangling_get_identifier ();
3519 fprintf (stderr
, "mangle_decl_string = '%s'\n\n",
3520 IDENTIFIER_POINTER (result
));
3525 current_function_decl
= saved_fn
;
3527 input_location
= saved_loc
;
3532 /* Return an identifier for the external mangled name of DECL. */
3535 get_mangled_id (tree decl
)
3537 tree id
= mangle_decl_string (decl
);
3538 return targetm
.mangle_decl_assembler_name (decl
, id
);
3541 /* If DECL is an implicit mangling alias, return its symtab node; otherwise
3544 static symtab_node
*
3545 decl_implicit_alias_p (tree decl
)
3547 if (DECL_P (decl
) && DECL_ARTIFICIAL (decl
)
3548 && DECL_IGNORED_P (decl
)
3549 && (TREE_CODE (decl
) == FUNCTION_DECL
3550 || (VAR_P (decl
) && TREE_STATIC (decl
))))
3552 symtab_node
*n
= symtab_node::get (decl
);
3553 if (n
&& n
->cpp_implicit_alias
)
3559 /* If DECL is a mangling alias, remove it from the symbol table and return
3560 true; otherwise return false. */
3563 maybe_remove_implicit_alias (tree decl
)
3565 if (symtab_node
*n
= decl_implicit_alias_p (decl
))
3573 /* Create an identifier for the external mangled name of DECL. */
3576 mangle_decl (const tree decl
)
3581 /* Don't bother mangling uninstantiated templates. */
3582 ++processing_template_decl
;
3583 if (TREE_CODE (decl
) == TYPE_DECL
)
3584 dep
= dependent_type_p (TREE_TYPE (decl
));
3586 dep
= (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
3587 && any_dependent_template_arguments_p (DECL_TI_ARGS (decl
)));
3588 --processing_template_decl
;
3592 /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
3593 It is not needed to assign names to anonymous namespace, but we use the
3594 "<anon>" marker to be able to tell if type is C++ ODR type or type
3595 produced by other language. */
3596 if (TREE_CODE (decl
) == TYPE_DECL
3597 && TYPE_STUB_DECL (TREE_TYPE (decl
))
3598 && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl
))))
3599 id
= get_identifier ("<anon>");
3602 gcc_assert (TREE_CODE (decl
) != TYPE_DECL
3603 || !no_linkage_check (TREE_TYPE (decl
), true));
3604 if (abi_version_at_least (10))
3605 if (tree fn
= decl_function_context (decl
))
3606 maybe_check_abi_tags (fn
, decl
);
3607 id
= get_mangled_id (decl
);
3609 SET_DECL_ASSEMBLER_NAME (decl
, id
);
3611 if (id
!= DECL_NAME (decl
)
3612 && !DECL_REALLY_EXTERN (decl
)
3613 /* Don't do this for a fake symbol we aren't going to emit anyway. */
3614 && TREE_CODE (decl
) != TYPE_DECL
3615 && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
)
3616 && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
3620 /* Check IDENTIFIER_GLOBAL_VALUE before setting to avoid redundant
3621 errors from multiple definitions. */
3622 tree d
= IDENTIFIER_GLOBAL_VALUE (id
);
3623 if (!d
|| decl_implicit_alias_p (d
))
3626 SET_IDENTIFIER_GLOBAL_VALUE (id
, decl
);
3629 if (!G
.need_abi_warning
)
3632 /* If the mangling will change in the future, emit an alias with the
3633 future mangled name for forward-compatibility. */
3639 SET_IDENTIFIER_GLOBAL_VALUE (id
, decl
);
3640 inform (DECL_SOURCE_LOCATION (decl
), "a later -fabi-version= (or "
3641 "=0) avoids this error with a change in mangling");
3644 save_ver
= flag_abi_version
;
3646 flag_abi_version
= flag_abi_compat_version
;
3647 id2
= mangle_decl_string (decl
);
3648 id2
= targetm
.mangle_decl_assembler_name (decl
, id2
);
3651 note_mangling_alias (decl
, id2
);
3655 if (flag_abi_compat_version
!= warn_abi_version
)
3657 flag_abi_version
= warn_abi_version
;
3658 id2
= mangle_decl_string (decl
);
3659 id2
= targetm
.mangle_decl_assembler_name (decl
, id2
);
3664 else if (warn_abi_version
!= 0
3665 && abi_version_at_least (warn_abi_version
))
3666 warning_at (DECL_SOURCE_LOCATION (G
.entity
), OPT_Wabi
,
3667 "the mangled name of %qD changed between "
3668 "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3669 G
.entity
, save_ver
, id2
,
3670 warn_abi_version
, id
);
3672 warning_at (DECL_SOURCE_LOCATION (G
.entity
), OPT_Wabi
,
3673 "the mangled name of %qD changes between "
3674 "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3675 G
.entity
, save_ver
, id
,
3676 warn_abi_version
, id2
);
3679 flag_abi_version
= save_ver
;
3683 /* Generate the mangled representation of TYPE. */
3686 mangle_type_string (const tree type
)
3690 start_mangling (type
);
3692 result
= finish_mangling ();
3694 fprintf (stderr
, "mangle_type_string = '%s'\n\n", result
);
3698 /* Create an identifier for the mangled name of a special component
3699 for belonging to TYPE. CODE is the ABI-specified code for this
3703 mangle_special_for_type (const tree type
, const char *code
)
3707 /* We don't have an actual decl here for the special component, so
3708 we can't just process the <encoded-name>. Instead, fake it. */
3709 start_mangling (type
);
3711 /* Start the mangling. */
3712 write_string ("_Z");
3713 write_string (code
);
3717 result
= finish_mangling_get_identifier ();
3720 fprintf (stderr
, "mangle_special_for_type = %s\n\n",
3721 IDENTIFIER_POINTER (result
));
3726 /* Create an identifier for the mangled representation of the typeinfo
3727 structure for TYPE. */
3730 mangle_typeinfo_for_type (const tree type
)
3732 return mangle_special_for_type (type
, "TI");
3735 /* Create an identifier for the mangled name of the NTBS containing
3736 the mangled name of TYPE. */
3739 mangle_typeinfo_string_for_type (const tree type
)
3741 return mangle_special_for_type (type
, "TS");
3744 /* Create an identifier for the mangled name of the vtable for TYPE. */
3747 mangle_vtbl_for_type (const tree type
)
3749 return mangle_special_for_type (type
, "TV");
3752 /* Returns an identifier for the mangled name of the VTT for TYPE. */
3755 mangle_vtt_for_type (const tree type
)
3757 return mangle_special_for_type (type
, "TT");
3760 /* Return an identifier for a construction vtable group. TYPE is
3761 the most derived class in the hierarchy; BINFO is the base
3762 subobject for which this construction vtable group will be used.
3764 This mangling isn't part of the ABI specification; in the ABI
3765 specification, the vtable group is dumped in the same COMDAT as the
3766 main vtable, and is referenced only from that vtable, so it doesn't
3767 need an external name. For binary formats without COMDAT sections,
3768 though, we need external names for the vtable groups.
3770 We use the production
3772 <special-name> ::= CT <type> <offset number> _ <base type> */
3775 mangle_ctor_vtbl_for_type (const tree type
, const tree binfo
)
3779 start_mangling (type
);
3781 write_string ("_Z");
3782 write_string ("TC");
3784 write_integer_cst (BINFO_OFFSET (binfo
));
3786 write_type (BINFO_TYPE (binfo
));
3788 result
= finish_mangling_get_identifier ();
3790 fprintf (stderr
, "mangle_ctor_vtbl_for_type = %s\n\n",
3791 IDENTIFIER_POINTER (result
));
3795 /* Mangle a this pointer or result pointer adjustment.
3797 <call-offset> ::= h <fixed offset number> _
3798 ::= v <fixed offset number> _ <virtual offset number> _ */
3801 mangle_call_offset (const tree fixed_offset
, const tree virtual_offset
)
3803 write_char (virtual_offset
? 'v' : 'h');
3805 /* For either flavor, write the fixed offset. */
3806 write_integer_cst (fixed_offset
);
3809 /* For a virtual thunk, add the virtual offset. */
3812 write_integer_cst (virtual_offset
);
3817 /* Return an identifier for the mangled name of a this-adjusting or
3818 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment
3819 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this
3820 is a virtual thunk, and it is the vtbl offset in
3821 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
3822 zero for a covariant thunk. Note, that FN_DECL might be a covariant
3823 thunk itself. A covariant thunk name always includes the adjustment
3824 for the this pointer, even if there is none.
3826 <special-name> ::= T <call-offset> <base encoding>
3827 ::= Tc <this_adjust call-offset> <result_adjust call-offset>
3831 mangle_thunk (tree fn_decl
, const int this_adjusting
, tree fixed_offset
,
3832 tree virtual_offset
)
3836 start_mangling (fn_decl
);
3838 write_string ("_Z");
3841 if (!this_adjusting
)
3843 /* Covariant thunk with no this adjustment */
3845 mangle_call_offset (integer_zero_node
, NULL_TREE
);
3846 mangle_call_offset (fixed_offset
, virtual_offset
);
3848 else if (!DECL_THUNK_P (fn_decl
))
3849 /* Plain this adjusting thunk. */
3850 mangle_call_offset (fixed_offset
, virtual_offset
);
3853 /* This adjusting thunk to covariant thunk. */
3855 mangle_call_offset (fixed_offset
, virtual_offset
);
3856 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn_decl
));
3857 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn_decl
);
3859 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
3860 mangle_call_offset (fixed_offset
, virtual_offset
);
3861 fn_decl
= THUNK_TARGET (fn_decl
);
3865 write_encoding (fn_decl
);
3867 result
= finish_mangling_get_identifier ();
3869 fprintf (stderr
, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result
));
3873 struct conv_type_hasher
: ggc_ptr_hash
<tree_node
>
3875 static hashval_t
hash (tree
);
3876 static bool equal (tree
, tree
);
3879 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3880 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
3883 static GTY (()) hash_table
<conv_type_hasher
> *conv_type_names
;
3885 /* Hash a node (VAL1) in the table. */
3888 conv_type_hasher::hash (tree val
)
3890 return (hashval_t
) TYPE_UID (TREE_TYPE (val
));
3893 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */
3896 conv_type_hasher::equal (tree val1
, tree val2
)
3898 return TREE_TYPE (val1
) == val2
;
3901 /* Return an identifier for the mangled unqualified name for a
3902 conversion operator to TYPE. This mangling is not specified by the
3903 ABI spec; it is only used internally. */
3906 mangle_conv_op_name_for_type (const tree type
)
3911 if (type
== error_mark_node
)
3912 return error_mark_node
;
3914 if (conv_type_names
== NULL
)
3915 conv_type_names
= hash_table
<conv_type_hasher
>::create_ggc (31);
3917 slot
= conv_type_names
->find_slot_with_hash (type
,
3918 (hashval_t
) TYPE_UID (type
),
3925 /* Create a unique name corresponding to TYPE. */
3926 sprintf (buffer
, "operator %lu",
3927 (unsigned long) conv_type_names
->elements ());
3928 identifier
= get_identifier (buffer
);
3931 /* Hang TYPE off the identifier so it can be found easily later
3932 when performing conversions. */
3933 TREE_TYPE (identifier
) = type
;
3935 /* Set bits on the identifier so we know later it's a conversion. */
3936 IDENTIFIER_OPNAME_P (identifier
) = 1;
3937 IDENTIFIER_TYPENAME_P (identifier
) = 1;
3943 /* Handle ABI backwards compatibility for past bugs where we didn't call
3944 check_abi_tags in places where it's needed: call check_abi_tags and warn if
3945 it makes a difference. If FOR_DECL is non-null, it's the declaration
3946 that we're actually trying to mangle; if it's null, we're mangling the
3947 guard variable for T. */
3950 maybe_check_abi_tags (tree t
, tree for_decl
)
3952 if (DECL_ASSEMBLER_NAME_SET_P (t
))
3955 tree attr
= lookup_attribute ("abi_tag", DECL_ATTRIBUTES (t
));
3956 tree oldtags
= NULL_TREE
;
3958 oldtags
= TREE_VALUE (attr
);
3963 attr
= lookup_attribute ("abi_tag", DECL_ATTRIBUTES (t
));
3964 if (attr
&& TREE_VALUE (attr
) != oldtags
3965 && abi_version_crosses (10))
3968 warning_at (DECL_SOURCE_LOCATION (for_decl
), OPT_Wabi
,
3969 "the mangled name of %qD changes between "
3970 "-fabi-version=%d and -fabi-version=%d",
3971 for_decl
, flag_abi_version
, warn_abi_version
);
3973 warning_at (DECL_SOURCE_LOCATION (t
), OPT_Wabi
,
3974 "the mangled name of the initialization guard variable for"
3975 "%qD changes between -fabi-version=%d and -fabi-version=%d",
3976 t
, flag_abi_version
, warn_abi_version
);
3980 /* Write out the appropriate string for this variable when generating
3981 another mangled name based on this one. */
3984 write_guarded_var_name (const tree variable
)
3986 if (DECL_NAME (variable
)
3987 && strncmp (IDENTIFIER_POINTER (DECL_NAME (variable
)), "_ZGR", 4) == 0)
3988 /* The name of a guard variable for a reference temporary should refer
3989 to the reference, not the temporary. */
3990 write_string (IDENTIFIER_POINTER (DECL_NAME (variable
)) + 4);
3992 write_name (variable
, /*ignore_local_scope=*/0);
3995 /* Return an identifier for the name of an initialization guard
3996 variable for indicated VARIABLE. */
3999 mangle_guard_variable (const tree variable
)
4001 if (abi_version_at_least (10))
4002 maybe_check_abi_tags (variable
);
4003 start_mangling (variable
);
4004 write_string ("_ZGV");
4005 write_guarded_var_name (variable
);
4006 return finish_mangling_get_identifier ();
4009 /* Return an identifier for the name of a thread_local initialization
4010 function for VARIABLE. */
4013 mangle_tls_init_fn (const tree variable
)
4015 start_mangling (variable
);
4016 write_string ("_ZTH");
4017 write_guarded_var_name (variable
);
4018 return finish_mangling_get_identifier ();
4021 /* Return an identifier for the name of a thread_local wrapper
4022 function for VARIABLE. */
4024 #define TLS_WRAPPER_PREFIX "_ZTW"
4027 mangle_tls_wrapper_fn (const tree variable
)
4029 start_mangling (variable
);
4030 write_string (TLS_WRAPPER_PREFIX
);
4031 write_guarded_var_name (variable
);
4032 return finish_mangling_get_identifier ();
4035 /* Return true iff FN is a thread_local wrapper function. */
4038 decl_tls_wrapper_p (const tree fn
)
4040 if (TREE_CODE (fn
) != FUNCTION_DECL
)
4042 tree name
= DECL_NAME (fn
);
4043 return strncmp (IDENTIFIER_POINTER (name
), TLS_WRAPPER_PREFIX
,
4044 strlen (TLS_WRAPPER_PREFIX
)) == 0;
4047 /* Return an identifier for the name of a temporary variable used to
4048 initialize a static reference. This isn't part of the ABI, but we might
4049 as well call them something readable. */
4051 static GTY(()) int temp_count
;
4054 mangle_ref_init_variable (const tree variable
)
4056 start_mangling (variable
);
4057 write_string ("_ZGR");
4058 check_abi_tags (variable
);
4059 write_name (variable
, /*ignore_local_scope=*/0);
4060 /* Avoid name clashes with aggregate initialization of multiple
4061 references at once. */
4062 write_unsigned_number (temp_count
++);
4063 return finish_mangling_get_identifier ();
4067 /* Foreign language type mangling section. */
4069 /* How to write the type codes for the integer Java type. */
4072 write_java_integer_type_codes (const tree type
)
4074 if (type
== java_int_type_node
)
4076 else if (type
== java_short_type_node
)
4078 else if (type
== java_byte_type_node
)
4080 else if (type
== java_char_type_node
)
4082 else if (type
== java_long_type_node
)
4084 else if (type
== java_boolean_type_node
)
4090 /* Given a CLASS_TYPE, such as a record for std::bad_exception this
4091 function generates a mangled name for the vtable map variable of
4092 the class type. For example, if the class type is
4093 "std::bad_exception", the mangled name for the class is
4094 "St13bad_exception". This function would generate the name
4095 "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
4096 "_VTV<std::bad_exception>::__vtable_map". */
4100 get_mangled_vtable_map_var_name (tree class_type
)
4102 char *var_name
= NULL
;
4103 const char *prefix
= "_ZN4_VTVI";
4104 const char *postfix
= "E12__vtable_mapE";
4106 gcc_assert (TREE_CODE (class_type
) == RECORD_TYPE
);
4108 tree class_id
= DECL_ASSEMBLER_NAME (TYPE_NAME (class_type
));
4110 if (strstr (IDENTIFIER_POINTER (class_id
), "<anon>") != NULL
)
4112 class_id
= get_mangled_id (TYPE_NAME (class_type
));
4113 vtbl_register_mangled_name (TYPE_NAME (class_type
), class_id
);
4116 unsigned int len
= strlen (IDENTIFIER_POINTER (class_id
)) +
4118 strlen (postfix
) + 1;
4120 var_name
= (char *) xmalloc (len
);
4122 sprintf (var_name
, "%s%s%s", prefix
, IDENTIFIER_POINTER (class_id
), postfix
);
4127 #include "gt-cp-mangle.h"