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, return nonzero and, if
268 TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
269 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 && DECL_USE_TEMPLATE (decl
)
294 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
))
295 && TREE_CODE (decl
) != TEMPLATE_DECL
)
297 if (template_info
!= NULL
)
298 /* For most templated decls, the template info is hanging
300 *template_info
= DECL_TEMPLATE_INFO (decl
);
305 /* It's not a template id. */
309 /* Produce debugging output of current substitution candidates. */
312 dump_substitution_candidates (void)
317 fprintf (stderr
, " ++ substitutions ");
318 FOR_EACH_VEC_ELT (*G
.substitutions
, i
, el
)
320 const char *name
= "???";
323 fprintf (stderr
, " ");
325 name
= IDENTIFIER_POINTER (DECL_NAME (el
));
326 else if (TREE_CODE (el
) == TREE_LIST
)
327 name
= IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el
)));
328 else if (TYPE_NAME (el
))
329 name
= TYPE_NAME_STRING (el
);
330 fprintf (stderr
, " S%d_ = ", i
- 1);
332 (CP_TYPE_RESTRICT_P (el
)
333 || CP_TYPE_VOLATILE_P (el
)
334 || CP_TYPE_CONST_P (el
)))
335 fprintf (stderr
, "CV-");
336 fprintf (stderr
, "%s (%s at %p)\n",
337 name
, get_tree_code_name (TREE_CODE (el
)), (void *) el
);
341 /* Both decls and types can be substitution candidates, but sometimes
342 they refer to the same thing. For instance, a TYPE_DECL and
343 RECORD_TYPE for the same class refer to the same thing, and should
344 be treated accordingly in substitutions. This function returns a
345 canonicalized tree node representing NODE that is used when adding
346 and substitution candidates and finding matches. */
349 canonicalize_for_substitution (tree node
)
351 /* For a TYPE_DECL, use the type instead. */
352 if (TREE_CODE (node
) == TYPE_DECL
)
353 node
= TREE_TYPE (node
);
355 && TYPE_CANONICAL (node
) != node
356 && TYPE_MAIN_VARIANT (node
) != node
)
359 /* Here we want to strip the topmost typedef only.
360 We need to do that so is_std_substitution can do proper
362 if (TREE_CODE (node
) == FUNCTION_TYPE
)
363 /* Use build_qualified_type and TYPE_QUALS here to preserve
364 the old buggy mangling of attribute noreturn with abi<5. */
365 node
= build_qualified_type (TYPE_MAIN_VARIANT (node
),
368 node
= cp_build_qualified_type (TYPE_MAIN_VARIANT (node
),
369 cp_type_quals (node
));
370 if (TREE_CODE (node
) == FUNCTION_TYPE
371 || TREE_CODE (node
) == METHOD_TYPE
)
372 node
= build_ref_qualified_type (node
, type_memfn_rqual (orig
));
377 /* Add NODE as a substitution candidate. NODE must not already be on
378 the list of candidates. */
381 add_substitution (tree node
)
386 fprintf (stderr
, " ++ add_substitution (%s at %10p)\n",
387 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
389 /* Get the canonicalized substitution candidate for NODE. */
390 c
= canonicalize_for_substitution (node
);
391 if (DEBUG_MANGLE
&& c
!= node
)
392 fprintf (stderr
, " ++ using candidate (%s at %10p)\n",
393 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
396 /* Make sure NODE isn't already a candidate. */
402 FOR_EACH_VEC_SAFE_ELT (G
.substitutions
, i
, candidate
)
404 gcc_assert (!(DECL_P (node
) && node
== candidate
));
405 gcc_assert (!(TYPE_P (node
) && TYPE_P (candidate
)
406 && same_type_p (node
, candidate
)));
410 /* Put the decl onto the varray of substitution candidates. */
411 vec_safe_push (G
.substitutions
, node
);
414 dump_substitution_candidates ();
417 /* Helper function for find_substitution. Returns nonzero if NODE,
418 which may be a decl or a CLASS_TYPE, is a template-id with template
419 name of substitution_index[INDEX] in the ::std namespace. */
422 is_std_substitution (const tree node
,
423 const substitution_identifier_index_t index
)
430 type
= TREE_TYPE (node
);
433 else if (CLASS_TYPE_P (node
))
436 decl
= TYPE_NAME (node
);
439 /* These are not the droids you're looking for. */
442 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl
))
443 && TYPE_LANG_SPECIFIC (type
)
444 && TYPE_TEMPLATE_INFO (type
)
445 && (DECL_NAME (TYPE_TI_TEMPLATE (type
))
446 == subst_identifiers
[index
]));
449 /* Helper function for find_substitution. Returns nonzero if NODE,
450 which may be a decl or a CLASS_TYPE, is the template-id
451 ::std::identifier<char>, where identifier is
452 substitution_index[INDEX]. */
455 is_std_substitution_char (const tree node
,
456 const substitution_identifier_index_t index
)
459 /* Check NODE's name is ::std::identifier. */
460 if (!is_std_substitution (node
, index
))
462 /* Figure out its template args. */
464 args
= DECL_TI_ARGS (node
);
465 else if (CLASS_TYPE_P (node
))
466 args
= CLASSTYPE_TI_ARGS (node
);
468 /* Oops, not a template. */
470 /* NODE's template arg list should be <char>. */
472 TREE_VEC_LENGTH (args
) == 1
473 && TREE_VEC_ELT (args
, 0) == char_type_node
;
476 /* Check whether a substitution should be used to represent NODE in
479 First, check standard special-case substitutions.
481 <substitution> ::= St
488 # ::std::basic_string
491 # ::std::basic_string<char,
492 ::std::char_traits<char>,
493 ::std::allocator<char> >
496 # ::std::basic_istream<char, ::std::char_traits<char> >
499 # ::std::basic_ostream<char, ::std::char_traits<char> >
502 # ::std::basic_iostream<char, ::std::char_traits<char> >
504 Then examine the stack of currently available substitution
505 candidates for entities appearing earlier in the same mangling
507 If a substitution is found, write its mangled representation and
508 return nonzero. If none is found, just return zero. */
511 find_substitution (tree node
)
514 const int size
= vec_safe_length (G
.substitutions
);
517 const char *abbr
= NULL
;
520 fprintf (stderr
, " ++ find_substitution (%s at %p)\n",
521 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
523 /* Obtain the canonicalized substitution representation for NODE.
524 This is what we'll compare against. */
525 node
= canonicalize_for_substitution (node
);
527 /* Check for builtin substitutions. */
529 decl
= TYPE_P (node
) ? TYPE_NAME (node
) : node
;
530 type
= TYPE_P (node
) ? node
: TREE_TYPE (node
);
532 /* Check for std::allocator. */
534 && is_std_substitution (decl
, SUBID_ALLOCATOR
)
535 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl
)))
538 /* Check for std::basic_string. */
539 else if (decl
&& is_std_substitution (decl
, SUBID_BASIC_STRING
))
543 /* If this is a type (i.e. a fully-qualified template-id),
545 std::basic_string <char,
546 std::char_traits<char>,
547 std::allocator<char> > . */
548 if (cp_type_quals (type
) == TYPE_UNQUALIFIED
549 && CLASSTYPE_USE_TEMPLATE (type
))
551 tree args
= CLASSTYPE_TI_ARGS (type
);
552 if (TREE_VEC_LENGTH (args
) == 3
553 && same_type_p (TREE_VEC_ELT (args
, 0), char_type_node
)
554 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
556 && is_std_substitution_char (TREE_VEC_ELT (args
, 2),
562 /* Substitute for the template name only if this isn't a type. */
566 /* Check for basic_{i,o,io}stream. */
567 else if (TYPE_P (node
)
568 && cp_type_quals (type
) == TYPE_UNQUALIFIED
569 && CLASS_TYPE_P (type
)
570 && CLASSTYPE_USE_TEMPLATE (type
)
571 && CLASSTYPE_TEMPLATE_INFO (type
) != NULL
)
573 /* First, check for the template
574 args <char, std::char_traits<char> > . */
575 tree args
= CLASSTYPE_TI_ARGS (type
);
576 if (TREE_VEC_LENGTH (args
) == 2
577 && TYPE_P (TREE_VEC_ELT (args
, 0))
578 && same_type_p (TREE_VEC_ELT (args
, 0), char_type_node
)
579 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
582 /* Got them. Is this basic_istream? */
583 if (is_std_substitution (decl
, SUBID_BASIC_ISTREAM
))
585 /* Or basic_ostream? */
586 else if (is_std_substitution (decl
, SUBID_BASIC_OSTREAM
))
588 /* Or basic_iostream? */
589 else if (is_std_substitution (decl
, SUBID_BASIC_IOSTREAM
))
594 /* Check for namespace std. */
595 else if (decl
&& DECL_NAMESPACE_STD_P (decl
))
601 tree tags
= NULL_TREE
;
602 if (OVERLOAD_TYPE_P (node
) || DECL_CLASS_TEMPLATE_P (node
))
603 tags
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (type
));
604 /* Now check the list of available substitutions for this mangling
606 if (!abbr
|| tags
) for (i
= 0; i
< size
; ++i
)
608 tree candidate
= (*G
.substitutions
)[i
];
609 /* NODE is a matched to a candidate if it's the same decl node or
610 if it's the same type. */
611 if (decl
== candidate
612 || (TYPE_P (candidate
) && type
&& TYPE_P (node
)
613 && same_type_p (type
, candidate
))
614 || NESTED_TEMPLATE_MATCH (node
, candidate
))
616 write_substitution (i
);
622 /* No substitution found. */
628 /* If there are ABI tags on the abbreviation, it becomes
629 a substitution candidate. */
630 write_abi_tags (tags
);
631 add_substitution (node
);
636 /* Returns whether DECL's symbol name should be the plain unqualified-id
637 rather than a more complicated mangled name. */
640 unmangled_name_p (const tree decl
)
642 if (TREE_CODE (decl
) == FUNCTION_DECL
)
644 /* The names of `extern "C"' functions are not mangled. */
645 return (DECL_EXTERN_C_FUNCTION_P (decl
)
646 /* But overloaded operator names *are* mangled. */
647 && !DECL_OVERLOADED_OPERATOR_P (decl
));
649 else if (VAR_P (decl
))
651 /* static variables are mangled. */
652 if (!DECL_EXTERNAL_LINKAGE_P (decl
))
655 /* extern "C" declarations aren't mangled. */
656 if (DECL_EXTERN_C_P (decl
))
659 /* Other variables at non-global scope are mangled. */
660 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
663 /* Variable template instantiations are mangled. */
664 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
665 && variable_template_p (DECL_TI_TEMPLATE (decl
)))
668 /* Declarations with ABI tags are mangled. */
669 if (lookup_attribute ("abi_tag", DECL_ATTRIBUTES (decl
)))
672 /* The names of non-static global variables aren't mangled. */
679 /* TOP_LEVEL is true, if this is being called at outermost level of
680 mangling. It should be false when mangling a decl appearing in an
681 expression within some other mangling.
683 <mangled-name> ::= _Z <encoding> */
686 write_mangled_name (const tree decl
, bool top_level
)
688 MANGLE_TRACE_TREE ("mangled-name", decl
);
690 check_abi_tags (decl
);
692 if (unmangled_name_p (decl
))
695 write_string (IDENTIFIER_POINTER (DECL_NAME (decl
)));
698 /* The standard notes: "The <encoding> of an extern "C"
699 function is treated like global-scope data, i.e. as its
700 <source-name> without a type." We cannot write
701 overloaded operators that way though, because it contains
702 characters invalid in assembler. */
704 write_source_name (DECL_NAME (decl
));
710 write_encoding (decl
);
714 /* Returns true if the return type of DECL is part of its signature, and
715 therefore its mangling. */
718 mangle_return_type_p (tree decl
)
720 return (!DECL_CONSTRUCTOR_P (decl
)
721 && !DECL_DESTRUCTOR_P (decl
)
722 && !DECL_CONV_FN_P (decl
)
723 && decl_is_template_id (decl
, NULL
));
726 /* <encoding> ::= <function name> <bare-function-type>
730 write_encoding (const tree decl
)
732 MANGLE_TRACE_TREE ("encoding", decl
);
734 if (DECL_LANG_SPECIFIC (decl
) && DECL_EXTERN_C_FUNCTION_P (decl
))
736 /* For overloaded operators write just the mangled name
737 without arguments. */
738 if (DECL_OVERLOADED_OPERATOR_P (decl
))
739 write_name (decl
, /*ignore_local_scope=*/0);
741 write_source_name (DECL_NAME (decl
));
745 write_name (decl
, /*ignore_local_scope=*/0);
746 if (TREE_CODE (decl
) == FUNCTION_DECL
)
751 if (decl_is_template_id (decl
, NULL
))
753 fn_type
= get_mostly_instantiated_function_type (decl
);
754 /* FN_TYPE will not have parameter types for in-charge or
755 VTT parameters. Therefore, we pass NULL_TREE to
756 write_bare_function_type -- otherwise, it will get
757 confused about which artificial parameters to skip. */
762 fn_type
= TREE_TYPE (decl
);
766 write_bare_function_type (fn_type
,
767 mangle_return_type_p (decl
),
772 /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
773 or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */
776 decl_mangling_context (tree decl
)
778 tree tcontext
= targetm
.cxx
.decl_mangling_context (decl
);
780 if (tcontext
!= NULL_TREE
)
783 if (TREE_CODE (decl
) == TEMPLATE_DECL
784 && DECL_TEMPLATE_RESULT (decl
))
785 decl
= DECL_TEMPLATE_RESULT (decl
);
787 if (TREE_CODE (decl
) == TYPE_DECL
788 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
790 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl
));
794 else if (template_type_parameter_p (decl
))
795 /* template type parms have no mangling context. */
797 return CP_DECL_CONTEXT (decl
);
800 /* <name> ::= <unscoped-name>
801 ::= <unscoped-template-name> <template-args>
805 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
806 called from <local-name>, which mangles the enclosing scope
807 elsewhere and then uses this function to mangle just the part
808 underneath the function scope. So don't use the <local-name>
809 production, to avoid an infinite recursion. */
812 write_name (tree decl
, const int ignore_local_scope
)
816 MANGLE_TRACE_TREE ("name", decl
);
818 if (TREE_CODE (decl
) == TYPE_DECL
)
820 /* In case this is a typedef, fish out the corresponding
821 TYPE_DECL for the main variant. */
822 decl
= TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
)));
825 context
= decl_mangling_context (decl
);
827 gcc_assert (context
!= NULL_TREE
);
829 if (abi_warn_or_compat_version_crosses (7)
830 && ignore_local_scope
831 && TREE_CODE (context
) == PARM_DECL
)
832 G
.need_abi_warning
= 1;
834 /* A decl in :: or ::std scope is treated specially. The former is
835 mangled using <unscoped-name> or <unscoped-template-name>, the
836 latter with a special substitution. Also, a name that is
837 directly in a local function scope is also mangled with
838 <unscoped-name> rather than a full <nested-name>. */
839 if (context
== global_namespace
840 || DECL_NAMESPACE_STD_P (context
)
841 || (ignore_local_scope
842 && (TREE_CODE (context
) == FUNCTION_DECL
843 || (abi_version_at_least (7)
844 && TREE_CODE (context
) == PARM_DECL
))))
847 /* Is this a template instance? */
848 if (decl_is_template_id (decl
, &template_info
))
850 /* Yes: use <unscoped-template-name>. */
851 write_unscoped_template_name (TI_TEMPLATE (template_info
));
852 write_template_args (TI_ARGS (template_info
));
855 /* Everything else gets an <unqualified-name>. */
856 write_unscoped_name (decl
);
860 /* Handle local names, unless we asked not to (that is, invoked
861 under <local-name>, to handle only the part of the name under
863 if (!ignore_local_scope
)
865 /* Scan up the list of scope context, looking for a
866 function. If we find one, this entity is in local
867 function scope. local_entity tracks context one scope
868 level down, so it will contain the element that's
869 directly in that function's scope, either decl or one of
870 its enclosing scopes. */
871 tree local_entity
= decl
;
872 while (context
!= global_namespace
)
874 /* Make sure we're always dealing with decls. */
875 if (TYPE_P (context
))
876 context
= TYPE_NAME (context
);
877 /* Is this a function? */
878 if (TREE_CODE (context
) == FUNCTION_DECL
879 || TREE_CODE (context
) == PARM_DECL
)
881 /* Yes, we have local scope. Use the <local-name>
882 production for the innermost function scope. */
883 write_local_name (context
, local_entity
, decl
);
886 /* Up one scope level. */
887 local_entity
= context
;
888 context
= decl_mangling_context (context
);
891 /* No local scope found? Fall through to <nested-name>. */
894 /* Other decls get a <nested-name> to encode their scope. */
895 write_nested_name (decl
);
899 /* <unscoped-name> ::= <unqualified-name>
900 ::= St <unqualified-name> # ::std:: */
903 write_unscoped_name (const tree decl
)
905 tree context
= decl_mangling_context (decl
);
907 MANGLE_TRACE_TREE ("unscoped-name", decl
);
909 /* Is DECL in ::std? */
910 if (DECL_NAMESPACE_STD_P (context
))
913 write_unqualified_name (decl
);
917 /* If not, it should be either in the global namespace, or directly
918 in a local function scope. A lambda can also be mangled in the
919 scope of a default argument. */
920 gcc_assert (context
== global_namespace
921 || TREE_CODE (context
) == PARM_DECL
922 || TREE_CODE (context
) == FUNCTION_DECL
);
924 write_unqualified_name (decl
);
928 /* <unscoped-template-name> ::= <unscoped-name>
929 ::= <substitution> */
932 write_unscoped_template_name (const tree decl
)
934 MANGLE_TRACE_TREE ("unscoped-template-name", decl
);
936 if (find_substitution (decl
))
938 write_unscoped_name (decl
);
939 add_substitution (decl
);
942 /* Write the nested name, including CV-qualifiers, of DECL.
944 <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
945 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
947 <ref-qualifier> ::= R # & ref-qualifier
948 ::= O # && ref-qualifier
949 <CV-qualifiers> ::= [r] [V] [K] */
952 write_nested_name (const tree decl
)
956 MANGLE_TRACE_TREE ("nested-name", decl
);
960 /* Write CV-qualifiers, if this is a member function. */
961 if (TREE_CODE (decl
) == FUNCTION_DECL
962 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
964 if (DECL_VOLATILE_MEMFUNC_P (decl
))
966 if (DECL_CONST_MEMFUNC_P (decl
))
968 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl
)))
970 if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl
)))
977 /* Is this a template instance? */
978 if (decl_is_template_id (decl
, &template_info
))
980 /* Yes, use <template-prefix>. */
981 write_template_prefix (decl
);
982 write_template_args (TI_ARGS (template_info
));
984 else if ((!abi_version_at_least (10) || TREE_CODE (decl
) == TYPE_DECL
)
985 && TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
987 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
988 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
990 write_template_prefix (decl
);
991 write_template_args (TREE_OPERAND (name
, 1));
995 write_prefix (decl_mangling_context (decl
));
996 write_unqualified_name (decl
);
1001 /* No, just use <prefix> */
1002 write_prefix (decl_mangling_context (decl
));
1003 write_unqualified_name (decl
);
1008 /* <prefix> ::= <prefix> <unqualified-name>
1009 ::= <template-param>
1010 ::= <template-prefix> <template-args>
1013 ::= <substitution> */
1016 write_prefix (const tree node
)
1019 /* Non-NULL if NODE represents a template-id. */
1020 tree template_info
= NULL
;
1023 || node
== global_namespace
)
1026 MANGLE_TRACE_TREE ("prefix", node
);
1028 if (TREE_CODE (node
) == DECLTYPE_TYPE
)
1034 if (find_substitution (node
))
1039 /* If this is a function or parm decl, that means we've hit function
1040 scope, so this prefix must be for a local name. In this
1041 case, we're under the <local-name> production, which encodes
1042 the enclosing function scope elsewhere. So don't continue
1044 if (TREE_CODE (node
) == FUNCTION_DECL
1045 || TREE_CODE (node
) == PARM_DECL
)
1049 decl_is_template_id (decl
, &template_info
);
1053 /* Node is a type. */
1054 decl
= TYPE_NAME (node
);
1055 if (CLASSTYPE_TEMPLATE_ID_P (node
))
1056 template_info
= TYPE_TEMPLATE_INFO (node
);
1059 if (TREE_CODE (node
) == TEMPLATE_TYPE_PARM
)
1060 write_template_param (node
);
1061 else if (template_info
!= NULL
)
1064 write_template_prefix (decl
);
1065 write_template_args (TI_ARGS (template_info
));
1067 else if (TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
1069 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
1070 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1072 write_template_prefix (decl
);
1073 write_template_args (TREE_OPERAND (name
, 1));
1077 write_prefix (decl_mangling_context (decl
));
1078 write_unqualified_name (decl
);
1082 /* Not templated. */
1084 write_prefix (decl_mangling_context (decl
));
1085 write_unqualified_name (decl
);
1087 || TREE_CODE (decl
) == FIELD_DECL
)
1089 /* <data-member-prefix> := <member source-name> M */
1095 add_substitution (node
);
1098 /* <template-prefix> ::= <prefix> <template component>
1099 ::= <template-param>
1100 ::= <substitution> */
1103 write_template_prefix (const tree node
)
1105 tree decl
= DECL_P (node
) ? node
: TYPE_NAME (node
);
1106 tree type
= DECL_P (node
) ? TREE_TYPE (node
) : node
;
1107 tree context
= decl_mangling_context (decl
);
1112 MANGLE_TRACE_TREE ("template-prefix", node
);
1114 /* Find the template decl. */
1115 if (decl_is_template_id (decl
, &template_info
))
1116 templ
= TI_TEMPLATE (template_info
);
1117 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
1118 /* For a typename type, all we have is the name. */
1119 templ
= DECL_NAME (decl
);
1122 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type
));
1124 templ
= TYPE_TI_TEMPLATE (type
);
1127 /* For a member template, though, the template name for the
1128 innermost name must have all the outer template levels
1129 instantiated. For instance, consider
1131 template<typename T> struct Outer {
1132 template<typename U> struct Inner {};
1135 The template name for `Inner' in `Outer<int>::Inner<float>' is
1136 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1137 levels separately, so there's no TEMPLATE_DECL available for this
1138 (there's only `Outer<T>::Inner<U>').
1140 In order to get the substitutions right, we create a special
1141 TREE_LIST to represent the substitution candidate for a nested
1142 template. The TREE_PURPOSE is the template's context, fully
1143 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1146 So, for the example above, `Outer<int>::Inner' is represented as a
1147 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1148 and whose value is `Outer<T>::Inner<U>'. */
1149 if (context
&& TYPE_P (context
))
1150 substitution
= build_tree_list (context
, templ
);
1152 substitution
= templ
;
1154 if (find_substitution (substitution
))
1157 if (TREE_TYPE (templ
)
1158 && TREE_CODE (TREE_TYPE (templ
)) == TEMPLATE_TEMPLATE_PARM
)
1159 write_template_param (TREE_TYPE (templ
));
1162 write_prefix (context
);
1163 write_unqualified_name (decl
);
1166 add_substitution (substitution
);
1169 /* We don't need to handle thunks, vtables, or VTTs here. Those are
1170 mangled through special entry points.
1172 <unqualified-name> ::= <operator-name>
1175 ::= <unnamed-type-name>
1176 ::= <local-source-name>
1178 <local-source-name> ::= L <source-name> <discriminator> */
1181 write_unqualified_id (tree identifier
)
1183 if (IDENTIFIER_TYPENAME_P (identifier
))
1184 write_conversion_operator_name (TREE_TYPE (identifier
));
1185 else if (IDENTIFIER_OPNAME_P (identifier
))
1188 const char *mangled_name
= NULL
;
1190 /* Unfortunately, there is no easy way to go from the
1191 name of the operator back to the corresponding tree
1193 for (i
= 0; i
< MAX_TREE_CODES
; ++i
)
1194 if (operator_name_info
[i
].identifier
== identifier
)
1196 /* The ABI says that we prefer binary operator
1197 names to unary operator names. */
1198 if (operator_name_info
[i
].arity
== 2)
1200 mangled_name
= operator_name_info
[i
].mangled_name
;
1203 else if (!mangled_name
)
1204 mangled_name
= operator_name_info
[i
].mangled_name
;
1206 else if (assignment_operator_name_info
[i
].identifier
1210 = assignment_operator_name_info
[i
].mangled_name
;
1213 write_string (mangled_name
);
1215 else if (UDLIT_OPER_P (identifier
))
1216 write_literal_operator_name (identifier
);
1218 write_source_name (identifier
);
1222 write_unqualified_name (tree decl
)
1224 MANGLE_TRACE_TREE ("unqualified-name", decl
);
1226 if (identifier_p (decl
))
1228 write_unqualified_id (decl
);
1234 if (DECL_NAME (decl
) == NULL_TREE
)
1237 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl
));
1238 write_source_name (DECL_ASSEMBLER_NAME (decl
));
1240 else if (DECL_DECLARES_FUNCTION_P (decl
))
1243 if (DECL_CONSTRUCTOR_P (decl
))
1244 write_special_name_constructor (decl
);
1245 else if (DECL_DESTRUCTOR_P (decl
))
1246 write_special_name_destructor (decl
);
1247 else if (DECL_CONV_FN_P (decl
))
1249 /* Conversion operator. Handle it right here.
1250 <operator> ::= cv <type> */
1252 if (decl_is_template_id (decl
, NULL
))
1255 fn_type
= get_mostly_instantiated_function_type (decl
);
1256 type
= TREE_TYPE (fn_type
);
1258 else if (FNDECL_USED_AUTO (decl
))
1259 type
= (DECL_STRUCT_FUNCTION (decl
)->language
1260 ->x_auto_return_pattern
);
1262 type
= DECL_CONV_FN_TYPE (decl
);
1263 write_conversion_operator_name (type
);
1265 else if (DECL_OVERLOADED_OPERATOR_P (decl
))
1267 operator_name_info_t
*oni
;
1268 if (DECL_ASSIGNMENT_OPERATOR_P (decl
))
1269 oni
= assignment_operator_name_info
;
1271 oni
= operator_name_info
;
1273 write_string (oni
[DECL_OVERLOADED_OPERATOR_P (decl
)].mangled_name
);
1275 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
1276 write_literal_operator_name (DECL_NAME (decl
));
1283 else if (VAR_OR_FUNCTION_DECL_P (decl
) && ! TREE_PUBLIC (decl
)
1284 && DECL_NAMESPACE_SCOPE_P (decl
)
1285 && decl_linkage (decl
) == lk_internal
)
1287 MANGLE_TRACE_TREE ("local-source-name", decl
);
1289 write_source_name (DECL_NAME (decl
));
1290 /* The default discriminator is 1, and that's all we ever use,
1291 so there's no code to output one here. */
1295 tree type
= TREE_TYPE (decl
);
1297 if (TREE_CODE (decl
) == TYPE_DECL
1298 && TYPE_ANONYMOUS_P (type
))
1299 write_unnamed_type_name (type
);
1300 else if (TREE_CODE (decl
) == TYPE_DECL
1301 && LAMBDA_TYPE_P (type
))
1302 write_closure_type_name (type
);
1304 write_source_name (DECL_NAME (decl
));
1307 /* We use the ABI tags from the primary template, ignoring tags on any
1308 specializations. This is necessary because C++ doesn't require a
1309 specialization to be declared before it is used unless the use
1310 requires a complete type, but we need to get the tags right on
1311 incomplete types as well. */
1312 if (tree tmpl
= most_general_template (decl
))
1313 decl
= DECL_TEMPLATE_RESULT (tmpl
);
1314 /* Don't crash on an unbound class template. */
1315 if (decl
&& TREE_CODE (decl
) != NAMESPACE_DECL
)
1317 tree attrs
= (TREE_CODE (decl
) == TYPE_DECL
1318 ? TYPE_ATTRIBUTES (TREE_TYPE (decl
))
1319 : DECL_ATTRIBUTES (decl
));
1320 write_abi_tags (lookup_attribute ("abi_tag", attrs
));
1324 /* Write the unqualified-name for a conversion operator to TYPE. */
1327 write_conversion_operator_name (const tree type
)
1329 write_string ("cv");
1333 /* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1335 <source-name> ::= </length/ number> <identifier> */
1338 write_source_name (tree identifier
)
1340 MANGLE_TRACE_TREE ("source-name", identifier
);
1342 /* Never write the whole template-id name including the template
1343 arguments; we only want the template name. */
1344 if (IDENTIFIER_TEMPLATE (identifier
))
1345 identifier
= IDENTIFIER_TEMPLATE (identifier
);
1347 write_unsigned_number (IDENTIFIER_LENGTH (identifier
));
1348 write_identifier (IDENTIFIER_POINTER (identifier
));
1351 /* Compare two TREE_STRINGs like strcmp. */
1354 tree_string_cmp (const void *p1
, const void *p2
)
1358 tree s1
= *(const tree
*)p1
;
1359 tree s2
= *(const tree
*)p2
;
1360 return strcmp (TREE_STRING_POINTER (s1
),
1361 TREE_STRING_POINTER (s2
));
1364 /* ID is the name of a function or type with abi_tags attribute TAGS.
1365 Write out the name, suitably decorated. */
1368 write_abi_tags (tree tags
)
1370 if (tags
== NULL_TREE
)
1373 tags
= TREE_VALUE (tags
);
1375 vec
<tree
, va_gc
> * vec
= make_tree_vector();
1377 for (tree t
= tags
; t
; t
= TREE_CHAIN (t
))
1379 if (ABI_TAG_IMPLICIT (t
))
1381 tree str
= TREE_VALUE (t
);
1382 vec_safe_push (vec
, str
);
1385 vec
->qsort (tree_string_cmp
);
1387 unsigned i
; tree str
;
1388 FOR_EACH_VEC_ELT (*vec
, i
, str
)
1391 write_unsigned_number (TREE_STRING_LENGTH (str
) - 1);
1392 write_identifier (TREE_STRING_POINTER (str
));
1395 release_tree_vector (vec
);
1398 /* Write a user-defined literal operator.
1399 ::= li <source-name> # "" <source-name>
1400 IDENTIFIER is an LITERAL_IDENTIFIER_NODE. */
1403 write_literal_operator_name (tree identifier
)
1405 const char* suffix
= UDLIT_OP_SUFFIX (identifier
);
1406 write_identifier (UDLIT_OP_MANGLED_PREFIX
);
1407 write_unsigned_number (strlen (suffix
));
1408 write_identifier (suffix
);
1411 /* Encode 0 as _, and 1+ as n-1_. */
1414 write_compact_number (int num
)
1417 write_unsigned_number (num
- 1);
1421 /* Return how many unnamed types precede TYPE in its enclosing class. */
1424 nested_anon_class_index (tree type
)
1427 tree member
= TYPE_FIELDS (TYPE_CONTEXT (type
));
1428 for (; member
; member
= DECL_CHAIN (member
))
1429 if (DECL_IMPLICIT_TYPEDEF_P (member
))
1431 tree memtype
= TREE_TYPE (member
);
1432 if (memtype
== type
)
1434 else if (TYPE_ANONYMOUS_P (memtype
))
1441 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1444 write_unnamed_type_name (const tree type
)
1447 MANGLE_TRACE_TREE ("unnamed-type-name", type
);
1449 if (TYPE_FUNCTION_SCOPE_P (type
))
1450 discriminator
= local_class_index (type
);
1451 else if (TYPE_CLASS_SCOPE_P (type
))
1452 discriminator
= nested_anon_class_index (type
);
1455 gcc_assert (no_linkage_check (type
, /*relaxed_p=*/true));
1456 /* Just use the old mangling at namespace scope. */
1457 write_source_name (TYPE_IDENTIFIER (type
));
1461 write_string ("Ut");
1462 write_compact_number (discriminator
);
1465 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1466 <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters */
1469 write_closure_type_name (const tree type
)
1471 tree fn
= lambda_function (type
);
1472 tree lambda
= CLASSTYPE_LAMBDA_EXPR (type
);
1473 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1475 MANGLE_TRACE_TREE ("closure-type-name", type
);
1477 write_string ("Ul");
1478 write_method_parms (parms
, /*method_p=*/1, fn
);
1480 write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda
));
1483 /* Convert NUMBER to ascii using base BASE and generating at least
1484 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1485 into which to store the characters. Returns the number of
1486 characters generated (these will be laid out in advance of where
1490 hwint_to_ascii (unsigned HOST_WIDE_INT number
, const unsigned int base
,
1491 char *buffer
, const unsigned int min_digits
)
1493 static const char base_digits
[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1494 unsigned digits
= 0;
1498 unsigned HOST_WIDE_INT d
= number
/ base
;
1500 *--buffer
= base_digits
[number
- d
* base
];
1504 while (digits
< min_digits
)
1506 *--buffer
= base_digits
[0];
1512 /* Non-terminal <number>.
1514 <number> ::= [n] </decimal integer/> */
1517 write_number (unsigned HOST_WIDE_INT number
, const int unsigned_p
,
1518 const unsigned int base
)
1520 char buffer
[sizeof (HOST_WIDE_INT
) * 8];
1523 if (!unsigned_p
&& (HOST_WIDE_INT
) number
< 0)
1526 number
= -((HOST_WIDE_INT
) number
);
1528 count
= hwint_to_ascii (number
, base
, buffer
+ sizeof (buffer
), 1);
1529 write_chars (buffer
+ sizeof (buffer
) - count
, count
);
1532 /* Write out an integral CST in decimal. Most numbers are small, and
1533 representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1534 bigger than that, which we must deal with. */
1537 write_integer_cst (const tree cst
)
1539 int sign
= tree_int_cst_sgn (cst
);
1540 widest_int abs_value
= wi::abs (wi::to_widest (cst
));
1541 if (!wi::fits_uhwi_p (abs_value
))
1543 /* A bignum. We do this in chunks, each of which fits in a
1545 char buffer
[sizeof (HOST_WIDE_INT
) * 8 * 2];
1546 unsigned HOST_WIDE_INT chunk
;
1547 unsigned chunk_digits
;
1548 char *ptr
= buffer
+ sizeof (buffer
);
1553 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1558 if (sizeof (HOST_WIDE_INT
) >= 8)
1560 /* It is at least 64 bits, so 10^18 is representable. */
1565 type
= c_common_signed_or_unsigned_type (1, TREE_TYPE (cst
));
1566 base
= build_int_cstu (type
, chunk
);
1567 n
= wide_int_to_tree (type
, cst
);
1572 n
= fold_build1_loc (input_location
, NEGATE_EXPR
, type
, n
);
1576 tree d
= fold_build2_loc (input_location
, FLOOR_DIV_EXPR
, type
, n
, base
);
1577 tree tmp
= fold_build2_loc (input_location
, MULT_EXPR
, type
, d
, base
);
1580 done
= integer_zerop (d
);
1581 tmp
= fold_build2_loc (input_location
, MINUS_EXPR
, type
, n
, tmp
);
1582 c
= hwint_to_ascii (TREE_INT_CST_LOW (tmp
), 10, ptr
,
1583 done
? 1 : chunk_digits
);
1589 write_chars (ptr
, count
);
1596 write_unsigned_number (abs_value
.to_uhwi ());
1600 /* Write out a floating-point literal.
1602 "Floating-point literals are encoded using the bit pattern of the
1603 target processor's internal representation of that number, as a
1604 fixed-length lowercase hexadecimal string, high-order bytes first
1605 (even if the target processor would store low-order bytes first).
1606 The "n" prefix is not used for floating-point literals; the sign
1607 bit is encoded with the rest of the number.
1609 Here are some examples, assuming the IEEE standard representation
1610 for floating point numbers. (Spaces are for readability, not
1611 part of the encoding.)
1614 -1.0f Lf bf80 0000 E
1615 1.17549435e-38f Lf 0080 0000 E
1616 1.40129846e-45f Lf 0000 0001 E
1617 0.0f Lf 0000 0000 E"
1619 Caller is responsible for the Lx and the E. */
1621 write_real_cst (const tree value
)
1623 long target_real
[4]; /* largest supported float */
1624 char buffer
[9]; /* eight hex digits in a 32-bit number */
1627 tree type
= TREE_TYPE (value
);
1628 int words
= GET_MODE_BITSIZE (TYPE_MODE (type
)) / 32;
1630 real_to_target (target_real
, &TREE_REAL_CST (value
),
1633 /* The value in target_real is in the target word order,
1634 so we must write it out backward if that happens to be
1635 little-endian. write_number cannot be used, it will
1636 produce uppercase. */
1637 if (FLOAT_WORDS_BIG_ENDIAN
)
1638 i
= 0, limit
= words
, dir
= 1;
1640 i
= words
- 1, limit
= -1, dir
= -1;
1642 for (; i
!= limit
; i
+= dir
)
1644 sprintf (buffer
, "%08lx", (unsigned long) target_real
[i
]);
1645 write_chars (buffer
, 8);
1649 /* Non-terminal <identifier>.
1651 <identifier> ::= </unqualified source code identifier> */
1654 write_identifier (const char *identifier
)
1656 MANGLE_TRACE ("identifier", identifier
);
1657 write_string (identifier
);
1660 /* Handle constructor productions of non-terminal <special-name>.
1661 CTOR is a constructor FUNCTION_DECL.
1663 <special-name> ::= C1 # complete object constructor
1664 ::= C2 # base object constructor
1665 ::= C3 # complete object allocating constructor
1667 Currently, allocating constructors are never used. */
1670 write_special_name_constructor (const tree ctor
)
1672 if (DECL_BASE_CONSTRUCTOR_P (ctor
))
1673 write_string ("C2");
1674 /* This is the old-style "[unified]" constructor.
1675 In some cases, we may emit this function and call
1676 it from the clones in order to share code and save space. */
1677 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor
))
1678 write_string ("C4");
1681 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor
));
1682 write_string ("C1");
1686 /* Handle destructor productions of non-terminal <special-name>.
1687 DTOR is a destructor FUNCTION_DECL.
1689 <special-name> ::= D0 # deleting (in-charge) destructor
1690 ::= D1 # complete object (in-charge) destructor
1691 ::= D2 # base object (not-in-charge) destructor */
1694 write_special_name_destructor (const tree dtor
)
1696 if (DECL_DELETING_DESTRUCTOR_P (dtor
))
1697 write_string ("D0");
1698 else if (DECL_BASE_DESTRUCTOR_P (dtor
))
1699 write_string ("D2");
1700 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor
))
1701 /* This is the old-style "[unified]" destructor.
1702 In some cases, we may emit this function and call
1703 it from the clones in order to share code and save space. */
1704 write_string ("D4");
1707 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor
));
1708 write_string ("D1");
1712 /* Scan the vector of local classes and return how many others with the
1713 same name (or same no name) and context precede ENTITY. */
1716 local_class_index (tree entity
)
1718 int ix
, discriminator
= 0;
1719 tree name
= (TYPE_ANONYMOUS_P (entity
) ? NULL_TREE
1720 : TYPE_IDENTIFIER (entity
));
1721 tree ctx
= TYPE_CONTEXT (entity
);
1722 for (ix
= 0; ; ix
++)
1724 tree type
= (*local_classes
)[ix
];
1726 return discriminator
;
1727 if (TYPE_CONTEXT (type
) == ctx
1728 && (name
? TYPE_IDENTIFIER (type
) == name
1729 : TYPE_ANONYMOUS_P (type
)))
1735 /* Return the discriminator for ENTITY appearing inside
1736 FUNCTION. The discriminator is the lexical ordinal of VAR among
1737 entities with the same name in the same FUNCTION. */
1740 discriminator_for_local_entity (tree entity
)
1742 if (DECL_DISCRIMINATOR_P (entity
))
1744 if (DECL_DISCRIMINATOR_SET_P (entity
))
1745 return DECL_DISCRIMINATOR (entity
);
1747 /* The first entity with a particular name doesn't get
1748 DECL_DISCRIMINATOR set up. */
1751 else if (TREE_CODE (entity
) == TYPE_DECL
)
1753 /* Scan the list of local classes. */
1754 entity
= TREE_TYPE (entity
);
1756 /* Lambdas and unnamed types have their own discriminators. */
1757 if (LAMBDA_TYPE_P (entity
) || TYPE_ANONYMOUS_P (entity
))
1760 return local_class_index (entity
);
1766 /* Return the discriminator for STRING, a string literal used inside
1767 FUNCTION. The discriminator is the lexical ordinal of STRING among
1768 string literals used in FUNCTION. */
1771 discriminator_for_string_literal (tree
/*function*/,
1774 /* For now, we don't discriminate amongst string literals. */
1778 /* <discriminator> := _ <number>
1780 The discriminator is used only for the second and later occurrences
1781 of the same name within a single function. In this case <number> is
1782 n - 2, if this is the nth occurrence, in lexical order. */
1785 write_discriminator (const int discriminator
)
1787 /* If discriminator is zero, don't write anything. Otherwise... */
1788 if (discriminator
> 0)
1791 write_unsigned_number (discriminator
- 1);
1795 /* Mangle the name of a function-scope entity. FUNCTION is the
1796 FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1797 default argument scope. ENTITY is the decl for the entity itself.
1798 LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1799 either ENTITY itself or an enclosing scope of ENTITY.
1801 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1802 := Z <function encoding> E s [<discriminator>]
1803 := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1806 write_local_name (tree function
, const tree local_entity
,
1809 tree parm
= NULL_TREE
;
1811 MANGLE_TRACE_TREE ("local-name", entity
);
1813 if (TREE_CODE (function
) == PARM_DECL
)
1816 function
= DECL_CONTEXT (parm
);
1820 write_encoding (function
);
1823 /* For this purpose, parameters are numbered from right-to-left. */
1828 for (t
= DECL_ARGUMENTS (function
); t
; t
= DECL_CHAIN (t
))
1836 write_compact_number (i
- 1);
1839 if (TREE_CODE (entity
) == STRING_CST
)
1842 write_discriminator (discriminator_for_string_literal (function
,
1847 /* Now the <entity name>. Let write_name know its being called
1848 from <local-name>, so it doesn't try to process the enclosing
1849 function scope again. */
1850 write_name (entity
, /*ignore_local_scope=*/1);
1851 write_discriminator (discriminator_for_local_entity (local_entity
));
1855 /* Non-terminals <type> and <CV-qualifier>.
1857 <type> ::= <builtin-type>
1859 ::= <class-enum-type>
1861 ::= <pointer-to-member-type>
1862 ::= <template-param>
1865 ::= P <type> # pointer-to
1866 ::= R <type> # reference-to
1867 ::= C <type> # complex pair (C 2000)
1868 ::= G <type> # imaginary (C 2000) [not supported]
1869 ::= U <source-name> <type> # vendor extended type qualifier
1873 <type> ::= RR <type> # rvalue reference-to
1874 <type> ::= Dt <expression> # decltype of an id-expression or
1875 # class member access
1876 <type> ::= DT <expression> # decltype of an expression
1877 <type> ::= Dn # decltype of nullptr
1879 TYPE is a type node. */
1882 write_type (tree type
)
1884 /* This gets set to nonzero if TYPE turns out to be a (possibly
1885 CV-qualified) builtin type. */
1886 int is_builtin_type
= 0;
1888 MANGLE_TRACE_TREE ("type", type
);
1890 if (type
== error_mark_node
)
1893 type
= canonicalize_for_substitution (type
);
1894 if (find_substitution (type
))
1898 if (write_CV_qualifiers_for_type (type
) > 0)
1899 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1900 mangle the unqualified type. The recursive call is needed here
1901 since both the qualified and unqualified types are substitution
1904 tree t
= TYPE_MAIN_VARIANT (type
);
1905 if (TYPE_ATTRIBUTES (t
) && !OVERLOAD_TYPE_P (t
))
1907 tree attrs
= NULL_TREE
;
1908 if (tx_safe_fn_type_p (type
))
1909 attrs
= tree_cons (get_identifier ("transaction_safe"),
1911 t
= cp_build_type_attribute_variant (t
, attrs
);
1913 gcc_assert (t
!= type
);
1914 if (TREE_CODE (t
) == FUNCTION_TYPE
1915 || TREE_CODE (t
) == METHOD_TYPE
)
1917 t
= build_ref_qualified_type (t
, type_memfn_rqual (type
));
1918 if (abi_version_at_least (8)
1919 || type
== TYPE_MAIN_VARIANT (type
))
1920 /* Avoid adding the unqualified function type as a substitution. */
1921 write_function_type (t
);
1924 if (abi_warn_or_compat_version_crosses (8))
1925 G
.need_abi_warning
= 1;
1930 else if (TREE_CODE (type
) == ARRAY_TYPE
)
1931 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1932 so that the cv-qualification of the element type is available
1933 in write_array_type. */
1934 write_array_type (type
);
1937 tree type_orig
= type
;
1939 /* See through any typedefs. */
1940 type
= TYPE_MAIN_VARIANT (type
);
1941 if (TREE_CODE (type
) == FUNCTION_TYPE
1942 || TREE_CODE (type
) == METHOD_TYPE
)
1943 type
= build_ref_qualified_type (type
, type_memfn_rqual (type_orig
));
1945 /* According to the C++ ABI, some library classes are passed the
1946 same as the scalar type of their single member and use the same
1948 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
1949 type
= TREE_TYPE (first_field (type
));
1951 if (TYPE_PTRDATAMEM_P (type
))
1952 write_pointer_to_member_type (type
);
1955 /* Handle any target-specific fundamental types. */
1956 const char *target_mangling
1957 = targetm
.mangle_type (type_orig
);
1959 if (target_mangling
)
1961 write_string (target_mangling
);
1962 /* Add substitutions for types other than fundamental
1964 if (!VOID_TYPE_P (type
)
1965 && TREE_CODE (type
) != INTEGER_TYPE
1966 && TREE_CODE (type
) != REAL_TYPE
1967 && TREE_CODE (type
) != BOOLEAN_TYPE
)
1968 add_substitution (type
);
1972 switch (TREE_CODE (type
))
1976 case INTEGER_TYPE
: /* Includes wchar_t. */
1978 case FIXED_POINT_TYPE
:
1980 /* If this is a typedef, TYPE may not be one of
1981 the standard builtin type nodes, but an alias of one. Use
1982 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
1983 write_builtin_type (TYPE_MAIN_VARIANT (type
));
1990 write_type (TREE_TYPE (type
));
1995 write_function_type (type
);
2001 /* A pointer-to-member function is represented as a special
2002 RECORD_TYPE, so check for this first. */
2003 if (TYPE_PTRMEMFUNC_P (type
))
2004 write_pointer_to_member_type (type
);
2006 write_class_enum_type (type
);
2010 case UNBOUND_CLASS_TEMPLATE
:
2011 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2012 ordinary nested names. */
2013 write_nested_name (TYPE_STUB_DECL (type
));
2017 case REFERENCE_TYPE
:
2018 if (TYPE_PTR_P (type
))
2020 else if (TYPE_REF_IS_RVALUE (type
))
2025 tree target
= TREE_TYPE (type
);
2026 /* Attribute const/noreturn are not reflected in mangling.
2027 We strip them here rather than at a lower level because
2028 a typedef or template argument can have function type
2029 with function-cv-quals (that use the same representation),
2030 but you can't have a pointer/reference to such a type. */
2031 if (TREE_CODE (target
) == FUNCTION_TYPE
)
2033 if (abi_warn_or_compat_version_crosses (5)
2034 && TYPE_QUALS (target
) != TYPE_UNQUALIFIED
)
2035 G
.need_abi_warning
= 1;
2036 if (abi_version_at_least (5))
2037 target
= build_qualified_type (target
, TYPE_UNQUALIFIED
);
2039 write_type (target
);
2043 case TEMPLATE_TYPE_PARM
:
2046 if (AUTO_IS_DECLTYPE (type
))
2047 write_identifier ("Dc");
2049 write_identifier ("Da");
2053 /* else fall through. */
2054 case TEMPLATE_PARM_INDEX
:
2055 write_template_param (type
);
2058 case TEMPLATE_TEMPLATE_PARM
:
2059 write_template_template_param (type
);
2062 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2063 write_template_template_param (type
);
2065 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type
)));
2069 if (abi_version_at_least (4))
2071 write_string ("Dv");
2072 /* Non-constant vector size would be encoded with
2073 _ expression, but we don't support that yet. */
2074 write_unsigned_number (TYPE_VECTOR_SUBPARTS (type
));
2078 write_string ("U8__vector");
2079 if (abi_warn_or_compat_version_crosses (4))
2080 G
.need_abi_warning
= 1;
2081 write_type (TREE_TYPE (type
));
2084 case TYPE_PACK_EXPANSION
:
2085 write_string ("Dp");
2086 write_type (PACK_EXPANSION_PATTERN (type
));
2090 /* These shouldn't make it into mangling. */
2091 gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type
)
2092 && !DECLTYPE_FOR_LAMBDA_PROXY (type
));
2094 /* In ABI <5, we stripped decltype of a plain decl. */
2095 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
))
2097 tree expr
= DECLTYPE_TYPE_EXPR (type
);
2098 tree etype
= NULL_TREE
;
2099 switch (TREE_CODE (expr
))
2106 case TEMPLATE_PARM_INDEX
:
2107 etype
= TREE_TYPE (expr
);
2114 if (etype
&& !type_uses_auto (etype
))
2116 if (abi_warn_or_compat_version_crosses (5))
2117 G
.need_abi_warning
= 1;
2118 if (!abi_version_at_least (5))
2127 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
))
2131 ++cp_unevaluated_operand
;
2132 write_expression (DECLTYPE_TYPE_EXPR (type
));
2133 --cp_unevaluated_operand
;
2138 write_string ("Dn");
2139 if (abi_version_at_least (7))
2141 if (abi_warn_or_compat_version_crosses (7))
2142 G
.need_abi_warning
= 1;
2146 sorry ("mangling typeof, use decltype instead");
2149 case UNDERLYING_TYPE
:
2150 sorry ("mangling __underlying_type");
2162 /* Types other than builtin types are substitution candidates. */
2163 if (!is_builtin_type
)
2164 add_substitution (type
);
2167 /* qsort callback for sorting a vector of attribute entries. */
2170 attr_strcmp (const void *p1
, const void *p2
)
2172 tree a1
= *(const tree
*)p1
;
2173 tree a2
= *(const tree
*)p2
;
2175 const attribute_spec
*as1
= lookup_attribute_spec (get_attribute_name (a1
));
2176 const attribute_spec
*as2
= lookup_attribute_spec (get_attribute_name (a2
));
2178 return strcmp (as1
->name
, as2
->name
);
2181 /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
2182 CV-qualifiers written for TYPE.
2184 <CV-qualifiers> ::= [r] [V] [K] */
2187 write_CV_qualifiers_for_type (const tree type
)
2189 int num_qualifiers
= 0;
2191 /* The order is specified by:
2193 "In cases where multiple order-insensitive qualifiers are
2194 present, they should be ordered 'K' (closest to the base type),
2195 'V', 'r', and 'U' (farthest from the base type) ..." */
2197 /* Mangle attributes that affect type identity as extended qualifiers.
2199 We don't do this with classes and enums because their attributes
2200 are part of their definitions, not something added on. */
2202 if (!OVERLOAD_TYPE_P (type
))
2205 for (tree a
= TYPE_ATTRIBUTES (type
); a
; a
= TREE_CHAIN (a
))
2207 tree name
= get_attribute_name (a
);
2208 const attribute_spec
*as
= lookup_attribute_spec (name
);
2209 if (as
&& as
->affects_type_identity
2210 && !is_attribute_p ("transaction_safe", name
)
2211 && !is_attribute_p ("abi_tag", name
))
2214 if (abi_warn_or_compat_version_crosses (10) && !vec
.is_empty ())
2215 G
.need_abi_warning
= true;
2216 if (abi_version_at_least (10))
2218 vec
.qsort (attr_strcmp
);
2219 while (!vec
.is_empty())
2222 const attribute_spec
*as
2223 = lookup_attribute_spec (get_attribute_name (a
));
2226 write_unsigned_number (strlen (as
->name
));
2227 write_string (as
->name
);
2231 for (tree args
= TREE_VALUE (a
); args
;
2232 args
= TREE_CHAIN (args
))
2234 tree arg
= TREE_VALUE (args
);
2235 write_template_arg (arg
);
2245 /* Note that we do not use cp_type_quals below; given "const
2246 int[3]", the "const" is emitted with the "int", not with the
2248 cp_cv_quals quals
= TYPE_QUALS (type
);
2250 if (quals
& TYPE_QUAL_RESTRICT
)
2255 if (quals
& TYPE_QUAL_VOLATILE
)
2260 if (quals
& TYPE_QUAL_CONST
)
2266 return num_qualifiers
;
2269 /* Non-terminal <builtin-type>.
2271 <builtin-type> ::= v # void
2276 ::= h # unsigned char
2278 ::= t # unsigned short
2280 ::= j # unsigned int
2282 ::= m # unsigned long
2283 ::= x # long long, __int64
2284 ::= y # unsigned long long, __int64
2286 ::= o # unsigned __int128
2289 ::= e # long double, __float80
2290 ::= g # __float128 [not supported]
2291 ::= u <source-name> # vendor extended type */
2294 write_builtin_type (tree type
)
2296 if (TYPE_CANONICAL (type
))
2297 type
= TYPE_CANONICAL (type
);
2299 switch (TREE_CODE (type
))
2310 /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2311 isn't in integer_type_nodes. */
2312 if (type
== wchar_type_node
)
2314 else if (type
== char16_type_node
)
2315 write_string ("Ds");
2316 else if (type
== char32_type_node
)
2317 write_string ("Di");
2318 else if (TYPE_FOR_JAVA (type
))
2319 write_java_integer_type_codes (type
);
2323 /* Assume TYPE is one of the shared integer type nodes. Find
2324 it in the array of these nodes. */
2326 for (itk
= 0; itk
< itk_none
; ++itk
)
2327 if (integer_types
[itk
] != NULL_TREE
2328 && integer_type_codes
[itk
] != '\0'
2329 && type
== integer_types
[itk
])
2331 /* Print the corresponding single-letter code. */
2332 write_char (integer_type_codes
[itk
]);
2336 if (itk
== itk_none
)
2338 tree t
= c_common_type_for_mode (TYPE_MODE (type
),
2339 TYPE_UNSIGNED (type
));
2346 if (TYPE_PRECISION (type
) == 128)
2347 write_char (TYPE_UNSIGNED (type
) ? 'o' : 'n');
2350 /* Allow for cases where TYPE is not one of the shared
2351 integer type nodes and write a "vendor extended builtin
2352 type" with a name the form intN or uintN, respectively.
2353 Situations like this can happen if you have an
2354 __attribute__((__mode__(__SI__))) type and use exotic
2355 switches like '-mint8' on AVR. Of course, this is
2356 undefined by the C++ ABI (and '-mint8' is not even
2357 Standard C conforming), but when using such special
2358 options you're pretty much in nowhere land anyway. */
2360 char prec
[11]; /* up to ten digits for an unsigned */
2362 prefix
= TYPE_UNSIGNED (type
) ? "uint" : "int";
2363 sprintf (prec
, "%u", (unsigned) TYPE_PRECISION (type
));
2364 write_char ('u'); /* "vendor extended builtin type" */
2365 write_unsigned_number (strlen (prefix
) + strlen (prec
));
2366 write_string (prefix
);
2367 write_string (prec
);
2374 if (type
== float_type_node
2375 || type
== java_float_type_node
)
2377 else if (type
== double_type_node
2378 || type
== java_double_type_node
)
2380 else if (type
== long_double_type_node
)
2382 else if (type
== dfloat32_type_node
)
2383 write_string ("Df");
2384 else if (type
== dfloat64_type_node
)
2385 write_string ("Dd");
2386 else if (type
== dfloat128_type_node
)
2387 write_string ("De");
2392 case FIXED_POINT_TYPE
:
2393 write_string ("DF");
2394 if (GET_MODE_IBIT (TYPE_MODE (type
)) > 0)
2395 write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type
)));
2396 if (type
== fract_type_node
2397 || type
== sat_fract_type_node
2398 || type
== accum_type_node
2399 || type
== sat_accum_type_node
)
2401 else if (type
== unsigned_fract_type_node
2402 || type
== sat_unsigned_fract_type_node
2403 || type
== unsigned_accum_type_node
2404 || type
== sat_unsigned_accum_type_node
)
2406 else if (type
== short_fract_type_node
2407 || type
== sat_short_fract_type_node
2408 || type
== short_accum_type_node
2409 || type
== sat_short_accum_type_node
)
2411 else if (type
== unsigned_short_fract_type_node
2412 || type
== sat_unsigned_short_fract_type_node
2413 || type
== unsigned_short_accum_type_node
2414 || type
== sat_unsigned_short_accum_type_node
)
2416 else if (type
== long_fract_type_node
2417 || type
== sat_long_fract_type_node
2418 || type
== long_accum_type_node
2419 || type
== sat_long_accum_type_node
)
2421 else if (type
== unsigned_long_fract_type_node
2422 || type
== sat_unsigned_long_fract_type_node
2423 || type
== unsigned_long_accum_type_node
2424 || type
== sat_unsigned_long_accum_type_node
)
2426 else if (type
== long_long_fract_type_node
2427 || type
== sat_long_long_fract_type_node
2428 || type
== long_long_accum_type_node
2429 || type
== sat_long_long_accum_type_node
)
2431 else if (type
== unsigned_long_long_fract_type_node
2432 || type
== sat_unsigned_long_long_fract_type_node
2433 || type
== unsigned_long_long_accum_type_node
2434 || type
== sat_unsigned_long_long_accum_type_node
)
2437 sorry ("mangling unknown fixed point type");
2438 write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type
)));
2439 if (TYPE_SATURATING (type
))
2450 /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
2451 METHOD_TYPE. The return type is mangled before the parameter
2454 <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E */
2457 write_function_type (const tree type
)
2459 MANGLE_TRACE_TREE ("function-type", type
);
2461 /* For a pointer to member function, the function type may have
2462 cv-qualifiers, indicating the quals for the artificial 'this'
2464 if (TREE_CODE (type
) == METHOD_TYPE
)
2466 /* The first parameter must be a POINTER_TYPE pointing to the
2467 `this' parameter. */
2468 tree this_type
= class_of_this_parm (type
);
2469 write_CV_qualifiers_for_type (this_type
);
2472 if (tx_safe_fn_type_p (type
))
2473 write_string ("Dx");
2476 /* We don't track whether or not a type is `extern "C"'. Note that
2477 you can have an `extern "C"' function that does not have
2478 `extern "C"' type, and vice versa:
2480 extern "C" typedef void function_t();
2481 function_t f; // f has C++ linkage, but its type is
2484 typedef void function_t();
2485 extern "C" function_t f; // Vice versa.
2488 write_bare_function_type (type
, /*include_return_type_p=*/1,
2490 if (FUNCTION_REF_QUALIFIED (type
))
2492 if (FUNCTION_RVALUE_QUALIFIED (type
))
2500 /* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
2501 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
2502 is mangled before the parameter types. If non-NULL, DECL is
2503 FUNCTION_DECL for the function whose type is being emitted.
2505 If DECL is a member of a Java type, then a literal 'J'
2506 is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2509 <bare-function-type> ::= [J]</signature/ type>+ */
2512 write_bare_function_type (const tree type
, const int include_return_type_p
,
2517 MANGLE_TRACE_TREE ("bare-function-type", type
);
2519 /* Detect Java methods and emit special encoding. */
2521 && DECL_FUNCTION_MEMBER_P (decl
)
2522 && TYPE_FOR_JAVA (DECL_CONTEXT (decl
))
2523 && !DECL_CONSTRUCTOR_P (decl
)
2524 && !DECL_DESTRUCTOR_P (decl
)
2525 && !DECL_CONV_FN_P (decl
))
2535 /* Mangle the return type, if requested. */
2536 if (include_return_type_p
|| java_method_p
)
2537 write_type (TREE_TYPE (type
));
2539 /* Now mangle the types of the arguments. */
2541 write_method_parms (TYPE_ARG_TYPES (type
),
2542 TREE_CODE (type
) == METHOD_TYPE
,
2547 /* Write the mangled representation of a method parameter list of
2548 types given in PARM_TYPES. If METHOD_P is nonzero, the function is
2549 considered a non-static method, and the this parameter is omitted.
2550 If non-NULL, DECL is the FUNCTION_DECL for the function whose
2551 parameters are being emitted. */
2554 write_method_parms (tree parm_types
, const int method_p
, const tree decl
)
2556 tree first_parm_type
;
2557 tree parm_decl
= decl
? DECL_ARGUMENTS (decl
) : NULL_TREE
;
2559 /* Assume this parameter type list is variable-length. If it ends
2560 with a void type, then it's not. */
2563 /* If this is a member function, skip the first arg, which is the
2565 "Member functions do not encode the type of their implicit this
2568 Similarly, there's no need to mangle artificial parameters, like
2569 the VTT parameters for constructors and destructors. */
2572 parm_types
= TREE_CHAIN (parm_types
);
2573 parm_decl
= parm_decl
? DECL_CHAIN (parm_decl
) : NULL_TREE
;
2575 while (parm_decl
&& DECL_ARTIFICIAL (parm_decl
))
2577 parm_types
= TREE_CHAIN (parm_types
);
2578 parm_decl
= DECL_CHAIN (parm_decl
);
2582 for (first_parm_type
= parm_types
;
2584 parm_types
= TREE_CHAIN (parm_types
))
2586 tree parm
= TREE_VALUE (parm_types
);
2587 if (parm
== void_type_node
)
2589 /* "Empty parameter lists, whether declared as () or
2590 conventionally as (void), are encoded with a void parameter
2592 if (parm_types
== first_parm_type
)
2594 /* If the parm list is terminated with a void type, it's
2597 /* A void type better be the last one. */
2598 gcc_assert (TREE_CHAIN (parm_types
) == NULL
);
2605 /* <builtin-type> ::= z # ellipsis */
2609 /* <class-enum-type> ::= <name> */
2612 write_class_enum_type (const tree type
)
2614 write_name (TYPE_NAME (type
), /*ignore_local_scope=*/0);
2617 /* Non-terminal <template-args>. ARGS is a TREE_VEC of template
2620 <template-args> ::= I <template-arg>* E */
2623 write_template_args (tree args
)
2628 MANGLE_TRACE_TREE ("template-args", args
);
2633 length
= TREE_VEC_LENGTH (args
);
2635 if (args
&& length
&& TREE_CODE (TREE_VEC_ELT (args
, 0)) == TREE_VEC
)
2637 /* We have nested template args. We want the innermost template
2639 args
= TREE_VEC_ELT (args
, length
- 1);
2640 length
= TREE_VEC_LENGTH (args
);
2642 for (i
= 0; i
< length
; ++i
)
2643 write_template_arg (TREE_VEC_ELT (args
, i
));
2650 <unqualified-name> <template-args>
2651 part of SCOPE_REF or COMPONENT_REF mangling. */
2654 write_member_name (tree member
)
2656 if (identifier_p (member
))
2657 write_unqualified_id (member
);
2658 else if (DECL_P (member
))
2659 write_unqualified_name (member
);
2660 else if (TREE_CODE (member
) == TEMPLATE_ID_EXPR
)
2662 tree name
= TREE_OPERAND (member
, 0);
2663 if (TREE_CODE (name
) == OVERLOAD
)
2664 name
= OVL_FUNCTION (name
);
2665 write_member_name (name
);
2666 write_template_args (TREE_OPERAND (member
, 1));
2669 write_expression (member
);
2672 /* <expression> ::= <unary operator-name> <expression>
2673 ::= <binary operator-name> <expression> <expression>
2676 <expr-primary> ::= <template-param>
2677 ::= L <type> <value number> E # literal
2678 ::= L <mangled-name> E # external name
2679 ::= st <type> # sizeof
2680 ::= sr <type> <unqualified-name> # dependent name
2681 ::= sr <type> <unqualified-name> <template-args> */
2684 write_expression (tree expr
)
2686 enum tree_code code
= TREE_CODE (expr
);
2688 /* Skip NOP_EXPRs. They can occur when (say) a pointer argument
2689 is converted (via qualification conversions) to another
2691 while (TREE_CODE (expr
) == NOP_EXPR
2692 /* Parentheses aren't mangled. */
2693 || code
== PAREN_EXPR
2694 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
2696 expr
= TREE_OPERAND (expr
, 0);
2697 code
= TREE_CODE (expr
);
2700 if (code
== BASELINK
2701 && (!type_unknown_p (expr
)
2702 || !BASELINK_QUALIFIED_P (expr
)))
2704 expr
= BASELINK_FUNCTIONS (expr
);
2705 code
= TREE_CODE (expr
);
2708 /* Handle pointers-to-members by making them look like expression
2710 if (code
== PTRMEM_CST
)
2712 expr
= build_nt (ADDR_EXPR
,
2713 build_qualified_name (/*type=*/NULL_TREE
,
2714 PTRMEM_CST_CLASS (expr
),
2715 PTRMEM_CST_MEMBER (expr
),
2716 /*template_p=*/false));
2717 code
= TREE_CODE (expr
);
2720 /* Handle template parameters. */
2721 if (code
== TEMPLATE_TYPE_PARM
2722 || code
== TEMPLATE_TEMPLATE_PARM
2723 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
2724 || code
== TEMPLATE_PARM_INDEX
)
2725 write_template_param (expr
);
2726 /* Handle literals. */
2727 else if (TREE_CODE_CLASS (code
) == tcc_constant
2728 || code
== CONST_DECL
)
2729 write_template_arg_literal (expr
);
2730 else if (code
== PARM_DECL
&& DECL_ARTIFICIAL (expr
))
2732 gcc_assert (!strcmp ("this", IDENTIFIER_POINTER (DECL_NAME (expr
))));
2733 write_string ("fpT");
2735 else if (code
== PARM_DECL
)
2737 /* A function parameter used in a late-specified return type. */
2738 int index
= DECL_PARM_INDEX (expr
);
2739 int level
= DECL_PARM_LEVEL (expr
);
2740 int delta
= G
.parm_depth
- level
+ 1;
2741 gcc_assert (index
>= 1);
2745 if (abi_version_at_least (5))
2747 /* Let L be the number of function prototype scopes from the
2748 innermost one (in which the parameter reference occurs) up
2749 to (and including) the one containing the declaration of
2750 the referenced parameter. If the parameter declaration
2751 clause of the innermost function prototype scope has been
2752 completely seen, it is not counted (in that case -- which
2753 is perhaps the most common -- L can be zero). */
2755 write_unsigned_number (delta
- 1);
2757 if (abi_warn_or_compat_version_crosses (5))
2758 G
.need_abi_warning
= true;
2761 write_compact_number (index
- 1);
2763 else if (DECL_P (expr
))
2766 write_mangled_name (expr
, false);
2769 else if (TREE_CODE (expr
) == SIZEOF_EXPR
2770 && SIZEOF_EXPR_TYPE_P (expr
))
2772 write_string ("st");
2773 write_type (TREE_TYPE (TREE_OPERAND (expr
, 0)));
2775 else if (TREE_CODE (expr
) == SIZEOF_EXPR
2776 && TYPE_P (TREE_OPERAND (expr
, 0)))
2778 write_string ("st");
2779 write_type (TREE_OPERAND (expr
, 0));
2781 else if (TREE_CODE (expr
) == ALIGNOF_EXPR
2782 && TYPE_P (TREE_OPERAND (expr
, 0)))
2784 write_string ("at");
2785 write_type (TREE_OPERAND (expr
, 0));
2787 else if (code
== SCOPE_REF
2788 || code
== BASELINK
)
2791 if (code
== SCOPE_REF
)
2793 scope
= TREE_OPERAND (expr
, 0);
2794 member
= TREE_OPERAND (expr
, 1);
2798 scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (expr
));
2799 member
= BASELINK_FUNCTIONS (expr
);
2802 /* If the MEMBER is a real declaration, then the qualifying
2803 scope was not dependent. Ideally, we would not have a
2804 SCOPE_REF in those cases, but sometimes we do. If the second
2805 argument is a DECL, then the name must not have been
2807 if (DECL_P (member
))
2808 write_expression (member
);
2811 write_string ("sr");
2813 write_member_name (member
);
2816 else if (INDIRECT_REF_P (expr
)
2817 && TREE_TYPE (TREE_OPERAND (expr
, 0))
2818 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2820 write_expression (TREE_OPERAND (expr
, 0));
2822 else if (identifier_p (expr
))
2824 /* An operator name appearing as a dependent name needs to be
2825 specially marked to disambiguate between a use of the operator
2826 name and a use of the operator in an expression. */
2827 if (IDENTIFIER_OPNAME_P (expr
))
2828 write_string ("on");
2829 write_unqualified_id (expr
);
2831 else if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
2833 tree fn
= TREE_OPERAND (expr
, 0);
2834 if (is_overloaded_fn (fn
))
2835 fn
= get_first_fn (fn
);
2837 fn
= DECL_NAME (fn
);
2838 if (IDENTIFIER_OPNAME_P (fn
))
2839 write_string ("on");
2840 write_unqualified_id (fn
);
2841 write_template_args (TREE_OPERAND (expr
, 1));
2843 else if (TREE_CODE (expr
) == MODOP_EXPR
)
2845 enum tree_code subop
= TREE_CODE (TREE_OPERAND (expr
, 1));
2846 const char *name
= (assignment_operator_name_info
[(int) subop
]
2848 write_string (name
);
2849 write_expression (TREE_OPERAND (expr
, 0));
2850 write_expression (TREE_OPERAND (expr
, 2));
2852 else if (code
== NEW_EXPR
|| code
== VEC_NEW_EXPR
)
2854 /* ::= [gs] nw <expression>* _ <type> E
2855 ::= [gs] nw <expression>* _ <type> <initializer>
2856 ::= [gs] na <expression>* _ <type> E
2857 ::= [gs] na <expression>* _ <type> <initializer>
2858 <initializer> ::= pi <expression>* E */
2859 tree placement
= TREE_OPERAND (expr
, 0);
2860 tree type
= TREE_OPERAND (expr
, 1);
2861 tree nelts
= TREE_OPERAND (expr
, 2);
2862 tree init
= TREE_OPERAND (expr
, 3);
2865 gcc_assert (code
== NEW_EXPR
);
2866 if (TREE_OPERAND (expr
, 2))
2867 code
= VEC_NEW_EXPR
;
2869 if (NEW_EXPR_USE_GLOBAL (expr
))
2870 write_string ("gs");
2872 write_string (operator_name_info
[(int) code
].mangled_name
);
2874 for (t
= placement
; t
; t
= TREE_CHAIN (t
))
2875 write_expression (TREE_VALUE (t
));
2882 ++processing_template_decl
;
2883 domain
= compute_array_index_type (NULL_TREE
, nelts
,
2884 tf_warning_or_error
);
2885 type
= build_cplus_array_type (type
, domain
);
2886 --processing_template_decl
;
2890 if (init
&& TREE_CODE (init
) == TREE_LIST
2891 && DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
2892 write_expression (TREE_VALUE (init
));
2896 write_string ("pi");
2897 if (init
&& init
!= void_node
)
2898 for (t
= init
; t
; t
= TREE_CHAIN (t
))
2899 write_expression (TREE_VALUE (t
));
2903 else if (code
== DELETE_EXPR
|| code
== VEC_DELETE_EXPR
)
2905 gcc_assert (code
== DELETE_EXPR
);
2906 if (DELETE_EXPR_USE_VEC (expr
))
2907 code
= VEC_DELETE_EXPR
;
2909 if (DELETE_EXPR_USE_GLOBAL (expr
))
2910 write_string ("gs");
2912 write_string (operator_name_info
[(int) code
].mangled_name
);
2914 write_expression (TREE_OPERAND (expr
, 0));
2916 else if (code
== THROW_EXPR
)
2918 tree op
= TREE_OPERAND (expr
, 0);
2921 write_string ("tw");
2922 write_expression (op
);
2925 write_string ("tr");
2927 else if (code
== CONSTRUCTOR
)
2929 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (expr
);
2930 unsigned i
; tree val
;
2932 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
2933 write_string ("il");
2936 write_string ("tl");
2937 write_type (TREE_TYPE (expr
));
2939 FOR_EACH_CONSTRUCTOR_VALUE (elts
, i
, val
)
2940 write_expression (val
);
2943 else if (dependent_name (expr
))
2945 write_unqualified_id (dependent_name (expr
));
2952 /* When we bind a variable or function to a non-type template
2953 argument with reference type, we create an ADDR_EXPR to show
2954 the fact that the entity's address has been taken. But, we
2955 don't actually want to output a mangling code for the `&'. */
2956 if (TREE_CODE (expr
) == ADDR_EXPR
2958 && TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
)
2960 expr
= TREE_OPERAND (expr
, 0);
2963 write_expression (expr
);
2967 code
= TREE_CODE (expr
);
2970 if (code
== COMPONENT_REF
)
2972 tree ob
= TREE_OPERAND (expr
, 0);
2974 if (TREE_CODE (ob
) == ARROW_EXPR
)
2976 write_string (operator_name_info
[(int)code
].mangled_name
);
2977 ob
= TREE_OPERAND (ob
, 0);
2978 write_expression (ob
);
2980 else if (!is_dummy_object (ob
))
2982 write_string ("dt");
2983 write_expression (ob
);
2985 /* else, for a non-static data member with no associated object (in
2986 unevaluated context), use the unresolved-name mangling. */
2988 write_member_name (TREE_OPERAND (expr
, 1));
2992 /* If it wasn't any of those, recursively expand the expression. */
2993 name
= operator_name_info
[(int) code
].mangled_name
;
2995 /* We used to mangle const_cast and static_cast like a C cast. */
2996 if (code
== CONST_CAST_EXPR
2997 || code
== STATIC_CAST_EXPR
)
2999 if (abi_warn_or_compat_version_crosses (6))
3000 G
.need_abi_warning
= 1;
3001 if (!abi_version_at_least (6))
3002 name
= operator_name_info
[CAST_EXPR
].mangled_name
;
3010 error ("use of built-in trait %qE in function signature; "
3011 "use library traits instead", expr
);
3015 sorry ("mangling %C", code
);
3021 write_string (name
);
3027 tree fn
= CALL_EXPR_FN (expr
);
3029 if (TREE_CODE (fn
) == ADDR_EXPR
)
3030 fn
= TREE_OPERAND (fn
, 0);
3032 /* Mangle a dependent name as the name, not whatever happens to
3033 be the first function in the overload set. */
3034 if ((TREE_CODE (fn
) == FUNCTION_DECL
3035 || TREE_CODE (fn
) == OVERLOAD
)
3036 && type_dependent_expression_p_push (expr
))
3037 fn
= DECL_NAME (get_first_fn (fn
));
3039 write_expression (fn
);
3042 for (i
= 0; i
< call_expr_nargs (expr
); ++i
)
3043 write_expression (CALL_EXPR_ARG (expr
, i
));
3048 write_type (TREE_TYPE (expr
));
3049 if (list_length (TREE_OPERAND (expr
, 0)) == 1)
3050 write_expression (TREE_VALUE (TREE_OPERAND (expr
, 0)));
3053 tree args
= TREE_OPERAND (expr
, 0);
3055 for (; args
; args
= TREE_CHAIN (args
))
3056 write_expression (TREE_VALUE (args
));
3061 case DYNAMIC_CAST_EXPR
:
3062 case REINTERPRET_CAST_EXPR
:
3063 case STATIC_CAST_EXPR
:
3064 case CONST_CAST_EXPR
:
3065 write_type (TREE_TYPE (expr
));
3066 write_expression (TREE_OPERAND (expr
, 0));
3069 case PREINCREMENT_EXPR
:
3070 case PREDECREMENT_EXPR
:
3071 if (abi_version_at_least (6))
3073 if (abi_warn_or_compat_version_crosses (6))
3074 G
.need_abi_warning
= 1;
3078 /* In the middle-end, some expressions have more operands than
3079 they do in templates (and mangling). */
3080 len
= cp_tree_operand_length (expr
);
3082 for (i
= 0; i
< len
; ++i
)
3084 tree operand
= TREE_OPERAND (expr
, i
);
3085 /* As a GNU extension, the middle operand of a
3086 conditional may be omitted. Since expression
3087 manglings are supposed to represent the input token
3088 stream, there's no good way to mangle such an
3089 expression without extending the C++ ABI. */
3090 if (code
== COND_EXPR
&& i
== 1 && !operand
)
3092 error ("omitted middle operand to %<?:%> operand "
3093 "cannot be mangled");
3096 write_expression (operand
);
3102 /* Literal subcase of non-terminal <template-arg>.
3104 "Literal arguments, e.g. "A<42L>", are encoded with their type
3105 and value. Negative integer values are preceded with "n"; for
3106 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
3107 encoded as 0, true as 1." */
3110 write_template_arg_literal (const tree value
)
3113 write_type (TREE_TYPE (value
));
3115 /* Write a null member pointer value as (type)0, regardless of its
3116 real representation. */
3117 if (null_member_pointer_value_p (value
))
3118 write_integer_cst (integer_zero_node
);
3120 switch (TREE_CODE (value
))
3123 write_integer_cst (DECL_INITIAL (value
));
3127 gcc_assert (!same_type_p (TREE_TYPE (value
), boolean_type_node
)
3128 || integer_zerop (value
) || integer_onep (value
));
3129 write_integer_cst (value
);
3133 write_real_cst (value
);
3137 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
3138 && TREE_CODE (TREE_IMAGPART (value
)) == INTEGER_CST
)
3140 write_integer_cst (TREE_REALPART (value
));
3142 write_integer_cst (TREE_IMAGPART (value
));
3144 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
3145 && TREE_CODE (TREE_IMAGPART (value
)) == REAL_CST
)
3147 write_real_cst (TREE_REALPART (value
));
3149 write_real_cst (TREE_IMAGPART (value
));
3156 sorry ("string literal in function template signature");
3166 /* Non-terminal <template-arg>.
3168 <template-arg> ::= <type> # type
3169 ::= L <type> </value/ number> E # literal
3170 ::= LZ <name> E # external name
3171 ::= X <expression> E # expression */
3174 write_template_arg (tree node
)
3176 enum tree_code code
= TREE_CODE (node
);
3178 MANGLE_TRACE_TREE ("template-arg", node
);
3180 /* A template template parameter's argument list contains TREE_LIST
3181 nodes of which the value field is the actual argument. */
3182 if (code
== TREE_LIST
)
3184 node
= TREE_VALUE (node
);
3185 /* If it's a decl, deal with its type instead. */
3188 node
= TREE_TYPE (node
);
3189 code
= TREE_CODE (node
);
3193 if (REFERENCE_REF_P (node
))
3194 node
= TREE_OPERAND (node
, 0);
3195 if (TREE_CODE (node
) == NOP_EXPR
3196 && TREE_CODE (TREE_TYPE (node
)) == REFERENCE_TYPE
)
3198 /* Template parameters can be of reference type. To maintain
3199 internal consistency, such arguments use a conversion from
3200 address of object to reference type. */
3201 gcc_assert (TREE_CODE (TREE_OPERAND (node
, 0)) == ADDR_EXPR
);
3202 node
= TREE_OPERAND (TREE_OPERAND (node
, 0), 0);
3205 if (TREE_CODE (node
) == BASELINK
3206 && !type_unknown_p (node
))
3208 if (abi_version_at_least (6))
3209 node
= BASELINK_FUNCTIONS (node
);
3210 if (abi_warn_or_compat_version_crosses (6))
3211 /* We wrongly wrapped a class-scope function in X/E. */
3212 G
.need_abi_warning
= 1;
3215 if (ARGUMENT_PACK_P (node
))
3217 /* Expand the template argument pack. */
3218 tree args
= ARGUMENT_PACK_ARGS (node
);
3219 int i
, length
= TREE_VEC_LENGTH (args
);
3220 if (abi_version_at_least (6))
3224 if (abi_warn_or_compat_version_crosses (6))
3225 G
.need_abi_warning
= 1;
3226 for (i
= 0; i
< length
; ++i
)
3227 write_template_arg (TREE_VEC_ELT (args
, i
));
3230 else if (TYPE_P (node
))
3232 else if (code
== TEMPLATE_DECL
)
3233 /* A template appearing as a template arg is a template template arg. */
3234 write_template_template_arg (node
);
3235 else if ((TREE_CODE_CLASS (code
) == tcc_constant
&& code
!= PTRMEM_CST
)
3236 || code
== CONST_DECL
3237 || null_member_pointer_value_p (node
))
3238 write_template_arg_literal (node
);
3239 else if (DECL_P (node
))
3242 /* Until ABI version 3, the underscore before the mangled name
3243 was incorrectly omitted. */
3244 if (!abi_version_at_least (3))
3247 write_string ("_Z");
3248 if (abi_warn_or_compat_version_crosses (3))
3249 G
.need_abi_warning
= 1;
3250 write_encoding (node
);
3255 /* Template arguments may be expressions. */
3257 write_expression (node
);
3262 /* <template-template-arg>
3264 ::= <substitution> */
3267 write_template_template_arg (const tree decl
)
3269 MANGLE_TRACE_TREE ("template-template-arg", decl
);
3271 if (find_substitution (decl
))
3273 write_name (decl
, /*ignore_local_scope=*/0);
3274 add_substitution (decl
);
3278 /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
3280 <array-type> ::= A [</dimension/ number>] _ </element/ type>
3281 ::= A <expression> _ </element/ type>
3283 "Array types encode the dimension (number of elements) and the
3284 element type. For variable length arrays, the dimension (but not
3285 the '_' separator) is omitted."
3286 Note that for flexible array members, like for other arrays of
3287 unspecified size, the dimension is also omitted. */
3290 write_array_type (const tree type
)
3293 if (TYPE_DOMAIN (type
))
3297 index_type
= TYPE_DOMAIN (type
);
3298 /* The INDEX_TYPE gives the upper and lower bounds of the array.
3299 It's null for flexible array members which have no upper bound
3300 (this is a change from GCC 5 and prior where such members were
3301 incorrectly mangled as zero-length arrays). */
3302 if (tree max
= TYPE_MAX_VALUE (index_type
))
3304 if (TREE_CODE (max
) == INTEGER_CST
)
3306 /* The ABI specifies that we should mangle the number of
3307 elements in the array, not the largest allowed index. */
3308 offset_int wmax
= wi::to_offset (max
) + 1;
3309 /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
3310 number of elements as zero. */
3311 wmax
= wi::zext (wmax
, TYPE_PRECISION (TREE_TYPE (max
)));
3312 gcc_assert (wi::fits_uhwi_p (wmax
));
3313 write_unsigned_number (wmax
.to_uhwi ());
3317 max
= TREE_OPERAND (max
, 0);
3318 write_expression (max
);
3323 write_type (TREE_TYPE (type
));
3326 /* Non-terminal <pointer-to-member-type> for pointer-to-member
3327 variables. TYPE is a pointer-to-member POINTER_TYPE.
3329 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
3332 write_pointer_to_member_type (const tree type
)
3335 write_type (TYPE_PTRMEM_CLASS_TYPE (type
));
3336 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type
));
3339 /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
3340 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3341 TEMPLATE_PARM_INDEX.
3343 <template-param> ::= T </parameter/ number> _ */
3346 write_template_param (const tree parm
)
3350 MANGLE_TRACE_TREE ("template-parm", parm
);
3352 switch (TREE_CODE (parm
))
3354 case TEMPLATE_TYPE_PARM
:
3355 case TEMPLATE_TEMPLATE_PARM
:
3356 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3357 parm_index
= TEMPLATE_TYPE_IDX (parm
);
3360 case TEMPLATE_PARM_INDEX
:
3361 parm_index
= TEMPLATE_PARM_IDX (parm
);
3369 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3370 earliest template param denoted by `_'. */
3371 write_compact_number (parm_index
);
3374 /* <template-template-param>
3375 ::= <template-param>
3376 ::= <substitution> */
3379 write_template_template_param (const tree parm
)
3381 tree templ
= NULL_TREE
;
3383 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3384 template template parameter. The substitution candidate here is
3385 only the template. */
3386 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
3389 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
));
3390 if (find_substitution (templ
))
3394 /* <template-param> encodes only the template parameter position,
3395 not its template arguments, which is fine here. */
3396 write_template_param (parm
);
3398 add_substitution (templ
);
3401 /* Non-terminal <substitution>.
3403 <substitution> ::= S <seq-id> _
3407 write_substitution (const int seq_id
)
3409 MANGLE_TRACE ("substitution", "");
3413 write_number (seq_id
- 1, /*unsigned=*/1, 36);
3417 /* Start mangling ENTITY. */
3420 start_mangling (const tree entity
)
3423 G
.need_abi_warning
= false;
3424 obstack_free (&name_obstack
, name_base
);
3425 mangle_obstack
= &name_obstack
;
3426 name_base
= obstack_alloc (&name_obstack
, 0);
3429 /* Done with mangling. If WARN is true, and the name of G.entity will
3430 be mangled differently in a future version of the ABI, issue a
3434 finish_mangling_internal (void)
3436 /* Clear all the substitutions. */
3437 vec_safe_truncate (G
.substitutions
, 0);
3439 /* Null-terminate the string. */
3444 /* Like finish_mangling_internal, but return the mangled string. */
3446 static inline const char *
3447 finish_mangling (void)
3449 finish_mangling_internal ();
3450 return (const char *) obstack_finish (mangle_obstack
);
3453 /* Like finish_mangling_internal, but return an identifier. */
3456 finish_mangling_get_identifier (void)
3458 finish_mangling_internal ();
3459 /* Don't obstack_finish here, and the next start_mangling will
3460 remove the identifier. */
3461 return get_identifier ((const char *) obstack_base (mangle_obstack
));
3464 /* Initialize data structures for mangling. */
3469 gcc_obstack_init (&name_obstack
);
3470 name_base
= obstack_alloc (&name_obstack
, 0);
3471 vec_alloc (G
.substitutions
, 0);
3473 /* Cache these identifiers for quick comparison when checking for
3474 standard substitutions. */
3475 subst_identifiers
[SUBID_ALLOCATOR
] = get_identifier ("allocator");
3476 subst_identifiers
[SUBID_BASIC_STRING
] = get_identifier ("basic_string");
3477 subst_identifiers
[SUBID_CHAR_TRAITS
] = get_identifier ("char_traits");
3478 subst_identifiers
[SUBID_BASIC_ISTREAM
] = get_identifier ("basic_istream");
3479 subst_identifiers
[SUBID_BASIC_OSTREAM
] = get_identifier ("basic_ostream");
3480 subst_identifiers
[SUBID_BASIC_IOSTREAM
] = get_identifier ("basic_iostream");
3483 /* Generate the mangled name of DECL. */
3486 mangle_decl_string (const tree decl
)
3489 location_t saved_loc
= input_location
;
3490 tree saved_fn
= NULL_TREE
;
3491 bool template_p
= false;
3493 /* We shouldn't be trying to mangle an uninstantiated template. */
3494 gcc_assert (!type_dependent_expression_p (decl
));
3496 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
3498 struct tinst_level
*tl
= current_instantiation ();
3499 if ((!tl
|| tl
->decl
!= decl
)
3500 && push_tinst_level (decl
))
3503 saved_fn
= current_function_decl
;
3504 current_function_decl
= NULL_TREE
;
3507 input_location
= DECL_SOURCE_LOCATION (decl
);
3509 start_mangling (decl
);
3511 if (TREE_CODE (decl
) == TYPE_DECL
)
3512 write_type (TREE_TYPE (decl
));
3514 write_mangled_name (decl
, true);
3516 result
= finish_mangling_get_identifier ();
3518 fprintf (stderr
, "mangle_decl_string = '%s'\n\n",
3519 IDENTIFIER_POINTER (result
));
3524 current_function_decl
= saved_fn
;
3526 input_location
= saved_loc
;
3531 /* Return an identifier for the external mangled name of DECL. */
3534 get_mangled_id (tree decl
)
3536 tree id
= mangle_decl_string (decl
);
3537 return targetm
.mangle_decl_assembler_name (decl
, id
);
3540 /* If DECL is an implicit mangling alias, return its symtab node; otherwise
3543 static symtab_node
*
3544 decl_implicit_alias_p (tree decl
)
3546 if (DECL_P (decl
) && DECL_ARTIFICIAL (decl
)
3547 && DECL_IGNORED_P (decl
)
3548 && (TREE_CODE (decl
) == FUNCTION_DECL
3549 || (VAR_P (decl
) && TREE_STATIC (decl
))))
3551 symtab_node
*n
= symtab_node::get (decl
);
3552 if (n
&& n
->cpp_implicit_alias
)
3558 /* If DECL is a mangling alias, remove it from the symbol table and return
3559 true; otherwise return false. */
3562 maybe_remove_implicit_alias (tree decl
)
3564 if (symtab_node
*n
= decl_implicit_alias_p (decl
))
3572 /* Create an identifier for the external mangled name of DECL. */
3575 mangle_decl (const tree decl
)
3580 /* Don't bother mangling uninstantiated templates. */
3581 ++processing_template_decl
;
3582 if (TREE_CODE (decl
) == TYPE_DECL
)
3583 dep
= dependent_type_p (TREE_TYPE (decl
));
3585 dep
= (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
3586 && any_dependent_template_arguments_p (DECL_TI_ARGS (decl
)));
3587 --processing_template_decl
;
3591 /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
3592 It is not needed to assign names to anonymous namespace, but we use the
3593 "<anon>" marker to be able to tell if type is C++ ODR type or type
3594 produced by other language. */
3595 if (TREE_CODE (decl
) == TYPE_DECL
3596 && TYPE_STUB_DECL (TREE_TYPE (decl
))
3597 && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl
))))
3598 id
= get_identifier ("<anon>");
3601 gcc_assert (TREE_CODE (decl
) != TYPE_DECL
3602 || !no_linkage_check (TREE_TYPE (decl
), true));
3603 if (abi_version_at_least (10))
3604 if (tree fn
= decl_function_context (decl
))
3605 maybe_check_abi_tags (fn
, decl
);
3606 id
= get_mangled_id (decl
);
3608 SET_DECL_ASSEMBLER_NAME (decl
, id
);
3610 if (id
!= DECL_NAME (decl
)
3611 && !DECL_REALLY_EXTERN (decl
)
3612 /* Don't do this for a fake symbol we aren't going to emit anyway. */
3613 && TREE_CODE (decl
) != TYPE_DECL
3614 && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
)
3615 && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
3619 /* Check IDENTIFIER_GLOBAL_VALUE before setting to avoid redundant
3620 errors from multiple definitions. */
3621 tree d
= IDENTIFIER_GLOBAL_VALUE (id
);
3622 if (!d
|| decl_implicit_alias_p (d
))
3625 SET_IDENTIFIER_GLOBAL_VALUE (id
, decl
);
3628 if (!G
.need_abi_warning
)
3631 /* If the mangling will change in the future, emit an alias with the
3632 future mangled name for forward-compatibility. */
3638 SET_IDENTIFIER_GLOBAL_VALUE (id
, decl
);
3639 inform (DECL_SOURCE_LOCATION (decl
), "a later -fabi-version= (or "
3640 "=0) avoids this error with a change in mangling");
3643 save_ver
= flag_abi_version
;
3645 flag_abi_version
= flag_abi_compat_version
;
3646 id2
= mangle_decl_string (decl
);
3647 id2
= targetm
.mangle_decl_assembler_name (decl
, id2
);
3650 note_mangling_alias (decl
, id2
);
3654 if (flag_abi_compat_version
!= warn_abi_version
)
3656 flag_abi_version
= warn_abi_version
;
3657 id2
= mangle_decl_string (decl
);
3658 id2
= targetm
.mangle_decl_assembler_name (decl
, id2
);
3663 else if (warn_abi_version
!= 0
3664 && abi_version_at_least (warn_abi_version
))
3665 warning_at (DECL_SOURCE_LOCATION (G
.entity
), OPT_Wabi
,
3666 "the mangled name of %qD changed between "
3667 "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3668 G
.entity
, save_ver
, id2
,
3669 warn_abi_version
, id
);
3671 warning_at (DECL_SOURCE_LOCATION (G
.entity
), OPT_Wabi
,
3672 "the mangled name of %qD changes between "
3673 "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3674 G
.entity
, save_ver
, id
,
3675 warn_abi_version
, id2
);
3678 flag_abi_version
= save_ver
;
3682 /* Generate the mangled representation of TYPE. */
3685 mangle_type_string (const tree type
)
3689 start_mangling (type
);
3691 result
= finish_mangling ();
3693 fprintf (stderr
, "mangle_type_string = '%s'\n\n", result
);
3697 /* Create an identifier for the mangled name of a special component
3698 for belonging to TYPE. CODE is the ABI-specified code for this
3702 mangle_special_for_type (const tree type
, const char *code
)
3706 /* We don't have an actual decl here for the special component, so
3707 we can't just process the <encoded-name>. Instead, fake it. */
3708 start_mangling (type
);
3710 /* Start the mangling. */
3711 write_string ("_Z");
3712 write_string (code
);
3716 result
= finish_mangling_get_identifier ();
3719 fprintf (stderr
, "mangle_special_for_type = %s\n\n",
3720 IDENTIFIER_POINTER (result
));
3725 /* Create an identifier for the mangled representation of the typeinfo
3726 structure for TYPE. */
3729 mangle_typeinfo_for_type (const tree type
)
3731 return mangle_special_for_type (type
, "TI");
3734 /* Create an identifier for the mangled name of the NTBS containing
3735 the mangled name of TYPE. */
3738 mangle_typeinfo_string_for_type (const tree type
)
3740 return mangle_special_for_type (type
, "TS");
3743 /* Create an identifier for the mangled name of the vtable for TYPE. */
3746 mangle_vtbl_for_type (const tree type
)
3748 return mangle_special_for_type (type
, "TV");
3751 /* Returns an identifier for the mangled name of the VTT for TYPE. */
3754 mangle_vtt_for_type (const tree type
)
3756 return mangle_special_for_type (type
, "TT");
3759 /* Return an identifier for a construction vtable group. TYPE is
3760 the most derived class in the hierarchy; BINFO is the base
3761 subobject for which this construction vtable group will be used.
3763 This mangling isn't part of the ABI specification; in the ABI
3764 specification, the vtable group is dumped in the same COMDAT as the
3765 main vtable, and is referenced only from that vtable, so it doesn't
3766 need an external name. For binary formats without COMDAT sections,
3767 though, we need external names for the vtable groups.
3769 We use the production
3771 <special-name> ::= CT <type> <offset number> _ <base type> */
3774 mangle_ctor_vtbl_for_type (const tree type
, const tree binfo
)
3778 start_mangling (type
);
3780 write_string ("_Z");
3781 write_string ("TC");
3783 write_integer_cst (BINFO_OFFSET (binfo
));
3785 write_type (BINFO_TYPE (binfo
));
3787 result
= finish_mangling_get_identifier ();
3789 fprintf (stderr
, "mangle_ctor_vtbl_for_type = %s\n\n",
3790 IDENTIFIER_POINTER (result
));
3794 /* Mangle a this pointer or result pointer adjustment.
3796 <call-offset> ::= h <fixed offset number> _
3797 ::= v <fixed offset number> _ <virtual offset number> _ */
3800 mangle_call_offset (const tree fixed_offset
, const tree virtual_offset
)
3802 write_char (virtual_offset
? 'v' : 'h');
3804 /* For either flavor, write the fixed offset. */
3805 write_integer_cst (fixed_offset
);
3808 /* For a virtual thunk, add the virtual offset. */
3811 write_integer_cst (virtual_offset
);
3816 /* Return an identifier for the mangled name of a this-adjusting or
3817 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment
3818 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this
3819 is a virtual thunk, and it is the vtbl offset in
3820 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
3821 zero for a covariant thunk. Note, that FN_DECL might be a covariant
3822 thunk itself. A covariant thunk name always includes the adjustment
3823 for the this pointer, even if there is none.
3825 <special-name> ::= T <call-offset> <base encoding>
3826 ::= Tc <this_adjust call-offset> <result_adjust call-offset>
3830 mangle_thunk (tree fn_decl
, const int this_adjusting
, tree fixed_offset
,
3831 tree virtual_offset
)
3835 start_mangling (fn_decl
);
3837 write_string ("_Z");
3840 if (!this_adjusting
)
3842 /* Covariant thunk with no this adjustment */
3844 mangle_call_offset (integer_zero_node
, NULL_TREE
);
3845 mangle_call_offset (fixed_offset
, virtual_offset
);
3847 else if (!DECL_THUNK_P (fn_decl
))
3848 /* Plain this adjusting thunk. */
3849 mangle_call_offset (fixed_offset
, virtual_offset
);
3852 /* This adjusting thunk to covariant thunk. */
3854 mangle_call_offset (fixed_offset
, virtual_offset
);
3855 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn_decl
));
3856 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn_decl
);
3858 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
3859 mangle_call_offset (fixed_offset
, virtual_offset
);
3860 fn_decl
= THUNK_TARGET (fn_decl
);
3864 write_encoding (fn_decl
);
3866 result
= finish_mangling_get_identifier ();
3868 fprintf (stderr
, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result
));
3872 struct conv_type_hasher
: ggc_ptr_hash
<tree_node
>
3874 static hashval_t
hash (tree
);
3875 static bool equal (tree
, tree
);
3878 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3879 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
3882 static GTY (()) hash_table
<conv_type_hasher
> *conv_type_names
;
3884 /* Hash a node (VAL1) in the table. */
3887 conv_type_hasher::hash (tree val
)
3889 return (hashval_t
) TYPE_UID (TREE_TYPE (val
));
3892 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */
3895 conv_type_hasher::equal (tree val1
, tree val2
)
3897 return TREE_TYPE (val1
) == val2
;
3900 /* Return an identifier for the mangled unqualified name for a
3901 conversion operator to TYPE. This mangling is not specified by the
3902 ABI spec; it is only used internally. */
3905 mangle_conv_op_name_for_type (const tree type
)
3910 if (type
== error_mark_node
)
3911 return error_mark_node
;
3913 if (conv_type_names
== NULL
)
3914 conv_type_names
= hash_table
<conv_type_hasher
>::create_ggc (31);
3916 slot
= conv_type_names
->find_slot_with_hash (type
,
3917 (hashval_t
) TYPE_UID (type
),
3924 /* Create a unique name corresponding to TYPE. */
3925 sprintf (buffer
, "operator %lu",
3926 (unsigned long) conv_type_names
->elements ());
3927 identifier
= get_identifier (buffer
);
3930 /* Hang TYPE off the identifier so it can be found easily later
3931 when performing conversions. */
3932 TREE_TYPE (identifier
) = type
;
3934 /* Set bits on the identifier so we know later it's a conversion. */
3935 IDENTIFIER_OPNAME_P (identifier
) = 1;
3936 IDENTIFIER_TYPENAME_P (identifier
) = 1;
3942 /* Handle ABI backwards compatibility for past bugs where we didn't call
3943 check_abi_tags in places where it's needed: call check_abi_tags and warn if
3944 it makes a difference. If FOR_DECL is non-null, it's the declaration
3945 that we're actually trying to mangle; if it's null, we're mangling the
3946 guard variable for T. */
3949 maybe_check_abi_tags (tree t
, tree for_decl
)
3951 if (DECL_ASSEMBLER_NAME_SET_P (t
))
3954 tree attr
= lookup_attribute ("abi_tag", DECL_ATTRIBUTES (t
));
3955 tree oldtags
= NULL_TREE
;
3957 oldtags
= TREE_VALUE (attr
);
3962 attr
= lookup_attribute ("abi_tag", DECL_ATTRIBUTES (t
));
3963 if (attr
&& TREE_VALUE (attr
) != oldtags
3964 && abi_version_crosses (10))
3967 warning_at (DECL_SOURCE_LOCATION (for_decl
), OPT_Wabi
,
3968 "the mangled name of %qD changes between "
3969 "-fabi-version=%d and -fabi-version=%d",
3970 for_decl
, flag_abi_version
, warn_abi_version
);
3972 warning_at (DECL_SOURCE_LOCATION (t
), OPT_Wabi
,
3973 "the mangled name of the initialization guard variable for"
3974 "%qD changes between -fabi-version=%d and -fabi-version=%d",
3975 t
, flag_abi_version
, warn_abi_version
);
3979 /* Write out the appropriate string for this variable when generating
3980 another mangled name based on this one. */
3983 write_guarded_var_name (const tree variable
)
3985 if (DECL_NAME (variable
)
3986 && strncmp (IDENTIFIER_POINTER (DECL_NAME (variable
)), "_ZGR", 4) == 0)
3987 /* The name of a guard variable for a reference temporary should refer
3988 to the reference, not the temporary. */
3989 write_string (IDENTIFIER_POINTER (DECL_NAME (variable
)) + 4);
3991 write_name (variable
, /*ignore_local_scope=*/0);
3994 /* Return an identifier for the name of an initialization guard
3995 variable for indicated VARIABLE. */
3998 mangle_guard_variable (const tree variable
)
4000 if (abi_version_at_least (10))
4001 maybe_check_abi_tags (variable
);
4002 start_mangling (variable
);
4003 write_string ("_ZGV");
4004 write_guarded_var_name (variable
);
4005 return finish_mangling_get_identifier ();
4008 /* Return an identifier for the name of a thread_local initialization
4009 function for VARIABLE. */
4012 mangle_tls_init_fn (const tree variable
)
4014 start_mangling (variable
);
4015 write_string ("_ZTH");
4016 write_guarded_var_name (variable
);
4017 return finish_mangling_get_identifier ();
4020 /* Return an identifier for the name of a thread_local wrapper
4021 function for VARIABLE. */
4023 #define TLS_WRAPPER_PREFIX "_ZTW"
4026 mangle_tls_wrapper_fn (const tree variable
)
4028 start_mangling (variable
);
4029 write_string (TLS_WRAPPER_PREFIX
);
4030 write_guarded_var_name (variable
);
4031 return finish_mangling_get_identifier ();
4034 /* Return true iff FN is a thread_local wrapper function. */
4037 decl_tls_wrapper_p (const tree fn
)
4039 if (TREE_CODE (fn
) != FUNCTION_DECL
)
4041 tree name
= DECL_NAME (fn
);
4042 return strncmp (IDENTIFIER_POINTER (name
), TLS_WRAPPER_PREFIX
,
4043 strlen (TLS_WRAPPER_PREFIX
)) == 0;
4046 /* Return an identifier for the name of a temporary variable used to
4047 initialize a static reference. This isn't part of the ABI, but we might
4048 as well call them something readable. */
4050 static GTY(()) int temp_count
;
4053 mangle_ref_init_variable (const tree variable
)
4055 start_mangling (variable
);
4056 write_string ("_ZGR");
4057 check_abi_tags (variable
);
4058 write_name (variable
, /*ignore_local_scope=*/0);
4059 /* Avoid name clashes with aggregate initialization of multiple
4060 references at once. */
4061 write_unsigned_number (temp_count
++);
4062 return finish_mangling_get_identifier ();
4066 /* Foreign language type mangling section. */
4068 /* How to write the type codes for the integer Java type. */
4071 write_java_integer_type_codes (const tree type
)
4073 if (type
== java_int_type_node
)
4075 else if (type
== java_short_type_node
)
4077 else if (type
== java_byte_type_node
)
4079 else if (type
== java_char_type_node
)
4081 else if (type
== java_long_type_node
)
4083 else if (type
== java_boolean_type_node
)
4089 /* Given a CLASS_TYPE, such as a record for std::bad_exception this
4090 function generates a mangled name for the vtable map variable of
4091 the class type. For example, if the class type is
4092 "std::bad_exception", the mangled name for the class is
4093 "St13bad_exception". This function would generate the name
4094 "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
4095 "_VTV<std::bad_exception>::__vtable_map". */
4099 get_mangled_vtable_map_var_name (tree class_type
)
4101 char *var_name
= NULL
;
4102 const char *prefix
= "_ZN4_VTVI";
4103 const char *postfix
= "E12__vtable_mapE";
4105 gcc_assert (TREE_CODE (class_type
) == RECORD_TYPE
);
4107 tree class_id
= DECL_ASSEMBLER_NAME (TYPE_NAME (class_type
));
4109 if (strstr (IDENTIFIER_POINTER (class_id
), "<anon>") != NULL
)
4111 class_id
= get_mangled_id (TYPE_NAME (class_type
));
4112 vtbl_register_mangled_name (TYPE_NAME (class_type
), class_id
);
4115 unsigned int len
= strlen (IDENTIFIER_POINTER (class_id
)) +
4117 strlen (postfix
) + 1;
4119 var_name
= (char *) xmalloc (len
);
4121 sprintf (var_name
, "%s%s%s", prefix
, IDENTIFIER_POINTER (class_id
), postfix
);
4126 #include "gt-cp-mangle.h"