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