1 /* Name mangling for the 3.0 -*- C++ -*- ABI.
2 Copyright (C) 2000-2020 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 (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \
85 || (CLASS_TYPE_P (NODE) \
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 /* And sometimes we can simplify the code path if we don't need to worry about
96 #define abi_flag_at_least(flag,N) (flag == 0 || flag >= N)
97 #define any_abi_below(N) \
98 (!abi_version_at_least (N) \
99 || !abi_flag_at_least (warn_abi_version, (N)) \
100 || !abi_flag_at_least (flag_abi_compat_version, (N)))
102 /* Things we only need one of. This module is not reentrant. */
103 struct GTY(()) globals
{
104 /* An array of the current substitution candidates, in the order
106 vec
<tree
, va_gc
> *substitutions
;
108 /* The entity that is being mangled. */
109 tree
GTY ((skip
)) entity
;
111 /* How many parameter scopes we are inside. */
114 /* True if the mangling will be different in a future version of the
116 bool need_abi_warning
;
118 /* True if the mangling will be different in C++17 mode. */
119 bool need_cxx17_warning
;
122 static GTY (()) globals G
;
124 /* The obstack on which we build mangled names. */
125 static struct obstack
*mangle_obstack
;
127 /* The obstack on which we build mangled names that are not going to
128 be IDENTIFIER_NODEs. */
129 static struct obstack name_obstack
;
131 /* The first object on the name_obstack; we use this to free memory
132 allocated on the name_obstack. */
133 static void *name_base
;
135 /* Indices into subst_identifiers. These are identifiers used in
136 special substitution rules. */
144 SUBID_BASIC_IOSTREAM
,
147 substitution_identifier_index_t
;
149 /* For quick substitution checks, look up these common identifiers
151 static GTY(()) tree subst_identifiers
[SUBID_MAX
];
153 /* Single-letter codes for builtin integer types, defined in
154 <builtin-type>. These are indexed by integer_type_kind values. */
156 integer_type_codes
[itk_none
] =
159 'a', /* itk_signed_char */
160 'h', /* itk_unsigned_char */
162 't', /* itk_unsigned_short */
164 'j', /* itk_unsigned_int */
166 'm', /* itk_unsigned_long */
167 'x', /* itk_long_long */
168 'y', /* itk_unsigned_long_long */
169 /* __intN types are handled separately */
170 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
173 static tree
maybe_template_info (const tree
);
175 /* Functions for handling substitutions. */
177 static inline tree
canonicalize_for_substitution (tree
);
178 static void add_substitution (tree
);
179 static inline int is_std_substitution (const tree
,
180 const substitution_identifier_index_t
);
181 static inline int is_std_substitution_char (const tree
,
182 const substitution_identifier_index_t
);
183 static int find_substitution (tree
);
184 static void mangle_call_offset (const tree
, const tree
);
186 /* Functions for emitting mangled representations of things. */
188 static void write_mangled_name (const tree
, bool);
189 static void write_encoding (const tree
);
190 static void write_name (tree
, const int);
191 static void write_abi_tags (tree
);
192 static void write_unscoped_name (const tree
);
193 static void write_unscoped_template_name (const tree
);
194 static void write_nested_name (const tree
);
195 static void write_prefix (const tree
);
196 static void write_template_prefix (const tree
);
197 static void write_unqualified_name (tree
);
198 static void write_conversion_operator_name (const tree
);
199 static void write_source_name (tree
);
200 static void write_literal_operator_name (tree
);
201 static void write_unnamed_type_name (const tree
);
202 static void write_closure_type_name (const tree
);
203 static int hwint_to_ascii (unsigned HOST_WIDE_INT
, const unsigned int, char *,
205 static void write_number (unsigned HOST_WIDE_INT
, const int,
207 static void write_compact_number (int num
);
208 static void write_integer_cst (const tree
);
209 static void write_real_cst (const tree
);
210 static void write_identifier (const char *);
211 static void write_special_name_constructor (const tree
);
212 static void write_special_name_destructor (const tree
);
213 static void write_type (tree
);
214 static int write_CV_qualifiers_for_type (const tree
);
215 static void write_builtin_type (tree
);
216 static void write_function_type (const tree
);
217 static void write_bare_function_type (const tree
, const int, const tree
);
218 static void write_method_parms (tree
, const int, const tree
);
219 static void write_class_enum_type (const tree
);
220 static void write_template_args (tree
);
221 static void write_expression (tree
);
222 static void write_template_arg_literal (const tree
);
223 static void write_template_arg (tree
);
224 static void write_template_template_arg (const tree
);
225 static void write_array_type (const tree
);
226 static void write_pointer_to_member_type (const tree
);
227 static void write_template_param (const tree
);
228 static void write_template_template_param (const tree
);
229 static void write_substitution (const int);
230 static int discriminator_for_local_entity (tree
);
231 static int discriminator_for_string_literal (tree
, tree
);
232 static void write_discriminator (const int);
233 static void write_local_name (tree
, const tree
, const tree
);
234 static void dump_substitution_candidates (void);
235 static tree
mangle_decl_string (const tree
);
236 static void maybe_check_abi_tags (tree
, tree
= NULL_TREE
, int = 10);
237 static bool equal_abi_tags (tree
, tree
);
239 /* Control functions. */
241 static inline void start_mangling (const tree
);
242 static tree
mangle_special_for_type (const tree
, const char *);
244 /* Append a single character to the end of the mangled
246 #define write_char(CHAR) \
247 obstack_1grow (mangle_obstack, (CHAR))
249 /* Append a sized buffer to the end of the mangled representation. */
250 #define write_chars(CHAR, LEN) \
251 obstack_grow (mangle_obstack, (CHAR), (LEN))
253 /* Append a NUL-terminated string to the end of the mangled
255 #define write_string(STRING) \
256 obstack_grow (mangle_obstack, (STRING), strlen (STRING))
258 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
259 same purpose (context, which may be a type) and value (template
260 decl). See write_template_prefix for more information on what this
262 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \
263 (TREE_CODE (NODE1) == TREE_LIST \
264 && TREE_CODE (NODE2) == TREE_LIST \
265 && ((TYPE_P (TREE_PURPOSE (NODE1)) \
266 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))) \
267 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \
268 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
270 /* Write out an unsigned quantity in base 10. */
271 #define write_unsigned_number(NUMBER) \
272 write_number ((NUMBER), /*unsigned_p=*/1, 10)
274 /* If DECL is a template instance (including the uninstantiated template
275 itself), return its TEMPLATE_INFO. Otherwise return NULL. */
278 maybe_template_info (const tree decl
)
280 if (TREE_CODE (decl
) == TYPE_DECL
)
282 /* TYPE_DECLs are handled specially. Look at its type to decide
283 if this is a template instantiation. */
284 const tree type
= TREE_TYPE (decl
);
286 if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_ID_P (type
))
287 return TYPE_TEMPLATE_INFO (type
);
291 /* Check if the template is a primary template. */
292 if (DECL_LANG_SPECIFIC (decl
) != NULL
293 && VAR_OR_FUNCTION_DECL_P (decl
)
294 && DECL_TEMPLATE_INFO (decl
)
295 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
)))
296 return DECL_TEMPLATE_INFO (decl
);
299 /* It's not a template id. */
303 /* Produce debugging output of current substitution candidates. */
306 dump_substitution_candidates (void)
311 fprintf (stderr
, " ++ substitutions ");
312 FOR_EACH_VEC_ELT (*G
.substitutions
, i
, el
)
314 const char *name
= "???";
317 fprintf (stderr
, " ");
319 name
= IDENTIFIER_POINTER (DECL_NAME (el
));
320 else if (TREE_CODE (el
) == TREE_LIST
)
321 name
= IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el
)));
322 else if (TYPE_NAME (el
))
323 name
= TYPE_NAME_STRING (el
);
324 fprintf (stderr
, " S%d_ = ", i
- 1);
326 (CP_TYPE_RESTRICT_P (el
)
327 || CP_TYPE_VOLATILE_P (el
)
328 || CP_TYPE_CONST_P (el
)))
329 fprintf (stderr
, "CV-");
330 fprintf (stderr
, "%s (%s at %p)\n",
331 name
, get_tree_code_name (TREE_CODE (el
)), (void *) el
);
335 /* <exception-spec> ::=
336 Do -- non-throwing exception specification
337 DO <expression> E -- computed (instantiation-dependent) noexcept
338 Dw <type>* E -- throw (types) */
341 write_exception_spec (tree spec
)
344 if (!spec
|| spec
== noexcept_false_spec
)
348 if (!flag_noexcept_type
)
350 G
.need_cxx17_warning
= true;
354 if (spec
== noexcept_true_spec
|| spec
== empty_except_spec
)
356 else if (tree expr
= TREE_PURPOSE (spec
))
358 /* noexcept (expr) */
359 gcc_assert (uses_template_parms (expr
));
361 write_expression (expr
);
366 /* throw (type-list) */
368 for (tree t
= spec
; t
; t
= TREE_CHAIN (t
))
369 write_type (TREE_VALUE (t
));
374 /* Both decls and types can be substitution candidates, but sometimes
375 they refer to the same thing. For instance, a TYPE_DECL and
376 RECORD_TYPE for the same class refer to the same thing, and should
377 be treated accordingly in substitutions. This function returns a
378 canonicalized tree node representing NODE that is used when adding
379 and substitution candidates and finding matches. */
382 canonicalize_for_substitution (tree node
)
384 /* For a TYPE_DECL, use the type instead. */
385 if (TREE_CODE (node
) == TYPE_DECL
)
386 node
= TREE_TYPE (node
);
388 && TYPE_CANONICAL (node
) != node
389 && TYPE_MAIN_VARIANT (node
) != node
)
392 /* Here we want to strip the topmost typedef only.
393 We need to do that so is_std_substitution can do proper
395 if (TREE_CODE (node
) == FUNCTION_TYPE
)
396 /* Use build_qualified_type and TYPE_QUALS here to preserve
397 the old buggy mangling of attribute noreturn with abi<5. */
398 node
= build_qualified_type (TYPE_MAIN_VARIANT (node
),
401 node
= cp_build_qualified_type (TYPE_MAIN_VARIANT (node
),
402 cp_type_quals (node
));
403 if (FUNC_OR_METHOD_TYPE_P (node
))
405 node
= build_ref_qualified_type (node
, type_memfn_rqual (orig
));
406 tree r
= canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (orig
));
407 if (flag_noexcept_type
)
408 node
= build_exception_variant (node
, r
);
410 /* Set the warning flag if appropriate. */
411 write_exception_spec (r
);
417 /* Add NODE as a substitution candidate. NODE must not already be on
418 the list of candidates. */
421 add_substitution (tree node
)
426 fprintf (stderr
, " ++ add_substitution (%s at %10p)\n",
427 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
429 /* Get the canonicalized substitution candidate for NODE. */
430 c
= canonicalize_for_substitution (node
);
431 if (DEBUG_MANGLE
&& c
!= node
)
432 fprintf (stderr
, " ++ using candidate (%s at %10p)\n",
433 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
436 /* Make sure NODE isn't already a candidate. */
442 FOR_EACH_VEC_SAFE_ELT (G
.substitutions
, i
, candidate
)
444 gcc_assert (!(DECL_P (node
) && node
== candidate
));
445 gcc_assert (!(TYPE_P (node
) && TYPE_P (candidate
)
446 && same_type_p (node
, candidate
)));
450 /* Put the decl onto the varray of substitution candidates. */
451 vec_safe_push (G
.substitutions
, node
);
454 dump_substitution_candidates ();
457 /* Helper function for find_substitution. Returns nonzero if NODE,
458 which may be a decl or a CLASS_TYPE, is a template-id with template
459 name of substitution_index[INDEX] in the ::std namespace. */
462 is_std_substitution (const tree node
,
463 const substitution_identifier_index_t index
)
470 type
= TREE_TYPE (node
);
473 else if (CLASS_TYPE_P (node
))
476 decl
= TYPE_NAME (node
);
479 /* These are not the droids you're looking for. */
482 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl
))
483 && TYPE_LANG_SPECIFIC (type
)
484 && TYPE_TEMPLATE_INFO (type
)
485 && (DECL_NAME (TYPE_TI_TEMPLATE (type
))
486 == subst_identifiers
[index
]));
489 /* Return the ABI tags (the TREE_VALUE of the "abi_tag" attribute entry) for T,
490 which can be a decl or type. */
493 get_abi_tags (tree t
)
495 if (!t
|| TREE_CODE (t
) == NAMESPACE_DECL
)
498 if (DECL_P (t
) && DECL_DECLARES_TYPE_P (t
))
503 attrs
= TYPE_ATTRIBUTES (t
);
505 attrs
= DECL_ATTRIBUTES (t
);
507 tree tags
= lookup_attribute ("abi_tag", attrs
);
509 tags
= TREE_VALUE (tags
);
513 /* Helper function for find_substitution. Returns nonzero if NODE,
514 which may be a decl or a CLASS_TYPE, is the template-id
515 ::std::identifier<char>, where identifier is
516 substitution_index[INDEX]. */
519 is_std_substitution_char (const tree node
,
520 const substitution_identifier_index_t index
)
523 /* Check NODE's name is ::std::identifier. */
524 if (!is_std_substitution (node
, index
))
526 /* Figure out its template args. */
528 args
= DECL_TI_ARGS (node
);
529 else if (CLASS_TYPE_P (node
))
530 args
= CLASSTYPE_TI_ARGS (node
);
532 /* Oops, not a template. */
534 /* NODE's template arg list should be <char>. */
536 TREE_VEC_LENGTH (args
) == 1
537 && TREE_VEC_ELT (args
, 0) == char_type_node
;
540 /* Check whether a substitution should be used to represent NODE in
543 First, check standard special-case substitutions.
545 <substitution> ::= St
552 # ::std::basic_string
555 # ::std::basic_string<char,
556 ::std::char_traits<char>,
557 ::std::allocator<char> >
560 # ::std::basic_istream<char, ::std::char_traits<char> >
563 # ::std::basic_ostream<char, ::std::char_traits<char> >
566 # ::std::basic_iostream<char, ::std::char_traits<char> >
568 Then examine the stack of currently available substitution
569 candidates for entities appearing earlier in the same mangling
571 If a substitution is found, write its mangled representation and
572 return nonzero. If none is found, just return zero. */
575 find_substitution (tree node
)
578 const int size
= vec_safe_length (G
.substitutions
);
581 const char *abbr
= NULL
;
584 fprintf (stderr
, " ++ find_substitution (%s at %p)\n",
585 get_tree_code_name (TREE_CODE (node
)), (void *) node
);
587 /* Obtain the canonicalized substitution representation for NODE.
588 This is what we'll compare against. */
589 node
= canonicalize_for_substitution (node
);
591 /* Check for builtin substitutions. */
593 decl
= TYPE_P (node
) ? TYPE_NAME (node
) : node
;
594 type
= TYPE_P (node
) ? node
: TREE_TYPE (node
);
596 /* Check for std::allocator. */
598 && is_std_substitution (decl
, SUBID_ALLOCATOR
)
599 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl
)))
602 /* Check for std::basic_string. */
603 else if (decl
&& is_std_substitution (decl
, SUBID_BASIC_STRING
))
607 /* If this is a type (i.e. a fully-qualified template-id),
609 std::basic_string <char,
610 std::char_traits<char>,
611 std::allocator<char> > . */
612 if (cp_type_quals (type
) == TYPE_UNQUALIFIED
613 && CLASSTYPE_USE_TEMPLATE (type
))
615 tree args
= CLASSTYPE_TI_ARGS (type
);
616 if (TREE_VEC_LENGTH (args
) == 3
617 && template_args_equal (TREE_VEC_ELT (args
, 0), char_type_node
)
618 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
620 && is_std_substitution_char (TREE_VEC_ELT (args
, 2),
626 /* Substitute for the template name only if this isn't a type. */
630 /* Check for basic_{i,o,io}stream. */
631 else if (TYPE_P (node
)
632 && cp_type_quals (type
) == TYPE_UNQUALIFIED
633 && CLASS_TYPE_P (type
)
634 && CLASSTYPE_USE_TEMPLATE (type
)
635 && CLASSTYPE_TEMPLATE_INFO (type
) != NULL
)
637 /* First, check for the template
638 args <char, std::char_traits<char> > . */
639 tree args
= CLASSTYPE_TI_ARGS (type
);
640 if (TREE_VEC_LENGTH (args
) == 2
641 && template_args_equal (TREE_VEC_ELT (args
, 0), char_type_node
)
642 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
645 /* Got them. Is this basic_istream? */
646 if (is_std_substitution (decl
, SUBID_BASIC_ISTREAM
))
648 /* Or basic_ostream? */
649 else if (is_std_substitution (decl
, SUBID_BASIC_OSTREAM
))
651 /* Or basic_iostream? */
652 else if (is_std_substitution (decl
, SUBID_BASIC_IOSTREAM
))
657 /* Check for namespace std. */
658 else if (decl
&& DECL_NAMESPACE_STD_P (decl
))
664 tree tags
= NULL_TREE
;
665 if (OVERLOAD_TYPE_P (node
) || DECL_CLASS_TEMPLATE_P (node
))
666 tags
= get_abi_tags (type
);
667 /* Now check the list of available substitutions for this mangling
669 if (!abbr
|| tags
) for (i
= 0; i
< size
; ++i
)
671 tree candidate
= (*G
.substitutions
)[i
];
672 /* NODE is a matched to a candidate if it's the same decl node or
673 if it's the same type. */
674 if (decl
== candidate
675 || (TYPE_P (candidate
) && type
&& TYPE_P (node
)
676 && same_type_p (type
, candidate
))
677 || NESTED_TEMPLATE_MATCH (node
, candidate
))
679 write_substitution (i
);
685 /* No substitution found. */
691 /* If there are ABI tags on the abbreviation, it becomes
692 a substitution candidate. */
693 write_abi_tags (tags
);
694 add_substitution (node
);
699 /* Returns whether DECL's symbol name should be the plain unqualified-id
700 rather than a more complicated mangled name. */
703 unmangled_name_p (const tree decl
)
705 if (TREE_CODE (decl
) == FUNCTION_DECL
)
707 /* The names of `extern "C"' functions are not mangled. */
708 return (DECL_EXTERN_C_FUNCTION_P (decl
)
709 /* But overloaded operator names *are* mangled. */
710 && !DECL_OVERLOADED_OPERATOR_P (decl
));
712 else if (VAR_P (decl
))
714 /* static variables are mangled. */
715 if (!DECL_EXTERNAL_LINKAGE_P (decl
))
718 /* extern "C" declarations aren't mangled. */
719 if (DECL_EXTERN_C_P (decl
))
722 /* Other variables at non-global scope are mangled. */
723 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
726 /* Variable template instantiations are mangled. */
727 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
728 && variable_template_p (DECL_TI_TEMPLATE (decl
)))
731 /* Declarations with ABI tags are mangled. */
732 if (get_abi_tags (decl
))
735 /* The names of non-static global variables aren't mangled. */
742 /* TOP_LEVEL is true, if this is being called at outermost level of
743 mangling. It should be false when mangling a decl appearing in an
744 expression within some other mangling.
746 <mangled-name> ::= _Z <encoding> */
749 write_mangled_name (const tree decl
, bool top_level
)
751 MANGLE_TRACE_TREE ("mangled-name", decl
);
753 check_abi_tags (decl
);
755 if (unmangled_name_p (decl
))
758 write_string (IDENTIFIER_POINTER (DECL_NAME (decl
)));
761 /* The standard notes: "The <encoding> of an extern "C"
762 function is treated like global-scope data, i.e. as its
763 <source-name> without a type." We cannot write
764 overloaded operators that way though, because it contains
765 characters invalid in assembler. */
767 write_source_name (DECL_NAME (decl
));
773 write_encoding (decl
);
777 /* Returns true if the return type of DECL is part of its signature, and
778 therefore its mangling. */
781 mangle_return_type_p (tree decl
)
783 return (!DECL_CONSTRUCTOR_P (decl
)
784 && !DECL_DESTRUCTOR_P (decl
)
785 && !DECL_CONV_FN_P (decl
)
786 && maybe_template_info (decl
));
789 /* <encoding> ::= <function name> <bare-function-type>
793 write_encoding (const tree decl
)
795 MANGLE_TRACE_TREE ("encoding", decl
);
797 if (DECL_LANG_SPECIFIC (decl
) && DECL_EXTERN_C_FUNCTION_P (decl
))
799 /* For overloaded operators write just the mangled name
800 without arguments. */
801 if (DECL_OVERLOADED_OPERATOR_P (decl
))
802 write_name (decl
, /*ignore_local_scope=*/0);
804 write_source_name (DECL_NAME (decl
));
808 write_name (decl
, /*ignore_local_scope=*/0);
809 if (TREE_CODE (decl
) == FUNCTION_DECL
)
814 if (maybe_template_info (decl
))
816 fn_type
= get_mostly_instantiated_function_type (decl
);
817 /* FN_TYPE will not have parameter types for in-charge or
818 VTT parameters. Therefore, we pass NULL_TREE to
819 write_bare_function_type -- otherwise, it will get
820 confused about which artificial parameters to skip. */
825 fn_type
= TREE_TYPE (decl
);
829 write_bare_function_type (fn_type
,
830 mangle_return_type_p (decl
),
835 /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
836 or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */
839 decl_mangling_context (tree decl
)
841 tree tcontext
= targetm
.cxx
.decl_mangling_context (decl
);
843 if (tcontext
!= NULL_TREE
)
846 if (TREE_CODE (decl
) == TEMPLATE_DECL
847 && DECL_TEMPLATE_RESULT (decl
))
848 decl
= DECL_TEMPLATE_RESULT (decl
);
850 if (TREE_CODE (decl
) == TYPE_DECL
851 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
853 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl
));
857 else if (template_type_parameter_p (decl
))
858 /* template type parms have no mangling context. */
861 tcontext
= CP_DECL_CONTEXT (decl
);
863 /* Ignore the artificial declare reduction functions. */
865 && TREE_CODE (tcontext
) == FUNCTION_DECL
866 && DECL_OMP_DECLARE_REDUCTION_P (tcontext
))
867 return decl_mangling_context (tcontext
);
872 /* <name> ::= <unscoped-name>
873 ::= <unscoped-template-name> <template-args>
877 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
878 called from <local-name>, which mangles the enclosing scope
879 elsewhere and then uses this function to mangle just the part
880 underneath the function scope. So don't use the <local-name>
881 production, to avoid an infinite recursion. */
884 write_name (tree decl
, const int ignore_local_scope
)
888 MANGLE_TRACE_TREE ("name", decl
);
890 if (TREE_CODE (decl
) == TYPE_DECL
)
892 /* In case this is a typedef, fish out the corresponding
893 TYPE_DECL for the main variant. */
894 decl
= TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
)));
897 context
= decl_mangling_context (decl
);
899 gcc_assert (context
!= NULL_TREE
);
901 if (abi_warn_or_compat_version_crosses (7)
902 && ignore_local_scope
903 && TREE_CODE (context
) == PARM_DECL
)
904 G
.need_abi_warning
= 1;
906 /* A decl in :: or ::std scope is treated specially. The former is
907 mangled using <unscoped-name> or <unscoped-template-name>, the
908 latter with a special substitution. Also, a name that is
909 directly in a local function scope is also mangled with
910 <unscoped-name> rather than a full <nested-name>. */
911 if (context
== global_namespace
912 || DECL_NAMESPACE_STD_P (context
)
913 || (ignore_local_scope
914 && (TREE_CODE (context
) == FUNCTION_DECL
915 || (abi_version_at_least (7)
916 && TREE_CODE (context
) == PARM_DECL
))))
918 /* Is this a template instance? */
919 if (tree info
= maybe_template_info (decl
))
921 /* Yes: use <unscoped-template-name>. */
922 write_unscoped_template_name (TI_TEMPLATE (info
));
923 write_template_args (TI_ARGS (info
));
926 /* Everything else gets an <unqualified-name>. */
927 write_unscoped_name (decl
);
931 /* Handle local names, unless we asked not to (that is, invoked
932 under <local-name>, to handle only the part of the name under
934 if (!ignore_local_scope
)
936 /* Scan up the list of scope context, looking for a
937 function. If we find one, this entity is in local
938 function scope. local_entity tracks context one scope
939 level down, so it will contain the element that's
940 directly in that function's scope, either decl or one of
941 its enclosing scopes. */
942 tree local_entity
= decl
;
943 while (context
!= global_namespace
)
945 /* Make sure we're always dealing with decls. */
946 if (TYPE_P (context
))
947 context
= TYPE_NAME (context
);
948 /* Is this a function? */
949 if (TREE_CODE (context
) == FUNCTION_DECL
950 || TREE_CODE (context
) == PARM_DECL
)
952 /* Yes, we have local scope. Use the <local-name>
953 production for the innermost function scope. */
954 write_local_name (context
, local_entity
, decl
);
957 /* Up one scope level. */
958 local_entity
= context
;
959 context
= decl_mangling_context (context
);
962 /* No local scope found? Fall through to <nested-name>. */
965 /* Other decls get a <nested-name> to encode their scope. */
966 write_nested_name (decl
);
970 /* <unscoped-name> ::= <unqualified-name>
971 ::= St <unqualified-name> # ::std:: */
974 write_unscoped_name (const tree decl
)
976 tree context
= decl_mangling_context (decl
);
978 MANGLE_TRACE_TREE ("unscoped-name", decl
);
980 /* Is DECL in ::std? */
981 if (DECL_NAMESPACE_STD_P (context
))
984 write_unqualified_name (decl
);
988 /* If not, it should be either in the global namespace, or directly
989 in a local function scope. A lambda can also be mangled in the
990 scope of a default argument. */
991 gcc_assert (context
== global_namespace
992 || TREE_CODE (context
) == PARM_DECL
993 || TREE_CODE (context
) == FUNCTION_DECL
);
995 write_unqualified_name (decl
);
999 /* <unscoped-template-name> ::= <unscoped-name>
1000 ::= <substitution> */
1003 write_unscoped_template_name (const tree decl
)
1005 MANGLE_TRACE_TREE ("unscoped-template-name", decl
);
1007 if (find_substitution (decl
))
1009 write_unscoped_name (decl
);
1010 add_substitution (decl
);
1013 /* Write the nested name, including CV-qualifiers, of DECL.
1015 <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1016 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1018 <ref-qualifier> ::= R # & ref-qualifier
1019 ::= O # && ref-qualifier
1020 <CV-qualifiers> ::= [r] [V] [K] */
1023 write_nested_name (const tree decl
)
1025 MANGLE_TRACE_TREE ("nested-name", decl
);
1029 /* Write CV-qualifiers, if this is a member function. */
1030 if (TREE_CODE (decl
) == FUNCTION_DECL
1031 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
1033 if (DECL_VOLATILE_MEMFUNC_P (decl
))
1035 if (DECL_CONST_MEMFUNC_P (decl
))
1037 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl
)))
1039 if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl
)))
1046 /* Is this a template instance? */
1047 if (tree info
= maybe_template_info (decl
))
1049 /* Yes, use <template-prefix>. */
1050 write_template_prefix (decl
);
1051 write_template_args (TI_ARGS (info
));
1053 else if ((!abi_version_at_least (10) || TREE_CODE (decl
) == TYPE_DECL
)
1054 && TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
1056 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
1057 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1059 write_template_prefix (decl
);
1060 write_template_args (TREE_OPERAND (name
, 1));
1064 write_prefix (decl_mangling_context (decl
));
1065 write_unqualified_name (decl
);
1070 /* No, just use <prefix> */
1071 write_prefix (decl_mangling_context (decl
));
1072 write_unqualified_name (decl
);
1077 /* <prefix> ::= <prefix> <unqualified-name>
1078 ::= <template-param>
1079 ::= <template-prefix> <template-args>
1082 ::= <substitution> */
1085 write_prefix (const tree node
)
1090 || node
== global_namespace
)
1093 MANGLE_TRACE_TREE ("prefix", node
);
1095 if (TREE_CODE (node
) == DECLTYPE_TYPE
)
1101 if (find_substitution (node
))
1104 tree template_info
= NULL_TREE
;
1107 /* If this is a function or parm decl, that means we've hit function
1108 scope, so this prefix must be for a local name. In this
1109 case, we're under the <local-name> production, which encodes
1110 the enclosing function scope elsewhere. So don't continue
1112 if (TREE_CODE (node
) == FUNCTION_DECL
1113 || TREE_CODE (node
) == PARM_DECL
)
1117 template_info
= maybe_template_info (decl
);
1121 /* Node is a type. */
1122 decl
= TYPE_NAME (node
);
1123 /* The DECL might not point at the node. */
1124 if (CLASSTYPE_TEMPLATE_ID_P (node
))
1125 template_info
= TYPE_TEMPLATE_INFO (node
);
1128 if (TREE_CODE (node
) == TEMPLATE_TYPE_PARM
)
1129 write_template_param (node
);
1130 else if (template_info
)
1133 write_template_prefix (decl
);
1134 write_template_args (TI_ARGS (template_info
));
1136 else if (TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
1138 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
1139 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1141 write_template_prefix (decl
);
1142 write_template_args (TREE_OPERAND (name
, 1));
1146 write_prefix (decl_mangling_context (decl
));
1147 write_unqualified_name (decl
);
1151 /* Not templated. */
1153 write_prefix (decl_mangling_context (decl
));
1154 write_unqualified_name (decl
);
1156 || TREE_CODE (decl
) == FIELD_DECL
)
1158 /* <data-member-prefix> := <member source-name> M */
1164 add_substitution (node
);
1167 /* <template-prefix> ::= <prefix> <template component>
1168 ::= <template-param>
1169 ::= <substitution> */
1172 write_template_prefix (const tree node
)
1174 tree decl
= DECL_P (node
) ? node
: TYPE_NAME (node
);
1175 tree type
= DECL_P (node
) ? TREE_TYPE (node
) : node
;
1176 tree context
= decl_mangling_context (decl
);
1180 MANGLE_TRACE_TREE ("template-prefix", node
);
1182 /* Find the template decl. */
1183 if (tree info
= maybe_template_info (decl
))
1184 templ
= TI_TEMPLATE (info
);
1185 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
1186 /* For a typename type, all we have is the name. */
1187 templ
= DECL_NAME (decl
);
1190 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type
));
1192 templ
= TYPE_TI_TEMPLATE (type
);
1195 /* For a member template, though, the template name for the
1196 innermost name must have all the outer template levels
1197 instantiated. For instance, consider
1199 template<typename T> struct Outer {
1200 template<typename U> struct Inner {};
1203 The template name for `Inner' in `Outer<int>::Inner<float>' is
1204 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1205 levels separately, so there's no TEMPLATE_DECL available for this
1206 (there's only `Outer<T>::Inner<U>').
1208 In order to get the substitutions right, we create a special
1209 TREE_LIST to represent the substitution candidate for a nested
1210 template. The TREE_PURPOSE is the template's context, fully
1211 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1214 So, for the example above, `Outer<int>::Inner' is represented as a
1215 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1216 and whose value is `Outer<T>::Inner<U>'. */
1217 if (context
&& TYPE_P (context
))
1218 substitution
= build_tree_list (context
, templ
);
1220 substitution
= templ
;
1222 if (find_substitution (substitution
))
1225 if (TREE_TYPE (templ
)
1226 && TREE_CODE (TREE_TYPE (templ
)) == TEMPLATE_TEMPLATE_PARM
)
1227 write_template_param (TREE_TYPE (templ
));
1230 write_prefix (context
);
1231 write_unqualified_name (decl
);
1234 add_substitution (substitution
);
1237 /* As the list of identifiers for the structured binding declaration
1238 DECL is likely gone, try to recover the DC <source-name>+ E portion
1239 from its mangled name. Return pointer to the DC and set len to
1240 the length up to and including the terminating E. On failure
1244 find_decomp_unqualified_name (tree decl
, size_t *len
)
1246 const char *p
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1247 const char *end
= p
+ IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
));
1248 bool nested
= false;
1249 if (strncmp (p
, "_Z", 2))
1252 if (!strncmp (p
, "St", 2))
1258 while (ISDIGIT (p
[0]))
1261 long num
= strtol (p
, &e
, 10);
1262 if (num
>= 1 && num
< end
- e
)
1268 if (strncmp (p
, "DC", 2))
1282 /* We don't need to handle thunks, vtables, or VTTs here. Those are
1283 mangled through special entry points.
1285 <unqualified-name> ::= <operator-name>
1288 ::= <unnamed-type-name>
1289 ::= <local-source-name>
1291 <local-source-name> ::= L <source-name> <discriminator> */
1294 write_unqualified_id (tree identifier
)
1296 if (IDENTIFIER_CONV_OP_P (identifier
))
1297 write_conversion_operator_name (TREE_TYPE (identifier
));
1298 else if (IDENTIFIER_OVL_OP_P (identifier
))
1300 const ovl_op_info_t
*ovl_op
= IDENTIFIER_OVL_OP_INFO (identifier
);
1301 write_string (ovl_op
->mangled_name
);
1303 else if (UDLIT_OPER_P (identifier
))
1304 write_literal_operator_name (identifier
);
1306 write_source_name (identifier
);
1310 write_unqualified_name (tree decl
)
1312 MANGLE_TRACE_TREE ("unqualified-name", decl
);
1314 if (identifier_p (decl
))
1316 write_unqualified_id (decl
);
1322 if (DECL_NAME (decl
) == NULL_TREE
)
1325 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl
));
1326 const char *decomp_str
= NULL
;
1327 size_t decomp_len
= 0;
1329 && DECL_DECOMPOSITION_P (decl
)
1330 && DECL_NAME (decl
) == NULL_TREE
1331 && DECL_NAMESPACE_SCOPE_P (decl
))
1332 decomp_str
= find_decomp_unqualified_name (decl
, &decomp_len
);
1334 write_chars (decomp_str
, decomp_len
);
1336 write_source_name (DECL_ASSEMBLER_NAME (decl
));
1338 else if (DECL_DECLARES_FUNCTION_P (decl
))
1341 if (DECL_CONSTRUCTOR_P (decl
))
1342 write_special_name_constructor (decl
);
1343 else if (DECL_DESTRUCTOR_P (decl
))
1344 write_special_name_destructor (decl
);
1345 else if (DECL_CONV_FN_P (decl
))
1347 /* Conversion operator. Handle it right here.
1348 <operator> ::= cv <type> */
1350 if (maybe_template_info (decl
))
1353 fn_type
= get_mostly_instantiated_function_type (decl
);
1354 type
= TREE_TYPE (fn_type
);
1356 else if (FNDECL_USED_AUTO (decl
))
1357 type
= DECL_SAVED_AUTO_RETURN_TYPE (decl
);
1359 type
= DECL_CONV_FN_TYPE (decl
);
1360 write_conversion_operator_name (type
);
1362 else if (DECL_OVERLOADED_OPERATOR_P (decl
))
1364 const char *mangled_name
1365 = (ovl_op_info
[DECL_ASSIGNMENT_OPERATOR_P (decl
)]
1366 [DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
)].mangled_name
);
1367 write_string (mangled_name
);
1369 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
1370 write_literal_operator_name (DECL_NAME (decl
));
1377 else if (VAR_OR_FUNCTION_DECL_P (decl
) && ! TREE_PUBLIC (decl
)
1378 && DECL_NAMESPACE_SCOPE_P (decl
)
1379 && decl_linkage (decl
) == lk_internal
)
1381 MANGLE_TRACE_TREE ("local-source-name", decl
);
1383 write_source_name (DECL_NAME (decl
));
1384 /* The default discriminator is 1, and that's all we ever use,
1385 so there's no code to output one here. */
1389 tree type
= TREE_TYPE (decl
);
1391 if (TREE_CODE (decl
) == TYPE_DECL
1392 && TYPE_UNNAMED_P (type
))
1393 write_unnamed_type_name (type
);
1394 else if (TREE_CODE (decl
) == TYPE_DECL
&& LAMBDA_TYPE_P (type
))
1395 write_closure_type_name (type
);
1397 write_source_name (DECL_NAME (decl
));
1400 /* We use the ABI tags from the primary class template, ignoring tags on any
1401 specializations. This is necessary because C++ doesn't require a
1402 specialization to be declared before it is used unless the use requires a
1403 complete type, but we need to get the tags right on incomplete types as
1405 if (tree tmpl
= most_general_template (decl
))
1407 tree res
= DECL_TEMPLATE_RESULT (tmpl
);
1408 if (res
== NULL_TREE
)
1409 /* UNBOUND_CLASS_TEMPLATE. */;
1410 else if (DECL_DECLARES_TYPE_P (decl
))
1412 else if (any_abi_below (11))
1414 /* ABI v10 implicit tags on the template. */
1415 tree mtags
= missing_abi_tags (res
);
1416 /* Explicit tags on the template. */
1417 tree ttags
= get_abi_tags (res
);
1418 /* Tags on the instantiation. */
1419 tree dtags
= get_abi_tags (decl
);
1421 if (mtags
&& abi_warn_or_compat_version_crosses (10))
1422 G
.need_abi_warning
= 1;
1424 /* Add the v10 tags to the explicit tags now. */
1425 mtags
= chainon (mtags
, ttags
);
1427 if (!G
.need_abi_warning
1428 && abi_warn_or_compat_version_crosses (11)
1429 && !equal_abi_tags (dtags
, mtags
))
1430 G
.need_abi_warning
= 1;
1432 if (!abi_version_at_least (10))
1433 /* In abi <10, we only got the explicit tags. */
1435 else if (flag_abi_version
== 10)
1437 /* In ABI 10, we want explict and implicit tags. */
1438 write_abi_tags (mtags
);
1444 tree tags
= get_abi_tags (decl
);
1445 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_CONV_FN_P (decl
)
1446 && any_abi_below (11))
1447 if (tree mtags
= missing_abi_tags (decl
))
1449 if (abi_warn_or_compat_version_crosses (11))
1450 G
.need_abi_warning
= true;
1451 if (!abi_version_at_least (11))
1452 tags
= chainon (mtags
, tags
);
1454 write_abi_tags (tags
);
1457 /* Write the unqualified-name for a conversion operator to TYPE. */
1460 write_conversion_operator_name (const tree type
)
1462 write_string ("cv");
1466 /* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1468 <source-name> ::= </length/ number> <identifier> */
1471 write_source_name (tree identifier
)
1473 MANGLE_TRACE_TREE ("source-name", identifier
);
1475 write_unsigned_number (IDENTIFIER_LENGTH (identifier
));
1476 write_identifier (IDENTIFIER_POINTER (identifier
));
1479 /* Compare two TREE_STRINGs like strcmp. */
1482 tree_string_cmp (const void *p1
, const void *p2
)
1486 tree s1
= *(const tree
*)p1
;
1487 tree s2
= *(const tree
*)p2
;
1488 return strcmp (TREE_STRING_POINTER (s1
),
1489 TREE_STRING_POINTER (s2
));
1492 /* Return the TREE_LIST of TAGS as a sorted VEC. */
1494 static vec
<tree
, va_gc
> *
1495 sorted_abi_tags (tree tags
)
1497 vec
<tree
, va_gc
> * vec
= make_tree_vector();
1499 for (tree t
= tags
; t
; t
= TREE_CHAIN (t
))
1501 if (ABI_TAG_IMPLICIT (t
))
1503 tree str
= TREE_VALUE (t
);
1504 vec_safe_push (vec
, str
);
1507 vec
->qsort (tree_string_cmp
);
1512 /* ID is the name of a function or type with abi_tags attribute TAGS.
1513 Write out the name, suitably decorated. */
1516 write_abi_tags (tree tags
)
1518 if (tags
== NULL_TREE
)
1521 vec
<tree
, va_gc
> * vec
= sorted_abi_tags (tags
);
1523 unsigned i
; tree str
;
1524 FOR_EACH_VEC_ELT (*vec
, i
, str
)
1527 write_unsigned_number (TREE_STRING_LENGTH (str
) - 1);
1528 write_identifier (TREE_STRING_POINTER (str
));
1531 release_tree_vector (vec
);
1534 /* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent. */
1537 equal_abi_tags (tree t1
, tree t2
)
1539 releasing_vec v1
= sorted_abi_tags (t1
);
1540 releasing_vec v2
= sorted_abi_tags (t2
);
1542 unsigned len1
= v1
->length();
1543 if (len1
!= v2
->length())
1545 for (unsigned i
= 0; i
< len1
; ++i
)
1546 if (tree_string_cmp (v1
[i
], v2
[i
]) != 0)
1551 /* Write a user-defined literal operator.
1552 ::= li <source-name> # "" <source-name>
1553 IDENTIFIER is an LITERAL_IDENTIFIER_NODE. */
1556 write_literal_operator_name (tree identifier
)
1558 const char* suffix
= UDLIT_OP_SUFFIX (identifier
);
1559 write_identifier (UDLIT_OP_MANGLED_PREFIX
);
1560 write_unsigned_number (strlen (suffix
));
1561 write_identifier (suffix
);
1564 /* Encode 0 as _, and 1+ as n-1_. */
1567 write_compact_number (int num
)
1570 write_unsigned_number (num
- 1);
1574 /* Return how many unnamed types precede TYPE in its enclosing class. */
1577 nested_anon_class_index (tree type
)
1580 tree member
= TYPE_FIELDS (TYPE_CONTEXT (type
));
1581 for (; member
; member
= DECL_CHAIN (member
))
1582 if (DECL_IMPLICIT_TYPEDEF_P (member
))
1584 tree memtype
= TREE_TYPE (member
);
1585 if (memtype
== type
)
1587 else if (TYPE_UNNAMED_P (memtype
))
1597 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1600 write_unnamed_type_name (const tree type
)
1603 MANGLE_TRACE_TREE ("unnamed-type-name", type
);
1605 if (TYPE_FUNCTION_SCOPE_P (type
))
1606 discriminator
= discriminator_for_local_entity (TYPE_NAME (type
));
1607 else if (TYPE_CLASS_SCOPE_P (type
))
1608 discriminator
= nested_anon_class_index (type
);
1611 gcc_assert (no_linkage_check (type
, /*relaxed_p=*/true));
1612 /* Just use the old mangling at namespace scope. */
1613 write_source_name (TYPE_IDENTIFIER (type
));
1617 write_string ("Ut");
1618 write_compact_number (discriminator
);
1621 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1622 <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters */
1625 write_closure_type_name (const tree type
)
1627 tree fn
= lambda_function (type
);
1628 tree lambda
= CLASSTYPE_LAMBDA_EXPR (type
);
1629 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1631 MANGLE_TRACE_TREE ("closure-type-name", type
);
1633 write_string ("Ul");
1634 write_method_parms (parms
, /*method_p=*/1, fn
);
1636 write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda
));
1639 /* Convert NUMBER to ascii using base BASE and generating at least
1640 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1641 into which to store the characters. Returns the number of
1642 characters generated (these will be laid out in advance of where
1646 hwint_to_ascii (unsigned HOST_WIDE_INT number
, const unsigned int base
,
1647 char *buffer
, const unsigned int min_digits
)
1649 static const char base_digits
[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1650 unsigned digits
= 0;
1654 unsigned HOST_WIDE_INT d
= number
/ base
;
1656 *--buffer
= base_digits
[number
- d
* base
];
1660 while (digits
< min_digits
)
1662 *--buffer
= base_digits
[0];
1668 /* Non-terminal <number>.
1670 <number> ::= [n] </decimal integer/> */
1673 write_number (unsigned HOST_WIDE_INT number
, const int unsigned_p
,
1674 const unsigned int base
)
1676 char buffer
[sizeof (HOST_WIDE_INT
) * 8];
1679 if (!unsigned_p
&& (HOST_WIDE_INT
) number
< 0)
1682 number
= -((HOST_WIDE_INT
) number
);
1684 count
= hwint_to_ascii (number
, base
, buffer
+ sizeof (buffer
), 1);
1685 write_chars (buffer
+ sizeof (buffer
) - count
, count
);
1688 /* Write out an integral CST in decimal. Most numbers are small, and
1689 representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1690 bigger than that, which we must deal with. */
1693 write_integer_cst (const tree cst
)
1695 int sign
= tree_int_cst_sgn (cst
);
1696 widest_int abs_value
= wi::abs (wi::to_widest (cst
));
1697 if (!wi::fits_uhwi_p (abs_value
))
1699 /* A bignum. We do this in chunks, each of which fits in a
1701 char buffer
[sizeof (HOST_WIDE_INT
) * 8 * 2];
1702 unsigned HOST_WIDE_INT chunk
;
1703 unsigned chunk_digits
;
1704 char *ptr
= buffer
+ sizeof (buffer
);
1709 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1714 if (sizeof (HOST_WIDE_INT
) >= 8)
1716 /* It is at least 64 bits, so 10^18 is representable. */
1721 type
= c_common_signed_or_unsigned_type (1, TREE_TYPE (cst
));
1722 base
= build_int_cstu (type
, chunk
);
1723 n
= wide_int_to_tree (type
, wi::to_wide (cst
));
1728 n
= fold_build1_loc (input_location
, NEGATE_EXPR
, type
, n
);
1732 tree d
= fold_build2_loc (input_location
, FLOOR_DIV_EXPR
, type
, n
, base
);
1733 tree tmp
= fold_build2_loc (input_location
, MULT_EXPR
, type
, d
, base
);
1736 done
= integer_zerop (d
);
1737 tmp
= fold_build2_loc (input_location
, MINUS_EXPR
, type
, n
, tmp
);
1738 c
= hwint_to_ascii (TREE_INT_CST_LOW (tmp
), 10, ptr
,
1739 done
? 1 : chunk_digits
);
1745 write_chars (ptr
, count
);
1752 write_unsigned_number (abs_value
.to_uhwi ());
1756 /* Write out a floating-point literal.
1758 "Floating-point literals are encoded using the bit pattern of the
1759 target processor's internal representation of that number, as a
1760 fixed-length lowercase hexadecimal string, high-order bytes first
1761 (even if the target processor would store low-order bytes first).
1762 The "n" prefix is not used for floating-point literals; the sign
1763 bit is encoded with the rest of the number.
1765 Here are some examples, assuming the IEEE standard representation
1766 for floating point numbers. (Spaces are for readability, not
1767 part of the encoding.)
1770 -1.0f Lf bf80 0000 E
1771 1.17549435e-38f Lf 0080 0000 E
1772 1.40129846e-45f Lf 0000 0001 E
1773 0.0f Lf 0000 0000 E"
1775 Caller is responsible for the Lx and the E. */
1777 write_real_cst (const tree value
)
1779 long target_real
[4]; /* largest supported float */
1780 /* Buffer for eight hex digits in a 32-bit number but big enough
1781 even for 64-bit long to avoid warnings. */
1785 tree type
= TREE_TYPE (value
);
1786 int words
= GET_MODE_BITSIZE (SCALAR_FLOAT_TYPE_MODE (type
)) / 32;
1788 real_to_target (target_real
, &TREE_REAL_CST (value
),
1791 /* The value in target_real is in the target word order,
1792 so we must write it out backward if that happens to be
1793 little-endian. write_number cannot be used, it will
1794 produce uppercase. */
1795 if (FLOAT_WORDS_BIG_ENDIAN
)
1796 i
= 0, limit
= words
, dir
= 1;
1798 i
= words
- 1, limit
= -1, dir
= -1;
1800 for (; i
!= limit
; i
+= dir
)
1802 sprintf (buffer
, "%08lx", (unsigned long) target_real
[i
]);
1803 write_chars (buffer
, 8);
1807 /* Non-terminal <identifier>.
1809 <identifier> ::= </unqualified source code identifier> */
1812 write_identifier (const char *identifier
)
1814 MANGLE_TRACE ("identifier", identifier
);
1815 write_string (identifier
);
1818 /* Handle constructor productions of non-terminal <special-name>.
1819 CTOR is a constructor FUNCTION_DECL.
1821 <special-name> ::= C1 # complete object constructor
1822 ::= C2 # base object constructor
1823 ::= C3 # complete object allocating constructor
1825 Currently, allocating constructors are never used. */
1828 write_special_name_constructor (const tree ctor
)
1831 bool new_inh
= (flag_new_inheriting_ctors
1832 && DECL_INHERITED_CTOR (ctor
));
1835 if (DECL_BASE_CONSTRUCTOR_P (ctor
))
1837 /* This is the old-style "[unified]" constructor.
1838 In some cases, we may emit this function and call
1839 it from the clones in order to share code and save space. */
1840 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor
))
1844 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor
));
1848 write_type (DECL_INHERITED_CTOR_BASE (ctor
));
1851 /* Handle destructor productions of non-terminal <special-name>.
1852 DTOR is a destructor FUNCTION_DECL.
1854 <special-name> ::= D0 # deleting (in-charge) destructor
1855 ::= D1 # complete object (in-charge) destructor
1856 ::= D2 # base object (not-in-charge) destructor */
1859 write_special_name_destructor (const tree dtor
)
1861 if (DECL_DELETING_DESTRUCTOR_P (dtor
))
1862 write_string ("D0");
1863 else if (DECL_BASE_DESTRUCTOR_P (dtor
))
1864 write_string ("D2");
1865 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor
))
1866 /* This is the old-style "[unified]" destructor.
1867 In some cases, we may emit this function and call
1868 it from the clones in order to share code and save space. */
1869 write_string ("D4");
1872 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor
));
1873 write_string ("D1");
1877 /* Return the discriminator for ENTITY appearing inside
1878 FUNCTION. The discriminator is the lexical ordinal of VAR or TYPE among
1879 entities with the same name and kind in the same FUNCTION. */
1882 discriminator_for_local_entity (tree entity
)
1884 if (!DECL_LANG_SPECIFIC (entity
))
1886 /* Some decls, like __FUNCTION__, don't need a discriminator. */
1887 gcc_checking_assert (DECL_ARTIFICIAL (entity
));
1890 else if (tree disc
= DECL_DISCRIMINATOR (entity
))
1891 return TREE_INT_CST_LOW (disc
);
1893 /* The first entity with a particular name doesn't get
1894 DECL_DISCRIMINATOR set up. */
1898 /* Return the discriminator for STRING, a string literal used inside
1899 FUNCTION. The discriminator is the lexical ordinal of STRING among
1900 string literals used in FUNCTION. */
1903 discriminator_for_string_literal (tree
/*function*/,
1906 /* For now, we don't discriminate amongst string literals. */
1910 /* <discriminator> := _ <number> # when number < 10
1911 := __ <number> _ # when number >= 10
1913 The discriminator is used only for the second and later occurrences
1914 of the same name within a single function. In this case <number> is
1915 n - 2, if this is the nth occurrence, in lexical order. */
1918 write_discriminator (const int discriminator
)
1920 /* If discriminator is zero, don't write anything. Otherwise... */
1921 if (discriminator
> 0)
1924 if (discriminator
- 1 >= 10)
1926 if (abi_warn_or_compat_version_crosses (11))
1927 G
.need_abi_warning
= 1;
1928 if (abi_version_at_least (11))
1931 write_unsigned_number (discriminator
- 1);
1932 if (abi_version_at_least (11) && discriminator
- 1 >= 10)
1937 /* Mangle the name of a function-scope entity. FUNCTION is the
1938 FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1939 default argument scope. ENTITY is the decl for the entity itself.
1940 LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1941 either ENTITY itself or an enclosing scope of ENTITY.
1943 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1944 := Z <function encoding> E s [<discriminator>]
1945 := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1948 write_local_name (tree function
, const tree local_entity
,
1951 tree parm
= NULL_TREE
;
1953 MANGLE_TRACE_TREE ("local-name", entity
);
1955 if (TREE_CODE (function
) == PARM_DECL
)
1958 function
= DECL_CONTEXT (parm
);
1962 write_encoding (function
);
1965 /* For this purpose, parameters are numbered from right-to-left. */
1970 for (t
= DECL_ARGUMENTS (function
); t
; t
= DECL_CHAIN (t
))
1978 write_compact_number (i
- 1);
1981 if (TREE_CODE (entity
) == STRING_CST
)
1984 write_discriminator (discriminator_for_string_literal (function
,
1989 /* Now the <entity name>. Let write_name know its being called
1990 from <local-name>, so it doesn't try to process the enclosing
1991 function scope again. */
1992 write_name (entity
, /*ignore_local_scope=*/1);
1993 if (DECL_DISCRIMINATOR_P (local_entity
)
1994 && !(TREE_CODE (local_entity
) == TYPE_DECL
1995 && TYPE_ANON_P (TREE_TYPE (local_entity
))))
1996 write_discriminator (discriminator_for_local_entity (local_entity
));
2000 /* Non-terminals <type> and <CV-qualifier>.
2002 <type> ::= <builtin-type>
2004 ::= <class-enum-type>
2006 ::= <pointer-to-member-type>
2007 ::= <template-param>
2010 ::= P <type> # pointer-to
2011 ::= R <type> # reference-to
2012 ::= C <type> # complex pair (C 2000)
2013 ::= G <type> # imaginary (C 2000) [not supported]
2014 ::= U <source-name> <type> # vendor extended type qualifier
2018 <type> ::= RR <type> # rvalue reference-to
2019 <type> ::= Dt <expression> # decltype of an id-expression or
2020 # class member access
2021 <type> ::= DT <expression> # decltype of an expression
2022 <type> ::= Dn # decltype of nullptr
2024 TYPE is a type node. */
2027 write_type (tree type
)
2029 /* This gets set to nonzero if TYPE turns out to be a (possibly
2030 CV-qualified) builtin type. */
2031 int is_builtin_type
= 0;
2033 MANGLE_TRACE_TREE ("type", type
);
2035 if (type
== error_mark_node
)
2038 type
= canonicalize_for_substitution (type
);
2039 if (find_substitution (type
))
2043 if (write_CV_qualifiers_for_type (type
) > 0)
2044 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
2045 mangle the unqualified type. The recursive call is needed here
2046 since both the qualified and unqualified types are substitution
2049 tree t
= TYPE_MAIN_VARIANT (type
);
2050 if (TYPE_ATTRIBUTES (t
) && !OVERLOAD_TYPE_P (t
))
2052 tree attrs
= NULL_TREE
;
2053 if (tx_safe_fn_type_p (type
))
2054 attrs
= tree_cons (get_identifier ("transaction_safe"),
2056 t
= cp_build_type_attribute_variant (t
, attrs
);
2058 gcc_assert (t
!= type
);
2059 if (FUNC_OR_METHOD_TYPE_P (t
))
2061 t
= build_ref_qualified_type (t
, type_memfn_rqual (type
));
2062 if (flag_noexcept_type
)
2064 tree r
= TYPE_RAISES_EXCEPTIONS (type
);
2065 t
= build_exception_variant (t
, r
);
2067 if (abi_version_at_least (8)
2068 || type
== TYPE_MAIN_VARIANT (type
))
2069 /* Avoid adding the unqualified function type as a substitution. */
2070 write_function_type (t
);
2073 if (abi_warn_or_compat_version_crosses (8))
2074 G
.need_abi_warning
= 1;
2079 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2080 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
2081 so that the cv-qualification of the element type is available
2082 in write_array_type. */
2083 write_array_type (type
);
2086 tree type_orig
= type
;
2088 /* See through any typedefs. */
2089 type
= TYPE_MAIN_VARIANT (type
);
2090 if (FUNC_OR_METHOD_TYPE_P (type
))
2091 type
= cxx_copy_lang_qualifiers (type
, type_orig
);
2093 /* According to the C++ ABI, some library classes are passed the
2094 same as the scalar type of their single member and use the same
2096 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
2097 type
= TREE_TYPE (first_field (type
));
2099 if (TYPE_PTRDATAMEM_P (type
))
2100 write_pointer_to_member_type (type
);
2103 /* Handle any target-specific fundamental types. */
2104 const char *target_mangling
2105 = targetm
.mangle_type (type_orig
);
2107 if (target_mangling
)
2109 write_string (target_mangling
);
2110 /* Add substitutions for types other than fundamental
2112 if (!VOID_TYPE_P (type
)
2113 && TREE_CODE (type
) != INTEGER_TYPE
2114 && TREE_CODE (type
) != REAL_TYPE
2115 && TREE_CODE (type
) != BOOLEAN_TYPE
)
2116 add_substitution (type
);
2120 switch (TREE_CODE (type
))
2124 case INTEGER_TYPE
: /* Includes wchar_t. */
2126 case FIXED_POINT_TYPE
:
2128 /* If this is a typedef, TYPE may not be one of
2129 the standard builtin type nodes, but an alias of one. Use
2130 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
2131 write_builtin_type (TYPE_MAIN_VARIANT (type
));
2138 write_type (TREE_TYPE (type
));
2143 write_function_type (type
);
2149 /* A pointer-to-member function is represented as a special
2150 RECORD_TYPE, so check for this first. */
2151 if (TYPE_PTRMEMFUNC_P (type
))
2152 write_pointer_to_member_type (type
);
2154 write_class_enum_type (type
);
2158 case UNBOUND_CLASS_TEMPLATE
:
2159 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2160 ordinary nested names. */
2161 write_nested_name (TYPE_STUB_DECL (type
));
2165 case REFERENCE_TYPE
:
2166 if (TYPE_PTR_P (type
))
2168 else if (TYPE_REF_IS_RVALUE (type
))
2173 tree target
= TREE_TYPE (type
);
2174 /* Attribute const/noreturn are not reflected in mangling.
2175 We strip them here rather than at a lower level because
2176 a typedef or template argument can have function type
2177 with function-cv-quals (that use the same representation),
2178 but you can't have a pointer/reference to such a type. */
2179 if (TREE_CODE (target
) == FUNCTION_TYPE
)
2181 if (abi_warn_or_compat_version_crosses (5)
2182 && TYPE_QUALS (target
) != TYPE_UNQUALIFIED
)
2183 G
.need_abi_warning
= 1;
2184 if (abi_version_at_least (5))
2185 target
= build_qualified_type (target
, TYPE_UNQUALIFIED
);
2187 write_type (target
);
2191 case TEMPLATE_TYPE_PARM
:
2194 if (AUTO_IS_DECLTYPE (type
))
2195 write_identifier ("Dc");
2197 write_identifier ("Da");
2202 case TEMPLATE_PARM_INDEX
:
2203 write_template_param (type
);
2206 case TEMPLATE_TEMPLATE_PARM
:
2207 write_template_template_param (type
);
2210 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2211 write_template_template_param (type
);
2213 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type
)));
2217 if (abi_version_at_least (4))
2219 write_string ("Dv");
2220 /* Non-constant vector size would be encoded with
2221 _ expression, but we don't support that yet. */
2222 write_unsigned_number (TYPE_VECTOR_SUBPARTS (type
)
2227 write_string ("U8__vector");
2228 if (abi_warn_or_compat_version_crosses (4))
2229 G
.need_abi_warning
= 1;
2230 write_type (TREE_TYPE (type
));
2233 case TYPE_PACK_EXPANSION
:
2234 write_string ("Dp");
2235 write_type (PACK_EXPANSION_PATTERN (type
));
2239 /* These shouldn't make it into mangling. */
2240 gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type
)
2241 && !DECLTYPE_FOR_LAMBDA_PROXY (type
));
2243 /* In ABI <5, we stripped decltype of a plain decl. */
2244 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
))
2246 tree expr
= DECLTYPE_TYPE_EXPR (type
);
2247 tree etype
= NULL_TREE
;
2248 switch (TREE_CODE (expr
))
2255 case TEMPLATE_PARM_INDEX
:
2256 etype
= TREE_TYPE (expr
);
2263 if (etype
&& !type_uses_auto (etype
))
2265 if (abi_warn_or_compat_version_crosses (5))
2266 G
.need_abi_warning
= 1;
2267 if (!abi_version_at_least (5))
2276 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
))
2280 ++cp_unevaluated_operand
;
2281 write_expression (DECLTYPE_TYPE_EXPR (type
));
2282 --cp_unevaluated_operand
;
2287 write_string ("Dn");
2288 if (abi_version_at_least (7))
2290 if (abi_warn_or_compat_version_crosses (7))
2291 G
.need_abi_warning
= 1;
2295 sorry ("mangling %<typeof%>, use %<decltype%> instead");
2298 case UNDERLYING_TYPE
:
2299 sorry ("mangling %<__underlying_type%>");
2311 /* Types other than builtin types are substitution candidates. */
2312 if (!is_builtin_type
)
2313 add_substitution (type
);
2316 /* qsort callback for sorting a vector of attribute entries. */
2319 attr_strcmp (const void *p1
, const void *p2
)
2321 tree a1
= *(const tree
*)p1
;
2322 tree a2
= *(const tree
*)p2
;
2324 const attribute_spec
*as1
= lookup_attribute_spec (get_attribute_name (a1
));
2325 const attribute_spec
*as2
= lookup_attribute_spec (get_attribute_name (a2
));
2327 return strcmp (as1
->name
, as2
->name
);
2330 /* Return true if we should mangle a type attribute with name NAME. */
2333 mangle_type_attribute_p (tree name
)
2335 const attribute_spec
*as
= lookup_attribute_spec (name
);
2336 if (!as
|| !as
->affects_type_identity
)
2339 /* Skip internal-only attributes, which are distinguished from others
2340 by having a space. At present, all internal-only attributes that
2341 affect type identity are target-specific and are handled by
2342 targetm.mangle_type instead.
2344 Another reason to do this is that a space isn't a valid identifier
2345 character for most file formats. */
2346 if (strchr (IDENTIFIER_POINTER (name
), ' '))
2349 /* The following attributes are mangled specially. */
2350 if (is_attribute_p ("transaction_safe", name
))
2352 if (is_attribute_p ("abi_tag", name
))
2358 /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
2359 CV-qualifiers written for TYPE.
2361 <CV-qualifiers> ::= [r] [V] [K] */
2364 write_CV_qualifiers_for_type (const tree type
)
2366 int num_qualifiers
= 0;
2368 /* The order is specified by:
2370 "In cases where multiple order-insensitive qualifiers are
2371 present, they should be ordered 'K' (closest to the base type),
2372 'V', 'r', and 'U' (farthest from the base type) ..." */
2374 /* Mangle attributes that affect type identity as extended qualifiers.
2376 We don't do this with classes and enums because their attributes
2377 are part of their definitions, not something added on. */
2379 if (!OVERLOAD_TYPE_P (type
))
2382 for (tree a
= TYPE_ATTRIBUTES (type
); a
; a
= TREE_CHAIN (a
))
2383 if (mangle_type_attribute_p (get_attribute_name (a
)))
2385 if (abi_warn_or_compat_version_crosses (10) && !vec
.is_empty ())
2386 G
.need_abi_warning
= true;
2387 if (abi_version_at_least (10))
2389 vec
.qsort (attr_strcmp
);
2390 while (!vec
.is_empty())
2393 const attribute_spec
*as
2394 = lookup_attribute_spec (get_attribute_name (a
));
2397 write_unsigned_number (strlen (as
->name
));
2398 write_string (as
->name
);
2402 for (tree args
= TREE_VALUE (a
); args
;
2403 args
= TREE_CHAIN (args
))
2405 tree arg
= TREE_VALUE (args
);
2406 write_template_arg (arg
);
2416 /* Note that we do not use cp_type_quals below; given "const
2417 int[3]", the "const" is emitted with the "int", not with the
2419 cp_cv_quals quals
= TYPE_QUALS (type
);
2421 if (quals
& TYPE_QUAL_RESTRICT
)
2426 if (quals
& TYPE_QUAL_VOLATILE
)
2431 if (quals
& TYPE_QUAL_CONST
)
2437 return num_qualifiers
;
2440 /* Non-terminal <builtin-type>.
2442 <builtin-type> ::= v # void
2447 ::= h # unsigned char
2449 ::= t # unsigned short
2451 ::= j # unsigned int
2453 ::= m # unsigned long
2454 ::= x # long long, __int64
2455 ::= y # unsigned long long, __int64
2457 ::= o # unsigned __int128
2460 ::= e # long double, __float80
2461 ::= g # __float128 [not supported]
2462 ::= u <source-name> # vendor extended type */
2465 write_builtin_type (tree type
)
2467 if (TYPE_CANONICAL (type
))
2468 type
= TYPE_CANONICAL (type
);
2470 switch (TREE_CODE (type
))
2481 /* TYPE may still be wchar_t, char8_t, char16_t, or char32_t, since that
2482 isn't in integer_type_nodes. */
2483 if (type
== wchar_type_node
)
2485 else if (type
== char8_type_node
)
2486 write_string ("Du");
2487 else if (type
== char16_type_node
)
2488 write_string ("Ds");
2489 else if (type
== char32_type_node
)
2490 write_string ("Di");
2494 /* Assume TYPE is one of the shared integer type nodes. Find
2495 it in the array of these nodes. */
2497 for (itk
= 0; itk
< itk_none
; ++itk
)
2498 if (integer_types
[itk
] != NULL_TREE
2499 && integer_type_codes
[itk
] != '\0'
2500 && type
== integer_types
[itk
])
2502 /* Print the corresponding single-letter code. */
2503 write_char (integer_type_codes
[itk
]);
2507 if (itk
== itk_none
)
2509 tree t
= c_common_type_for_mode (TYPE_MODE (type
),
2510 TYPE_UNSIGNED (type
));
2517 if (TYPE_PRECISION (type
) == 128)
2518 write_char (TYPE_UNSIGNED (type
) ? 'o' : 'n');
2521 /* Allow for cases where TYPE is not one of the shared
2522 integer type nodes and write a "vendor extended builtin
2523 type" with a name the form intN or uintN, respectively.
2524 Situations like this can happen if you have an
2525 __attribute__((__mode__(__SI__))) type and use exotic
2526 switches like '-mint8' on AVR. Of course, this is
2527 undefined by the C++ ABI (and '-mint8' is not even
2528 Standard C conforming), but when using such special
2529 options you're pretty much in nowhere land anyway. */
2531 char prec
[11]; /* up to ten digits for an unsigned */
2533 prefix
= TYPE_UNSIGNED (type
) ? "uint" : "int";
2534 sprintf (prec
, "%u", (unsigned) TYPE_PRECISION (type
));
2535 write_char ('u'); /* "vendor extended builtin type" */
2536 write_unsigned_number (strlen (prefix
) + strlen (prec
));
2537 write_string (prefix
);
2538 write_string (prec
);
2545 if (type
== float_type_node
)
2547 else if (type
== double_type_node
)
2549 else if (type
== long_double_type_node
)
2551 else if (type
== dfloat32_type_node
|| type
== fallback_dfloat32_type
)
2552 write_string ("Df");
2553 else if (type
== dfloat64_type_node
|| type
== fallback_dfloat64_type
)
2554 write_string ("Dd");
2555 else if (type
== dfloat128_type_node
|| type
== fallback_dfloat128_type
)
2556 write_string ("De");
2561 case FIXED_POINT_TYPE
:
2562 write_string ("DF");
2563 if (GET_MODE_IBIT (TYPE_MODE (type
)) > 0)
2564 write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type
)));
2565 if (type
== fract_type_node
2566 || type
== sat_fract_type_node
2567 || type
== accum_type_node
2568 || type
== sat_accum_type_node
)
2570 else if (type
== unsigned_fract_type_node
2571 || type
== sat_unsigned_fract_type_node
2572 || type
== unsigned_accum_type_node
2573 || type
== sat_unsigned_accum_type_node
)
2575 else if (type
== short_fract_type_node
2576 || type
== sat_short_fract_type_node
2577 || type
== short_accum_type_node
2578 || type
== sat_short_accum_type_node
)
2580 else if (type
== unsigned_short_fract_type_node
2581 || type
== sat_unsigned_short_fract_type_node
2582 || type
== unsigned_short_accum_type_node
2583 || type
== sat_unsigned_short_accum_type_node
)
2585 else if (type
== long_fract_type_node
2586 || type
== sat_long_fract_type_node
2587 || type
== long_accum_type_node
2588 || type
== sat_long_accum_type_node
)
2590 else if (type
== unsigned_long_fract_type_node
2591 || type
== sat_unsigned_long_fract_type_node
2592 || type
== unsigned_long_accum_type_node
2593 || type
== sat_unsigned_long_accum_type_node
)
2595 else if (type
== long_long_fract_type_node
2596 || type
== sat_long_long_fract_type_node
2597 || type
== long_long_accum_type_node
2598 || type
== sat_long_long_accum_type_node
)
2600 else if (type
== unsigned_long_long_fract_type_node
2601 || type
== sat_unsigned_long_long_fract_type_node
2602 || type
== unsigned_long_long_accum_type_node
2603 || type
== sat_unsigned_long_long_accum_type_node
)
2606 sorry ("mangling unknown fixed point type");
2607 write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type
)));
2608 if (TYPE_SATURATING (type
))
2619 /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
2620 METHOD_TYPE. The return type is mangled before the parameter
2623 <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E */
2626 write_function_type (const tree type
)
2628 MANGLE_TRACE_TREE ("function-type", type
);
2630 /* For a pointer to member function, the function type may have
2631 cv-qualifiers, indicating the quals for the artificial 'this'
2633 if (TREE_CODE (type
) == METHOD_TYPE
)
2635 /* The first parameter must be a POINTER_TYPE pointing to the
2636 `this' parameter. */
2637 tree this_type
= class_of_this_parm (type
);
2638 write_CV_qualifiers_for_type (this_type
);
2641 write_exception_spec (TYPE_RAISES_EXCEPTIONS (type
));
2643 if (tx_safe_fn_type_p (type
))
2644 write_string ("Dx");
2647 /* We don't track whether or not a type is `extern "C"'. Note that
2648 you can have an `extern "C"' function that does not have
2649 `extern "C"' type, and vice versa:
2651 extern "C" typedef void function_t();
2652 function_t f; // f has C++ linkage, but its type is
2655 typedef void function_t();
2656 extern "C" function_t f; // Vice versa.
2659 write_bare_function_type (type
, /*include_return_type_p=*/1,
2661 if (FUNCTION_REF_QUALIFIED (type
))
2663 if (FUNCTION_RVALUE_QUALIFIED (type
))
2671 /* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
2672 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
2673 is mangled before the parameter types. If non-NULL, DECL is
2674 FUNCTION_DECL for the function whose type is being emitted. */
2677 write_bare_function_type (const tree type
, const int include_return_type_p
,
2680 MANGLE_TRACE_TREE ("bare-function-type", type
);
2682 /* Mangle the return type, if requested. */
2683 if (include_return_type_p
)
2684 write_type (TREE_TYPE (type
));
2686 /* Now mangle the types of the arguments. */
2688 write_method_parms (TYPE_ARG_TYPES (type
),
2689 TREE_CODE (type
) == METHOD_TYPE
,
2694 /* Write the mangled representation of a method parameter list of
2695 types given in PARM_TYPES. If METHOD_P is nonzero, the function is
2696 considered a non-static method, and the this parameter is omitted.
2697 If non-NULL, DECL is the FUNCTION_DECL for the function whose
2698 parameters are being emitted. */
2701 write_method_parms (tree parm_types
, const int method_p
, const tree decl
)
2703 tree first_parm_type
;
2704 tree parm_decl
= decl
? DECL_ARGUMENTS (decl
) : NULL_TREE
;
2706 /* Assume this parameter type list is variable-length. If it ends
2707 with a void type, then it's not. */
2710 /* If this is a member function, skip the first arg, which is the
2712 "Member functions do not encode the type of their implicit this
2715 Similarly, there's no need to mangle artificial parameters, like
2716 the VTT parameters for constructors and destructors. */
2719 parm_types
= TREE_CHAIN (parm_types
);
2720 parm_decl
= parm_decl
? DECL_CHAIN (parm_decl
) : NULL_TREE
;
2722 while (parm_decl
&& DECL_ARTIFICIAL (parm_decl
))
2724 parm_types
= TREE_CHAIN (parm_types
);
2725 parm_decl
= DECL_CHAIN (parm_decl
);
2728 if (decl
&& ctor_omit_inherited_parms (decl
))
2729 /* Bring back parameters omitted from an inherited ctor. */
2730 parm_types
= FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (decl
));
2733 for (first_parm_type
= parm_types
;
2735 parm_types
= TREE_CHAIN (parm_types
))
2737 tree parm
= TREE_VALUE (parm_types
);
2738 if (parm
== void_type_node
)
2740 /* "Empty parameter lists, whether declared as () or
2741 conventionally as (void), are encoded with a void parameter
2743 if (parm_types
== first_parm_type
)
2745 /* If the parm list is terminated with a void type, it's
2748 /* A void type better be the last one. */
2749 gcc_assert (TREE_CHAIN (parm_types
) == NULL
);
2756 /* <builtin-type> ::= z # ellipsis */
2760 /* <class-enum-type> ::= <name> */
2763 write_class_enum_type (const tree type
)
2765 write_name (TYPE_NAME (type
), /*ignore_local_scope=*/0);
2768 /* Non-terminal <template-args>. ARGS is a TREE_VEC of template
2771 <template-args> ::= I <template-arg>* E */
2774 write_template_args (tree args
)
2779 MANGLE_TRACE_TREE ("template-args", args
);
2784 length
= TREE_VEC_LENGTH (args
);
2786 if (args
&& length
&& TREE_CODE (TREE_VEC_ELT (args
, 0)) == TREE_VEC
)
2788 /* We have nested template args. We want the innermost template
2790 args
= TREE_VEC_ELT (args
, length
- 1);
2791 length
= TREE_VEC_LENGTH (args
);
2793 for (i
= 0; i
< length
; ++i
)
2794 write_template_arg (TREE_VEC_ELT (args
, i
));
2801 <unqualified-name> <template-args>
2802 part of SCOPE_REF or COMPONENT_REF mangling. */
2805 write_member_name (tree member
)
2807 if (identifier_p (member
))
2809 if (abi_version_at_least (11) && IDENTIFIER_ANY_OP_P (member
))
2811 write_string ("on");
2812 if (abi_warn_or_compat_version_crosses (11))
2813 G
.need_abi_warning
= 1;
2815 write_unqualified_id (member
);
2817 else if (DECL_P (member
))
2818 write_unqualified_name (member
);
2819 else if (TREE_CODE (member
) == TEMPLATE_ID_EXPR
)
2821 tree name
= TREE_OPERAND (member
, 0);
2822 name
= OVL_FIRST (name
);
2823 write_member_name (name
);
2824 write_template_args (TREE_OPERAND (member
, 1));
2827 write_expression (member
);
2830 /* EXPR is a base COMPONENT_REF; write the minimized base conversion path for
2831 converting to BASE, or just the conversion of EXPR if BASE is null.
2833 "Given a fully explicit base path P := C_n -> ... -> C_0, the minimized base
2834 path Min(P) is defined as follows: let C_i be the last element for which the
2835 conversion to C_0 is unambiguous; if that element is C_n, the minimized path
2836 is C_n -> C_0; otherwise, the minimized path is Min(C_n -> ... -> C_i) ->
2839 We mangle the conversion to C_i if it's different from C_n. */
2842 write_base_ref (tree expr
, tree base
= NULL_TREE
)
2844 if (TREE_CODE (expr
) != COMPONENT_REF
)
2847 tree field
= TREE_OPERAND (expr
, 1);
2849 if (TREE_CODE (field
) != FIELD_DECL
|| !DECL_FIELD_IS_BASE (field
))
2852 tree object
= TREE_OPERAND (expr
, 0);
2854 tree binfo
= NULL_TREE
;
2857 tree cur
= TREE_TYPE (object
);
2858 binfo
= lookup_base (cur
, base
, ba_unique
, NULL
, tf_none
);
2861 /* We're at the end of the base conversion chain, so it can't be
2863 base
= TREE_TYPE (field
);
2865 if (binfo
== error_mark_node
)
2867 /* cur->base is ambiguous, so make the conversion to
2868 last explicit, expressed as a cast (last&)object. */
2869 tree last
= TREE_TYPE (expr
);
2870 write_string (OVL_OP_INFO (false, CAST_EXPR
)->mangled_name
);
2871 write_type (build_reference_type (last
));
2872 write_expression (object
);
2874 else if (write_base_ref (object
, base
))
2875 /* cur->base is unambiguous, but we had another base conversion
2876 underneath and wrote it out. */;
2878 /* No more base conversions, just write out the object. */
2879 write_expression (object
);
2884 /* <expression> ::= <unary operator-name> <expression>
2885 ::= <binary operator-name> <expression> <expression>
2888 <expr-primary> ::= <template-param>
2889 ::= L <type> <value number> E # literal
2890 ::= L <mangled-name> E # external name
2891 ::= st <type> # sizeof
2892 ::= sr <type> <unqualified-name> # dependent name
2893 ::= sr <type> <unqualified-name> <template-args> */
2896 write_expression (tree expr
)
2898 enum tree_code code
= TREE_CODE (expr
);
2900 if (TREE_CODE (expr
) == TARGET_EXPR
)
2902 expr
= TARGET_EXPR_INITIAL (expr
);
2903 code
= TREE_CODE (expr
);
2906 /* Skip NOP_EXPR and CONVERT_EXPR. They can occur when (say) a pointer
2907 argument is converted (via qualification conversions) to another type. */
2908 while (CONVERT_EXPR_CODE_P (code
)
2909 || code
== IMPLICIT_CONV_EXPR
2910 || location_wrapper_p (expr
)
2911 /* Parentheses aren't mangled. */
2912 || code
== PAREN_EXPR
2913 || code
== NON_LVALUE_EXPR
2914 || (code
== VIEW_CONVERT_EXPR
2915 && TREE_CODE (TREE_OPERAND (expr
, 0)) == TEMPLATE_PARM_INDEX
))
2917 expr
= TREE_OPERAND (expr
, 0);
2918 code
= TREE_CODE (expr
);
2921 if (code
== BASELINK
2922 && (!type_unknown_p (expr
)
2923 || !BASELINK_QUALIFIED_P (expr
)))
2925 expr
= BASELINK_FUNCTIONS (expr
);
2926 code
= TREE_CODE (expr
);
2929 /* Handle pointers-to-members by making them look like expression
2931 if (code
== PTRMEM_CST
)
2933 expr
= build_nt (ADDR_EXPR
,
2934 build_qualified_name (/*type=*/NULL_TREE
,
2935 PTRMEM_CST_CLASS (expr
),
2936 PTRMEM_CST_MEMBER (expr
),
2937 /*template_p=*/false));
2938 code
= TREE_CODE (expr
);
2941 /* Handle template parameters. */
2942 if (code
== TEMPLATE_TYPE_PARM
2943 || code
== TEMPLATE_TEMPLATE_PARM
2944 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
2945 || code
== TEMPLATE_PARM_INDEX
)
2946 write_template_param (expr
);
2947 /* Handle literals. */
2948 else if (TREE_CODE_CLASS (code
) == tcc_constant
2949 || code
== CONST_DECL
)
2950 write_template_arg_literal (expr
);
2951 else if (code
== PARM_DECL
&& DECL_ARTIFICIAL (expr
))
2953 gcc_assert (id_equal (DECL_NAME (expr
), "this"));
2954 write_string ("fpT");
2956 else if (code
== PARM_DECL
)
2958 /* A function parameter used in a late-specified return type. */
2959 int index
= DECL_PARM_INDEX (expr
);
2960 int level
= DECL_PARM_LEVEL (expr
);
2961 int delta
= G
.parm_depth
- level
+ 1;
2962 gcc_assert (index
>= 1);
2966 if (abi_version_at_least (5))
2968 /* Let L be the number of function prototype scopes from the
2969 innermost one (in which the parameter reference occurs) up
2970 to (and including) the one containing the declaration of
2971 the referenced parameter. If the parameter declaration
2972 clause of the innermost function prototype scope has been
2973 completely seen, it is not counted (in that case -- which
2974 is perhaps the most common -- L can be zero). */
2976 write_unsigned_number (delta
- 1);
2978 if (abi_warn_or_compat_version_crosses (5))
2979 G
.need_abi_warning
= true;
2982 write_compact_number (index
- 1);
2984 else if (DECL_P (expr
))
2987 write_mangled_name (expr
, false);
2990 else if (TREE_CODE (expr
) == SIZEOF_EXPR
)
2992 tree op
= TREE_OPERAND (expr
, 0);
2994 if (PACK_EXPANSION_P (op
))
2996 if (abi_warn_or_compat_version_crosses (11))
2997 G
.need_abi_warning
= true;
2998 if (abi_version_at_least (11))
3000 /* sZ rather than szDp. */
3001 write_string ("sZ");
3002 write_expression (PACK_EXPANSION_PATTERN (op
));
3007 if (SIZEOF_EXPR_TYPE_P (expr
))
3009 write_string ("st");
3010 write_type (TREE_TYPE (op
));
3012 else if (ARGUMENT_PACK_P (op
))
3014 tree args
= ARGUMENT_PACK_ARGS (op
);
3015 int length
= TREE_VEC_LENGTH (args
);
3016 if (abi_warn_or_compat_version_crosses (10))
3017 G
.need_abi_warning
= true;
3018 if (abi_version_at_least (10))
3020 /* sP <template-arg>* E # sizeof...(T), size of a captured
3021 template parameter pack from an alias template */
3022 write_string ("sP");
3023 for (int i
= 0; i
< length
; ++i
)
3024 write_template_arg (TREE_VEC_ELT (args
, i
));
3029 /* In GCC 5 we represented this sizeof wrong, with the effect
3030 that we mangled it as the last element of the pack. */
3031 tree arg
= TREE_VEC_ELT (args
, length
-1);
3034 write_string ("st");
3039 write_string ("sz");
3040 write_expression (arg
);
3044 else if (TYPE_P (TREE_OPERAND (expr
, 0)))
3046 write_string ("st");
3047 write_type (TREE_OPERAND (expr
, 0));
3052 else if (TREE_CODE (expr
) == ALIGNOF_EXPR
3053 && TYPE_P (TREE_OPERAND (expr
, 0)))
3055 write_string ("at");
3056 write_type (TREE_OPERAND (expr
, 0));
3058 else if (code
== SCOPE_REF
3059 || code
== BASELINK
)
3062 if (code
== SCOPE_REF
)
3064 scope
= TREE_OPERAND (expr
, 0);
3065 member
= TREE_OPERAND (expr
, 1);
3066 if (BASELINK_P (member
))
3067 member
= BASELINK_FUNCTIONS (member
);
3071 scope
= BINFO_TYPE (BASELINK_ACCESS_BINFO (expr
));
3072 member
= BASELINK_FUNCTIONS (expr
);
3075 /* If the MEMBER is a real declaration, then the qualifying
3076 scope was not dependent. Ideally, we would not have a
3077 SCOPE_REF in those cases, but sometimes we do. If the second
3078 argument is a DECL, then the name must not have been
3080 if (DECL_P (member
))
3081 write_expression (member
);
3084 write_string ("sr");
3086 write_member_name (member
);
3089 else if (INDIRECT_REF_P (expr
)
3090 && TREE_TYPE (TREE_OPERAND (expr
, 0))
3091 && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr
, 0))))
3093 write_expression (TREE_OPERAND (expr
, 0));
3095 else if (identifier_p (expr
))
3097 /* An operator name appearing as a dependent name needs to be
3098 specially marked to disambiguate between a use of the operator
3099 name and a use of the operator in an expression. */
3100 if (IDENTIFIER_ANY_OP_P (expr
))
3101 write_string ("on");
3102 write_unqualified_id (expr
);
3104 else if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
3106 tree fn
= TREE_OPERAND (expr
, 0);
3108 if (IDENTIFIER_ANY_OP_P (fn
))
3109 write_string ("on");
3110 write_unqualified_id (fn
);
3111 write_template_args (TREE_OPERAND (expr
, 1));
3113 else if (TREE_CODE (expr
) == MODOP_EXPR
)
3115 enum tree_code subop
= TREE_CODE (TREE_OPERAND (expr
, 1));
3116 const char *name
= OVL_OP_INFO (true, subop
)->mangled_name
;
3118 write_string (name
);
3119 write_expression (TREE_OPERAND (expr
, 0));
3120 write_expression (TREE_OPERAND (expr
, 2));
3122 else if (code
== NEW_EXPR
|| code
== VEC_NEW_EXPR
)
3124 /* ::= [gs] nw <expression>* _ <type> E
3125 ::= [gs] nw <expression>* _ <type> <initializer>
3126 ::= [gs] na <expression>* _ <type> E
3127 ::= [gs] na <expression>* _ <type> <initializer>
3128 <initializer> ::= pi <expression>* E */
3129 tree placement
= TREE_OPERAND (expr
, 0);
3130 tree type
= TREE_OPERAND (expr
, 1);
3131 tree nelts
= TREE_OPERAND (expr
, 2);
3132 tree init
= TREE_OPERAND (expr
, 3);
3135 gcc_assert (code
== NEW_EXPR
);
3136 if (TREE_OPERAND (expr
, 2))
3137 code
= VEC_NEW_EXPR
;
3139 if (NEW_EXPR_USE_GLOBAL (expr
))
3140 write_string ("gs");
3142 write_string (OVL_OP_INFO (false, code
)->mangled_name
);
3144 for (t
= placement
; t
; t
= TREE_CHAIN (t
))
3145 write_expression (TREE_VALUE (t
));
3152 ++processing_template_decl
;
3153 domain
= compute_array_index_type (NULL_TREE
, nelts
,
3154 tf_warning_or_error
);
3155 type
= build_cplus_array_type (type
, domain
);
3156 --processing_template_decl
;
3160 if (init
&& TREE_CODE (init
) == TREE_LIST
3161 && DIRECT_LIST_INIT_P (TREE_VALUE (init
)))
3162 write_expression (TREE_VALUE (init
));
3166 write_string ("pi");
3167 if (init
&& init
!= void_node
)
3168 for (t
= init
; t
; t
= TREE_CHAIN (t
))
3169 write_expression (TREE_VALUE (t
));
3173 else if (code
== DELETE_EXPR
|| code
== VEC_DELETE_EXPR
)
3175 gcc_assert (code
== DELETE_EXPR
);
3176 if (DELETE_EXPR_USE_VEC (expr
))
3177 code
= VEC_DELETE_EXPR
;
3179 if (DELETE_EXPR_USE_GLOBAL (expr
))
3180 write_string ("gs");
3182 write_string (OVL_OP_INFO (false, code
)->mangled_name
);
3184 write_expression (TREE_OPERAND (expr
, 0));
3186 else if (code
== THROW_EXPR
)
3188 tree op
= TREE_OPERAND (expr
, 0);
3191 write_string ("tw");
3192 write_expression (op
);
3195 write_string ("tr");
3197 else if (code
== CONSTRUCTOR
)
3199 bool braced_init
= BRACE_ENCLOSED_INITIALIZER_P (expr
);
3200 tree etype
= TREE_TYPE (expr
);
3203 write_string ("il");
3206 write_string ("tl");
3210 bool nontriv
= !trivial_type_p (etype
);
3211 if (nontriv
|| !zero_init_expr_p (expr
))
3213 /* Convert braced initializer lists to STRING_CSTs so that
3214 A<"Foo"> mangles the same as A<{'F', 'o', 'o', 0}> while
3215 still using the latter mangling for strings that
3216 originated as braced initializer lists. */
3217 expr
= braced_lists_to_strings (etype
, expr
);
3219 if (TREE_CODE (expr
) == CONSTRUCTOR
)
3221 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (expr
);
3222 unsigned last_nonzero
= UINT_MAX
, i
;
3223 constructor_elt
*ce
;
3227 FOR_EACH_CONSTRUCTOR_VALUE (elts
, i
, val
)
3228 if (!zero_init_expr_p (val
))
3231 if (nontriv
|| last_nonzero
!= UINT_MAX
)
3232 for (HOST_WIDE_INT i
= 0; vec_safe_iterate (elts
, i
, &ce
); ++i
)
3234 if (i
> last_nonzero
)
3236 /* FIXME handle RANGE_EXPR */
3237 if (TREE_CODE (etype
) == UNION_TYPE
)
3239 /* Express the active member as a designator. */
3240 write_string ("di");
3241 write_unqualified_name (ce
->index
);
3243 write_expression (ce
->value
);
3248 gcc_assert (TREE_CODE (expr
) == STRING_CST
);
3249 write_expression (expr
);
3254 else if (code
== LAMBDA_EXPR
)
3256 /* [temp.over.link] Two lambda-expressions are never considered
3259 So just use the closure type mangling. */
3260 write_string ("tl");
3261 write_type (LAMBDA_EXPR_CLOSURE (expr
));
3264 else if (dependent_name (expr
))
3266 write_unqualified_id (dependent_name (expr
));
3274 /* When we bind a variable or function to a non-type template
3275 argument with reference type, we create an ADDR_EXPR to show
3276 the fact that the entity's address has been taken. But, we
3277 don't actually want to output a mangling code for the `&'. */
3278 if (TREE_CODE (expr
) == ADDR_EXPR
3280 && TYPE_REF_P (TREE_TYPE (expr
)))
3282 expr
= TREE_OPERAND (expr
, 0);
3285 write_expression (expr
);
3289 code
= TREE_CODE (expr
);
3292 if (code
== COMPONENT_REF
)
3294 tree ob
= TREE_OPERAND (expr
, 0);
3296 if (TREE_CODE (ob
) == ARROW_EXPR
)
3298 write_string (OVL_OP_INFO (false, code
)->mangled_name
);
3299 ob
= TREE_OPERAND (ob
, 0);
3300 write_expression (ob
);
3302 else if (write_base_ref (expr
))
3304 else if (!is_dummy_object (ob
))
3306 write_string ("dt");
3307 write_expression (ob
);
3309 /* else, for a non-static data member with no associated object (in
3310 unevaluated context), use the unresolved-name mangling. */
3312 write_member_name (TREE_OPERAND (expr
, 1));
3316 /* If it wasn't any of those, recursively expand the expression. */
3317 name
= OVL_OP_INFO (false, code
)->mangled_name
;
3319 /* We used to mangle const_cast and static_cast like a C cast. */
3320 if (code
== CONST_CAST_EXPR
3321 || code
== STATIC_CAST_EXPR
)
3323 if (abi_warn_or_compat_version_crosses (6))
3324 G
.need_abi_warning
= 1;
3325 if (!abi_version_at_least (6))
3326 name
= OVL_OP_INFO (false, CAST_EXPR
)->mangled_name
;
3334 error ("use of built-in trait %qE in function signature; "
3335 "use library traits instead", expr
);
3339 sorry ("mangling %C", code
);
3345 write_string (name
);
3351 tree fn
= CALL_EXPR_FN (expr
);
3353 if (TREE_CODE (fn
) == ADDR_EXPR
)
3354 fn
= TREE_OPERAND (fn
, 0);
3356 /* Mangle a dependent name as the name, not whatever happens to
3357 be the first function in the overload set. */
3359 && type_dependent_expression_p_push (expr
))
3362 write_expression (fn
);
3365 for (i
= 0; i
< call_expr_nargs (expr
); ++i
)
3366 write_expression (CALL_EXPR_ARG (expr
, i
));
3371 write_type (TREE_TYPE (expr
));
3372 if (list_length (TREE_OPERAND (expr
, 0)) == 1)
3373 write_expression (TREE_VALUE (TREE_OPERAND (expr
, 0)));
3376 tree args
= TREE_OPERAND (expr
, 0);
3378 for (; args
; args
= TREE_CHAIN (args
))
3379 write_expression (TREE_VALUE (args
));
3384 case DYNAMIC_CAST_EXPR
:
3385 case REINTERPRET_CAST_EXPR
:
3386 case STATIC_CAST_EXPR
:
3387 case CONST_CAST_EXPR
:
3388 write_type (TREE_TYPE (expr
));
3389 write_expression (TREE_OPERAND (expr
, 0));
3392 case PREINCREMENT_EXPR
:
3393 case PREDECREMENT_EXPR
:
3394 if (abi_version_at_least (6))
3396 if (abi_warn_or_compat_version_crosses (6))
3397 G
.need_abi_warning
= 1;
3401 /* In the middle-end, some expressions have more operands than
3402 they do in templates (and mangling). */
3403 len
= cp_tree_operand_length (expr
);
3405 for (i
= 0; i
< len
; ++i
)
3407 tree operand
= TREE_OPERAND (expr
, i
);
3408 /* As a GNU extension, the middle operand of a
3409 conditional may be omitted. Since expression
3410 manglings are supposed to represent the input token
3411 stream, there's no good way to mangle such an
3412 expression without extending the C++ ABI. */
3413 if (code
== COND_EXPR
&& i
== 1 && !operand
)
3415 error ("omitted middle operand to %<?:%> operand "
3416 "cannot be mangled");
3419 else if (FOLD_EXPR_P (expr
))
3421 /* The first 'operand' of a fold-expression is the operator
3422 that it folds over. */
3425 int fcode
= TREE_INT_CST_LOW (operand
);
3426 write_string (OVL_OP_INFO (false, fcode
)->mangled_name
);
3429 else if (code
== BINARY_LEFT_FOLD_EXPR
)
3431 /* The order of operands of the binary left and right
3432 folds is the same, but we want to mangle them in
3433 lexical order, i.e. non-pack first. */
3435 operand
= FOLD_EXPR_INIT (expr
);
3437 operand
= FOLD_EXPR_PACK (expr
);
3439 if (PACK_EXPANSION_P (operand
))
3440 operand
= PACK_EXPANSION_PATTERN (operand
);
3442 write_expression (operand
);
3448 /* Literal subcase of non-terminal <template-arg>.
3450 "Literal arguments, e.g. "A<42L>", are encoded with their type
3451 and value. Negative integer values are preceded with "n"; for
3452 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
3453 encoded as 0, true as 1." */
3456 write_template_arg_literal (const tree value
)
3458 if (TREE_CODE (value
) == STRING_CST
)
3459 /* Temporarily mangle strings as braced initializer lists. */
3460 write_string ("tl");
3464 tree valtype
= TREE_TYPE (value
);
3465 write_type (valtype
);
3467 /* Write a null member pointer value as (type)0, regardless of its
3468 real representation. */
3469 if (null_member_pointer_value_p (value
))
3470 write_integer_cst (integer_zero_node
);
3472 switch (TREE_CODE (value
))
3475 write_integer_cst (DECL_INITIAL (value
));
3479 gcc_assert (!same_type_p (TREE_TYPE (value
), boolean_type_node
)
3480 || integer_zerop (value
) || integer_onep (value
));
3481 if (!(abi_version_at_least (14)
3482 && NULLPTR_TYPE_P (TREE_TYPE (value
))))
3483 write_integer_cst (value
);
3487 write_real_cst (value
);
3491 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
3492 && TREE_CODE (TREE_IMAGPART (value
)) == INTEGER_CST
)
3494 write_integer_cst (TREE_REALPART (value
));
3496 write_integer_cst (TREE_IMAGPART (value
));
3498 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
3499 && TREE_CODE (TREE_IMAGPART (value
)) == REAL_CST
)
3501 write_real_cst (TREE_REALPART (value
));
3503 write_real_cst (TREE_IMAGPART (value
));
3511 /* Mangle strings the same as braced initializer lists. */
3512 unsigned n
= TREE_STRING_LENGTH (value
);
3513 const char *str
= TREE_STRING_POINTER (value
);
3515 /* Count the number of trailing nuls and subtract them from
3516 STRSIZE because they don't need to be mangled. */
3517 for (const char *p
= str
+ n
- 1; ; --p
)
3521 n
-= str
+ n
- !!*p
- p
;
3525 tree eltype
= TREE_TYPE (valtype
);
3526 for (const char *p
= str
; n
--; ++p
)
3529 write_type (eltype
);
3530 write_unsigned_number (*(const unsigned char*)p
);
3543 /* Non-terminal <template-arg>.
3545 <template-arg> ::= <type> # type
3546 ::= L <type> </value/ number> E # literal
3547 ::= LZ <name> E # external name
3548 ::= X <expression> E # expression */
3551 write_template_arg (tree node
)
3553 enum tree_code code
= TREE_CODE (node
);
3555 MANGLE_TRACE_TREE ("template-arg", node
);
3557 /* A template template parameter's argument list contains TREE_LIST
3558 nodes of which the value field is the actual argument. */
3559 if (code
== TREE_LIST
)
3561 node
= TREE_VALUE (node
);
3562 /* If it's a decl, deal with its type instead. */
3565 node
= TREE_TYPE (node
);
3566 code
= TREE_CODE (node
);
3570 if (template_parm_object_p (node
))
3571 /* We want to mangle the argument, not the var we stored it in. */
3572 node
= tparm_object_argument (node
);
3574 /* Strip a conversion added by convert_nontype_argument. */
3575 if (TREE_CODE (node
) == IMPLICIT_CONV_EXPR
)
3576 node
= TREE_OPERAND (node
, 0);
3577 if (REFERENCE_REF_P (node
))
3578 node
= TREE_OPERAND (node
, 0);
3579 if (TREE_CODE (node
) == NOP_EXPR
3580 && TYPE_REF_P (TREE_TYPE (node
)))
3582 /* Template parameters can be of reference type. To maintain
3583 internal consistency, such arguments use a conversion from
3584 address of object to reference type. */
3585 gcc_assert (TREE_CODE (TREE_OPERAND (node
, 0)) == ADDR_EXPR
);
3586 node
= TREE_OPERAND (TREE_OPERAND (node
, 0), 0);
3589 if (TREE_CODE (node
) == BASELINK
3590 && !type_unknown_p (node
))
3592 if (abi_version_at_least (6))
3593 node
= BASELINK_FUNCTIONS (node
);
3594 if (abi_warn_or_compat_version_crosses (6))
3595 /* We wrongly wrapped a class-scope function in X/E. */
3596 G
.need_abi_warning
= 1;
3599 if (ARGUMENT_PACK_P (node
))
3601 /* Expand the template argument pack. */
3602 tree args
= ARGUMENT_PACK_ARGS (node
);
3603 int i
, length
= TREE_VEC_LENGTH (args
);
3604 if (abi_version_at_least (6))
3608 if (abi_warn_or_compat_version_crosses (6))
3609 G
.need_abi_warning
= 1;
3610 for (i
= 0; i
< length
; ++i
)
3611 write_template_arg (TREE_VEC_ELT (args
, i
));
3614 else if (TYPE_P (node
))
3616 else if (code
== TEMPLATE_DECL
)
3617 /* A template appearing as a template arg is a template template arg. */
3618 write_template_template_arg (node
);
3619 else if ((TREE_CODE_CLASS (code
) == tcc_constant
&& code
!= PTRMEM_CST
)
3620 || code
== CONST_DECL
3621 || null_member_pointer_value_p (node
))
3622 write_template_arg_literal (node
);
3623 else if (DECL_P (node
))
3626 /* Until ABI version 3, the underscore before the mangled name
3627 was incorrectly omitted. */
3628 if (!abi_version_at_least (3))
3631 write_string ("_Z");
3632 if (abi_warn_or_compat_version_crosses (3))
3633 G
.need_abi_warning
= 1;
3634 write_encoding (node
);
3639 /* Template arguments may be expressions. */
3641 write_expression (node
);
3646 /* <template-template-arg>
3648 ::= <substitution> */
3651 write_template_template_arg (const tree decl
)
3653 MANGLE_TRACE_TREE ("template-template-arg", decl
);
3655 if (find_substitution (decl
))
3657 write_name (decl
, /*ignore_local_scope=*/0);
3658 add_substitution (decl
);
3662 /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
3664 <array-type> ::= A [</dimension/ number>] _ </element/ type>
3665 ::= A <expression> _ </element/ type>
3667 "Array types encode the dimension (number of elements) and the
3668 element type. For variable length arrays, the dimension (but not
3669 the '_' separator) is omitted."
3670 Note that for flexible array members, like for other arrays of
3671 unspecified size, the dimension is also omitted. */
3674 write_array_type (const tree type
)
3677 if (TYPE_DOMAIN (type
))
3681 index_type
= TYPE_DOMAIN (type
);
3682 /* The INDEX_TYPE gives the upper and lower bounds of the array.
3683 It's null for flexible array members which have no upper bound
3684 (this is a change from GCC 5 and prior where such members were
3685 incorrectly mangled as zero-length arrays). */
3686 if (tree max
= TYPE_MAX_VALUE (index_type
))
3688 if (TREE_CODE (max
) == INTEGER_CST
)
3690 /* The ABI specifies that we should mangle the number of
3691 elements in the array, not the largest allowed index. */
3692 offset_int wmax
= wi::to_offset (max
) + 1;
3693 /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
3694 number of elements as zero. */
3695 wmax
= wi::zext (wmax
, TYPE_PRECISION (TREE_TYPE (max
)));
3696 gcc_assert (wi::fits_uhwi_p (wmax
));
3697 write_unsigned_number (wmax
.to_uhwi ());
3701 max
= TREE_OPERAND (max
, 0);
3702 write_expression (max
);
3707 write_type (TREE_TYPE (type
));
3710 /* Non-terminal <pointer-to-member-type> for pointer-to-member
3711 variables. TYPE is a pointer-to-member POINTER_TYPE.
3713 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
3716 write_pointer_to_member_type (const tree type
)
3719 write_type (TYPE_PTRMEM_CLASS_TYPE (type
));
3720 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type
));
3723 /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
3724 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3725 TEMPLATE_PARM_INDEX.
3727 <template-param> ::= T </parameter/ number> _ */
3730 write_template_param (const tree parm
)
3734 MANGLE_TRACE_TREE ("template-parm", parm
);
3736 switch (TREE_CODE (parm
))
3738 case TEMPLATE_TYPE_PARM
:
3739 case TEMPLATE_TEMPLATE_PARM
:
3740 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3741 parm_index
= TEMPLATE_TYPE_IDX (parm
);
3744 case TEMPLATE_PARM_INDEX
:
3745 parm_index
= TEMPLATE_PARM_IDX (parm
);
3753 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3754 earliest template param denoted by `_'. */
3755 write_compact_number (parm_index
);
3758 /* <template-template-param>
3759 ::= <template-param>
3760 ::= <substitution> */
3763 write_template_template_param (const tree parm
)
3765 tree templ
= NULL_TREE
;
3767 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3768 template template parameter. The substitution candidate here is
3769 only the template. */
3770 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
3773 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
));
3774 if (find_substitution (templ
))
3778 /* <template-param> encodes only the template parameter position,
3779 not its template arguments, which is fine here. */
3780 write_template_param (parm
);
3782 add_substitution (templ
);
3785 /* Non-terminal <substitution>.
3787 <substitution> ::= S <seq-id> _
3791 write_substitution (const int seq_id
)
3793 MANGLE_TRACE ("substitution", "");
3797 write_number (seq_id
- 1, /*unsigned=*/1, 36);
3801 /* Start mangling ENTITY. */
3804 start_mangling (const tree entity
)
3807 G
.need_abi_warning
= false;
3808 G
.need_cxx17_warning
= false;
3809 obstack_free (&name_obstack
, name_base
);
3810 mangle_obstack
= &name_obstack
;
3811 name_base
= obstack_alloc (&name_obstack
, 0);
3814 /* Done with mangling. If WARN is true, and the name of G.entity will
3815 be mangled differently in a future version of the ABI, issue a
3819 finish_mangling_internal (void)
3821 /* Clear all the substitutions. */
3822 vec_safe_truncate (G
.substitutions
, 0);
3824 /* Null-terminate the string. */
3829 /* Like finish_mangling_internal, but return the mangled string. */
3831 static inline const char *
3832 finish_mangling (void)
3834 finish_mangling_internal ();
3835 return (const char *) obstack_finish (mangle_obstack
);
3838 /* Like finish_mangling_internal, but return an identifier. */
3841 finish_mangling_get_identifier (void)
3843 finish_mangling_internal ();
3844 /* Don't obstack_finish here, and the next start_mangling will
3845 remove the identifier. */
3846 return get_identifier ((const char *) obstack_base (mangle_obstack
));
3849 /* Initialize data structures for mangling. */
3854 gcc_obstack_init (&name_obstack
);
3855 name_base
= obstack_alloc (&name_obstack
, 0);
3856 vec_alloc (G
.substitutions
, 0);
3858 /* Cache these identifiers for quick comparison when checking for
3859 standard substitutions. */
3860 subst_identifiers
[SUBID_ALLOCATOR
] = get_identifier ("allocator");
3861 subst_identifiers
[SUBID_BASIC_STRING
] = get_identifier ("basic_string");
3862 subst_identifiers
[SUBID_CHAR_TRAITS
] = get_identifier ("char_traits");
3863 subst_identifiers
[SUBID_BASIC_ISTREAM
] = get_identifier ("basic_istream");
3864 subst_identifiers
[SUBID_BASIC_OSTREAM
] = get_identifier ("basic_ostream");
3865 subst_identifiers
[SUBID_BASIC_IOSTREAM
] = get_identifier ("basic_iostream");
3868 /* Generate the mangled name of DECL. */
3871 mangle_decl_string (const tree decl
)
3874 tree saved_fn
= NULL_TREE
;
3875 bool template_p
= false;
3877 /* We shouldn't be trying to mangle an uninstantiated template. */
3878 gcc_assert (!type_dependent_expression_p (decl
));
3880 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
3882 struct tinst_level
*tl
= current_instantiation ();
3883 if ((!tl
|| tl
->maybe_get_node () != decl
)
3884 && push_tinst_level (decl
))
3887 saved_fn
= current_function_decl
;
3888 current_function_decl
= NULL_TREE
;
3891 iloc_sentinel
ils (DECL_SOURCE_LOCATION (decl
));
3893 start_mangling (decl
);
3895 if (TREE_CODE (decl
) == TYPE_DECL
)
3896 write_type (TREE_TYPE (decl
));
3898 write_mangled_name (decl
, true);
3900 result
= finish_mangling_get_identifier ();
3902 fprintf (stderr
, "mangle_decl_string = '%s'\n\n",
3903 IDENTIFIER_POINTER (result
));
3908 current_function_decl
= saved_fn
;
3914 /* Return an identifier for the external mangled name of DECL. */
3917 get_mangled_id (tree decl
)
3919 tree id
= mangle_decl_string (decl
);
3920 return targetm
.mangle_decl_assembler_name (decl
, id
);
3923 /* Create an identifier for the external mangled name of DECL. */
3926 mangle_decl (const tree decl
)
3931 /* Don't bother mangling uninstantiated templates. */
3932 ++processing_template_decl
;
3933 if (TREE_CODE (decl
) == TYPE_DECL
)
3934 dep
= dependent_type_p (TREE_TYPE (decl
));
3936 dep
= (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
)
3937 && any_dependent_template_arguments_p (DECL_TI_ARGS (decl
)));
3938 --processing_template_decl
;
3942 /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
3943 It is not needed to assign names to anonymous namespace, but we use the
3944 "<anon>" marker to be able to tell if type is C++ ODR type or type
3945 produced by other language. */
3946 if (TREE_CODE (decl
) == TYPE_DECL
3947 && TYPE_STUB_DECL (TREE_TYPE (decl
))
3948 && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl
))))
3949 id
= get_identifier ("<anon>");
3952 gcc_assert (TREE_CODE (decl
) != TYPE_DECL
3953 || !no_linkage_check (TREE_TYPE (decl
), true));
3954 if (abi_version_at_least (10))
3955 if (tree fn
= decl_function_context (decl
))
3956 maybe_check_abi_tags (fn
, decl
);
3957 id
= get_mangled_id (decl
);
3959 SET_DECL_ASSEMBLER_NAME (decl
, id
);
3961 if (G
.need_cxx17_warning
3962 && (TREE_PUBLIC (decl
) || DECL_REALLY_EXTERN (decl
)))
3963 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wnoexcept_type
,
3964 "mangled name for %qD will change in C++17 because the "
3965 "exception specification is part of a function type",
3968 if (id
!= DECL_NAME (decl
)
3969 /* Don't do this for a fake symbol we aren't going to emit anyway. */
3970 && TREE_CODE (decl
) != TYPE_DECL
3971 && !DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
))
3973 int save_ver
= flag_abi_version
;
3974 tree id2
= NULL_TREE
;
3976 if (!DECL_REALLY_EXTERN (decl
))
3978 record_mangling (decl
, G
.need_abi_warning
);
3980 if (!G
.need_abi_warning
)
3983 flag_abi_version
= flag_abi_compat_version
;
3984 id2
= mangle_decl_string (decl
);
3985 id2
= targetm
.mangle_decl_assembler_name (decl
, id2
);
3986 flag_abi_version
= save_ver
;
3989 note_mangling_alias (decl
, id2
);
3994 const char fabi_version
[] = "-fabi-version";
3996 if (flag_abi_compat_version
!= warn_abi_version
3997 || id2
== NULL_TREE
)
3999 flag_abi_version
= warn_abi_version
;
4000 id2
= mangle_decl_string (decl
);
4001 id2
= targetm
.mangle_decl_assembler_name (decl
, id2
);
4003 flag_abi_version
= save_ver
;
4007 else if (warn_abi_version
!= 0
4008 && abi_version_at_least (warn_abi_version
))
4009 warning_at (DECL_SOURCE_LOCATION (G
.entity
), OPT_Wabi
,
4010 "the mangled name of %qD changed between "
4011 "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
4012 G
.entity
, fabi_version
, warn_abi_version
, id2
,
4013 fabi_version
, save_ver
, id
);
4015 warning_at (DECL_SOURCE_LOCATION (G
.entity
), OPT_Wabi
,
4016 "the mangled name of %qD changes between "
4017 "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
4018 G
.entity
, fabi_version
, save_ver
, id
,
4019 fabi_version
, warn_abi_version
, id2
);
4022 flag_abi_version
= save_ver
;
4026 /* Generate the mangled representation of TYPE. */
4029 mangle_type_string (const tree type
)
4033 start_mangling (type
);
4035 result
= finish_mangling ();
4037 fprintf (stderr
, "mangle_type_string = '%s'\n\n", result
);
4041 /* Create an identifier for the mangled name of a special component
4042 for belonging to TYPE. CODE is the ABI-specified code for this
4046 mangle_special_for_type (const tree type
, const char *code
)
4050 /* We don't have an actual decl here for the special component, so
4051 we can't just process the <encoded-name>. Instead, fake it. */
4052 start_mangling (type
);
4054 /* Start the mangling. */
4055 write_string ("_Z");
4056 write_string (code
);
4060 result
= finish_mangling_get_identifier ();
4063 fprintf (stderr
, "mangle_special_for_type = %s\n\n",
4064 IDENTIFIER_POINTER (result
));
4069 /* Create an identifier for the mangled representation of the typeinfo
4070 structure for TYPE. */
4073 mangle_typeinfo_for_type (const tree type
)
4075 return mangle_special_for_type (type
, "TI");
4078 /* Create an identifier for the mangled name of the NTBS containing
4079 the mangled name of TYPE. */
4082 mangle_typeinfo_string_for_type (const tree type
)
4084 return mangle_special_for_type (type
, "TS");
4087 /* Create an identifier for the mangled name of the vtable for TYPE. */
4090 mangle_vtbl_for_type (const tree type
)
4092 return mangle_special_for_type (type
, "TV");
4095 /* Returns an identifier for the mangled name of the VTT for TYPE. */
4098 mangle_vtt_for_type (const tree type
)
4100 return mangle_special_for_type (type
, "TT");
4103 /* Returns an identifier for the mangled name of the decomposition
4104 artificial variable DECL. DECLS is the vector of the VAR_DECLs
4105 for the identifier-list. */
4108 mangle_decomp (const tree decl
, vec
<tree
> &decls
)
4110 gcc_assert (!type_dependent_expression_p (decl
));
4112 location_t saved_loc
= input_location
;
4113 input_location
= DECL_SOURCE_LOCATION (decl
);
4115 start_mangling (decl
);
4116 write_string ("_Z");
4118 tree context
= decl_mangling_context (decl
);
4119 gcc_assert (context
!= NULL_TREE
);
4121 bool nested
= false;
4122 if (DECL_NAMESPACE_STD_P (context
))
4123 write_string ("St");
4124 else if (context
!= global_namespace
)
4128 write_prefix (decl_mangling_context (decl
));
4131 write_string ("DC");
4134 FOR_EACH_VEC_ELT (decls
, i
, d
)
4135 write_unqualified_name (d
);
4141 tree id
= finish_mangling_get_identifier ();
4143 fprintf (stderr
, "mangle_decomp = '%s'\n\n",
4144 IDENTIFIER_POINTER (id
));
4146 input_location
= saved_loc
;
4150 /* Return an identifier for a construction vtable group. TYPE is
4151 the most derived class in the hierarchy; BINFO is the base
4152 subobject for which this construction vtable group will be used.
4154 This mangling isn't part of the ABI specification; in the ABI
4155 specification, the vtable group is dumped in the same COMDAT as the
4156 main vtable, and is referenced only from that vtable, so it doesn't
4157 need an external name. For binary formats without COMDAT sections,
4158 though, we need external names for the vtable groups.
4160 We use the production
4162 <special-name> ::= CT <type> <offset number> _ <base type> */
4165 mangle_ctor_vtbl_for_type (const tree type
, const tree binfo
)
4169 start_mangling (type
);
4171 write_string ("_Z");
4172 write_string ("TC");
4174 write_integer_cst (BINFO_OFFSET (binfo
));
4176 write_type (BINFO_TYPE (binfo
));
4178 result
= finish_mangling_get_identifier ();
4180 fprintf (stderr
, "mangle_ctor_vtbl_for_type = %s\n\n",
4181 IDENTIFIER_POINTER (result
));
4185 /* Mangle a this pointer or result pointer adjustment.
4187 <call-offset> ::= h <fixed offset number> _
4188 ::= v <fixed offset number> _ <virtual offset number> _ */
4191 mangle_call_offset (const tree fixed_offset
, const tree virtual_offset
)
4193 write_char (virtual_offset
? 'v' : 'h');
4195 /* For either flavor, write the fixed offset. */
4196 write_integer_cst (fixed_offset
);
4199 /* For a virtual thunk, add the virtual offset. */
4202 write_integer_cst (virtual_offset
);
4207 /* Return an identifier for the mangled name of a this-adjusting or
4208 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment
4209 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this
4210 is a virtual thunk, and it is the vtbl offset in
4211 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
4212 zero for a covariant thunk. Note, that FN_DECL might be a covariant
4213 thunk itself. A covariant thunk name always includes the adjustment
4214 for the this pointer, even if there is none.
4216 <special-name> ::= T <call-offset> <base encoding>
4217 ::= Tc <this_adjust call-offset> <result_adjust call-offset>
4221 mangle_thunk (tree fn_decl
, const int this_adjusting
, tree fixed_offset
,
4222 tree virtual_offset
, tree thunk
)
4226 if (abi_version_at_least (11))
4227 maybe_check_abi_tags (fn_decl
, thunk
, 11);
4229 start_mangling (fn_decl
);
4231 write_string ("_Z");
4234 if (!this_adjusting
)
4236 /* Covariant thunk with no this adjustment */
4238 mangle_call_offset (integer_zero_node
, NULL_TREE
);
4239 mangle_call_offset (fixed_offset
, virtual_offset
);
4241 else if (!DECL_THUNK_P (fn_decl
))
4242 /* Plain this adjusting thunk. */
4243 mangle_call_offset (fixed_offset
, virtual_offset
);
4246 /* This adjusting thunk to covariant thunk. */
4248 mangle_call_offset (fixed_offset
, virtual_offset
);
4249 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn_decl
));
4250 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn_decl
);
4252 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
4253 mangle_call_offset (fixed_offset
, virtual_offset
);
4254 fn_decl
= THUNK_TARGET (fn_decl
);
4258 write_encoding (fn_decl
);
4260 result
= finish_mangling_get_identifier ();
4262 fprintf (stderr
, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result
));
4266 /* Handle ABI backwards compatibility for past bugs where we didn't call
4267 check_abi_tags in places where it's needed: call check_abi_tags and warn if
4268 it makes a difference. If FOR_DECL is non-null, it's the declaration
4269 that we're actually trying to mangle; if it's null, we're mangling the
4270 guard variable for T. */
4273 maybe_check_abi_tags (tree t
, tree for_decl
, int ver
)
4275 if (DECL_ASSEMBLER_NAME_SET_P (t
))
4278 tree oldtags
= get_abi_tags (t
);
4282 tree newtags
= get_abi_tags (t
);
4283 if (newtags
&& newtags
!= oldtags
4284 && abi_version_crosses (ver
))
4286 if (for_decl
&& DECL_THUNK_P (for_decl
))
4287 warning_at (DECL_SOURCE_LOCATION (t
), OPT_Wabi
,
4288 "the mangled name of a thunk for %qD changes between "
4289 "%<-fabi-version=%d%> and %<-fabi-version=%d%>",
4290 t
, flag_abi_version
, warn_abi_version
);
4292 warning_at (DECL_SOURCE_LOCATION (for_decl
), OPT_Wabi
,
4293 "the mangled name of %qD changes between "
4294 "%<-fabi-version=%d%> and %<-fabi-version=%d%>",
4295 for_decl
, flag_abi_version
, warn_abi_version
);
4297 warning_at (DECL_SOURCE_LOCATION (t
), OPT_Wabi
,
4298 "the mangled name of the initialization guard variable "
4299 "for %qD changes between %<-fabi-version=%d%> and "
4300 "%<-fabi-version=%d%>",
4301 t
, flag_abi_version
, warn_abi_version
);
4305 /* Write out the appropriate string for this variable when generating
4306 another mangled name based on this one. */
4309 write_guarded_var_name (const tree variable
)
4311 if (DECL_NAME (variable
)
4312 && strncmp (IDENTIFIER_POINTER (DECL_NAME (variable
)), "_ZGR", 4) == 0)
4313 /* The name of a guard variable for a reference temporary should refer
4314 to the reference, not the temporary. */
4315 write_string (IDENTIFIER_POINTER (DECL_NAME (variable
)) + 4);
4317 write_name (variable
, /*ignore_local_scope=*/0);
4320 /* Return an identifier for the name of an initialization guard
4321 variable for indicated VARIABLE. */
4324 mangle_guard_variable (const tree variable
)
4326 if (abi_version_at_least (10))
4327 maybe_check_abi_tags (variable
);
4328 start_mangling (variable
);
4329 write_string ("_ZGV");
4330 write_guarded_var_name (variable
);
4331 return finish_mangling_get_identifier ();
4334 /* Return an identifier for the name of a thread_local initialization
4335 function for VARIABLE. */
4338 mangle_tls_init_fn (const tree variable
)
4340 check_abi_tags (variable
);
4341 start_mangling (variable
);
4342 write_string ("_ZTH");
4343 write_guarded_var_name (variable
);
4344 return finish_mangling_get_identifier ();
4347 /* Return an identifier for the name of a thread_local wrapper
4348 function for VARIABLE. */
4350 #define TLS_WRAPPER_PREFIX "_ZTW"
4353 mangle_tls_wrapper_fn (const tree variable
)
4355 check_abi_tags (variable
);
4356 start_mangling (variable
);
4357 write_string (TLS_WRAPPER_PREFIX
);
4358 write_guarded_var_name (variable
);
4359 return finish_mangling_get_identifier ();
4362 /* Return true iff FN is a thread_local wrapper function. */
4365 decl_tls_wrapper_p (const tree fn
)
4367 if (TREE_CODE (fn
) != FUNCTION_DECL
)
4369 tree name
= DECL_NAME (fn
);
4370 return strncmp (IDENTIFIER_POINTER (name
), TLS_WRAPPER_PREFIX
,
4371 strlen (TLS_WRAPPER_PREFIX
)) == 0;
4374 /* Return an identifier for the name of a temporary variable used to
4375 initialize a static reference. This is now part of the ABI. */
4378 mangle_ref_init_variable (const tree variable
)
4380 start_mangling (variable
);
4381 write_string ("_ZGR");
4382 check_abi_tags (variable
);
4383 write_name (variable
, /*ignore_local_scope=*/0);
4384 /* Avoid name clashes with aggregate initialization of multiple
4385 references at once. */
4386 write_compact_number (current_ref_temp_count
++);
4387 return finish_mangling_get_identifier ();
4390 /* Return an identifier for the mangled name of a C++20 template parameter
4391 object for template argument EXPR. */
4394 mangle_template_parm_object (tree expr
)
4396 start_mangling (expr
);
4397 write_string ("_ZTAX");
4398 write_expression (expr
);
4400 return finish_mangling_get_identifier ();
4403 /* Given a CLASS_TYPE, such as a record for std::bad_exception this
4404 function generates a mangled name for the vtable map variable of
4405 the class type. For example, if the class type is
4406 "std::bad_exception", the mangled name for the class is
4407 "St13bad_exception". This function would generate the name
4408 "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
4409 "_VTV<std::bad_exception>::__vtable_map". */
4413 get_mangled_vtable_map_var_name (tree class_type
)
4415 char *var_name
= NULL
;
4416 const char *prefix
= "_ZN4_VTVI";
4417 const char *postfix
= "E12__vtable_mapE";
4419 gcc_assert (TREE_CODE (class_type
) == RECORD_TYPE
);
4421 tree class_id
= DECL_ASSEMBLER_NAME (TYPE_NAME (class_type
));
4423 if (strstr (IDENTIFIER_POINTER (class_id
), "<anon>") != NULL
)
4425 class_id
= get_mangled_id (TYPE_NAME (class_type
));
4426 vtbl_register_mangled_name (TYPE_NAME (class_type
), class_id
);
4429 unsigned int len
= strlen (IDENTIFIER_POINTER (class_id
)) +
4431 strlen (postfix
) + 1;
4433 var_name
= (char *) xmalloc (len
);
4435 sprintf (var_name
, "%s%s%s", prefix
, IDENTIFIER_POINTER (class_id
), postfix
);
4440 #include "gt-cp-mangle.h"