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
);
227 /* Control functions. */
229 static inline void start_mangling (const tree
);
230 static tree
mangle_special_for_type (const tree
, const char *);
232 /* Foreign language functions. */
234 static void write_java_integer_type_codes (const tree
);
236 /* Append a single character to the end of the mangled
238 #define write_char(CHAR) \
239 obstack_1grow (mangle_obstack, (CHAR))
241 /* Append a sized buffer to the end of the mangled representation. */
242 #define write_chars(CHAR, LEN) \
243 obstack_grow (mangle_obstack, (CHAR), (LEN))
245 /* Append a NUL-terminated string to the end of the mangled
247 #define write_string(STRING) \
248 obstack_grow (mangle_obstack, (STRING), strlen (STRING))
250 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
251 same purpose (context, which may be a type) and value (template
252 decl). See write_template_prefix for more information on what this
254 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \
255 (TREE_CODE (NODE1) == TREE_LIST \
256 && TREE_CODE (NODE2) == TREE_LIST \
257 && ((TYPE_P (TREE_PURPOSE (NODE1)) \
258 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))) \
259 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \
260 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
262 /* Write out an unsigned quantity in base 10. */
263 #define write_unsigned_number(NUMBER) \
264 write_number ((NUMBER), /*unsigned_p=*/1, 10)
266 /* If DECL is a template instance, return nonzero and, if
267 TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
268 Otherwise return zero. */
271 decl_is_template_id (const tree decl
, tree
* const template_info
)
273 if (TREE_CODE (decl
) == TYPE_DECL
)
275 /* TYPE_DECLs are handled specially. Look at its type to decide
276 if this is a template instantiation. */
277 const tree type
= TREE_TYPE (decl
);
279 if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_ID_P (type
))
281 if (template_info
!= NULL
)
282 /* For a templated TYPE_DECL, the template info is hanging
284 *template_info
= TYPE_TEMPLATE_INFO (type
);
290 /* Check if this is a primary template. */
291 if (DECL_LANG_SPECIFIC (decl
) != NULL
292 && DECL_USE_TEMPLATE (decl
)
293 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
))
294 && TREE_CODE (decl
) != TEMPLATE_DECL
)
296 if (template_info
!= NULL
)
297 /* For most templated decls, the template info is hanging
299 *template_info
= DECL_TEMPLATE_INFO (decl
);
304 /* It's not a template id. */
308 /* Produce debugging output of current substitution candidates. */
311 dump_substitution_candidates (void)
316 fprintf (stderr
, " ++ substitutions ");
317 FOR_EACH_VEC_ELT (*G
.substitutions
, i
, el
)
319 const char *name
= "???";
322 fprintf (stderr
, " ");
324 name
= IDENTIFIER_POINTER (DECL_NAME (el
));
325 else if (TREE_CODE (el
) == TREE_LIST
)
326 name
= IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el
)));
327 else if (TYPE_NAME (el
))
328 name
= TYPE_NAME_STRING (el
);
329 fprintf (stderr
, " S%d_ = ", i
- 1);
331 (CP_TYPE_RESTRICT_P (el
)
332 || CP_TYPE_VOLATILE_P (el
)
333 || CP_TYPE_CONST_P (el
)))
334 fprintf (stderr
, "CV-");
335 fprintf (stderr
, "%s (%s at %p)\n",
336 name
, get_tree_code_name (TREE_CODE (el
)), (void *) el
);
340 /* Both decls and types can be substitution candidates, but sometimes
341 they refer to the same thing. For instance, a TYPE_DECL and
342 RECORD_TYPE for the same class refer to the same thing, and should
343 be treated accordingly in substitutions. This function returns a
344 canonicalized tree node representing NODE that is used when adding
345 and substitution candidates and finding matches. */
348 canonicalize_for_substitution (tree node
)
350 /* For a TYPE_DECL, use the type instead. */
351 if (TREE_CODE (node
) == TYPE_DECL
)
352 node
= TREE_TYPE (node
);
354 && TYPE_CANONICAL (node
) != node
355 && TYPE_MAIN_VARIANT (node
) != node
)
358 /* Here we want to strip the topmost typedef only.
359 We need to do that so is_std_substitution can do proper
361 if (TREE_CODE (node
) == FUNCTION_TYPE
)
362 /* Use build_qualified_type and TYPE_QUALS here to preserve
363 the old buggy mangling of attribute noreturn with abi<5. */
364 node
= build_qualified_type (TYPE_MAIN_VARIANT (node
),
367 node
= cp_build_qualified_type (TYPE_MAIN_VARIANT (node
),
368 cp_type_quals (node
));
369 if (TREE_CODE (node
) == FUNCTION_TYPE
370 || TREE_CODE (node
) == METHOD_TYPE
)
371 node
= build_ref_qualified_type (node
, type_memfn_rqual (orig
));
376 /* Add NODE as a substitution candidate. NODE must not already be on
377 the list of candidates. */
380 add_substitution (tree node
)
385 fprintf (stderr
, " ++ add_substitution (%s at %10p)\n",
386 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
388 /* Get the canonicalized substitution candidate for NODE. */
389 c
= canonicalize_for_substitution (node
);
390 if (DEBUG_MANGLE
&& c
!= node
)
391 fprintf (stderr
, " ++ using candidate (%s at %10p)\n",
392 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
395 /* Make sure NODE isn't already a candidate. */
401 FOR_EACH_VEC_SAFE_ELT (G
.substitutions
, i
, candidate
)
403 gcc_assert (!(DECL_P (node
) && node
== candidate
));
404 gcc_assert (!(TYPE_P (node
) && TYPE_P (candidate
)
405 && same_type_p (node
, candidate
)));
409 /* Put the decl onto the varray of substitution candidates. */
410 vec_safe_push (G
.substitutions
, node
);
413 dump_substitution_candidates ();
416 /* Helper function for find_substitution. Returns nonzero if NODE,
417 which may be a decl or a CLASS_TYPE, is a template-id with template
418 name of substitution_index[INDEX] in the ::std namespace. */
421 is_std_substitution (const tree node
,
422 const substitution_identifier_index_t index
)
429 type
= TREE_TYPE (node
);
432 else if (CLASS_TYPE_P (node
))
435 decl
= TYPE_NAME (node
);
438 /* These are not the droids you're looking for. */
441 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl
))
442 && TYPE_LANG_SPECIFIC (type
)
443 && TYPE_TEMPLATE_INFO (type
)
444 && (DECL_NAME (TYPE_TI_TEMPLATE (type
))
445 == subst_identifiers
[index
]));
448 /* Helper function for find_substitution. Returns nonzero if NODE,
449 which may be a decl or a CLASS_TYPE, is the template-id
450 ::std::identifier<char>, where identifier is
451 substitution_index[INDEX]. */
454 is_std_substitution_char (const tree node
,
455 const substitution_identifier_index_t index
)
458 /* Check NODE's name is ::std::identifier. */
459 if (!is_std_substitution (node
, index
))
461 /* Figure out its template args. */
463 args
= DECL_TI_ARGS (node
);
464 else if (CLASS_TYPE_P (node
))
465 args
= CLASSTYPE_TI_ARGS (node
);
467 /* Oops, not a template. */
469 /* NODE's template arg list should be <char>. */
471 TREE_VEC_LENGTH (args
) == 1
472 && TREE_VEC_ELT (args
, 0) == char_type_node
;
475 /* Check whether a substitution should be used to represent NODE in
478 First, check standard special-case substitutions.
480 <substitution> ::= St
487 # ::std::basic_string
490 # ::std::basic_string<char,
491 ::std::char_traits<char>,
492 ::std::allocator<char> >
495 # ::std::basic_istream<char, ::std::char_traits<char> >
498 # ::std::basic_ostream<char, ::std::char_traits<char> >
501 # ::std::basic_iostream<char, ::std::char_traits<char> >
503 Then examine the stack of currently available substitution
504 candidates for entities appearing earlier in the same mangling
506 If a substitution is found, write its mangled representation and
507 return nonzero. If none is found, just return zero. */
510 find_substitution (tree node
)
513 const int size
= vec_safe_length (G
.substitutions
);
516 const char *abbr
= NULL
;
519 fprintf (stderr
, " ++ find_substitution (%s at %p)\n",
520 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
522 /* Obtain the canonicalized substitution representation for NODE.
523 This is what we'll compare against. */
524 node
= canonicalize_for_substitution (node
);
526 /* Check for builtin substitutions. */
528 decl
= TYPE_P (node
) ? TYPE_NAME (node
) : node
;
529 type
= TYPE_P (node
) ? node
: TREE_TYPE (node
);
531 /* Check for std::allocator. */
533 && is_std_substitution (decl
, SUBID_ALLOCATOR
)
534 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl
)))
537 /* Check for std::basic_string. */
538 else if (decl
&& is_std_substitution (decl
, SUBID_BASIC_STRING
))
542 /* If this is a type (i.e. a fully-qualified template-id),
544 std::basic_string <char,
545 std::char_traits<char>,
546 std::allocator<char> > . */
547 if (cp_type_quals (type
) == TYPE_UNQUALIFIED
548 && CLASSTYPE_USE_TEMPLATE (type
))
550 tree args
= CLASSTYPE_TI_ARGS (type
);
551 if (TREE_VEC_LENGTH (args
) == 3
552 && same_type_p (TREE_VEC_ELT (args
, 0), char_type_node
)
553 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
555 && is_std_substitution_char (TREE_VEC_ELT (args
, 2),
561 /* Substitute for the template name only if this isn't a type. */
565 /* Check for basic_{i,o,io}stream. */
566 else if (TYPE_P (node
)
567 && cp_type_quals (type
) == TYPE_UNQUALIFIED
568 && CLASS_TYPE_P (type
)
569 && CLASSTYPE_USE_TEMPLATE (type
)
570 && CLASSTYPE_TEMPLATE_INFO (type
) != NULL
)
572 /* First, check for the template
573 args <char, std::char_traits<char> > . */
574 tree args
= CLASSTYPE_TI_ARGS (type
);
575 if (TREE_VEC_LENGTH (args
) == 2
576 && TYPE_P (TREE_VEC_ELT (args
, 0))
577 && same_type_p (TREE_VEC_ELT (args
, 0), char_type_node
)
578 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
581 /* Got them. Is this basic_istream? */
582 if (is_std_substitution (decl
, SUBID_BASIC_ISTREAM
))
584 /* Or basic_ostream? */
585 else if (is_std_substitution (decl
, SUBID_BASIC_OSTREAM
))
587 /* Or basic_iostream? */
588 else if (is_std_substitution (decl
, SUBID_BASIC_IOSTREAM
))
593 /* Check for namespace std. */
594 else if (decl
&& DECL_NAMESPACE_STD_P (decl
))
600 tree tags
= NULL_TREE
;
601 if (OVERLOAD_TYPE_P (node
) || DECL_CLASS_TEMPLATE_P (node
))
602 tags
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (type
));
603 /* Now check the list of available substitutions for this mangling
605 if (!abbr
|| tags
) for (i
= 0; i
< size
; ++i
)
607 tree candidate
= (*G
.substitutions
)[i
];
608 /* NODE is a matched to a candidate if it's the same decl node or
609 if it's the same type. */
610 if (decl
== candidate
611 || (TYPE_P (candidate
) && type
&& TYPE_P (node
)
612 && same_type_p (type
, candidate
))
613 || NESTED_TEMPLATE_MATCH (node
, candidate
))
615 write_substitution (i
);
621 /* No substitution found. */
627 /* If there are ABI tags on the abbreviation, it becomes
628 a substitution candidate. */
629 write_abi_tags (tags
);
630 add_substitution (node
);
635 /* Returns whether DECL's symbol name should be the plain unqualified-id
636 rather than a more complicated mangled name. */
639 unmangled_name_p (const tree decl
)
641 if (TREE_CODE (decl
) == FUNCTION_DECL
)
643 /* The names of `extern "C"' functions are not mangled. */
644 return (DECL_EXTERN_C_FUNCTION_P (decl
)
645 /* But overloaded operator names *are* mangled. */
646 && !DECL_OVERLOADED_OPERATOR_P (decl
));
648 else if (VAR_P (decl
))
650 /* static variables are mangled. */
651 if (!DECL_EXTERNAL_LINKAGE_P (decl
))
654 /* extern "C" declarations aren't mangled. */
655 if (DECL_EXTERN_C_P (decl
))
658 /* Other variables at non-global scope are mangled. */
659 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
662 /* Variable template instantiations are mangled. */
663 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
664 && variable_template_p (DECL_TI_TEMPLATE (decl
)))
667 /* Declarations with ABI tags are mangled. */
668 if (lookup_attribute ("abi_tag", DECL_ATTRIBUTES (decl
)))
671 /* The names of non-static global variables aren't mangled. */
678 /* TOP_LEVEL is true, if this is being called at outermost level of
679 mangling. It should be false when mangling a decl appearing in an
680 expression within some other mangling.
682 <mangled-name> ::= _Z <encoding> */
685 write_mangled_name (const tree decl
, bool top_level
)
687 MANGLE_TRACE_TREE ("mangled-name", decl
);
689 check_abi_tags (decl
);
691 if (unmangled_name_p (decl
))
694 write_string (IDENTIFIER_POINTER (DECL_NAME (decl
)));
697 /* The standard notes: "The <encoding> of an extern "C"
698 function is treated like global-scope data, i.e. as its
699 <source-name> without a type." We cannot write
700 overloaded operators that way though, because it contains
701 characters invalid in assembler. */
703 write_source_name (DECL_NAME (decl
));
709 write_encoding (decl
);
713 /* Returns true if the return type of DECL is part of its signature, and
714 therefore its mangling. */
717 mangle_return_type_p (tree decl
)
719 return (!DECL_CONSTRUCTOR_P (decl
)
720 && !DECL_DESTRUCTOR_P (decl
)
721 && !DECL_CONV_FN_P (decl
)
722 && decl_is_template_id (decl
, NULL
));
725 /* <encoding> ::= <function name> <bare-function-type>
729 write_encoding (const tree decl
)
731 MANGLE_TRACE_TREE ("encoding", decl
);
733 if (DECL_LANG_SPECIFIC (decl
) && DECL_EXTERN_C_FUNCTION_P (decl
))
735 /* For overloaded operators write just the mangled name
736 without arguments. */
737 if (DECL_OVERLOADED_OPERATOR_P (decl
))
738 write_name (decl
, /*ignore_local_scope=*/0);
740 write_source_name (DECL_NAME (decl
));
744 write_name (decl
, /*ignore_local_scope=*/0);
745 if (TREE_CODE (decl
) == FUNCTION_DECL
)
750 if (decl_is_template_id (decl
, NULL
))
752 fn_type
= get_mostly_instantiated_function_type (decl
);
753 /* FN_TYPE will not have parameter types for in-charge or
754 VTT parameters. Therefore, we pass NULL_TREE to
755 write_bare_function_type -- otherwise, it will get
756 confused about which artificial parameters to skip. */
761 fn_type
= TREE_TYPE (decl
);
765 write_bare_function_type (fn_type
,
766 mangle_return_type_p (decl
),
771 /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
772 or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */
775 decl_mangling_context (tree decl
)
777 tree tcontext
= targetm
.cxx
.decl_mangling_context (decl
);
779 if (tcontext
!= NULL_TREE
)
782 if (TREE_CODE (decl
) == TEMPLATE_DECL
783 && DECL_TEMPLATE_RESULT (decl
))
784 decl
= DECL_TEMPLATE_RESULT (decl
);
786 if (TREE_CODE (decl
) == TYPE_DECL
787 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
789 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl
));
793 else if (template_type_parameter_p (decl
))
794 /* template type parms have no mangling context. */
796 return CP_DECL_CONTEXT (decl
);
799 /* <name> ::= <unscoped-name>
800 ::= <unscoped-template-name> <template-args>
804 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
805 called from <local-name>, which mangles the enclosing scope
806 elsewhere and then uses this function to mangle just the part
807 underneath the function scope. So don't use the <local-name>
808 production, to avoid an infinite recursion. */
811 write_name (tree decl
, const int ignore_local_scope
)
815 MANGLE_TRACE_TREE ("name", decl
);
817 if (TREE_CODE (decl
) == TYPE_DECL
)
819 /* In case this is a typedef, fish out the corresponding
820 TYPE_DECL for the main variant. */
821 decl
= TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
)));
824 context
= decl_mangling_context (decl
);
826 gcc_assert (context
!= NULL_TREE
);
828 if (abi_warn_or_compat_version_crosses (7)
829 && ignore_local_scope
830 && TREE_CODE (context
) == PARM_DECL
)
831 G
.need_abi_warning
= 1;
833 /* A decl in :: or ::std scope is treated specially. The former is
834 mangled using <unscoped-name> or <unscoped-template-name>, the
835 latter with a special substitution. Also, a name that is
836 directly in a local function scope is also mangled with
837 <unscoped-name> rather than a full <nested-name>. */
838 if (context
== global_namespace
839 || DECL_NAMESPACE_STD_P (context
)
840 || (ignore_local_scope
841 && (TREE_CODE (context
) == FUNCTION_DECL
842 || (abi_version_at_least (7)
843 && TREE_CODE (context
) == PARM_DECL
))))
846 /* Is this a template instance? */
847 if (decl_is_template_id (decl
, &template_info
))
849 /* Yes: use <unscoped-template-name>. */
850 write_unscoped_template_name (TI_TEMPLATE (template_info
));
851 write_template_args (TI_ARGS (template_info
));
854 /* Everything else gets an <unqualified-name>. */
855 write_unscoped_name (decl
);
859 /* Handle local names, unless we asked not to (that is, invoked
860 under <local-name>, to handle only the part of the name under
862 if (!ignore_local_scope
)
864 /* Scan up the list of scope context, looking for a
865 function. If we find one, this entity is in local
866 function scope. local_entity tracks context one scope
867 level down, so it will contain the element that's
868 directly in that function's scope, either decl or one of
869 its enclosing scopes. */
870 tree local_entity
= decl
;
871 while (context
!= global_namespace
)
873 /* Make sure we're always dealing with decls. */
874 if (TYPE_P (context
))
875 context
= TYPE_NAME (context
);
876 /* Is this a function? */
877 if (TREE_CODE (context
) == FUNCTION_DECL
878 || TREE_CODE (context
) == PARM_DECL
)
880 /* Yes, we have local scope. Use the <local-name>
881 production for the innermost function scope. */
882 write_local_name (context
, local_entity
, decl
);
885 /* Up one scope level. */
886 local_entity
= context
;
887 context
= decl_mangling_context (context
);
890 /* No local scope found? Fall through to <nested-name>. */
893 /* Other decls get a <nested-name> to encode their scope. */
894 write_nested_name (decl
);
898 /* <unscoped-name> ::= <unqualified-name>
899 ::= St <unqualified-name> # ::std:: */
902 write_unscoped_name (const tree decl
)
904 tree context
= decl_mangling_context (decl
);
906 MANGLE_TRACE_TREE ("unscoped-name", decl
);
908 /* Is DECL in ::std? */
909 if (DECL_NAMESPACE_STD_P (context
))
912 write_unqualified_name (decl
);
916 /* If not, it should be either in the global namespace, or directly
917 in a local function scope. A lambda can also be mangled in the
918 scope of a default argument. */
919 gcc_assert (context
== global_namespace
920 || TREE_CODE (context
) == PARM_DECL
921 || TREE_CODE (context
) == FUNCTION_DECL
);
923 write_unqualified_name (decl
);
927 /* <unscoped-template-name> ::= <unscoped-name>
928 ::= <substitution> */
931 write_unscoped_template_name (const tree decl
)
933 MANGLE_TRACE_TREE ("unscoped-template-name", decl
);
935 if (find_substitution (decl
))
937 write_unscoped_name (decl
);
938 add_substitution (decl
);
941 /* Write the nested name, including CV-qualifiers, of DECL.
943 <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
944 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
946 <ref-qualifier> ::= R # & ref-qualifier
947 ::= O # && ref-qualifier
948 <CV-qualifiers> ::= [r] [V] [K] */
951 write_nested_name (const tree decl
)
955 MANGLE_TRACE_TREE ("nested-name", decl
);
959 /* Write CV-qualifiers, if this is a member function. */
960 if (TREE_CODE (decl
) == FUNCTION_DECL
961 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
963 if (DECL_VOLATILE_MEMFUNC_P (decl
))
965 if (DECL_CONST_MEMFUNC_P (decl
))
967 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl
)))
969 if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl
)))
976 /* Is this a template instance? */
977 if (decl_is_template_id (decl
, &template_info
))
979 /* Yes, use <template-prefix>. */
980 write_template_prefix (decl
);
981 write_template_args (TI_ARGS (template_info
));
983 else if ((!abi_version_at_least (10) || TREE_CODE (decl
) == TYPE_DECL
)
984 && TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
986 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
987 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
989 write_template_prefix (decl
);
990 write_template_args (TREE_OPERAND (name
, 1));
994 write_prefix (decl_mangling_context (decl
));
995 write_unqualified_name (decl
);
1000 /* No, just use <prefix> */
1001 write_prefix (decl_mangling_context (decl
));
1002 write_unqualified_name (decl
);
1007 /* <prefix> ::= <prefix> <unqualified-name>
1008 ::= <template-param>
1009 ::= <template-prefix> <template-args>
1012 ::= <substitution> */
1015 write_prefix (const tree node
)
1018 /* Non-NULL if NODE represents a template-id. */
1019 tree template_info
= NULL
;
1022 || node
== global_namespace
)
1025 MANGLE_TRACE_TREE ("prefix", node
);
1027 if (TREE_CODE (node
) == DECLTYPE_TYPE
)
1033 if (find_substitution (node
))
1038 /* If this is a function or parm decl, that means we've hit function
1039 scope, so this prefix must be for a local name. In this
1040 case, we're under the <local-name> production, which encodes
1041 the enclosing function scope elsewhere. So don't continue
1043 if (TREE_CODE (node
) == FUNCTION_DECL
1044 || TREE_CODE (node
) == PARM_DECL
)
1048 decl_is_template_id (decl
, &template_info
);
1052 /* Node is a type. */
1053 decl
= TYPE_NAME (node
);
1054 if (CLASSTYPE_TEMPLATE_ID_P (node
))
1055 template_info
= TYPE_TEMPLATE_INFO (node
);
1058 if (TREE_CODE (node
) == TEMPLATE_TYPE_PARM
)
1059 write_template_param (node
);
1060 else if (template_info
!= NULL
)
1063 write_template_prefix (decl
);
1064 write_template_args (TI_ARGS (template_info
));
1066 else if (TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
1068 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
1069 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1071 write_template_prefix (decl
);
1072 write_template_args (TREE_OPERAND (name
, 1));
1076 write_prefix (decl_mangling_context (decl
));
1077 write_unqualified_name (decl
);
1081 /* Not templated. */
1083 write_prefix (decl_mangling_context (decl
));
1084 write_unqualified_name (decl
);
1086 || TREE_CODE (decl
) == FIELD_DECL
)
1088 /* <data-member-prefix> := <member source-name> M */
1094 add_substitution (node
);
1097 /* <template-prefix> ::= <prefix> <template component>
1098 ::= <template-param>
1099 ::= <substitution> */
1102 write_template_prefix (const tree node
)
1104 tree decl
= DECL_P (node
) ? node
: TYPE_NAME (node
);
1105 tree type
= DECL_P (node
) ? TREE_TYPE (node
) : node
;
1106 tree context
= decl_mangling_context (decl
);
1111 MANGLE_TRACE_TREE ("template-prefix", node
);
1113 /* Find the template decl. */
1114 if (decl_is_template_id (decl
, &template_info
))
1115 templ
= TI_TEMPLATE (template_info
);
1116 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
1117 /* For a typename type, all we have is the name. */
1118 templ
= DECL_NAME (decl
);
1121 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type
));
1123 templ
= TYPE_TI_TEMPLATE (type
);
1126 /* For a member template, though, the template name for the
1127 innermost name must have all the outer template levels
1128 instantiated. For instance, consider
1130 template<typename T> struct Outer {
1131 template<typename U> struct Inner {};
1134 The template name for `Inner' in `Outer<int>::Inner<float>' is
1135 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1136 levels separately, so there's no TEMPLATE_DECL available for this
1137 (there's only `Outer<T>::Inner<U>').
1139 In order to get the substitutions right, we create a special
1140 TREE_LIST to represent the substitution candidate for a nested
1141 template. The TREE_PURPOSE is the template's context, fully
1142 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1145 So, for the example above, `Outer<int>::Inner' is represented as a
1146 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1147 and whose value is `Outer<T>::Inner<U>'. */
1148 if (context
&& TYPE_P (context
))
1149 substitution
= build_tree_list (context
, templ
);
1151 substitution
= templ
;
1153 if (find_substitution (substitution
))
1156 if (TREE_TYPE (templ
)
1157 && TREE_CODE (TREE_TYPE (templ
)) == TEMPLATE_TEMPLATE_PARM
)
1158 write_template_param (TREE_TYPE (templ
));
1161 write_prefix (context
);
1162 write_unqualified_name (decl
);
1165 add_substitution (substitution
);
1168 /* We don't need to handle thunks, vtables, or VTTs here. Those are
1169 mangled through special entry points.
1171 <unqualified-name> ::= <operator-name>
1174 ::= <unnamed-type-name>
1175 ::= <local-source-name>
1177 <local-source-name> ::= L <source-name> <discriminator> */
1180 write_unqualified_id (tree identifier
)
1182 if (IDENTIFIER_TYPENAME_P (identifier
))
1183 write_conversion_operator_name (TREE_TYPE (identifier
));
1184 else if (IDENTIFIER_OPNAME_P (identifier
))
1187 const char *mangled_name
= NULL
;
1189 /* Unfortunately, there is no easy way to go from the
1190 name of the operator back to the corresponding tree
1192 for (i
= 0; i
< MAX_TREE_CODES
; ++i
)
1193 if (operator_name_info
[i
].identifier
== identifier
)
1195 /* The ABI says that we prefer binary operator
1196 names to unary operator names. */
1197 if (operator_name_info
[i
].arity
== 2)
1199 mangled_name
= operator_name_info
[i
].mangled_name
;
1202 else if (!mangled_name
)
1203 mangled_name
= operator_name_info
[i
].mangled_name
;
1205 else if (assignment_operator_name_info
[i
].identifier
1209 = assignment_operator_name_info
[i
].mangled_name
;
1212 write_string (mangled_name
);
1214 else if (UDLIT_OPER_P (identifier
))
1215 write_literal_operator_name (identifier
);
1217 write_source_name (identifier
);
1221 write_unqualified_name (tree decl
)
1223 MANGLE_TRACE_TREE ("unqualified-name", decl
);
1225 if (identifier_p (decl
))
1227 write_unqualified_id (decl
);
1233 if (DECL_NAME (decl
) == NULL_TREE
)
1236 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl
));
1237 write_source_name (DECL_ASSEMBLER_NAME (decl
));
1239 else if (DECL_DECLARES_FUNCTION_P (decl
))
1242 if (DECL_CONSTRUCTOR_P (decl
))
1243 write_special_name_constructor (decl
);
1244 else if (DECL_DESTRUCTOR_P (decl
))
1245 write_special_name_destructor (decl
);
1246 else if (DECL_CONV_FN_P (decl
))
1248 /* Conversion operator. Handle it right here.
1249 <operator> ::= cv <type> */
1251 if (decl_is_template_id (decl
, NULL
))
1254 fn_type
= get_mostly_instantiated_function_type (decl
);
1255 type
= TREE_TYPE (fn_type
);
1257 else if (FNDECL_USED_AUTO (decl
))
1258 type
= (DECL_STRUCT_FUNCTION (decl
)->language
1259 ->x_auto_return_pattern
);
1261 type
= DECL_CONV_FN_TYPE (decl
);
1262 write_conversion_operator_name (type
);
1264 else if (DECL_OVERLOADED_OPERATOR_P (decl
))
1266 operator_name_info_t
*oni
;
1267 if (DECL_ASSIGNMENT_OPERATOR_P (decl
))
1268 oni
= assignment_operator_name_info
;
1270 oni
= operator_name_info
;
1272 write_string (oni
[DECL_OVERLOADED_OPERATOR_P (decl
)].mangled_name
);
1274 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
1275 write_literal_operator_name (DECL_NAME (decl
));
1282 else if (VAR_OR_FUNCTION_DECL_P (decl
) && ! TREE_PUBLIC (decl
)
1283 && DECL_NAMESPACE_SCOPE_P (decl
)
1284 && decl_linkage (decl
) == lk_internal
)
1286 MANGLE_TRACE_TREE ("local-source-name", decl
);
1288 write_source_name (DECL_NAME (decl
));
1289 /* The default discriminator is 1, and that's all we ever use,
1290 so there's no code to output one here. */
1294 tree type
= TREE_TYPE (decl
);
1296 if (TREE_CODE (decl
) == TYPE_DECL
1297 && TYPE_ANONYMOUS_P (type
))
1298 write_unnamed_type_name (type
);
1299 else if (TREE_CODE (decl
) == TYPE_DECL
1300 && LAMBDA_TYPE_P (type
))
1301 write_closure_type_name (type
);
1303 write_source_name (DECL_NAME (decl
));
1306 /* We use the ABI tags from the primary template, ignoring tags on any
1307 specializations. This is necessary because C++ doesn't require a
1308 specialization to be declared before it is used unless the use
1309 requires a complete type, but we need to get the tags right on
1310 incomplete types as well. */
1311 if (tree tmpl
= most_general_template (decl
))
1312 decl
= DECL_TEMPLATE_RESULT (tmpl
);
1313 /* Don't crash on an unbound class template. */
1314 if (decl
&& TREE_CODE (decl
) != NAMESPACE_DECL
)
1316 tree attrs
= (TREE_CODE (decl
) == TYPE_DECL
1317 ? TYPE_ATTRIBUTES (TREE_TYPE (decl
))
1318 : DECL_ATTRIBUTES (decl
));
1319 write_abi_tags (lookup_attribute ("abi_tag", attrs
));
1323 /* Write the unqualified-name for a conversion operator to TYPE. */
1326 write_conversion_operator_name (const tree type
)
1328 write_string ("cv");
1332 /* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1334 <source-name> ::= </length/ number> <identifier> */
1337 write_source_name (tree identifier
)
1339 MANGLE_TRACE_TREE ("source-name", identifier
);
1341 /* Never write the whole template-id name including the template
1342 arguments; we only want the template name. */
1343 if (IDENTIFIER_TEMPLATE (identifier
))
1344 identifier
= IDENTIFIER_TEMPLATE (identifier
);
1346 write_unsigned_number (IDENTIFIER_LENGTH (identifier
));
1347 write_identifier (IDENTIFIER_POINTER (identifier
));
1350 /* Compare two TREE_STRINGs like strcmp. */
1353 tree_string_cmp (const void *p1
, const void *p2
)
1357 tree s1
= *(const tree
*)p1
;
1358 tree s2
= *(const tree
*)p2
;
1359 return strcmp (TREE_STRING_POINTER (s1
),
1360 TREE_STRING_POINTER (s2
));
1363 /* ID is the name of a function or type with abi_tags attribute TAGS.
1364 Write out the name, suitably decorated. */
1367 write_abi_tags (tree tags
)
1369 if (tags
== NULL_TREE
)
1372 tags
= TREE_VALUE (tags
);
1374 vec
<tree
, va_gc
> * vec
= make_tree_vector();
1376 for (tree t
= tags
; t
; t
= TREE_CHAIN (t
))
1378 if (ABI_TAG_IMPLICIT (t
))
1380 tree str
= TREE_VALUE (t
);
1381 vec_safe_push (vec
, str
);
1384 vec
->qsort (tree_string_cmp
);
1386 unsigned i
; tree str
;
1387 FOR_EACH_VEC_ELT (*vec
, i
, str
)
1390 write_unsigned_number (TREE_STRING_LENGTH (str
) - 1);
1391 write_identifier (TREE_STRING_POINTER (str
));
1394 release_tree_vector (vec
);
1397 /* Write a user-defined literal operator.
1398 ::= li <source-name> # "" <source-name>
1399 IDENTIFIER is an LITERAL_IDENTIFIER_NODE. */
1402 write_literal_operator_name (tree identifier
)
1404 const char* suffix
= UDLIT_OP_SUFFIX (identifier
);
1405 write_identifier (UDLIT_OP_MANGLED_PREFIX
);
1406 write_unsigned_number (strlen (suffix
));
1407 write_identifier (suffix
);
1410 /* Encode 0 as _, and 1+ as n-1_. */
1413 write_compact_number (int num
)
1416 write_unsigned_number (num
- 1);
1420 /* Return how many unnamed types precede TYPE in its enclosing class. */
1423 nested_anon_class_index (tree type
)
1426 tree member
= TYPE_FIELDS (TYPE_CONTEXT (type
));
1427 for (; member
; member
= DECL_CHAIN (member
))
1428 if (DECL_IMPLICIT_TYPEDEF_P (member
))
1430 tree memtype
= TREE_TYPE (member
);
1431 if (memtype
== type
)
1433 else if (TYPE_ANONYMOUS_P (memtype
))
1440 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1443 write_unnamed_type_name (const tree type
)
1446 MANGLE_TRACE_TREE ("unnamed-type-name", type
);
1448 if (TYPE_FUNCTION_SCOPE_P (type
))
1449 discriminator
= local_class_index (type
);
1450 else if (TYPE_CLASS_SCOPE_P (type
))
1451 discriminator
= nested_anon_class_index (type
);
1454 gcc_assert (no_linkage_check (type
, /*relaxed_p=*/true));
1455 /* Just use the old mangling at namespace scope. */
1456 write_source_name (TYPE_IDENTIFIER (type
));
1460 write_string ("Ut");
1461 write_compact_number (discriminator
);
1464 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1465 <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters */
1468 write_closure_type_name (const tree type
)
1470 tree fn
= lambda_function (type
);
1471 tree lambda
= CLASSTYPE_LAMBDA_EXPR (type
);
1472 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1474 MANGLE_TRACE_TREE ("closure-type-name", type
);
1476 write_string ("Ul");
1477 write_method_parms (parms
, /*method_p=*/1, fn
);
1479 write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda
));
1482 /* Convert NUMBER to ascii using base BASE and generating at least
1483 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1484 into which to store the characters. Returns the number of
1485 characters generated (these will be laid out in advance of where
1489 hwint_to_ascii (unsigned HOST_WIDE_INT number
, const unsigned int base
,
1490 char *buffer
, const unsigned int min_digits
)
1492 static const char base_digits
[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1493 unsigned digits
= 0;
1497 unsigned HOST_WIDE_INT d
= number
/ base
;
1499 *--buffer
= base_digits
[number
- d
* base
];
1503 while (digits
< min_digits
)
1505 *--buffer
= base_digits
[0];
1511 /* Non-terminal <number>.
1513 <number> ::= [n] </decimal integer/> */
1516 write_number (unsigned HOST_WIDE_INT number
, const int unsigned_p
,
1517 const unsigned int base
)
1519 char buffer
[sizeof (HOST_WIDE_INT
) * 8];
1522 if (!unsigned_p
&& (HOST_WIDE_INT
) number
< 0)
1525 number
= -((HOST_WIDE_INT
) number
);
1527 count
= hwint_to_ascii (number
, base
, buffer
+ sizeof (buffer
), 1);
1528 write_chars (buffer
+ sizeof (buffer
) - count
, count
);
1531 /* Write out an integral CST in decimal. Most numbers are small, and
1532 representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1533 bigger than that, which we must deal with. */
1536 write_integer_cst (const tree cst
)
1538 int sign
= tree_int_cst_sgn (cst
);
1539 widest_int abs_value
= wi::abs (wi::to_widest (cst
));
1540 if (!wi::fits_uhwi_p (abs_value
))
1542 /* A bignum. We do this in chunks, each of which fits in a
1544 char buffer
[sizeof (HOST_WIDE_INT
) * 8 * 2];
1545 unsigned HOST_WIDE_INT chunk
;
1546 unsigned chunk_digits
;
1547 char *ptr
= buffer
+ sizeof (buffer
);
1552 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1557 if (sizeof (HOST_WIDE_INT
) >= 8)
1559 /* It is at least 64 bits, so 10^18 is representable. */
1564 type
= c_common_signed_or_unsigned_type (1, TREE_TYPE (cst
));
1565 base
= build_int_cstu (type
, chunk
);
1566 n
= wide_int_to_tree (type
, cst
);
1571 n
= fold_build1_loc (input_location
, NEGATE_EXPR
, type
, n
);
1575 tree d
= fold_build2_loc (input_location
, FLOOR_DIV_EXPR
, type
, n
, base
);
1576 tree tmp
= fold_build2_loc (input_location
, MULT_EXPR
, type
, d
, base
);
1579 done
= integer_zerop (d
);
1580 tmp
= fold_build2_loc (input_location
, MINUS_EXPR
, type
, n
, tmp
);
1581 c
= hwint_to_ascii (TREE_INT_CST_LOW (tmp
), 10, ptr
,
1582 done
? 1 : chunk_digits
);
1588 write_chars (ptr
, count
);
1595 write_unsigned_number (abs_value
.to_uhwi ());
1599 /* Write out a floating-point literal.
1601 "Floating-point literals are encoded using the bit pattern of the
1602 target processor's internal representation of that number, as a
1603 fixed-length lowercase hexadecimal string, high-order bytes first
1604 (even if the target processor would store low-order bytes first).
1605 The "n" prefix is not used for floating-point literals; the sign
1606 bit is encoded with the rest of the number.
1608 Here are some examples, assuming the IEEE standard representation
1609 for floating point numbers. (Spaces are for readability, not
1610 part of the encoding.)
1613 -1.0f Lf bf80 0000 E
1614 1.17549435e-38f Lf 0080 0000 E
1615 1.40129846e-45f Lf 0000 0001 E
1616 0.0f Lf 0000 0000 E"
1618 Caller is responsible for the Lx and the E. */
1620 write_real_cst (const tree value
)
1622 long target_real
[4]; /* largest supported float */
1623 char buffer
[9]; /* eight hex digits in a 32-bit number */
1626 tree type
= TREE_TYPE (value
);
1627 int words
= GET_MODE_BITSIZE (TYPE_MODE (type
)) / 32;
1629 real_to_target (target_real
, &TREE_REAL_CST (value
),
1632 /* The value in target_real is in the target word order,
1633 so we must write it out backward if that happens to be
1634 little-endian. write_number cannot be used, it will
1635 produce uppercase. */
1636 if (FLOAT_WORDS_BIG_ENDIAN
)
1637 i
= 0, limit
= words
, dir
= 1;
1639 i
= words
- 1, limit
= -1, dir
= -1;
1641 for (; i
!= limit
; i
+= dir
)
1643 sprintf (buffer
, "%08lx", (unsigned long) target_real
[i
]);
1644 write_chars (buffer
, 8);
1648 /* Non-terminal <identifier>.
1650 <identifier> ::= </unqualified source code identifier> */
1653 write_identifier (const char *identifier
)
1655 MANGLE_TRACE ("identifier", identifier
);
1656 write_string (identifier
);
1659 /* Handle constructor productions of non-terminal <special-name>.
1660 CTOR is a constructor FUNCTION_DECL.
1662 <special-name> ::= C1 # complete object constructor
1663 ::= C2 # base object constructor
1664 ::= C3 # complete object allocating constructor
1666 Currently, allocating constructors are never used. */
1669 write_special_name_constructor (const tree ctor
)
1671 if (DECL_BASE_CONSTRUCTOR_P (ctor
))
1672 write_string ("C2");
1673 /* This is the old-style "[unified]" constructor.
1674 In some cases, we may emit this function and call
1675 it from the clones in order to share code and save space. */
1676 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor
))
1677 write_string ("C4");
1680 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor
));
1681 write_string ("C1");
1685 /* Handle destructor productions of non-terminal <special-name>.
1686 DTOR is a destructor FUNCTION_DECL.
1688 <special-name> ::= D0 # deleting (in-charge) destructor
1689 ::= D1 # complete object (in-charge) destructor
1690 ::= D2 # base object (not-in-charge) destructor */
1693 write_special_name_destructor (const tree dtor
)
1695 if (DECL_DELETING_DESTRUCTOR_P (dtor
))
1696 write_string ("D0");
1697 else if (DECL_BASE_DESTRUCTOR_P (dtor
))
1698 write_string ("D2");
1699 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor
))
1700 /* This is the old-style "[unified]" destructor.
1701 In some cases, we may emit this function and call
1702 it from the clones in order to share code and save space. */
1703 write_string ("D4");
1706 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor
));
1707 write_string ("D1");
1711 /* Scan the vector of local classes and return how many others with the
1712 same name (or same no name) and context precede ENTITY. */
1715 local_class_index (tree entity
)
1717 int ix
, discriminator
= 0;
1718 tree name
= (TYPE_ANONYMOUS_P (entity
) ? NULL_TREE
1719 : TYPE_IDENTIFIER (entity
));
1720 tree ctx
= TYPE_CONTEXT (entity
);
1721 for (ix
= 0; ; ix
++)
1723 tree type
= (*local_classes
)[ix
];
1725 return discriminator
;
1726 if (TYPE_CONTEXT (type
) == ctx
1727 && (name
? TYPE_IDENTIFIER (type
) == name
1728 : TYPE_ANONYMOUS_P (type
)))
1734 /* Return the discriminator for ENTITY appearing inside
1735 FUNCTION. The discriminator is the lexical ordinal of VAR among
1736 entities with the same name in the same FUNCTION. */
1739 discriminator_for_local_entity (tree entity
)
1741 if (DECL_DISCRIMINATOR_P (entity
))
1743 if (DECL_DISCRIMINATOR_SET_P (entity
))
1744 return DECL_DISCRIMINATOR (entity
);
1746 /* The first entity with a particular name doesn't get
1747 DECL_DISCRIMINATOR set up. */
1750 else if (TREE_CODE (entity
) == TYPE_DECL
)
1752 /* Scan the list of local classes. */
1753 entity
= TREE_TYPE (entity
);
1755 /* Lambdas and unnamed types have their own discriminators. */
1756 if (LAMBDA_TYPE_P (entity
) || TYPE_ANONYMOUS_P (entity
))
1759 return local_class_index (entity
);
1765 /* Return the discriminator for STRING, a string literal used inside
1766 FUNCTION. The discriminator is the lexical ordinal of STRING among
1767 string literals used in FUNCTION. */
1770 discriminator_for_string_literal (tree
/*function*/,
1773 /* For now, we don't discriminate amongst string literals. */
1777 /* <discriminator> := _ <number>
1779 The discriminator is used only for the second and later occurrences
1780 of the same name within a single function. In this case <number> is
1781 n - 2, if this is the nth occurrence, in lexical order. */
1784 write_discriminator (const int discriminator
)
1786 /* If discriminator is zero, don't write anything. Otherwise... */
1787 if (discriminator
> 0)
1790 write_unsigned_number (discriminator
- 1);
1794 /* Mangle the name of a function-scope entity. FUNCTION is the
1795 FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1796 default argument scope. ENTITY is the decl for the entity itself.
1797 LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1798 either ENTITY itself or an enclosing scope of ENTITY.
1800 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1801 := Z <function encoding> E s [<discriminator>]
1802 := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1805 write_local_name (tree function
, const tree local_entity
,
1808 tree parm
= NULL_TREE
;
1810 MANGLE_TRACE_TREE ("local-name", entity
);
1812 if (TREE_CODE (function
) == PARM_DECL
)
1815 function
= DECL_CONTEXT (parm
);
1819 write_encoding (function
);
1822 /* For this purpose, parameters are numbered from right-to-left. */
1827 for (t
= DECL_ARGUMENTS (function
); t
; t
= DECL_CHAIN (t
))
1835 write_compact_number (i
- 1);
1838 if (TREE_CODE (entity
) == STRING_CST
)
1841 write_discriminator (discriminator_for_string_literal (function
,
1846 /* Now the <entity name>. Let write_name know its being called
1847 from <local-name>, so it doesn't try to process the enclosing
1848 function scope again. */
1849 write_name (entity
, /*ignore_local_scope=*/1);
1850 write_discriminator (discriminator_for_local_entity (local_entity
));
1854 /* Non-terminals <type> and <CV-qualifier>.
1856 <type> ::= <builtin-type>
1858 ::= <class-enum-type>
1860 ::= <pointer-to-member-type>
1861 ::= <template-param>
1864 ::= P <type> # pointer-to
1865 ::= R <type> # reference-to
1866 ::= C <type> # complex pair (C 2000)
1867 ::= G <type> # imaginary (C 2000) [not supported]
1868 ::= U <source-name> <type> # vendor extended type qualifier
1872 <type> ::= RR <type> # rvalue reference-to
1873 <type> ::= Dt <expression> # decltype of an id-expression or
1874 # class member access
1875 <type> ::= DT <expression> # decltype of an expression
1876 <type> ::= Dn # decltype of nullptr
1878 TYPE is a type node. */
1881 write_type (tree type
)
1883 /* This gets set to nonzero if TYPE turns out to be a (possibly
1884 CV-qualified) builtin type. */
1885 int is_builtin_type
= 0;
1887 MANGLE_TRACE_TREE ("type", type
);
1889 if (type
== error_mark_node
)
1892 type
= canonicalize_for_substitution (type
);
1893 if (find_substitution (type
))
1897 if (write_CV_qualifiers_for_type (type
) > 0)
1898 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1899 mangle the unqualified type. The recursive call is needed here
1900 since both the qualified and unqualified types are substitution
1903 tree t
= TYPE_MAIN_VARIANT (type
);
1904 if (TYPE_ATTRIBUTES (t
) && !OVERLOAD_TYPE_P (t
))
1906 tree attrs
= NULL_TREE
;
1907 if (tx_safe_fn_type_p (type
))
1908 attrs
= tree_cons (get_identifier ("transaction_safe"),
1910 t
= cp_build_type_attribute_variant (t
, attrs
);
1912 gcc_assert (t
!= type
);
1913 if (TREE_CODE (t
) == FUNCTION_TYPE
1914 || TREE_CODE (t
) == METHOD_TYPE
)
1916 t
= build_ref_qualified_type (t
, type_memfn_rqual (type
));
1917 if (abi_version_at_least (8)
1918 || type
== TYPE_MAIN_VARIANT (type
))
1919 /* Avoid adding the unqualified function type as a substitution. */
1920 write_function_type (t
);
1923 if (abi_warn_or_compat_version_crosses (8))
1924 G
.need_abi_warning
= 1;
1929 else if (TREE_CODE (type
) == ARRAY_TYPE
)
1930 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1931 so that the cv-qualification of the element type is available
1932 in write_array_type. */
1933 write_array_type (type
);
1936 tree type_orig
= type
;
1938 /* See through any typedefs. */
1939 type
= TYPE_MAIN_VARIANT (type
);
1940 if (TREE_CODE (type
) == FUNCTION_TYPE
1941 || TREE_CODE (type
) == METHOD_TYPE
)
1942 type
= build_ref_qualified_type (type
, type_memfn_rqual (type_orig
));
1944 /* According to the C++ ABI, some library classes are passed the
1945 same as the scalar type of their single member and use the same
1947 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
1948 type
= TREE_TYPE (first_field (type
));
1950 if (TYPE_PTRDATAMEM_P (type
))
1951 write_pointer_to_member_type (type
);
1954 /* Handle any target-specific fundamental types. */
1955 const char *target_mangling
1956 = targetm
.mangle_type (type_orig
);
1958 if (target_mangling
)
1960 write_string (target_mangling
);
1961 /* Add substitutions for types other than fundamental
1963 if (!VOID_TYPE_P (type
)
1964 && TREE_CODE (type
) != INTEGER_TYPE
1965 && TREE_CODE (type
) != REAL_TYPE
1966 && TREE_CODE (type
) != BOOLEAN_TYPE
)
1967 add_substitution (type
);
1971 switch (TREE_CODE (type
))
1975 case INTEGER_TYPE
: /* Includes wchar_t. */
1977 case FIXED_POINT_TYPE
:
1979 /* If this is a typedef, TYPE may not be one of
1980 the standard builtin type nodes, but an alias of one. Use
1981 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
1982 write_builtin_type (TYPE_MAIN_VARIANT (type
));
1989 write_type (TREE_TYPE (type
));
1994 write_function_type (type
);
2000 /* A pointer-to-member function is represented as a special
2001 RECORD_TYPE, so check for this first. */
2002 if (TYPE_PTRMEMFUNC_P (type
))
2003 write_pointer_to_member_type (type
);
2005 write_class_enum_type (type
);
2009 case UNBOUND_CLASS_TEMPLATE
:
2010 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2011 ordinary nested names. */
2012 write_nested_name (TYPE_STUB_DECL (type
));
2016 case REFERENCE_TYPE
:
2017 if (TYPE_PTR_P (type
))
2019 else if (TYPE_REF_IS_RVALUE (type
))
2024 tree target
= TREE_TYPE (type
);
2025 /* Attribute const/noreturn are not reflected in mangling.
2026 We strip them here rather than at a lower level because
2027 a typedef or template argument can have function type
2028 with function-cv-quals (that use the same representation),
2029 but you can't have a pointer/reference to such a type. */
2030 if (TREE_CODE (target
) == FUNCTION_TYPE
)
2032 if (abi_warn_or_compat_version_crosses (5)
2033 && TYPE_QUALS (target
) != TYPE_UNQUALIFIED
)
2034 G
.need_abi_warning
= 1;
2035 if (abi_version_at_least (5))
2036 target
= build_qualified_type (target
, TYPE_UNQUALIFIED
);
2038 write_type (target
);
2042 case TEMPLATE_TYPE_PARM
:
2045 if (AUTO_IS_DECLTYPE (type
))
2046 write_identifier ("Dc");
2048 write_identifier ("Da");
2052 /* else fall through. */
2053 case TEMPLATE_PARM_INDEX
:
2054 write_template_param (type
);
2057 case TEMPLATE_TEMPLATE_PARM
:
2058 write_template_template_param (type
);
2061 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2062 write_template_template_param (type
);
2064 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type
)));
2068 if (abi_version_at_least (4))
2070 write_string ("Dv");
2071 /* Non-constant vector size would be encoded with
2072 _ expression, but we don't support that yet. */
2073 write_unsigned_number (TYPE_VECTOR_SUBPARTS (type
));
2077 write_string ("U8__vector");
2078 if (abi_warn_or_compat_version_crosses (4))
2079 G
.need_abi_warning
= 1;
2080 write_type (TREE_TYPE (type
));
2083 case TYPE_PACK_EXPANSION
:
2084 write_string ("Dp");
2085 write_type (PACK_EXPANSION_PATTERN (type
));
2089 /* These shouldn't make it into mangling. */
2090 gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type
)
2091 && !DECLTYPE_FOR_LAMBDA_PROXY (type
));
2093 /* In ABI <5, we stripped decltype of a plain decl. */
2094 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
))
2096 tree expr
= DECLTYPE_TYPE_EXPR (type
);
2097 tree etype
= NULL_TREE
;
2098 switch (TREE_CODE (expr
))
2105 case TEMPLATE_PARM_INDEX
:
2106 etype
= TREE_TYPE (expr
);
2113 if (etype
&& !type_uses_auto (etype
))
2115 if (abi_warn_or_compat_version_crosses (5))
2116 G
.need_abi_warning
= 1;
2117 if (!abi_version_at_least (5))
2126 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
))
2130 ++cp_unevaluated_operand
;
2131 write_expression (DECLTYPE_TYPE_EXPR (type
));
2132 --cp_unevaluated_operand
;
2137 write_string ("Dn");
2138 if (abi_version_at_least (7))
2140 if (abi_warn_or_compat_version_crosses (7))
2141 G
.need_abi_warning
= 1;
2145 sorry ("mangling typeof, use decltype instead");
2148 case UNDERLYING_TYPE
:
2149 sorry ("mangling __underlying_type");
2161 /* Types other than builtin types are substitution candidates. */
2162 if (!is_builtin_type
)
2163 add_substitution (type
);
2166 /* qsort callback for sorting a vector of attribute entries. */
2169 attr_strcmp (const void *p1
, const void *p2
)
2171 tree a1
= *(const tree
*)p1
;
2172 tree a2
= *(const tree
*)p2
;
2174 const attribute_spec
*as1
= lookup_attribute_spec (get_attribute_name (a1
));
2175 const attribute_spec
*as2
= lookup_attribute_spec (get_attribute_name (a2
));
2177 return strcmp (as1
->name
, as2
->name
);
2180 /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
2181 CV-qualifiers written for TYPE.
2183 <CV-qualifiers> ::= [r] [V] [K] */
2186 write_CV_qualifiers_for_type (const tree type
)
2188 int num_qualifiers
= 0;
2190 /* The order is specified by:
2192 "In cases where multiple order-insensitive qualifiers are
2193 present, they should be ordered 'K' (closest to the base type),
2194 'V', 'r', and 'U' (farthest from the base type) ..." */
2196 /* Mangle attributes that affect type identity as extended qualifiers.
2198 We don't do this with classes and enums because their attributes
2199 are part of their definitions, not something added on. */
2201 if (!OVERLOAD_TYPE_P (type
))
2204 for (tree a
= TYPE_ATTRIBUTES (type
); a
; a
= TREE_CHAIN (a
))
2206 tree name
= get_attribute_name (a
);
2207 const attribute_spec
*as
= lookup_attribute_spec (name
);
2208 if (as
&& as
->affects_type_identity
2209 && !is_attribute_p ("transaction_safe", name
)
2210 && !is_attribute_p ("abi_tag", name
))
2213 if (abi_warn_or_compat_version_crosses (10) && !vec
.is_empty ())
2214 G
.need_abi_warning
= true;
2215 if (abi_version_at_least (10))
2217 vec
.qsort (attr_strcmp
);
2218 while (!vec
.is_empty())
2221 const attribute_spec
*as
2222 = lookup_attribute_spec (get_attribute_name (a
));
2225 write_unsigned_number (strlen (as
->name
));
2226 write_string (as
->name
);
2230 for (tree args
= TREE_VALUE (a
); args
;
2231 args
= TREE_CHAIN (args
))
2233 tree arg
= TREE_VALUE (args
);
2234 write_template_arg (arg
);
2244 /* Note that we do not use cp_type_quals below; given "const
2245 int[3]", the "const" is emitted with the "int", not with the
2247 cp_cv_quals quals
= TYPE_QUALS (type
);
2249 if (quals
& TYPE_QUAL_RESTRICT
)
2254 if (quals
& TYPE_QUAL_VOLATILE
)
2259 if (quals
& TYPE_QUAL_CONST
)
2265 return num_qualifiers
;
2268 /* Non-terminal <builtin-type>.
2270 <builtin-type> ::= v # void
2275 ::= h # unsigned char
2277 ::= t # unsigned short
2279 ::= j # unsigned int
2281 ::= m # unsigned long
2282 ::= x # long long, __int64
2283 ::= y # unsigned long long, __int64
2285 ::= o # unsigned __int128
2288 ::= e # long double, __float80
2289 ::= g # __float128 [not supported]
2290 ::= u <source-name> # vendor extended type */
2293 write_builtin_type (tree type
)
2295 if (TYPE_CANONICAL (type
))
2296 type
= TYPE_CANONICAL (type
);
2298 switch (TREE_CODE (type
))
2309 /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2310 isn't in integer_type_nodes. */
2311 if (type
== wchar_type_node
)
2313 else if (type
== char16_type_node
)
2314 write_string ("Ds");
2315 else if (type
== char32_type_node
)
2316 write_string ("Di");
2317 else if (TYPE_FOR_JAVA (type
))
2318 write_java_integer_type_codes (type
);
2322 /* Assume TYPE is one of the shared integer type nodes. Find
2323 it in the array of these nodes. */
2325 for (itk
= 0; itk
< itk_none
; ++itk
)
2326 if (integer_types
[itk
] != NULL_TREE
2327 && integer_type_codes
[itk
] != '\0'
2328 && type
== integer_types
[itk
])
2330 /* Print the corresponding single-letter code. */
2331 write_char (integer_type_codes
[itk
]);
2335 if (itk
== itk_none
)
2337 tree t
= c_common_type_for_mode (TYPE_MODE (type
),
2338 TYPE_UNSIGNED (type
));
2345 if (TYPE_PRECISION (type
) == 128)
2346 write_char (TYPE_UNSIGNED (type
) ? 'o' : 'n');
2349 /* Allow for cases where TYPE is not one of the shared
2350 integer type nodes and write a "vendor extended builtin
2351 type" with a name the form intN or uintN, respectively.
2352 Situations like this can happen if you have an
2353 __attribute__((__mode__(__SI__))) type and use exotic
2354 switches like '-mint8' on AVR. Of course, this is
2355 undefined by the C++ ABI (and '-mint8' is not even
2356 Standard C conforming), but when using such special
2357 options you're pretty much in nowhere land anyway. */
2359 char prec
[11]; /* up to ten digits for an unsigned */
2361 prefix
= TYPE_UNSIGNED (type
) ? "uint" : "int";
2362 sprintf (prec
, "%u", (unsigned) TYPE_PRECISION (type
));
2363 write_char ('u'); /* "vendor extended builtin type" */
2364 write_unsigned_number (strlen (prefix
) + strlen (prec
));
2365 write_string (prefix
);
2366 write_string (prec
);
2373 if (type
== float_type_node
2374 || type
== java_float_type_node
)
2376 else if (type
== double_type_node
2377 || type
== java_double_type_node
)
2379 else if (type
== long_double_type_node
)
2381 else if (type
== dfloat32_type_node
)
2382 write_string ("Df");
2383 else if (type
== dfloat64_type_node
)
2384 write_string ("Dd");
2385 else if (type
== dfloat128_type_node
)
2386 write_string ("De");
2391 case FIXED_POINT_TYPE
:
2392 write_string ("DF");
2393 if (GET_MODE_IBIT (TYPE_MODE (type
)) > 0)
2394 write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type
)));
2395 if (type
== fract_type_node
2396 || type
== sat_fract_type_node
2397 || type
== accum_type_node
2398 || type
== sat_accum_type_node
)
2400 else if (type
== unsigned_fract_type_node
2401 || type
== sat_unsigned_fract_type_node
2402 || type
== unsigned_accum_type_node
2403 || type
== sat_unsigned_accum_type_node
)
2405 else if (type
== short_fract_type_node
2406 || type
== sat_short_fract_type_node
2407 || type
== short_accum_type_node
2408 || type
== sat_short_accum_type_node
)
2410 else if (type
== unsigned_short_fract_type_node
2411 || type
== sat_unsigned_short_fract_type_node
2412 || type
== unsigned_short_accum_type_node
2413 || type
== sat_unsigned_short_accum_type_node
)
2415 else if (type
== long_fract_type_node
2416 || type
== sat_long_fract_type_node
2417 || type
== long_accum_type_node
2418 || type
== sat_long_accum_type_node
)
2420 else if (type
== unsigned_long_fract_type_node
2421 || type
== sat_unsigned_long_fract_type_node
2422 || type
== unsigned_long_accum_type_node
2423 || type
== sat_unsigned_long_accum_type_node
)
2425 else if (type
== long_long_fract_type_node
2426 || type
== sat_long_long_fract_type_node
2427 || type
== long_long_accum_type_node
2428 || type
== sat_long_long_accum_type_node
)
2430 else if (type
== unsigned_long_long_fract_type_node
2431 || type
== sat_unsigned_long_long_fract_type_node
2432 || type
== unsigned_long_long_accum_type_node
2433 || type
== sat_unsigned_long_long_accum_type_node
)
2436 sorry ("mangling unknown fixed point type");
2437 write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type
)));
2438 if (TYPE_SATURATING (type
))
2449 /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
2450 METHOD_TYPE. The return type is mangled before the parameter
2453 <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E */
2456 write_function_type (const tree type
)
2458 MANGLE_TRACE_TREE ("function-type", type
);
2460 /* For a pointer to member function, the function type may have
2461 cv-qualifiers, indicating the quals for the artificial 'this'
2463 if (TREE_CODE (type
) == METHOD_TYPE
)
2465 /* The first parameter must be a POINTER_TYPE pointing to the
2466 `this' parameter. */
2467 tree this_type
= class_of_this_parm (type
);
2468 write_CV_qualifiers_for_type (this_type
);
2471 if (tx_safe_fn_type_p (type
))
2472 write_string ("Dx");
2475 /* We don't track whether or not a type is `extern "C"'. Note that
2476 you can have an `extern "C"' function that does not have
2477 `extern "C"' type, and vice versa:
2479 extern "C" typedef void function_t();
2480 function_t f; // f has C++ linkage, but its type is
2483 typedef void function_t();
2484 extern "C" function_t f; // Vice versa.
2487 write_bare_function_type (type
, /*include_return_type_p=*/1,
2489 if (FUNCTION_REF_QUALIFIED (type
))
2491 if (FUNCTION_RVALUE_QUALIFIED (type
))
2499 /* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
2500 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
2501 is mangled before the parameter types. If non-NULL, DECL is
2502 FUNCTION_DECL for the function whose type is being emitted.
2504 If DECL is a member of a Java type, then a literal 'J'
2505 is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2508 <bare-function-type> ::= [J]</signature/ type>+ */
2511 write_bare_function_type (const tree type
, const int include_return_type_p
,
2516 MANGLE_TRACE_TREE ("bare-function-type", type
);
2518 /* Detect Java methods and emit special encoding. */
2520 && DECL_FUNCTION_MEMBER_P (decl
)
2521 && TYPE_FOR_JAVA (DECL_CONTEXT (decl
))
2522 && !DECL_CONSTRUCTOR_P (decl
)
2523 && !DECL_DESTRUCTOR_P (decl
)
2524 && !DECL_CONV_FN_P (decl
))
2534 /* Mangle the return type, if requested. */
2535 if (include_return_type_p
|| java_method_p
)
2536 write_type (TREE_TYPE (type
));
2538 /* Now mangle the types of the arguments. */
2540 write_method_parms (TYPE_ARG_TYPES (type
),
2541 TREE_CODE (type
) == METHOD_TYPE
,
2546 /* Write the mangled representation of a method parameter list of
2547 types given in PARM_TYPES. If METHOD_P is nonzero, the function is
2548 considered a non-static method, and the this parameter is omitted.
2549 If non-NULL, DECL is the FUNCTION_DECL for the function whose
2550 parameters are being emitted. */
2553 write_method_parms (tree parm_types
, const int method_p
, const tree decl
)
2555 tree first_parm_type
;
2556 tree parm_decl
= decl
? DECL_ARGUMENTS (decl
) : NULL_TREE
;
2558 /* Assume this parameter type list is variable-length. If it ends
2559 with a void type, then it's not. */
2562 /* If this is a member function, skip the first arg, which is the
2564 "Member functions do not encode the type of their implicit this
2567 Similarly, there's no need to mangle artificial parameters, like
2568 the VTT parameters for constructors and destructors. */
2571 parm_types
= TREE_CHAIN (parm_types
);
2572 parm_decl
= parm_decl
? DECL_CHAIN (parm_decl
) : NULL_TREE
;
2574 while (parm_decl
&& DECL_ARTIFICIAL (parm_decl
))
2576 parm_types
= TREE_CHAIN (parm_types
);
2577 parm_decl
= DECL_CHAIN (parm_decl
);
2581 for (first_parm_type
= parm_types
;
2583 parm_types
= TREE_CHAIN (parm_types
))
2585 tree parm
= TREE_VALUE (parm_types
);
2586 if (parm
== void_type_node
)
2588 /* "Empty parameter lists, whether declared as () or
2589 conventionally as (void), are encoded with a void parameter
2591 if (parm_types
== first_parm_type
)
2593 /* If the parm list is terminated with a void type, it's
2596 /* A void type better be the last one. */
2597 gcc_assert (TREE_CHAIN (parm_types
) == NULL
);
2604 /* <builtin-type> ::= z # ellipsis */
2608 /* <class-enum-type> ::= <name> */
2611 write_class_enum_type (const tree type
)
2613 write_name (TYPE_NAME (type
), /*ignore_local_scope=*/0);
2616 /* Non-terminal <template-args>. ARGS is a TREE_VEC of template
2619 <template-args> ::= I <template-arg>* E */
2622 write_template_args (tree args
)
2627 MANGLE_TRACE_TREE ("template-args", args
);
2632 length
= TREE_VEC_LENGTH (args
);
2634 if (args
&& length
&& TREE_CODE (TREE_VEC_ELT (args
, 0)) == TREE_VEC
)
2636 /* We have nested template args. We want the innermost template
2638 args
= TREE_VEC_ELT (args
, length
- 1);
2639 length
= TREE_VEC_LENGTH (args
);
2641 for (i
= 0; i
< length
; ++i
)
2642 write_template_arg (TREE_VEC_ELT (args
, i
));
2649 <unqualified-name> <template-args>
2650 part of SCOPE_REF or COMPONENT_REF mangling. */
2653 write_member_name (tree member
)
2655 if (identifier_p (member
))
2656 write_unqualified_id (member
);
2657 else if (DECL_P (member
))
2658 write_unqualified_name (member
);
2659 else if (TREE_CODE (member
) == TEMPLATE_ID_EXPR
)
2661 tree name
= TREE_OPERAND (member
, 0);
2662 if (TREE_CODE (name
) == OVERLOAD
)
2663 name
= OVL_FUNCTION (name
);
2664 write_member_name (name
);
2665 write_template_args (TREE_OPERAND (member
, 1));
2668 write_expression (member
);
2671 /* <expression> ::= <unary operator-name> <expression>
2672 ::= <binary operator-name> <expression> <expression>
2675 <expr-primary> ::= <template-param>
2676 ::= L <type> <value number> E # literal
2677 ::= L <mangled-name> E # external name
2678 ::= st <type> # sizeof
2679 ::= sr <type> <unqualified-name> # dependent name
2680 ::= sr <type> <unqualified-name> <template-args> */
2683 write_expression (tree expr
)
2685 enum tree_code code
= TREE_CODE (expr
);
2687 /* Skip NOP_EXPRs. They can occur when (say) a pointer argument
2688 is converted (via qualification conversions) to another
2690 while (TREE_CODE (expr
) == NOP_EXPR
2691 /* Parentheses aren't mangled. */
2692 || code
== PAREN_EXPR
2693 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
2695 expr
= TREE_OPERAND (expr
, 0);
2696 code
= TREE_CODE (expr
);
2699 if (code
== BASELINK
2700 && (!type_unknown_p (expr
)
2701 || !BASELINK_QUALIFIED_P (expr
)))
2703 expr
= BASELINK_FUNCTIONS (expr
);
2704 code
= TREE_CODE (expr
);
2707 /* Handle pointers-to-members by making them look like expression
2709 if (code
== PTRMEM_CST
)
2711 expr
= build_nt (ADDR_EXPR
,
2712 build_qualified_name (/*type=*/NULL_TREE
,
2713 PTRMEM_CST_CLASS (expr
),
2714 PTRMEM_CST_MEMBER (expr
),
2715 /*template_p=*/false));
2716 code
= TREE_CODE (expr
);
2719 /* Handle template parameters. */
2720 if (code
== TEMPLATE_TYPE_PARM
2721 || code
== TEMPLATE_TEMPLATE_PARM
2722 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
2723 || code
== TEMPLATE_PARM_INDEX
)
2724 write_template_param (expr
);
2725 /* Handle literals. */
2726 else if (TREE_CODE_CLASS (code
) == tcc_constant
2727 || code
== CONST_DECL
)
2728 write_template_arg_literal (expr
);
2729 else if (code
== PARM_DECL
&& DECL_ARTIFICIAL (expr
))
2731 gcc_assert (!strcmp ("this", IDENTIFIER_POINTER (DECL_NAME (expr
))));
2732 write_string ("fpT");
2734 else if (code
== PARM_DECL
)
2736 /* A function parameter used in a late-specified return type. */
2737 int index
= DECL_PARM_INDEX (expr
);
2738 int level
= DECL_PARM_LEVEL (expr
);
2739 int delta
= G
.parm_depth
- level
+ 1;
2740 gcc_assert (index
>= 1);
2744 if (abi_version_at_least (5))
2746 /* Let L be the number of function prototype scopes from the
2747 innermost one (in which the parameter reference occurs) up
2748 to (and including) the one containing the declaration of
2749 the referenced parameter. If the parameter declaration
2750 clause of the innermost function prototype scope has been
2751 completely seen, it is not counted (in that case -- which
2752 is perhaps the most common -- L can be zero). */
2754 write_unsigned_number (delta
- 1);
2756 if (abi_warn_or_compat_version_crosses (5))
2757 G
.need_abi_warning
= true;
2760 write_compact_number (index
- 1);
2762 else if (DECL_P (expr
))
2765 write_mangled_name (expr
, false);
2768 else if (TREE_CODE (expr
) == SIZEOF_EXPR
2769 && SIZEOF_EXPR_TYPE_P (expr
))
2771 write_string ("st");
2772 write_type (TREE_TYPE (TREE_OPERAND (expr
, 0)));
2774 else if (TREE_CODE (expr
) == SIZEOF_EXPR
2775 && TYPE_P (TREE_OPERAND (expr
, 0)))
2777 write_string ("st");
2778 write_type (TREE_OPERAND (expr
, 0));
2780 else if (TREE_CODE (expr
) == ALIGNOF_EXPR
2781 && TYPE_P (TREE_OPERAND (expr
, 0)))
2783 write_string ("at");
2784 write_type (TREE_OPERAND (expr
, 0));
2786 else if (code
== SCOPE_REF
2787 || code
== BASELINK
)
2790 if (code
== SCOPE_REF
)
2792 scope
= TREE_OPERAND (expr
, 0);
2793 member
= TREE_OPERAND (expr
, 1);
2797 scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (expr
));
2798 member
= BASELINK_FUNCTIONS (expr
);
2801 /* If the MEMBER is a real declaration, then the qualifying
2802 scope was not dependent. Ideally, we would not have a
2803 SCOPE_REF in those cases, but sometimes we do. If the second
2804 argument is a DECL, then the name must not have been
2806 if (DECL_P (member
))
2807 write_expression (member
);
2810 write_string ("sr");
2812 write_member_name (member
);
2815 else if (INDIRECT_REF_P (expr
)
2816 && TREE_TYPE (TREE_OPERAND (expr
, 0))
2817 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2819 write_expression (TREE_OPERAND (expr
, 0));
2821 else if (identifier_p (expr
))
2823 /* An operator name appearing as a dependent name needs to be
2824 specially marked to disambiguate between a use of the operator
2825 name and a use of the operator in an expression. */
2826 if (IDENTIFIER_OPNAME_P (expr
))
2827 write_string ("on");
2828 write_unqualified_id (expr
);
2830 else if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
2832 tree fn
= TREE_OPERAND (expr
, 0);
2833 if (is_overloaded_fn (fn
))
2834 fn
= get_first_fn (fn
);
2836 fn
= DECL_NAME (fn
);
2837 if (IDENTIFIER_OPNAME_P (fn
))
2838 write_string ("on");
2839 write_unqualified_id (fn
);
2840 write_template_args (TREE_OPERAND (expr
, 1));
2842 else if (TREE_CODE (expr
) == MODOP_EXPR
)
2844 enum tree_code subop
= TREE_CODE (TREE_OPERAND (expr
, 1));
2845 const char *name
= (assignment_operator_name_info
[(int) subop
]
2847 write_string (name
);
2848 write_expression (TREE_OPERAND (expr
, 0));
2849 write_expression (TREE_OPERAND (expr
, 2));
2851 else if (code
== NEW_EXPR
|| code
== VEC_NEW_EXPR
)
2853 /* ::= [gs] nw <expression>* _ <type> E
2854 ::= [gs] nw <expression>* _ <type> <initializer>
2855 ::= [gs] na <expression>* _ <type> E
2856 ::= [gs] na <expression>* _ <type> <initializer>
2857 <initializer> ::= pi <expression>* E */
2858 tree placement
= TREE_OPERAND (expr
, 0);
2859 tree type
= TREE_OPERAND (expr
, 1);
2860 tree nelts
= TREE_OPERAND (expr
, 2);
2861 tree init
= TREE_OPERAND (expr
, 3);
2864 gcc_assert (code
== NEW_EXPR
);
2865 if (TREE_OPERAND (expr
, 2))
2866 code
= VEC_NEW_EXPR
;
2868 if (NEW_EXPR_USE_GLOBAL (expr
))
2869 write_string ("gs");
2871 write_string (operator_name_info
[(int) code
].mangled_name
);
2873 for (t
= placement
; t
; t
= TREE_CHAIN (t
))
2874 write_expression (TREE_VALUE (t
));
2881 ++processing_template_decl
;
2882 domain
= compute_array_index_type (NULL_TREE
, nelts
,
2883 tf_warning_or_error
);
2884 type
= build_cplus_array_type (type
, domain
);
2885 --processing_template_decl
;
2889 if (init
&& TREE_CODE (init
) == TREE_LIST
2890 && DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
2891 write_expression (TREE_VALUE (init
));
2895 write_string ("pi");
2896 if (init
&& init
!= void_node
)
2897 for (t
= init
; t
; t
= TREE_CHAIN (t
))
2898 write_expression (TREE_VALUE (t
));
2902 else if (code
== DELETE_EXPR
|| code
== VEC_DELETE_EXPR
)
2904 gcc_assert (code
== DELETE_EXPR
);
2905 if (DELETE_EXPR_USE_VEC (expr
))
2906 code
= VEC_DELETE_EXPR
;
2908 if (DELETE_EXPR_USE_GLOBAL (expr
))
2909 write_string ("gs");
2911 write_string (operator_name_info
[(int) code
].mangled_name
);
2913 write_expression (TREE_OPERAND (expr
, 0));
2915 else if (code
== THROW_EXPR
)
2917 tree op
= TREE_OPERAND (expr
, 0);
2920 write_string ("tw");
2921 write_expression (op
);
2924 write_string ("tr");
2926 else if (code
== CONSTRUCTOR
)
2928 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (expr
);
2929 unsigned i
; tree val
;
2931 if (BRACE_ENCLOSED_INITIALIZER_P (expr
))
2932 write_string ("il");
2935 write_string ("tl");
2936 write_type (TREE_TYPE (expr
));
2938 FOR_EACH_CONSTRUCTOR_VALUE (elts
, i
, val
)
2939 write_expression (val
);
2942 else if (dependent_name (expr
))
2944 write_unqualified_id (dependent_name (expr
));
2951 /* When we bind a variable or function to a non-type template
2952 argument with reference type, we create an ADDR_EXPR to show
2953 the fact that the entity's address has been taken. But, we
2954 don't actually want to output a mangling code for the `&'. */
2955 if (TREE_CODE (expr
) == ADDR_EXPR
2957 && TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
)
2959 expr
= TREE_OPERAND (expr
, 0);
2962 write_expression (expr
);
2966 code
= TREE_CODE (expr
);
2969 if (code
== COMPONENT_REF
)
2971 tree ob
= TREE_OPERAND (expr
, 0);
2973 if (TREE_CODE (ob
) == ARROW_EXPR
)
2975 write_string (operator_name_info
[(int)code
].mangled_name
);
2976 ob
= TREE_OPERAND (ob
, 0);
2977 write_expression (ob
);
2979 else if (!is_dummy_object (ob
))
2981 write_string ("dt");
2982 write_expression (ob
);
2984 /* else, for a non-static data member with no associated object (in
2985 unevaluated context), use the unresolved-name mangling. */
2987 write_member_name (TREE_OPERAND (expr
, 1));
2991 /* If it wasn't any of those, recursively expand the expression. */
2992 name
= operator_name_info
[(int) code
].mangled_name
;
2994 /* We used to mangle const_cast and static_cast like a C cast. */
2995 if (code
== CONST_CAST_EXPR
2996 || code
== STATIC_CAST_EXPR
)
2998 if (abi_warn_or_compat_version_crosses (6))
2999 G
.need_abi_warning
= 1;
3000 if (!abi_version_at_least (6))
3001 name
= operator_name_info
[CAST_EXPR
].mangled_name
;
3009 error ("use of built-in trait %qE in function signature; "
3010 "use library traits instead", expr
);
3014 sorry ("mangling %C", code
);
3020 write_string (name
);
3026 tree fn
= CALL_EXPR_FN (expr
);
3028 if (TREE_CODE (fn
) == ADDR_EXPR
)
3029 fn
= TREE_OPERAND (fn
, 0);
3031 /* Mangle a dependent name as the name, not whatever happens to
3032 be the first function in the overload set. */
3033 if ((TREE_CODE (fn
) == FUNCTION_DECL
3034 || TREE_CODE (fn
) == OVERLOAD
)
3035 && type_dependent_expression_p_push (expr
))
3036 fn
= DECL_NAME (get_first_fn (fn
));
3038 write_expression (fn
);
3041 for (i
= 0; i
< call_expr_nargs (expr
); ++i
)
3042 write_expression (CALL_EXPR_ARG (expr
, i
));
3047 write_type (TREE_TYPE (expr
));
3048 if (list_length (TREE_OPERAND (expr
, 0)) == 1)
3049 write_expression (TREE_VALUE (TREE_OPERAND (expr
, 0)));
3052 tree args
= TREE_OPERAND (expr
, 0);
3054 for (; args
; args
= TREE_CHAIN (args
))
3055 write_expression (TREE_VALUE (args
));
3060 case DYNAMIC_CAST_EXPR
:
3061 case REINTERPRET_CAST_EXPR
:
3062 case STATIC_CAST_EXPR
:
3063 case CONST_CAST_EXPR
:
3064 write_type (TREE_TYPE (expr
));
3065 write_expression (TREE_OPERAND (expr
, 0));
3068 case PREINCREMENT_EXPR
:
3069 case PREDECREMENT_EXPR
:
3070 if (abi_version_at_least (6))
3072 if (abi_warn_or_compat_version_crosses (6))
3073 G
.need_abi_warning
= 1;
3077 /* In the middle-end, some expressions have more operands than
3078 they do in templates (and mangling). */
3079 len
= cp_tree_operand_length (expr
);
3081 for (i
= 0; i
< len
; ++i
)
3083 tree operand
= TREE_OPERAND (expr
, i
);
3084 /* As a GNU extension, the middle operand of a
3085 conditional may be omitted. Since expression
3086 manglings are supposed to represent the input token
3087 stream, there's no good way to mangle such an
3088 expression without extending the C++ ABI. */
3089 if (code
== COND_EXPR
&& i
== 1 && !operand
)
3091 error ("omitted middle operand to %<?:%> operand "
3092 "cannot be mangled");
3095 write_expression (operand
);
3101 /* Literal subcase of non-terminal <template-arg>.
3103 "Literal arguments, e.g. "A<42L>", are encoded with their type
3104 and value. Negative integer values are preceded with "n"; for
3105 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
3106 encoded as 0, true as 1." */
3109 write_template_arg_literal (const tree value
)
3112 write_type (TREE_TYPE (value
));
3114 /* Write a null member pointer value as (type)0, regardless of its
3115 real representation. */
3116 if (null_member_pointer_value_p (value
))
3117 write_integer_cst (integer_zero_node
);
3119 switch (TREE_CODE (value
))
3122 write_integer_cst (DECL_INITIAL (value
));
3126 gcc_assert (!same_type_p (TREE_TYPE (value
), boolean_type_node
)
3127 || integer_zerop (value
) || integer_onep (value
));
3128 write_integer_cst (value
);
3132 write_real_cst (value
);
3136 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
3137 && TREE_CODE (TREE_IMAGPART (value
)) == INTEGER_CST
)
3139 write_integer_cst (TREE_REALPART (value
));
3141 write_integer_cst (TREE_IMAGPART (value
));
3143 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
3144 && TREE_CODE (TREE_IMAGPART (value
)) == REAL_CST
)
3146 write_real_cst (TREE_REALPART (value
));
3148 write_real_cst (TREE_IMAGPART (value
));
3155 sorry ("string literal in function template signature");
3165 /* Non-terminal <template-arg>.
3167 <template-arg> ::= <type> # type
3168 ::= L <type> </value/ number> E # literal
3169 ::= LZ <name> E # external name
3170 ::= X <expression> E # expression */
3173 write_template_arg (tree node
)
3175 enum tree_code code
= TREE_CODE (node
);
3177 MANGLE_TRACE_TREE ("template-arg", node
);
3179 /* A template template parameter's argument list contains TREE_LIST
3180 nodes of which the value field is the actual argument. */
3181 if (code
== TREE_LIST
)
3183 node
= TREE_VALUE (node
);
3184 /* If it's a decl, deal with its type instead. */
3187 node
= TREE_TYPE (node
);
3188 code
= TREE_CODE (node
);
3192 if (REFERENCE_REF_P (node
))
3193 node
= TREE_OPERAND (node
, 0);
3194 if (TREE_CODE (node
) == NOP_EXPR
3195 && TREE_CODE (TREE_TYPE (node
)) == REFERENCE_TYPE
)
3197 /* Template parameters can be of reference type. To maintain
3198 internal consistency, such arguments use a conversion from
3199 address of object to reference type. */
3200 gcc_assert (TREE_CODE (TREE_OPERAND (node
, 0)) == ADDR_EXPR
);
3201 node
= TREE_OPERAND (TREE_OPERAND (node
, 0), 0);
3204 if (TREE_CODE (node
) == BASELINK
3205 && !type_unknown_p (node
))
3207 if (abi_version_at_least (6))
3208 node
= BASELINK_FUNCTIONS (node
);
3209 if (abi_warn_or_compat_version_crosses (6))
3210 /* We wrongly wrapped a class-scope function in X/E. */
3211 G
.need_abi_warning
= 1;
3214 if (ARGUMENT_PACK_P (node
))
3216 /* Expand the template argument pack. */
3217 tree args
= ARGUMENT_PACK_ARGS (node
);
3218 int i
, length
= TREE_VEC_LENGTH (args
);
3219 if (abi_version_at_least (6))
3223 if (abi_warn_or_compat_version_crosses (6))
3224 G
.need_abi_warning
= 1;
3225 for (i
= 0; i
< length
; ++i
)
3226 write_template_arg (TREE_VEC_ELT (args
, i
));
3229 else if (TYPE_P (node
))
3231 else if (code
== TEMPLATE_DECL
)
3232 /* A template appearing as a template arg is a template template arg. */
3233 write_template_template_arg (node
);
3234 else if ((TREE_CODE_CLASS (code
) == tcc_constant
&& code
!= PTRMEM_CST
)
3235 || code
== CONST_DECL
3236 || null_member_pointer_value_p (node
))
3237 write_template_arg_literal (node
);
3238 else if (DECL_P (node
))
3241 /* Until ABI version 3, the underscore before the mangled name
3242 was incorrectly omitted. */
3243 if (!abi_version_at_least (3))
3246 write_string ("_Z");
3247 if (abi_warn_or_compat_version_crosses (3))
3248 G
.need_abi_warning
= 1;
3249 write_encoding (node
);
3254 /* Template arguments may be expressions. */
3256 write_expression (node
);
3261 /* <template-template-arg>
3263 ::= <substitution> */
3266 write_template_template_arg (const tree decl
)
3268 MANGLE_TRACE_TREE ("template-template-arg", decl
);
3270 if (find_substitution (decl
))
3272 write_name (decl
, /*ignore_local_scope=*/0);
3273 add_substitution (decl
);
3277 /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
3279 <array-type> ::= A [</dimension/ number>] _ </element/ type>
3280 ::= A <expression> _ </element/ type>
3282 "Array types encode the dimension (number of elements) and the
3283 element type. For variable length arrays, the dimension (but not
3284 the '_' separator) is omitted."
3285 Note that for flexible array members, like for other arrays of
3286 unspecified size, the dimension is also omitted. */
3289 write_array_type (const tree type
)
3292 if (TYPE_DOMAIN (type
))
3296 index_type
= TYPE_DOMAIN (type
);
3297 /* The INDEX_TYPE gives the upper and lower bounds of the array.
3298 It's null for flexible array members which have no upper bound
3299 (this is a change from GCC 5 and prior where such members were
3300 incorrectly mangled as zero-length arrays). */
3301 if (tree max
= TYPE_MAX_VALUE (index_type
))
3303 if (TREE_CODE (max
) == INTEGER_CST
)
3305 /* The ABI specifies that we should mangle the number of
3306 elements in the array, not the largest allowed index. */
3307 offset_int wmax
= wi::to_offset (max
) + 1;
3308 /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
3309 number of elements as zero. */
3310 wmax
= wi::zext (wmax
, TYPE_PRECISION (TREE_TYPE (max
)));
3311 gcc_assert (wi::fits_uhwi_p (wmax
));
3312 write_unsigned_number (wmax
.to_uhwi ());
3316 max
= TREE_OPERAND (max
, 0);
3317 write_expression (max
);
3322 write_type (TREE_TYPE (type
));
3325 /* Non-terminal <pointer-to-member-type> for pointer-to-member
3326 variables. TYPE is a pointer-to-member POINTER_TYPE.
3328 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
3331 write_pointer_to_member_type (const tree type
)
3334 write_type (TYPE_PTRMEM_CLASS_TYPE (type
));
3335 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type
));
3338 /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
3339 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3340 TEMPLATE_PARM_INDEX.
3342 <template-param> ::= T </parameter/ number> _ */
3345 write_template_param (const tree parm
)
3349 MANGLE_TRACE_TREE ("template-parm", parm
);
3351 switch (TREE_CODE (parm
))
3353 case TEMPLATE_TYPE_PARM
:
3354 case TEMPLATE_TEMPLATE_PARM
:
3355 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3356 parm_index
= TEMPLATE_TYPE_IDX (parm
);
3359 case TEMPLATE_PARM_INDEX
:
3360 parm_index
= TEMPLATE_PARM_IDX (parm
);
3368 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3369 earliest template param denoted by `_'. */
3370 write_compact_number (parm_index
);
3373 /* <template-template-param>
3374 ::= <template-param>
3375 ::= <substitution> */
3378 write_template_template_param (const tree parm
)
3380 tree templ
= NULL_TREE
;
3382 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3383 template template parameter. The substitution candidate here is
3384 only the template. */
3385 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
3388 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
));
3389 if (find_substitution (templ
))
3393 /* <template-param> encodes only the template parameter position,
3394 not its template arguments, which is fine here. */
3395 write_template_param (parm
);
3397 add_substitution (templ
);
3400 /* Non-terminal <substitution>.
3402 <substitution> ::= S <seq-id> _
3406 write_substitution (const int seq_id
)
3408 MANGLE_TRACE ("substitution", "");
3412 write_number (seq_id
- 1, /*unsigned=*/1, 36);
3416 /* Start mangling ENTITY. */
3419 start_mangling (const tree entity
)
3422 G
.need_abi_warning
= false;
3423 obstack_free (&name_obstack
, name_base
);
3424 mangle_obstack
= &name_obstack
;
3425 name_base
= obstack_alloc (&name_obstack
, 0);
3428 /* Done with mangling. If WARN is true, and the name of G.entity will
3429 be mangled differently in a future version of the ABI, issue a
3433 finish_mangling_internal (void)
3435 /* Clear all the substitutions. */
3436 vec_safe_truncate (G
.substitutions
, 0);
3438 /* Null-terminate the string. */
3443 /* Like finish_mangling_internal, but return the mangled string. */
3445 static inline const char *
3446 finish_mangling (void)
3448 finish_mangling_internal ();
3449 return (const char *) obstack_finish (mangle_obstack
);
3452 /* Like finish_mangling_internal, but return an identifier. */
3455 finish_mangling_get_identifier (void)
3457 finish_mangling_internal ();
3458 /* Don't obstack_finish here, and the next start_mangling will
3459 remove the identifier. */
3460 return get_identifier ((const char *) obstack_base (mangle_obstack
));
3463 /* Initialize data structures for mangling. */
3468 gcc_obstack_init (&name_obstack
);
3469 name_base
= obstack_alloc (&name_obstack
, 0);
3470 vec_alloc (G
.substitutions
, 0);
3472 /* Cache these identifiers for quick comparison when checking for
3473 standard substitutions. */
3474 subst_identifiers
[SUBID_ALLOCATOR
] = get_identifier ("allocator");
3475 subst_identifiers
[SUBID_BASIC_STRING
] = get_identifier ("basic_string");
3476 subst_identifiers
[SUBID_CHAR_TRAITS
] = get_identifier ("char_traits");
3477 subst_identifiers
[SUBID_BASIC_ISTREAM
] = get_identifier ("basic_istream");
3478 subst_identifiers
[SUBID_BASIC_OSTREAM
] = get_identifier ("basic_ostream");
3479 subst_identifiers
[SUBID_BASIC_IOSTREAM
] = get_identifier ("basic_iostream");
3482 /* Generate the mangled name of DECL. */
3485 mangle_decl_string (const tree decl
)
3488 location_t saved_loc
= input_location
;
3489 tree saved_fn
= NULL_TREE
;
3490 bool template_p
= false;
3492 /* We shouldn't be trying to mangle an uninstantiated template. */
3493 gcc_assert (!type_dependent_expression_p (decl
));
3495 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
3497 struct tinst_level
*tl
= current_instantiation ();
3498 if ((!tl
|| tl
->decl
!= decl
)
3499 && push_tinst_level (decl
))
3502 saved_fn
= current_function_decl
;
3503 current_function_decl
= NULL_TREE
;
3506 input_location
= DECL_SOURCE_LOCATION (decl
);
3508 start_mangling (decl
);
3510 if (TREE_CODE (decl
) == TYPE_DECL
)
3511 write_type (TREE_TYPE (decl
));
3513 write_mangled_name (decl
, true);
3515 result
= finish_mangling_get_identifier ();
3517 fprintf (stderr
, "mangle_decl_string = '%s'\n\n",
3518 IDENTIFIER_POINTER (result
));
3523 current_function_decl
= saved_fn
;
3525 input_location
= saved_loc
;
3530 /* Return an identifier for the external mangled name of DECL. */
3533 get_mangled_id (tree decl
)
3535 tree id
= mangle_decl_string (decl
);
3536 return targetm
.mangle_decl_assembler_name (decl
, id
);
3539 /* If DECL is an implicit mangling alias, return its symtab node; otherwise
3542 static symtab_node
*
3543 decl_implicit_alias_p (tree decl
)
3545 if (DECL_P (decl
) && DECL_ARTIFICIAL (decl
)
3546 && DECL_IGNORED_P (decl
)
3547 && (TREE_CODE (decl
) == FUNCTION_DECL
3548 || (VAR_P (decl
) && TREE_STATIC (decl
))))
3550 symtab_node
*n
= symtab_node::get (decl
);
3551 if (n
&& n
->cpp_implicit_alias
)
3557 /* If DECL is a mangling alias, remove it from the symbol table and return
3558 true; otherwise return false. */
3561 maybe_remove_implicit_alias (tree decl
)
3563 if (symtab_node
*n
= decl_implicit_alias_p (decl
))
3571 /* Create an identifier for the external mangled name of DECL. */
3574 mangle_decl (const tree decl
)
3579 /* Don't bother mangling uninstantiated templates. */
3580 ++processing_template_decl
;
3581 if (TREE_CODE (decl
) == TYPE_DECL
)
3582 dep
= dependent_type_p (TREE_TYPE (decl
));
3584 dep
= (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
3585 && any_dependent_template_arguments_p (DECL_TI_ARGS (decl
)));
3586 --processing_template_decl
;
3590 /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
3591 It is not needed to assign names to anonymous namespace, but we use the
3592 "<anon>" marker to be able to tell if type is C++ ODR type or type
3593 produced by other language. */
3594 if (TREE_CODE (decl
) == TYPE_DECL
3595 && TYPE_STUB_DECL (TREE_TYPE (decl
))
3596 && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl
))))
3597 id
= get_identifier ("<anon>");
3600 gcc_assert (TREE_CODE (decl
) != TYPE_DECL
3601 || !no_linkage_check (TREE_TYPE (decl
), true));
3602 id
= get_mangled_id (decl
);
3604 SET_DECL_ASSEMBLER_NAME (decl
, id
);
3606 if (id
!= DECL_NAME (decl
)
3607 && !DECL_REALLY_EXTERN (decl
)
3608 /* Don't do this for a fake symbol we aren't going to emit anyway. */
3609 && TREE_CODE (decl
) != TYPE_DECL
3610 && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
)
3611 && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
3615 /* Check IDENTIFIER_GLOBAL_VALUE before setting to avoid redundant
3616 errors from multiple definitions. */
3617 tree d
= IDENTIFIER_GLOBAL_VALUE (id
);
3618 if (!d
|| decl_implicit_alias_p (d
))
3621 SET_IDENTIFIER_GLOBAL_VALUE (id
, decl
);
3624 if (!G
.need_abi_warning
)
3627 /* If the mangling will change in the future, emit an alias with the
3628 future mangled name for forward-compatibility. */
3634 SET_IDENTIFIER_GLOBAL_VALUE (id
, decl
);
3635 inform (DECL_SOURCE_LOCATION (decl
), "a later -fabi-version= (or "
3636 "=0) avoids this error with a change in mangling");
3639 save_ver
= flag_abi_version
;
3641 flag_abi_version
= flag_abi_compat_version
;
3642 id2
= mangle_decl_string (decl
);
3643 id2
= targetm
.mangle_decl_assembler_name (decl
, id2
);
3646 note_mangling_alias (decl
, id2
);
3650 if (flag_abi_compat_version
!= warn_abi_version
)
3652 flag_abi_version
= warn_abi_version
;
3653 id2
= mangle_decl_string (decl
);
3654 id2
= targetm
.mangle_decl_assembler_name (decl
, id2
);
3659 else if (warn_abi_version
!= 0
3660 && abi_version_at_least (warn_abi_version
))
3661 warning_at (DECL_SOURCE_LOCATION (G
.entity
), OPT_Wabi
,
3662 "the mangled name of %qD changed between "
3663 "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3664 G
.entity
, save_ver
, id2
,
3665 warn_abi_version
, id
);
3667 warning_at (DECL_SOURCE_LOCATION (G
.entity
), OPT_Wabi
,
3668 "the mangled name of %qD changes between "
3669 "-fabi-version=%d (%D) and -fabi-version=%d (%D)",
3670 G
.entity
, save_ver
, id
,
3671 warn_abi_version
, id2
);
3674 flag_abi_version
= save_ver
;
3678 /* Generate the mangled representation of TYPE. */
3681 mangle_type_string (const tree type
)
3685 start_mangling (type
);
3687 result
= finish_mangling ();
3689 fprintf (stderr
, "mangle_type_string = '%s'\n\n", result
);
3693 /* Create an identifier for the mangled name of a special component
3694 for belonging to TYPE. CODE is the ABI-specified code for this
3698 mangle_special_for_type (const tree type
, const char *code
)
3702 /* We don't have an actual decl here for the special component, so
3703 we can't just process the <encoded-name>. Instead, fake it. */
3704 start_mangling (type
);
3706 /* Start the mangling. */
3707 write_string ("_Z");
3708 write_string (code
);
3712 result
= finish_mangling_get_identifier ();
3715 fprintf (stderr
, "mangle_special_for_type = %s\n\n",
3716 IDENTIFIER_POINTER (result
));
3721 /* Create an identifier for the mangled representation of the typeinfo
3722 structure for TYPE. */
3725 mangle_typeinfo_for_type (const tree type
)
3727 return mangle_special_for_type (type
, "TI");
3730 /* Create an identifier for the mangled name of the NTBS containing
3731 the mangled name of TYPE. */
3734 mangle_typeinfo_string_for_type (const tree type
)
3736 return mangle_special_for_type (type
, "TS");
3739 /* Create an identifier for the mangled name of the vtable for TYPE. */
3742 mangle_vtbl_for_type (const tree type
)
3744 return mangle_special_for_type (type
, "TV");
3747 /* Returns an identifier for the mangled name of the VTT for TYPE. */
3750 mangle_vtt_for_type (const tree type
)
3752 return mangle_special_for_type (type
, "TT");
3755 /* Return an identifier for a construction vtable group. TYPE is
3756 the most derived class in the hierarchy; BINFO is the base
3757 subobject for which this construction vtable group will be used.
3759 This mangling isn't part of the ABI specification; in the ABI
3760 specification, the vtable group is dumped in the same COMDAT as the
3761 main vtable, and is referenced only from that vtable, so it doesn't
3762 need an external name. For binary formats without COMDAT sections,
3763 though, we need external names for the vtable groups.
3765 We use the production
3767 <special-name> ::= CT <type> <offset number> _ <base type> */
3770 mangle_ctor_vtbl_for_type (const tree type
, const tree binfo
)
3774 start_mangling (type
);
3776 write_string ("_Z");
3777 write_string ("TC");
3779 write_integer_cst (BINFO_OFFSET (binfo
));
3781 write_type (BINFO_TYPE (binfo
));
3783 result
= finish_mangling_get_identifier ();
3785 fprintf (stderr
, "mangle_ctor_vtbl_for_type = %s\n\n",
3786 IDENTIFIER_POINTER (result
));
3790 /* Mangle a this pointer or result pointer adjustment.
3792 <call-offset> ::= h <fixed offset number> _
3793 ::= v <fixed offset number> _ <virtual offset number> _ */
3796 mangle_call_offset (const tree fixed_offset
, const tree virtual_offset
)
3798 write_char (virtual_offset
? 'v' : 'h');
3800 /* For either flavor, write the fixed offset. */
3801 write_integer_cst (fixed_offset
);
3804 /* For a virtual thunk, add the virtual offset. */
3807 write_integer_cst (virtual_offset
);
3812 /* Return an identifier for the mangled name of a this-adjusting or
3813 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment
3814 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this
3815 is a virtual thunk, and it is the vtbl offset in
3816 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
3817 zero for a covariant thunk. Note, that FN_DECL might be a covariant
3818 thunk itself. A covariant thunk name always includes the adjustment
3819 for the this pointer, even if there is none.
3821 <special-name> ::= T <call-offset> <base encoding>
3822 ::= Tc <this_adjust call-offset> <result_adjust call-offset>
3826 mangle_thunk (tree fn_decl
, const int this_adjusting
, tree fixed_offset
,
3827 tree virtual_offset
)
3831 start_mangling (fn_decl
);
3833 write_string ("_Z");
3836 if (!this_adjusting
)
3838 /* Covariant thunk with no this adjustment */
3840 mangle_call_offset (integer_zero_node
, NULL_TREE
);
3841 mangle_call_offset (fixed_offset
, virtual_offset
);
3843 else if (!DECL_THUNK_P (fn_decl
))
3844 /* Plain this adjusting thunk. */
3845 mangle_call_offset (fixed_offset
, virtual_offset
);
3848 /* This adjusting thunk to covariant thunk. */
3850 mangle_call_offset (fixed_offset
, virtual_offset
);
3851 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn_decl
));
3852 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn_decl
);
3854 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
3855 mangle_call_offset (fixed_offset
, virtual_offset
);
3856 fn_decl
= THUNK_TARGET (fn_decl
);
3860 write_encoding (fn_decl
);
3862 result
= finish_mangling_get_identifier ();
3864 fprintf (stderr
, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result
));
3868 struct conv_type_hasher
: ggc_ptr_hash
<tree_node
>
3870 static hashval_t
hash (tree
);
3871 static bool equal (tree
, tree
);
3874 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3875 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
3878 static GTY (()) hash_table
<conv_type_hasher
> *conv_type_names
;
3880 /* Hash a node (VAL1) in the table. */
3883 conv_type_hasher::hash (tree val
)
3885 return (hashval_t
) TYPE_UID (TREE_TYPE (val
));
3888 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */
3891 conv_type_hasher::equal (tree val1
, tree val2
)
3893 return TREE_TYPE (val1
) == val2
;
3896 /* Return an identifier for the mangled unqualified name for a
3897 conversion operator to TYPE. This mangling is not specified by the
3898 ABI spec; it is only used internally. */
3901 mangle_conv_op_name_for_type (const tree type
)
3906 if (type
== error_mark_node
)
3907 return error_mark_node
;
3909 if (conv_type_names
== NULL
)
3910 conv_type_names
= hash_table
<conv_type_hasher
>::create_ggc (31);
3912 slot
= conv_type_names
->find_slot_with_hash (type
,
3913 (hashval_t
) TYPE_UID (type
),
3920 /* Create a unique name corresponding to TYPE. */
3921 sprintf (buffer
, "operator %lu",
3922 (unsigned long) conv_type_names
->elements ());
3923 identifier
= get_identifier (buffer
);
3926 /* Hang TYPE off the identifier so it can be found easily later
3927 when performing conversions. */
3928 TREE_TYPE (identifier
) = type
;
3930 /* Set bits on the identifier so we know later it's a conversion. */
3931 IDENTIFIER_OPNAME_P (identifier
) = 1;
3932 IDENTIFIER_TYPENAME_P (identifier
) = 1;
3938 /* Handle ABI backwards compatibility for past bugs where we didn't call
3939 check_abi_tags in places where it's needed: call check_abi_tags and warn if
3940 it makes a difference. */
3943 maybe_check_abi_tags (tree t
)
3945 tree attr
= lookup_attribute ("abi_tag", DECL_ATTRIBUTES (t
));
3946 tree oldtags
= NULL_TREE
;
3948 oldtags
= TREE_VALUE (attr
);
3953 attr
= lookup_attribute ("abi_tag", DECL_ATTRIBUTES (t
));
3954 if (attr
&& TREE_VALUE (attr
) != oldtags
3955 && abi_version_crosses (10))
3956 warning_at (DECL_SOURCE_LOCATION (t
), OPT_Wabi
,
3957 "the mangled name of the initialization guard variable for"
3958 "%qD changes between -fabi-version=%d and -fabi-version=%d",
3959 t
, flag_abi_version
, warn_abi_version
);
3962 /* Write out the appropriate string for this variable when generating
3963 another mangled name based on this one. */
3966 write_guarded_var_name (const tree variable
)
3968 if (DECL_NAME (variable
)
3969 && strncmp (IDENTIFIER_POINTER (DECL_NAME (variable
)), "_ZGR", 4) == 0)
3970 /* The name of a guard variable for a reference temporary should refer
3971 to the reference, not the temporary. */
3972 write_string (IDENTIFIER_POINTER (DECL_NAME (variable
)) + 4);
3975 /* Before ABI v10 we were failing to call check_abi_tags here. So if
3976 we're in pre-10 mode, wait until after write_name to call it. */
3977 if (abi_version_at_least (10))
3978 maybe_check_abi_tags (variable
);
3979 write_name (variable
, /*ignore_local_scope=*/0);
3980 if (!abi_version_at_least (10))
3981 maybe_check_abi_tags (variable
);
3985 /* Return an identifier for the name of an initialization guard
3986 variable for indicated VARIABLE. */
3989 mangle_guard_variable (const tree variable
)
3991 start_mangling (variable
);
3992 write_string ("_ZGV");
3993 write_guarded_var_name (variable
);
3994 return finish_mangling_get_identifier ();
3997 /* Return an identifier for the name of a thread_local initialization
3998 function for VARIABLE. */
4001 mangle_tls_init_fn (const tree variable
)
4003 start_mangling (variable
);
4004 write_string ("_ZTH");
4005 write_guarded_var_name (variable
);
4006 return finish_mangling_get_identifier ();
4009 /* Return an identifier for the name of a thread_local wrapper
4010 function for VARIABLE. */
4012 #define TLS_WRAPPER_PREFIX "_ZTW"
4015 mangle_tls_wrapper_fn (const tree variable
)
4017 start_mangling (variable
);
4018 write_string (TLS_WRAPPER_PREFIX
);
4019 write_guarded_var_name (variable
);
4020 return finish_mangling_get_identifier ();
4023 /* Return true iff FN is a thread_local wrapper function. */
4026 decl_tls_wrapper_p (const tree fn
)
4028 if (TREE_CODE (fn
) != FUNCTION_DECL
)
4030 tree name
= DECL_NAME (fn
);
4031 return strncmp (IDENTIFIER_POINTER (name
), TLS_WRAPPER_PREFIX
,
4032 strlen (TLS_WRAPPER_PREFIX
)) == 0;
4035 /* Return an identifier for the name of a temporary variable used to
4036 initialize a static reference. This isn't part of the ABI, but we might
4037 as well call them something readable. */
4039 static GTY(()) int temp_count
;
4042 mangle_ref_init_variable (const tree variable
)
4044 start_mangling (variable
);
4045 write_string ("_ZGR");
4046 check_abi_tags (variable
);
4047 write_name (variable
, /*ignore_local_scope=*/0);
4048 /* Avoid name clashes with aggregate initialization of multiple
4049 references at once. */
4050 write_unsigned_number (temp_count
++);
4051 return finish_mangling_get_identifier ();
4055 /* Foreign language type mangling section. */
4057 /* How to write the type codes for the integer Java type. */
4060 write_java_integer_type_codes (const tree type
)
4062 if (type
== java_int_type_node
)
4064 else if (type
== java_short_type_node
)
4066 else if (type
== java_byte_type_node
)
4068 else if (type
== java_char_type_node
)
4070 else if (type
== java_long_type_node
)
4072 else if (type
== java_boolean_type_node
)
4078 /* Given a CLASS_TYPE, such as a record for std::bad_exception this
4079 function generates a mangled name for the vtable map variable of
4080 the class type. For example, if the class type is
4081 "std::bad_exception", the mangled name for the class is
4082 "St13bad_exception". This function would generate the name
4083 "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
4084 "_VTV<std::bad_exception>::__vtable_map". */
4088 get_mangled_vtable_map_var_name (tree class_type
)
4090 char *var_name
= NULL
;
4091 const char *prefix
= "_ZN4_VTVI";
4092 const char *postfix
= "E12__vtable_mapE";
4094 gcc_assert (TREE_CODE (class_type
) == RECORD_TYPE
);
4096 tree class_id
= DECL_ASSEMBLER_NAME (TYPE_NAME (class_type
));
4098 if (strstr (IDENTIFIER_POINTER (class_id
), "<anon>") != NULL
)
4100 class_id
= get_mangled_id (TYPE_NAME (class_type
));
4101 vtbl_register_mangled_name (TYPE_NAME (class_type
), class_id
);
4104 unsigned int len
= strlen (IDENTIFIER_POINTER (class_id
)) +
4106 strlen (postfix
) + 1;
4108 var_name
= (char *) xmalloc (len
);
4110 sprintf (var_name
, "%s%s%s", prefix
, IDENTIFIER_POINTER (class_id
), postfix
);
4115 #include "gt-cp-mangle.h"