1 /* Name mangling for the 3.0 C++ ABI.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Written by Alex Samuel <samuel@codesourcery.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This file implements mangling of C++ names according to the IA64
23 C++ ABI specification. A mangled name encodes a function or
24 variable's name, scope, type, and/or template arguments into a text
25 identifier. This identifier is used as the function's or
26 variable's linkage name, to preserve compatibility between C++'s
27 language features (templates, scoping, and overloading) and C
30 Additionally, g++ uses mangled names internally. To support this,
31 mangling of types is allowed, even though the mangled name of a
32 type should not appear by itself as an exported name. Ditto for
33 uninstantiated templates.
35 The primary entry point for this module is mangle_decl, which
36 returns an identifier containing the mangled name for a decl.
37 Additional entry points are provided to build mangled names of
38 particular constructs when the appropriate decl for that construct
39 is not available. These are:
41 mangle_typeinfo_for_type: typeinfo data
42 mangle_typeinfo_string_for_type: typeinfo type name
43 mangle_vtbl_for_type: virtual table data
44 mangle_vtt_for_type: VTT data
45 mangle_ctor_vtbl_for_type: `C-in-B' constructor virtual table data
46 mangle_thunk: thunk function or entry */
50 #include "coretypes.h"
60 /* Debugging support. */
62 /* Define DEBUG_MANGLE to enable very verbose trace messages. */
64 #define DEBUG_MANGLE 0
67 /* Macros for tracing the write_* functions. */
69 # define MANGLE_TRACE(FN, INPUT) \
70 fprintf (stderr, " %-24s: %-24s\n", (FN), (INPUT))
71 # define MANGLE_TRACE_TREE(FN, NODE) \
72 fprintf (stderr, " %-24s: %-24s (%p)\n", \
73 (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE))
75 # define MANGLE_TRACE(FN, INPUT)
76 # define MANGLE_TRACE_TREE(FN, NODE)
79 /* Nonzero if NODE is a class template-id. We can't rely on
80 CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
81 that hard to distinguish A<T> from A, where A<T> is the type as
82 instantiated outside of the template, and A is the type used
83 without parameters inside the template. */
84 #define CLASSTYPE_TEMPLATE_ID_P(NODE) \
85 (TYPE_LANG_SPECIFIC (NODE) != NULL \
86 && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \
87 || (CLASSTYPE_TEMPLATE_INFO (NODE) != NULL \
88 && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))))
90 /* Things we only need one of. This module is not reentrant. */
91 typedef struct GTY(()) globals
{
92 /* An array of the current substitution candidates, in the order
94 VEC(tree
,gc
) *substitutions
;
96 /* The entity that is being mangled. */
97 tree
GTY ((skip
)) entity
;
99 /* True if the mangling will be different in a future version of the
101 bool need_abi_warning
;
104 static GTY (()) globals G
;
106 /* The obstack on which we build mangled names. */
107 static struct obstack
*mangle_obstack
;
109 /* The obstack on which we build mangled names that are not going to
110 be IDENTIFIER_NODEs. */
111 static struct obstack name_obstack
;
113 /* The first object on the name_obstack; we use this to free memory
114 allocated on the name_obstack. */
115 static void *name_base
;
117 /* Indices into subst_identifiers. These are identifiers used in
118 special substitution rules. */
126 SUBID_BASIC_IOSTREAM
,
129 substitution_identifier_index_t
;
131 /* For quick substitution checks, look up these common identifiers
133 static GTY(()) tree subst_identifiers
[SUBID_MAX
];
135 /* Single-letter codes for builtin integer types, defined in
136 <builtin-type>. These are indexed by integer_type_kind values. */
138 integer_type_codes
[itk_none
] =
141 'a', /* itk_signed_char */
142 'h', /* itk_unsigned_char */
144 't', /* itk_unsigned_short */
146 'j', /* itk_unsigned_int */
148 'm', /* itk_unsigned_long */
149 'x', /* itk_long_long */
150 'y', /* itk_unsigned_long_long */
151 'n', /* itk_int128 */
152 'o', /* itk_unsigned_int128 */
155 static int decl_is_template_id (const tree
, tree
* const);
157 /* Functions for handling substitutions. */
159 static inline tree
canonicalize_for_substitution (tree
);
160 static void add_substitution (tree
);
161 static inline int is_std_substitution (const tree
,
162 const substitution_identifier_index_t
);
163 static inline int is_std_substitution_char (const tree
,
164 const substitution_identifier_index_t
);
165 static int find_substitution (tree
);
166 static void mangle_call_offset (const tree
, const tree
);
168 /* Functions for emitting mangled representations of things. */
170 static void write_mangled_name (const tree
, bool);
171 static void write_encoding (const tree
);
172 static void write_name (tree
, const int);
173 static void write_unscoped_name (const tree
);
174 static void write_unscoped_template_name (const tree
);
175 static void write_nested_name (const tree
);
176 static void write_prefix (const tree
);
177 static void write_template_prefix (const tree
);
178 static void write_unqualified_name (const tree
);
179 static void write_conversion_operator_name (const tree
);
180 static void write_source_name (tree
);
181 static void write_unnamed_type_name (const tree
);
182 static void write_closure_type_name (const tree
);
183 static int hwint_to_ascii (unsigned HOST_WIDE_INT
, const unsigned int, char *,
185 static void write_number (unsigned HOST_WIDE_INT
, const int,
187 static void write_compact_number (int num
);
188 static void write_integer_cst (const tree
);
189 static void write_real_cst (const tree
);
190 static void write_identifier (const char *);
191 static void write_special_name_constructor (const tree
);
192 static void write_special_name_destructor (const tree
);
193 static void write_type (tree
);
194 static int write_CV_qualifiers_for_type (const tree
);
195 static void write_builtin_type (tree
);
196 static void write_function_type (const tree
);
197 static void write_bare_function_type (const tree
, const int, const tree
);
198 static void write_method_parms (tree
, const int, const tree
);
199 static void write_class_enum_type (const tree
);
200 static void write_template_args (tree
);
201 static void write_expression (tree
);
202 static void write_template_arg_literal (const tree
);
203 static void write_template_arg (tree
);
204 static void write_template_template_arg (const tree
);
205 static void write_array_type (const tree
);
206 static void write_pointer_to_member_type (const tree
);
207 static void write_template_param (const tree
);
208 static void write_template_template_param (const tree
);
209 static void write_substitution (const int);
210 static int discriminator_for_local_entity (tree
);
211 static int discriminator_for_string_literal (tree
, tree
);
212 static void write_discriminator (const int);
213 static void write_local_name (tree
, const tree
, const tree
);
214 static void dump_substitution_candidates (void);
215 static tree
mangle_decl_string (const tree
);
216 static int local_class_index (tree
);
218 /* Control functions. */
220 static inline void start_mangling (const tree
);
221 static inline const char *finish_mangling (const bool);
222 static tree
mangle_special_for_type (const tree
, const char *);
224 /* Foreign language functions. */
226 static void write_java_integer_type_codes (const tree
);
228 /* Append a single character to the end of the mangled
230 #define write_char(CHAR) \
231 obstack_1grow (mangle_obstack, (CHAR))
233 /* Append a sized buffer to the end of the mangled representation. */
234 #define write_chars(CHAR, LEN) \
235 obstack_grow (mangle_obstack, (CHAR), (LEN))
237 /* Append a NUL-terminated string to the end of the mangled
239 #define write_string(STRING) \
240 obstack_grow (mangle_obstack, (STRING), strlen (STRING))
242 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
243 same purpose (context, which may be a type) and value (template
244 decl). See write_template_prefix for more information on what this
246 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \
247 (TREE_CODE (NODE1) == TREE_LIST \
248 && TREE_CODE (NODE2) == TREE_LIST \
249 && ((TYPE_P (TREE_PURPOSE (NODE1)) \
250 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))) \
251 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \
252 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
254 /* Write out an unsigned quantity in base 10. */
255 #define write_unsigned_number(NUMBER) \
256 write_number ((NUMBER), /*unsigned_p=*/1, 10)
258 /* If DECL is a template instance, return nonzero and, if
259 TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
260 Otherwise return zero. */
263 decl_is_template_id (const tree decl
, tree
* const template_info
)
265 if (TREE_CODE (decl
) == TYPE_DECL
)
267 /* TYPE_DECLs are handled specially. Look at its type to decide
268 if this is a template instantiation. */
269 const tree type
= TREE_TYPE (decl
);
271 if (CLASS_TYPE_P (type
) && CLASSTYPE_TEMPLATE_ID_P (type
))
273 if (template_info
!= NULL
)
274 /* For a templated TYPE_DECL, the template info is hanging
276 *template_info
= TYPE_TEMPLATE_INFO (type
);
282 /* Check if this is a primary template. */
283 if (DECL_LANG_SPECIFIC (decl
) != NULL
284 && DECL_USE_TEMPLATE (decl
)
285 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl
))
286 && TREE_CODE (decl
) != TEMPLATE_DECL
)
288 if (template_info
!= NULL
)
289 /* For most templated decls, the template info is hanging
291 *template_info
= DECL_TEMPLATE_INFO (decl
);
296 /* It's not a template id. */
300 /* Produce debugging output of current substitution candidates. */
303 dump_substitution_candidates (void)
308 fprintf (stderr
, " ++ substitutions ");
309 FOR_EACH_VEC_ELT (tree
, G
.substitutions
, i
, el
)
311 const char *name
= "???";
314 fprintf (stderr
, " ");
316 name
= IDENTIFIER_POINTER (DECL_NAME (el
));
317 else if (TREE_CODE (el
) == TREE_LIST
)
318 name
= IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el
)));
319 else if (TYPE_NAME (el
))
320 name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el
)));
321 fprintf (stderr
, " S%d_ = ", i
- 1);
323 (CP_TYPE_RESTRICT_P (el
)
324 || CP_TYPE_VOLATILE_P (el
)
325 || CP_TYPE_CONST_P (el
)))
326 fprintf (stderr
, "CV-");
327 fprintf (stderr
, "%s (%s at %p)\n",
328 name
, tree_code_name
[TREE_CODE (el
)], (void *) el
);
332 /* Both decls and types can be substitution candidates, but sometimes
333 they refer to the same thing. For instance, a TYPE_DECL and
334 RECORD_TYPE for the same class refer to the same thing, and should
335 be treated accordingly in substitutions. This function returns a
336 canonicalized tree node representing NODE that is used when adding
337 and substitution candidates and finding matches. */
340 canonicalize_for_substitution (tree node
)
342 /* For a TYPE_DECL, use the type instead. */
343 if (TREE_CODE (node
) == TYPE_DECL
)
344 node
= TREE_TYPE (node
);
346 && TYPE_CANONICAL (node
) != node
347 && TYPE_MAIN_VARIANT (node
) != node
)
349 /* Here we want to strip the topmost typedef only.
350 We need to do that so is_std_substitution can do proper
352 if (TREE_CODE (node
) == FUNCTION_TYPE
)
353 /* Use build_qualified_type and TYPE_QUALS here to preserve
354 the old buggy mangling of attribute noreturn with abi<5. */
355 node
= build_qualified_type (TYPE_MAIN_VARIANT (node
),
358 node
= cp_build_qualified_type (TYPE_MAIN_VARIANT (node
),
359 cp_type_quals (node
));
364 /* Add NODE as a substitution candidate. NODE must not already be on
365 the list of candidates. */
368 add_substitution (tree node
)
373 fprintf (stderr
, " ++ add_substitution (%s at %10p)\n",
374 tree_code_name
[TREE_CODE (node
)], (void *) node
);
376 /* Get the canonicalized substitution candidate for NODE. */
377 c
= canonicalize_for_substitution (node
);
378 if (DEBUG_MANGLE
&& c
!= node
)
379 fprintf (stderr
, " ++ using candidate (%s at %10p)\n",
380 tree_code_name
[TREE_CODE (node
)], (void *) node
);
384 /* Make sure NODE isn't already a candidate. */
389 FOR_EACH_VEC_ELT (tree
, G
.substitutions
, i
, candidate
)
391 gcc_assert (!(DECL_P (node
) && node
== candidate
));
392 gcc_assert (!(TYPE_P (node
) && TYPE_P (candidate
)
393 && same_type_p (node
, candidate
)));
396 #endif /* ENABLE_CHECKING */
398 /* Put the decl onto the varray of substitution candidates. */
399 VEC_safe_push (tree
, gc
, G
.substitutions
, node
);
402 dump_substitution_candidates ();
405 /* Helper function for find_substitution. Returns nonzero if NODE,
406 which may be a decl or a CLASS_TYPE, is a template-id with template
407 name of substitution_index[INDEX] in the ::std namespace. */
410 is_std_substitution (const tree node
,
411 const substitution_identifier_index_t index
)
418 type
= TREE_TYPE (node
);
421 else if (CLASS_TYPE_P (node
))
424 decl
= TYPE_NAME (node
);
427 /* These are not the droids you're looking for. */
430 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl
))
431 && TYPE_LANG_SPECIFIC (type
)
432 && TYPE_TEMPLATE_INFO (type
)
433 && (DECL_NAME (TYPE_TI_TEMPLATE (type
))
434 == subst_identifiers
[index
]));
437 /* Helper function for find_substitution. Returns nonzero if NODE,
438 which may be a decl or a CLASS_TYPE, is the template-id
439 ::std::identifier<char>, where identifier is
440 substitution_index[INDEX]. */
443 is_std_substitution_char (const tree node
,
444 const substitution_identifier_index_t index
)
447 /* Check NODE's name is ::std::identifier. */
448 if (!is_std_substitution (node
, index
))
450 /* Figure out its template args. */
452 args
= DECL_TI_ARGS (node
);
453 else if (CLASS_TYPE_P (node
))
454 args
= CLASSTYPE_TI_ARGS (node
);
456 /* Oops, not a template. */
458 /* NODE's template arg list should be <char>. */
460 TREE_VEC_LENGTH (args
) == 1
461 && TREE_VEC_ELT (args
, 0) == char_type_node
;
464 /* Check whether a substitution should be used to represent NODE in
467 First, check standard special-case substitutions.
469 <substitution> ::= St
476 # ::std::basic_string
479 # ::std::basic_string<char,
480 ::std::char_traits<char>,
481 ::std::allocator<char> >
484 # ::std::basic_istream<char, ::std::char_traits<char> >
487 # ::std::basic_ostream<char, ::std::char_traits<char> >
490 # ::std::basic_iostream<char, ::std::char_traits<char> >
492 Then examine the stack of currently available substitution
493 candidates for entities appearing earlier in the same mangling
495 If a substitution is found, write its mangled representation and
496 return nonzero. If none is found, just return zero. */
499 find_substitution (tree node
)
502 const int size
= VEC_length (tree
, G
.substitutions
);
507 fprintf (stderr
, " ++ find_substitution (%s at %p)\n",
508 tree_code_name
[TREE_CODE (node
)], (void *) node
);
510 /* Obtain the canonicalized substitution representation for NODE.
511 This is what we'll compare against. */
512 node
= canonicalize_for_substitution (node
);
514 /* Check for builtin substitutions. */
516 decl
= TYPE_P (node
) ? TYPE_NAME (node
) : node
;
517 type
= TYPE_P (node
) ? node
: TREE_TYPE (node
);
519 /* Check for std::allocator. */
521 && is_std_substitution (decl
, SUBID_ALLOCATOR
)
522 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl
)))
528 /* Check for std::basic_string. */
529 if (decl
&& is_std_substitution (decl
, SUBID_BASIC_STRING
))
533 /* If this is a type (i.e. a fully-qualified template-id),
535 std::basic_string <char,
536 std::char_traits<char>,
537 std::allocator<char> > . */
538 if (cp_type_quals (type
) == TYPE_UNQUALIFIED
539 && CLASSTYPE_USE_TEMPLATE (type
))
541 tree args
= CLASSTYPE_TI_ARGS (type
);
542 if (TREE_VEC_LENGTH (args
) == 3
543 && same_type_p (TREE_VEC_ELT (args
, 0), char_type_node
)
544 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
546 && is_std_substitution_char (TREE_VEC_ELT (args
, 2),
555 /* Substitute for the template name only if this isn't a type. */
562 /* Check for basic_{i,o,io}stream. */
564 && cp_type_quals (type
) == TYPE_UNQUALIFIED
565 && CLASS_TYPE_P (type
)
566 && CLASSTYPE_USE_TEMPLATE (type
)
567 && CLASSTYPE_TEMPLATE_INFO (type
) != NULL
)
569 /* First, check for the template
570 args <char, std::char_traits<char> > . */
571 tree args
= CLASSTYPE_TI_ARGS (type
);
572 if (TREE_VEC_LENGTH (args
) == 2
573 && TYPE_P (TREE_VEC_ELT (args
, 0))
574 && same_type_p (TREE_VEC_ELT (args
, 0), char_type_node
)
575 && is_std_substitution_char (TREE_VEC_ELT (args
, 1),
578 /* Got them. Is this basic_istream? */
579 if (is_std_substitution (decl
, SUBID_BASIC_ISTREAM
))
584 /* Or basic_ostream? */
585 else if (is_std_substitution (decl
, SUBID_BASIC_OSTREAM
))
590 /* Or basic_iostream? */
591 else if (is_std_substitution (decl
, SUBID_BASIC_IOSTREAM
))
599 /* Check for namespace std. */
600 if (decl
&& DECL_NAMESPACE_STD_P (decl
))
606 /* Now check the list of available substitutions for this mangling
608 for (i
= 0; i
< size
; ++i
)
610 tree candidate
= VEC_index (tree
, G
.substitutions
, i
);
611 /* NODE is a matched to a candidate if it's the same decl node or
612 if it's the same type. */
613 if (decl
== candidate
614 || (TYPE_P (candidate
) && type
&& TYPE_P (type
)
615 && same_type_p (type
, candidate
))
616 || NESTED_TEMPLATE_MATCH (node
, candidate
))
618 write_substitution (i
);
623 /* No substitution found. */
628 /* TOP_LEVEL is true, if this is being called at outermost level of
629 mangling. It should be false when mangling a decl appearing in an
630 expression within some other mangling.
632 <mangled-name> ::= _Z <encoding> */
635 write_mangled_name (const tree decl
, bool top_level
)
637 MANGLE_TRACE_TREE ("mangled-name", decl
);
639 if (/* The names of `extern "C"' functions are not mangled. */
640 DECL_EXTERN_C_FUNCTION_P (decl
)
641 /* But overloaded operator names *are* mangled. */
642 && !DECL_OVERLOADED_OPERATOR_P (decl
))
647 write_string (IDENTIFIER_POINTER (DECL_NAME (decl
)));
650 /* The standard notes: "The <encoding> of an extern "C"
651 function is treated like global-scope data, i.e. as its
652 <source-name> without a type." We cannot write
653 overloaded operators that way though, because it contains
654 characters invalid in assembler. */
655 if (abi_version_at_least (2))
658 G
.need_abi_warning
= true;
659 write_source_name (DECL_NAME (decl
));
662 else if (TREE_CODE (decl
) == VAR_DECL
663 /* The names of non-static global variables aren't mangled. */
664 && DECL_EXTERNAL_LINKAGE_P (decl
)
665 && (CP_DECL_CONTEXT (decl
) == global_namespace
666 /* And neither are `extern "C"' variables. */
667 || DECL_EXTERN_C_P (decl
)))
669 if (top_level
|| abi_version_at_least (2))
673 G
.need_abi_warning
= true;
681 write_encoding (decl
);
682 if (DECL_LANG_SPECIFIC (decl
)
683 && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
)
684 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
)))
685 /* We need a distinct mangled name for these entities, but
686 we should never actually output it. So, we append some
687 characters the assembler won't like. */
688 write_string (" *INTERNAL* ");
692 /* <encoding> ::= <function name> <bare-function-type>
696 write_encoding (const tree decl
)
698 MANGLE_TRACE_TREE ("encoding", decl
);
700 if (DECL_LANG_SPECIFIC (decl
) && DECL_EXTERN_C_FUNCTION_P (decl
))
702 /* For overloaded operators write just the mangled name
703 without arguments. */
704 if (DECL_OVERLOADED_OPERATOR_P (decl
))
705 write_name (decl
, /*ignore_local_scope=*/0);
707 write_source_name (DECL_NAME (decl
));
711 write_name (decl
, /*ignore_local_scope=*/0);
712 if (TREE_CODE (decl
) == FUNCTION_DECL
)
717 if (decl_is_template_id (decl
, NULL
))
719 fn_type
= get_mostly_instantiated_function_type (decl
);
720 /* FN_TYPE will not have parameter types for in-charge or
721 VTT parameters. Therefore, we pass NULL_TREE to
722 write_bare_function_type -- otherwise, it will get
723 confused about which artificial parameters to skip. */
728 fn_type
= TREE_TYPE (decl
);
732 write_bare_function_type (fn_type
,
733 (!DECL_CONSTRUCTOR_P (decl
)
734 && !DECL_DESTRUCTOR_P (decl
)
735 && !DECL_CONV_FN_P (decl
)
736 && decl_is_template_id (decl
, NULL
)),
741 /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
742 or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */
745 decl_mangling_context (tree decl
)
747 if (TREE_CODE (decl
) == TYPE_DECL
748 && LAMBDA_TYPE_P (TREE_TYPE (decl
)))
750 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl
));
754 else if (TREE_CODE (decl
) == TYPE_DECL
755 && TREE_CODE (TREE_TYPE (decl
)) == TEMPLATE_TYPE_PARM
)
756 /* template type parms have no mangling context. */
758 return CP_DECL_CONTEXT (decl
);
761 /* <name> ::= <unscoped-name>
762 ::= <unscoped-template-name> <template-args>
766 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
767 called from <local-name>, which mangles the enclosing scope
768 elsewhere and then uses this function to mangle just the part
769 underneath the function scope. So don't use the <local-name>
770 production, to avoid an infinite recursion. */
773 write_name (tree decl
, const int ignore_local_scope
)
777 MANGLE_TRACE_TREE ("name", decl
);
779 if (TREE_CODE (decl
) == TYPE_DECL
)
781 /* In case this is a typedef, fish out the corresponding
782 TYPE_DECL for the main variant. */
783 decl
= TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
)));
786 context
= decl_mangling_context (decl
);
788 /* A decl in :: or ::std scope is treated specially. The former is
789 mangled using <unscoped-name> or <unscoped-template-name>, the
790 latter with a special substitution. Also, a name that is
791 directly in a local function scope is also mangled with
792 <unscoped-name> rather than a full <nested-name>. */
794 || context
== global_namespace
795 || DECL_NAMESPACE_STD_P (context
)
796 || (ignore_local_scope
&& TREE_CODE (context
) == FUNCTION_DECL
))
799 /* Is this a template instance? */
800 if (decl_is_template_id (decl
, &template_info
))
802 /* Yes: use <unscoped-template-name>. */
803 write_unscoped_template_name (TI_TEMPLATE (template_info
));
804 write_template_args (TI_ARGS (template_info
));
807 /* Everything else gets an <unqualified-name>. */
808 write_unscoped_name (decl
);
812 /* Handle local names, unless we asked not to (that is, invoked
813 under <local-name>, to handle only the part of the name under
815 if (!ignore_local_scope
)
817 /* Scan up the list of scope context, looking for a
818 function. If we find one, this entity is in local
819 function scope. local_entity tracks context one scope
820 level down, so it will contain the element that's
821 directly in that function's scope, either decl or one of
822 its enclosing scopes. */
823 tree local_entity
= decl
;
824 while (context
!= NULL
&& context
!= global_namespace
)
826 /* Make sure we're always dealing with decls. */
827 if (context
!= NULL
&& TYPE_P (context
))
828 context
= TYPE_NAME (context
);
829 /* Is this a function? */
830 if (TREE_CODE (context
) == FUNCTION_DECL
831 || TREE_CODE (context
) == PARM_DECL
)
833 /* Yes, we have local scope. Use the <local-name>
834 production for the innermost function scope. */
835 write_local_name (context
, local_entity
, decl
);
838 /* Up one scope level. */
839 local_entity
= context
;
840 context
= decl_mangling_context (context
);
843 /* No local scope found? Fall through to <nested-name>. */
846 /* Other decls get a <nested-name> to encode their scope. */
847 write_nested_name (decl
);
851 /* <unscoped-name> ::= <unqualified-name>
852 ::= St <unqualified-name> # ::std:: */
855 write_unscoped_name (const tree decl
)
857 tree context
= CP_DECL_CONTEXT (decl
);
859 MANGLE_TRACE_TREE ("unscoped-name", decl
);
861 /* Is DECL in ::std? */
862 if (DECL_NAMESPACE_STD_P (context
))
865 write_unqualified_name (decl
);
869 /* If not, it should be either in the global namespace, or directly
870 in a local function scope. */
871 gcc_assert (context
== global_namespace
873 || TREE_CODE (context
) == FUNCTION_DECL
);
875 write_unqualified_name (decl
);
879 /* <unscoped-template-name> ::= <unscoped-name>
880 ::= <substitution> */
883 write_unscoped_template_name (const tree decl
)
885 MANGLE_TRACE_TREE ("unscoped-template-name", decl
);
887 if (find_substitution (decl
))
889 write_unscoped_name (decl
);
890 add_substitution (decl
);
893 /* Write the nested name, including CV-qualifiers, of DECL.
895 <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
896 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
898 <CV-qualifiers> ::= [r] [V] [K] */
901 write_nested_name (const tree decl
)
905 MANGLE_TRACE_TREE ("nested-name", decl
);
909 /* Write CV-qualifiers, if this is a member function. */
910 if (TREE_CODE (decl
) == FUNCTION_DECL
911 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
913 if (DECL_VOLATILE_MEMFUNC_P (decl
))
915 if (DECL_CONST_MEMFUNC_P (decl
))
919 /* Is this a template instance? */
920 if (decl_is_template_id (decl
, &template_info
))
922 /* Yes, use <template-prefix>. */
923 write_template_prefix (decl
);
924 write_template_args (TI_ARGS (template_info
));
926 else if (TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
928 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
929 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
931 write_template_prefix (decl
);
932 write_template_args (TREE_OPERAND (name
, 1));
936 write_prefix (CP_DECL_CONTEXT (decl
));
937 write_unqualified_name (decl
);
942 /* No, just use <prefix> */
943 write_prefix (DECL_CONTEXT (decl
));
944 write_unqualified_name (decl
);
949 /* <prefix> ::= <prefix> <unqualified-name>
951 ::= <template-prefix> <template-args>
953 ::= <substitution> */
956 write_prefix (const tree node
)
959 /* Non-NULL if NODE represents a template-id. */
960 tree template_info
= NULL
;
963 || node
== global_namespace
)
966 MANGLE_TRACE_TREE ("prefix", node
);
968 if (find_substitution (node
))
973 /* If this is a function or parm decl, that means we've hit function
974 scope, so this prefix must be for a local name. In this
975 case, we're under the <local-name> production, which encodes
976 the enclosing function scope elsewhere. So don't continue
978 if (TREE_CODE (node
) == FUNCTION_DECL
979 || TREE_CODE (node
) == PARM_DECL
)
983 decl_is_template_id (decl
, &template_info
);
987 /* Node is a type. */
988 decl
= TYPE_NAME (node
);
989 if (CLASSTYPE_TEMPLATE_ID_P (node
))
990 template_info
= TYPE_TEMPLATE_INFO (node
);
993 /* In G++ 3.2, the name of the template parameter was used. */
994 if (TREE_CODE (node
) == TEMPLATE_TYPE_PARM
995 && !abi_version_at_least (2))
996 G
.need_abi_warning
= true;
998 if (TREE_CODE (node
) == TEMPLATE_TYPE_PARM
999 && abi_version_at_least (2))
1000 write_template_param (node
);
1001 else if (template_info
!= NULL
)
1004 write_template_prefix (decl
);
1005 write_template_args (TI_ARGS (template_info
));
1007 else if (TREE_CODE (TREE_TYPE (decl
)) == TYPENAME_TYPE
)
1009 tree name
= TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl
));
1010 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1012 write_template_prefix (decl
);
1013 write_template_args (TREE_OPERAND (name
, 1));
1017 write_prefix (CP_DECL_CONTEXT (decl
));
1018 write_unqualified_name (decl
);
1022 /* Not templated. */
1024 write_prefix (decl_mangling_context (decl
));
1025 write_unqualified_name (decl
);
1026 if (TREE_CODE (decl
) == VAR_DECL
1027 || TREE_CODE (decl
) == FIELD_DECL
)
1029 /* <data-member-prefix> := <member source-name> M */
1035 add_substitution (node
);
1038 /* <template-prefix> ::= <prefix> <template component>
1039 ::= <template-param>
1040 ::= <substitution> */
1043 write_template_prefix (const tree node
)
1045 tree decl
= DECL_P (node
) ? node
: TYPE_NAME (node
);
1046 tree type
= DECL_P (node
) ? TREE_TYPE (node
) : node
;
1047 tree context
= CP_DECL_CONTEXT (decl
);
1052 MANGLE_TRACE_TREE ("template-prefix", node
);
1054 /* Find the template decl. */
1055 if (decl_is_template_id (decl
, &template_info
))
1056 templ
= TI_TEMPLATE (template_info
);
1057 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
1058 /* For a typename type, all we have is the name. */
1059 templ
= DECL_NAME (decl
);
1062 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type
));
1064 templ
= TYPE_TI_TEMPLATE (type
);
1067 /* For a member template, though, the template name for the
1068 innermost name must have all the outer template levels
1069 instantiated. For instance, consider
1071 template<typename T> struct Outer {
1072 template<typename U> struct Inner {};
1075 The template name for `Inner' in `Outer<int>::Inner<float>' is
1076 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1077 levels separately, so there's no TEMPLATE_DECL available for this
1078 (there's only `Outer<T>::Inner<U>').
1080 In order to get the substitutions right, we create a special
1081 TREE_LIST to represent the substitution candidate for a nested
1082 template. The TREE_PURPOSE is the template's context, fully
1083 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1086 So, for the example above, `Outer<int>::Inner' is represented as a
1087 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1088 and whose value is `Outer<T>::Inner<U>'. */
1089 if (TYPE_P (context
))
1090 substitution
= build_tree_list (context
, templ
);
1092 substitution
= templ
;
1094 if (find_substitution (substitution
))
1097 /* In G++ 3.2, the name of the template template parameter was used. */
1098 if (TREE_TYPE (templ
)
1099 && TREE_CODE (TREE_TYPE (templ
)) == TEMPLATE_TEMPLATE_PARM
1100 && !abi_version_at_least (2))
1101 G
.need_abi_warning
= true;
1103 if (TREE_TYPE (templ
)
1104 && TREE_CODE (TREE_TYPE (templ
)) == TEMPLATE_TEMPLATE_PARM
1105 && abi_version_at_least (2))
1106 write_template_param (TREE_TYPE (templ
));
1109 write_prefix (context
);
1110 write_unqualified_name (decl
);
1113 add_substitution (substitution
);
1116 /* We don't need to handle thunks, vtables, or VTTs here. Those are
1117 mangled through special entry points.
1119 <unqualified-name> ::= <operator-name>
1122 ::= <unnamed-type-name>
1123 ::= <local-source-name>
1125 <local-source-name> ::= L <source-name> <discriminator> */
1128 write_unqualified_id (tree identifier
)
1130 if (IDENTIFIER_TYPENAME_P (identifier
))
1131 write_conversion_operator_name (TREE_TYPE (identifier
));
1132 else if (IDENTIFIER_OPNAME_P (identifier
))
1135 const char *mangled_name
= NULL
;
1137 /* Unfortunately, there is no easy way to go from the
1138 name of the operator back to the corresponding tree
1140 for (i
= 0; i
< MAX_TREE_CODES
; ++i
)
1141 if (operator_name_info
[i
].identifier
== identifier
)
1143 /* The ABI says that we prefer binary operator
1144 names to unary operator names. */
1145 if (operator_name_info
[i
].arity
== 2)
1147 mangled_name
= operator_name_info
[i
].mangled_name
;
1150 else if (!mangled_name
)
1151 mangled_name
= operator_name_info
[i
].mangled_name
;
1153 else if (assignment_operator_name_info
[i
].identifier
1157 = assignment_operator_name_info
[i
].mangled_name
;
1160 write_string (mangled_name
);
1163 write_source_name (identifier
);
1167 write_unqualified_name (const tree decl
)
1169 MANGLE_TRACE_TREE ("unqualified-name", decl
);
1171 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
1173 write_unqualified_id (decl
);
1177 if (DECL_NAME (decl
) == NULL_TREE
)
1179 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl
));
1180 write_source_name (DECL_ASSEMBLER_NAME (decl
));
1183 else if (DECL_DECLARES_FUNCTION_P (decl
))
1186 if (DECL_CONSTRUCTOR_P (decl
))
1187 write_special_name_constructor (decl
);
1188 else if (DECL_DESTRUCTOR_P (decl
))
1189 write_special_name_destructor (decl
);
1190 else if (DECL_CONV_FN_P (decl
))
1192 /* Conversion operator. Handle it right here.
1193 <operator> ::= cv <type> */
1195 if (decl_is_template_id (decl
, NULL
))
1198 fn_type
= get_mostly_instantiated_function_type (decl
);
1199 type
= TREE_TYPE (fn_type
);
1202 type
= DECL_CONV_FN_TYPE (decl
);
1203 write_conversion_operator_name (type
);
1205 else if (DECL_OVERLOADED_OPERATOR_P (decl
))
1207 operator_name_info_t
*oni
;
1208 if (DECL_ASSIGNMENT_OPERATOR_P (decl
))
1209 oni
= assignment_operator_name_info
;
1211 oni
= operator_name_info
;
1213 write_string (oni
[DECL_OVERLOADED_OPERATOR_P (decl
)].mangled_name
);
1222 if (VAR_OR_FUNCTION_DECL_P (decl
) && ! TREE_PUBLIC (decl
)
1223 && DECL_NAMESPACE_SCOPE_P (decl
)
1224 && decl_linkage (decl
) == lk_internal
)
1226 MANGLE_TRACE_TREE ("local-source-name", decl
);
1228 write_source_name (DECL_NAME (decl
));
1229 /* The default discriminator is 1, and that's all we ever use,
1230 so there's no code to output one here. */
1234 tree type
= TREE_TYPE (decl
);
1236 if (TREE_CODE (decl
) == TYPE_DECL
1237 && TYPE_ANONYMOUS_P (type
))
1238 write_unnamed_type_name (type
);
1239 else if (TREE_CODE (decl
) == TYPE_DECL
1240 && LAMBDA_TYPE_P (type
))
1241 write_closure_type_name (type
);
1243 write_source_name (DECL_NAME (decl
));
1247 /* Write the unqualified-name for a conversion operator to TYPE. */
1250 write_conversion_operator_name (const tree type
)
1252 write_string ("cv");
1256 /* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1258 <source-name> ::= </length/ number> <identifier> */
1261 write_source_name (tree identifier
)
1263 MANGLE_TRACE_TREE ("source-name", identifier
);
1265 /* Never write the whole template-id name including the template
1266 arguments; we only want the template name. */
1267 if (IDENTIFIER_TEMPLATE (identifier
))
1268 identifier
= IDENTIFIER_TEMPLATE (identifier
);
1270 write_unsigned_number (IDENTIFIER_LENGTH (identifier
));
1271 write_identifier (IDENTIFIER_POINTER (identifier
));
1274 /* Encode 0 as _, and 1+ as n-1_. */
1277 write_compact_number (int num
)
1280 write_unsigned_number (num
- 1);
1284 /* Return how many unnamed types precede TYPE in its enclosing class. */
1287 nested_anon_class_index (tree type
)
1290 tree member
= TYPE_FIELDS (TYPE_CONTEXT (type
));
1291 for (; member
; member
= DECL_CHAIN (member
))
1292 if (DECL_IMPLICIT_TYPEDEF_P (member
))
1294 tree memtype
= TREE_TYPE (member
);
1295 if (memtype
== type
)
1297 else if (TYPE_ANONYMOUS_P (memtype
))
1304 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1307 write_unnamed_type_name (const tree type
__attribute__ ((__unused__
)))
1310 MANGLE_TRACE_TREE ("unnamed-type-name", type
);
1312 if (TYPE_FUNCTION_SCOPE_P (type
))
1313 discriminator
= local_class_index (type
);
1314 else if (TYPE_CLASS_SCOPE_P (type
))
1315 discriminator
= nested_anon_class_index (type
);
1318 gcc_assert (no_linkage_check (type
, /*relaxed_p=*/true));
1319 /* Just use the old mangling at namespace scope. */
1320 write_source_name (TYPE_IDENTIFIER (type
));
1324 write_string ("Ut");
1325 write_compact_number (discriminator
);
1328 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1329 <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters */
1332 write_closure_type_name (const tree type
)
1334 tree fn
= lambda_function (type
);
1335 tree lambda
= CLASSTYPE_LAMBDA_EXPR (type
);
1336 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
1338 MANGLE_TRACE_TREE ("closure-type-name", type
);
1340 write_string ("Ul");
1341 write_method_parms (parms
, /*method_p=*/1, fn
);
1343 write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda
));
1346 /* Convert NUMBER to ascii using base BASE and generating at least
1347 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1348 into which to store the characters. Returns the number of
1349 characters generated (these will be layed out in advance of where
1353 hwint_to_ascii (unsigned HOST_WIDE_INT number
, const unsigned int base
,
1354 char *buffer
, const unsigned int min_digits
)
1356 static const char base_digits
[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1357 unsigned digits
= 0;
1361 unsigned HOST_WIDE_INT d
= number
/ base
;
1363 *--buffer
= base_digits
[number
- d
* base
];
1367 while (digits
< min_digits
)
1369 *--buffer
= base_digits
[0];
1375 /* Non-terminal <number>.
1377 <number> ::= [n] </decimal integer/> */
1380 write_number (unsigned HOST_WIDE_INT number
, const int unsigned_p
,
1381 const unsigned int base
)
1383 char buffer
[sizeof (HOST_WIDE_INT
) * 8];
1386 if (!unsigned_p
&& (HOST_WIDE_INT
) number
< 0)
1389 number
= -((HOST_WIDE_INT
) number
);
1391 count
= hwint_to_ascii (number
, base
, buffer
+ sizeof (buffer
), 1);
1392 write_chars (buffer
+ sizeof (buffer
) - count
, count
);
1395 /* Write out an integral CST in decimal. Most numbers are small, and
1396 representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1397 bigger than that, which we must deal with. */
1400 write_integer_cst (const tree cst
)
1402 int sign
= tree_int_cst_sgn (cst
);
1404 if (TREE_INT_CST_HIGH (cst
) + (sign
< 0))
1406 /* A bignum. We do this in chunks, each of which fits in a
1408 char buffer
[sizeof (HOST_WIDE_INT
) * 8 * 2];
1409 unsigned HOST_WIDE_INT chunk
;
1410 unsigned chunk_digits
;
1411 char *ptr
= buffer
+ sizeof (buffer
);
1416 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1421 if (sizeof (HOST_WIDE_INT
) >= 8)
1423 /* It is at least 64 bits, so 10^18 is representable. */
1428 type
= c_common_signed_or_unsigned_type (1, TREE_TYPE (cst
));
1429 base
= build_int_cstu (type
, chunk
);
1430 n
= build_int_cst_wide (type
,
1431 TREE_INT_CST_LOW (cst
), TREE_INT_CST_HIGH (cst
));
1436 n
= fold_build1_loc (input_location
, NEGATE_EXPR
, type
, n
);
1440 tree d
= fold_build2_loc (input_location
, FLOOR_DIV_EXPR
, type
, n
, base
);
1441 tree tmp
= fold_build2_loc (input_location
, MULT_EXPR
, type
, d
, base
);
1444 done
= integer_zerop (d
);
1445 tmp
= fold_build2_loc (input_location
, MINUS_EXPR
, type
, n
, tmp
);
1446 c
= hwint_to_ascii (TREE_INT_CST_LOW (tmp
), 10, ptr
,
1447 done
? 1 : chunk_digits
);
1453 write_chars (ptr
, count
);
1458 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (cst
);
1465 write_unsigned_number (low
);
1469 /* Write out a floating-point literal.
1471 "Floating-point literals are encoded using the bit pattern of the
1472 target processor's internal representation of that number, as a
1473 fixed-length lowercase hexadecimal string, high-order bytes first
1474 (even if the target processor would store low-order bytes first).
1475 The "n" prefix is not used for floating-point literals; the sign
1476 bit is encoded with the rest of the number.
1478 Here are some examples, assuming the IEEE standard representation
1479 for floating point numbers. (Spaces are for readability, not
1480 part of the encoding.)
1483 -1.0f Lf bf80 0000 E
1484 1.17549435e-38f Lf 0080 0000 E
1485 1.40129846e-45f Lf 0000 0001 E
1486 0.0f Lf 0000 0000 E"
1488 Caller is responsible for the Lx and the E. */
1490 write_real_cst (const tree value
)
1492 if (abi_version_at_least (2))
1494 long target_real
[4]; /* largest supported float */
1495 char buffer
[9]; /* eight hex digits in a 32-bit number */
1498 tree type
= TREE_TYPE (value
);
1499 int words
= GET_MODE_BITSIZE (TYPE_MODE (type
)) / 32;
1501 real_to_target (target_real
, &TREE_REAL_CST (value
),
1504 /* The value in target_real is in the target word order,
1505 so we must write it out backward if that happens to be
1506 little-endian. write_number cannot be used, it will
1507 produce uppercase. */
1508 if (FLOAT_WORDS_BIG_ENDIAN
)
1509 i
= 0, limit
= words
, dir
= 1;
1511 i
= words
- 1, limit
= -1, dir
= -1;
1513 for (; i
!= limit
; i
+= dir
)
1515 sprintf (buffer
, "%08lx", (unsigned long) target_real
[i
]);
1516 write_chars (buffer
, 8);
1521 /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out
1522 literally. Note that compatibility with 3.2 is impossible,
1523 because the old floating-point emulator used a different
1524 format for REAL_VALUE_TYPE. */
1526 for (i
= 0; i
< sizeof (TREE_REAL_CST (value
)); ++i
)
1527 write_number (((unsigned char *) &TREE_REAL_CST (value
))[i
],
1530 G
.need_abi_warning
= 1;
1534 /* Non-terminal <identifier>.
1536 <identifier> ::= </unqualified source code identifier> */
1539 write_identifier (const char *identifier
)
1541 MANGLE_TRACE ("identifier", identifier
);
1542 write_string (identifier
);
1545 /* Handle constructor productions of non-terminal <special-name>.
1546 CTOR is a constructor FUNCTION_DECL.
1548 <special-name> ::= C1 # complete object constructor
1549 ::= C2 # base object constructor
1550 ::= C3 # complete object allocating constructor
1552 Currently, allocating constructors are never used.
1554 We also need to provide mangled names for the maybe-in-charge
1555 constructor, so we treat it here too. mangle_decl_string will
1556 append *INTERNAL* to that, to make sure we never emit it. */
1559 write_special_name_constructor (const tree ctor
)
1561 if (DECL_BASE_CONSTRUCTOR_P (ctor
))
1562 write_string ("C2");
1565 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor
)
1566 /* Even though we don't ever emit a definition of
1567 the old-style destructor, we still have to
1568 consider entities (like static variables) nested
1570 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor
));
1571 write_string ("C1");
1575 /* Handle destructor productions of non-terminal <special-name>.
1576 DTOR is a destructor FUNCTION_DECL.
1578 <special-name> ::= D0 # deleting (in-charge) destructor
1579 ::= D1 # complete object (in-charge) destructor
1580 ::= D2 # base object (not-in-charge) destructor
1582 We also need to provide mangled names for the maybe-incharge
1583 destructor, so we treat it here too. mangle_decl_string will
1584 append *INTERNAL* to that, to make sure we never emit it. */
1587 write_special_name_destructor (const tree dtor
)
1589 if (DECL_DELETING_DESTRUCTOR_P (dtor
))
1590 write_string ("D0");
1591 else if (DECL_BASE_DESTRUCTOR_P (dtor
))
1592 write_string ("D2");
1595 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor
)
1596 /* Even though we don't ever emit a definition of
1597 the old-style destructor, we still have to
1598 consider entities (like static variables) nested
1600 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor
));
1601 write_string ("D1");
1605 /* Scan the vector of local classes and return how many others with the
1606 same name (or same no name) and context precede ENTITY. */
1609 local_class_index (tree entity
)
1611 int ix
, discriminator
= 0;
1612 tree name
= (TYPE_ANONYMOUS_P (entity
) ? NULL_TREE
1613 : TYPE_IDENTIFIER (entity
));
1614 tree ctx
= TYPE_CONTEXT (entity
);
1615 for (ix
= 0; ; ix
++)
1617 tree type
= VEC_index (tree
, local_classes
, ix
);
1619 return discriminator
;
1620 if (TYPE_CONTEXT (type
) == ctx
1621 && (name
? TYPE_IDENTIFIER (type
) == name
1622 : TYPE_ANONYMOUS_P (type
)))
1628 /* Return the discriminator for ENTITY appearing inside
1629 FUNCTION. The discriminator is the lexical ordinal of VAR among
1630 entities with the same name in the same FUNCTION. */
1633 discriminator_for_local_entity (tree entity
)
1635 if (DECL_DISCRIMINATOR_P (entity
))
1637 if (DECL_DISCRIMINATOR_SET_P (entity
))
1638 return DECL_DISCRIMINATOR (entity
);
1640 /* The first entity with a particular name doesn't get
1641 DECL_DISCRIMINATOR set up. */
1644 else if (TREE_CODE (entity
) == TYPE_DECL
)
1646 /* Scan the list of local classes. */
1647 entity
= TREE_TYPE (entity
);
1649 /* Lambdas and unnamed types have their own discriminators. */
1650 if (LAMBDA_TYPE_P (entity
) || TYPE_ANONYMOUS_P (entity
))
1653 return local_class_index (entity
);
1659 /* Return the discriminator for STRING, a string literal used inside
1660 FUNCTION. The discriminator is the lexical ordinal of STRING among
1661 string literals used in FUNCTION. */
1664 discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED
,
1665 tree string ATTRIBUTE_UNUSED
)
1667 /* For now, we don't discriminate amongst string literals. */
1671 /* <discriminator> := _ <number>
1673 The discriminator is used only for the second and later occurrences
1674 of the same name within a single function. In this case <number> is
1675 n - 2, if this is the nth occurrence, in lexical order. */
1678 write_discriminator (const int discriminator
)
1680 /* If discriminator is zero, don't write anything. Otherwise... */
1681 if (discriminator
> 0)
1684 write_unsigned_number (discriminator
- 1);
1688 /* Mangle the name of a function-scope entity. FUNCTION is the
1689 FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
1690 default argument scope. ENTITY is the decl for the entity itself.
1691 LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
1692 either ENTITY itself or an enclosing scope of ENTITY.
1694 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1695 := Z <function encoding> E s [<discriminator>]
1696 := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
1699 write_local_name (tree function
, const tree local_entity
,
1702 tree parm
= NULL_TREE
;
1704 MANGLE_TRACE_TREE ("local-name", entity
);
1706 if (TREE_CODE (function
) == PARM_DECL
)
1709 function
= DECL_CONTEXT (parm
);
1713 write_encoding (function
);
1716 /* For this purpose, parameters are numbered from right-to-left. */
1721 for (t
= DECL_ARGUMENTS (function
); t
; t
= DECL_CHAIN (t
))
1729 write_compact_number (i
- 1);
1732 if (TREE_CODE (entity
) == STRING_CST
)
1735 write_discriminator (discriminator_for_string_literal (function
,
1740 /* Now the <entity name>. Let write_name know its being called
1741 from <local-name>, so it doesn't try to process the enclosing
1742 function scope again. */
1743 write_name (entity
, /*ignore_local_scope=*/1);
1744 write_discriminator (discriminator_for_local_entity (local_entity
));
1748 /* Non-terminals <type> and <CV-qualifier>.
1750 <type> ::= <builtin-type>
1752 ::= <class-enum-type>
1754 ::= <pointer-to-member-type>
1755 ::= <template-param>
1758 ::= P <type> # pointer-to
1759 ::= R <type> # reference-to
1760 ::= C <type> # complex pair (C 2000)
1761 ::= G <type> # imaginary (C 2000) [not supported]
1762 ::= U <source-name> <type> # vendor extended type qualifier
1766 <type> ::= RR <type> # rvalue reference-to
1767 <type> ::= Dt <expression> # decltype of an id-expression or
1768 # class member access
1769 <type> ::= DT <expression> # decltype of an expression
1770 <type> ::= Dn # decltype of nullptr
1772 TYPE is a type node. */
1775 write_type (tree type
)
1777 /* This gets set to nonzero if TYPE turns out to be a (possibly
1778 CV-qualified) builtin type. */
1779 int is_builtin_type
= 0;
1781 MANGLE_TRACE_TREE ("type", type
);
1783 if (type
== error_mark_node
)
1786 type
= canonicalize_for_substitution (type
);
1787 if (find_substitution (type
))
1790 /* According to the C++ ABI, some library classes are passed the
1791 same as the scalar type of their single member and use the same
1793 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
1794 type
= TREE_TYPE (first_field (type
));
1796 if (write_CV_qualifiers_for_type (type
) > 0)
1797 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1798 mangle the unqualified type. The recursive call is needed here
1799 since both the qualified and unqualified types are substitution
1801 write_type (TYPE_MAIN_VARIANT (type
));
1802 else if (TREE_CODE (type
) == ARRAY_TYPE
)
1803 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1804 so that the cv-qualification of the element type is available
1805 in write_array_type. */
1806 write_array_type (type
);
1809 tree type_orig
= type
;
1811 /* See through any typedefs. */
1812 type
= TYPE_MAIN_VARIANT (type
);
1814 if (TYPE_PTRMEM_P (type
))
1815 write_pointer_to_member_type (type
);
1818 /* Handle any target-specific fundamental types. */
1819 const char *target_mangling
1820 = targetm
.mangle_type (type_orig
);
1822 if (target_mangling
)
1824 write_string (target_mangling
);
1825 /* Add substitutions for types other than fundamental
1827 if (TREE_CODE (type
) != VOID_TYPE
1828 && TREE_CODE (type
) != INTEGER_TYPE
1829 && TREE_CODE (type
) != REAL_TYPE
1830 && TREE_CODE (type
) != BOOLEAN_TYPE
)
1831 add_substitution (type
);
1835 switch (TREE_CODE (type
))
1839 case INTEGER_TYPE
: /* Includes wchar_t. */
1841 case FIXED_POINT_TYPE
:
1843 /* If this is a typedef, TYPE may not be one of
1844 the standard builtin type nodes, but an alias of one. Use
1845 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
1846 write_builtin_type (TYPE_MAIN_VARIANT (type
));
1853 write_type (TREE_TYPE (type
));
1858 write_function_type (type
);
1864 /* A pointer-to-member function is represented as a special
1865 RECORD_TYPE, so check for this first. */
1866 if (TYPE_PTRMEMFUNC_P (type
))
1867 write_pointer_to_member_type (type
);
1869 write_class_enum_type (type
);
1873 case UNBOUND_CLASS_TEMPLATE
:
1874 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1875 ordinary nested names. */
1876 write_nested_name (TYPE_STUB_DECL (type
));
1881 write_type (TREE_TYPE (type
));
1884 case REFERENCE_TYPE
:
1885 if (TYPE_REF_IS_RVALUE (type
))
1889 write_type (TREE_TYPE (type
));
1892 case TEMPLATE_TYPE_PARM
:
1893 case TEMPLATE_PARM_INDEX
:
1894 write_template_param (type
);
1897 case TEMPLATE_TEMPLATE_PARM
:
1898 write_template_template_param (type
);
1901 case BOUND_TEMPLATE_TEMPLATE_PARM
:
1902 write_template_template_param (type
);
1904 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type
)));
1908 if (abi_version_at_least (4))
1910 write_string ("Dv");
1911 /* Non-constant vector size would be encoded with
1912 _ expression, but we don't support that yet. */
1913 write_unsigned_number (TYPE_VECTOR_SUBPARTS (type
));
1918 G
.need_abi_warning
= 1;
1919 write_string ("U8__vector");
1921 write_type (TREE_TYPE (type
));
1924 case TYPE_PACK_EXPANSION
:
1925 write_string ("Dp");
1926 write_type (PACK_EXPANSION_PATTERN (type
));
1930 /* These shouldn't make it into mangling. */
1931 gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type
)
1932 && !DECLTYPE_FOR_LAMBDA_RETURN (type
));
1935 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type
))
1939 ++cp_unevaluated_operand
;
1940 write_expression (DECLTYPE_TYPE_EXPR (type
));
1941 --cp_unevaluated_operand
;
1946 write_string ("Dn");
1950 sorry ("mangling typeof, use decltype instead");
1962 /* Types other than builtin types are substitution candidates. */
1963 if (!is_builtin_type
)
1964 add_substitution (type
);
1967 /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
1968 CV-qualifiers written for TYPE.
1970 <CV-qualifiers> ::= [r] [V] [K] */
1973 write_CV_qualifiers_for_type (const tree type
)
1975 int num_qualifiers
= 0;
1977 /* The order is specified by:
1979 "In cases where multiple order-insensitive qualifiers are
1980 present, they should be ordered 'K' (closest to the base type),
1981 'V', 'r', and 'U' (farthest from the base type) ..."
1983 Note that we do not use cp_type_quals below; given "const
1984 int[3]", the "const" is emitted with the "int", not with the
1986 cp_cv_quals quals
= TYPE_QUALS (type
);
1988 /* Attribute const/noreturn are not reflected in mangling. */
1989 if (abi_version_at_least (5)
1990 && (TREE_CODE (type
) == FUNCTION_TYPE
1991 || TREE_CODE (type
) == METHOD_TYPE
))
1994 if (quals
& TYPE_QUAL_RESTRICT
)
1999 if (quals
& TYPE_QUAL_VOLATILE
)
2004 if (quals
& TYPE_QUAL_CONST
)
2010 return num_qualifiers
;
2013 /* Non-terminal <builtin-type>.
2015 <builtin-type> ::= v # void
2020 ::= h # unsigned char
2022 ::= t # unsigned short
2024 ::= j # unsigned int
2026 ::= m # unsigned long
2027 ::= x # long long, __int64
2028 ::= y # unsigned long long, __int64
2030 ::= o # unsigned __int128
2033 ::= e # long double, __float80
2034 ::= g # __float128 [not supported]
2035 ::= u <source-name> # vendor extended type */
2038 write_builtin_type (tree type
)
2040 if (TYPE_CANONICAL (type
))
2041 type
= TYPE_CANONICAL (type
);
2043 switch (TREE_CODE (type
))
2054 /* TYPE may still be wchar_t, char16_t, or char32_t, since that
2055 isn't in integer_type_nodes. */
2056 if (type
== wchar_type_node
)
2058 else if (type
== char16_type_node
)
2059 write_string ("Ds");
2060 else if (type
== char32_type_node
)
2061 write_string ("Di");
2062 else if (TYPE_FOR_JAVA (type
))
2063 write_java_integer_type_codes (type
);
2067 /* Assume TYPE is one of the shared integer type nodes. Find
2068 it in the array of these nodes. */
2070 for (itk
= 0; itk
< itk_none
; ++itk
)
2071 if (integer_types
[itk
] != NULL_TREE
2072 && type
== integer_types
[itk
])
2074 /* Print the corresponding single-letter code. */
2075 write_char (integer_type_codes
[itk
]);
2079 if (itk
== itk_none
)
2081 tree t
= c_common_type_for_mode (TYPE_MODE (type
),
2082 TYPE_UNSIGNED (type
));
2089 if (TYPE_PRECISION (type
) == 128)
2090 write_char (TYPE_UNSIGNED (type
) ? 'o' : 'n');
2093 /* Allow for cases where TYPE is not one of the shared
2094 integer type nodes and write a "vendor extended builtin
2095 type" with a name the form intN or uintN, respectively.
2096 Situations like this can happen if you have an
2097 __attribute__((__mode__(__SI__))) type and use exotic
2098 switches like '-mint8' on AVR. Of course, this is
2099 undefined by the C++ ABI (and '-mint8' is not even
2100 Standard C conforming), but when using such special
2101 options you're pretty much in nowhere land anyway. */
2103 char prec
[11]; /* up to ten digits for an unsigned */
2105 prefix
= TYPE_UNSIGNED (type
) ? "uint" : "int";
2106 sprintf (prec
, "%u", (unsigned) TYPE_PRECISION (type
));
2107 write_char ('u'); /* "vendor extended builtin type" */
2108 write_unsigned_number (strlen (prefix
) + strlen (prec
));
2109 write_string (prefix
);
2110 write_string (prec
);
2117 if (type
== float_type_node
2118 || type
== java_float_type_node
)
2120 else if (type
== double_type_node
2121 || type
== java_double_type_node
)
2123 else if (type
== long_double_type_node
)
2125 else if (type
== dfloat32_type_node
)
2126 write_string ("Df");
2127 else if (type
== dfloat64_type_node
)
2128 write_string ("Dd");
2129 else if (type
== dfloat128_type_node
)
2130 write_string ("De");
2135 case FIXED_POINT_TYPE
:
2136 write_string ("DF");
2137 if (GET_MODE_IBIT (TYPE_MODE (type
)) > 0)
2138 write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type
)));
2139 if (type
== fract_type_node
2140 || type
== sat_fract_type_node
2141 || type
== accum_type_node
2142 || type
== sat_accum_type_node
)
2144 else if (type
== unsigned_fract_type_node
2145 || type
== sat_unsigned_fract_type_node
2146 || type
== unsigned_accum_type_node
2147 || type
== sat_unsigned_accum_type_node
)
2149 else if (type
== short_fract_type_node
2150 || type
== sat_short_fract_type_node
2151 || type
== short_accum_type_node
2152 || type
== sat_short_accum_type_node
)
2154 else if (type
== unsigned_short_fract_type_node
2155 || type
== sat_unsigned_short_fract_type_node
2156 || type
== unsigned_short_accum_type_node
2157 || type
== sat_unsigned_short_accum_type_node
)
2159 else if (type
== long_fract_type_node
2160 || type
== sat_long_fract_type_node
2161 || type
== long_accum_type_node
2162 || type
== sat_long_accum_type_node
)
2164 else if (type
== unsigned_long_fract_type_node
2165 || type
== sat_unsigned_long_fract_type_node
2166 || type
== unsigned_long_accum_type_node
2167 || type
== sat_unsigned_long_accum_type_node
)
2169 else if (type
== long_long_fract_type_node
2170 || type
== sat_long_long_fract_type_node
2171 || type
== long_long_accum_type_node
2172 || type
== sat_long_long_accum_type_node
)
2174 else if (type
== unsigned_long_long_fract_type_node
2175 || type
== sat_unsigned_long_long_fract_type_node
2176 || type
== unsigned_long_long_accum_type_node
2177 || type
== sat_unsigned_long_long_accum_type_node
)
2180 sorry ("mangling unknown fixed point type");
2181 write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type
)));
2182 if (TYPE_SATURATING (type
))
2193 /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
2194 METHOD_TYPE. The return type is mangled before the parameter
2197 <function-type> ::= F [Y] <bare-function-type> E */
2200 write_function_type (const tree type
)
2202 MANGLE_TRACE_TREE ("function-type", type
);
2204 /* For a pointer to member function, the function type may have
2205 cv-qualifiers, indicating the quals for the artificial 'this'
2207 if (TREE_CODE (type
) == METHOD_TYPE
)
2209 /* The first parameter must be a POINTER_TYPE pointing to the
2210 `this' parameter. */
2211 tree this_type
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
)));
2212 write_CV_qualifiers_for_type (this_type
);
2216 /* We don't track whether or not a type is `extern "C"'. Note that
2217 you can have an `extern "C"' function that does not have
2218 `extern "C"' type, and vice versa:
2220 extern "C" typedef void function_t();
2221 function_t f; // f has C++ linkage, but its type is
2224 typedef void function_t();
2225 extern "C" function_t f; // Vice versa.
2228 write_bare_function_type (type
, /*include_return_type_p=*/1,
2233 /* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
2234 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
2235 is mangled before the parameter types. If non-NULL, DECL is
2236 FUNCTION_DECL for the function whose type is being emitted.
2238 If DECL is a member of a Java type, then a literal 'J'
2239 is output and the return type is mangled as if INCLUDE_RETURN_TYPE
2242 <bare-function-type> ::= [J]</signature/ type>+ */
2245 write_bare_function_type (const tree type
, const int include_return_type_p
,
2250 MANGLE_TRACE_TREE ("bare-function-type", type
);
2252 /* Detect Java methods and emit special encoding. */
2254 && DECL_FUNCTION_MEMBER_P (decl
)
2255 && TYPE_FOR_JAVA (DECL_CONTEXT (decl
))
2256 && !DECL_CONSTRUCTOR_P (decl
)
2257 && !DECL_DESTRUCTOR_P (decl
)
2258 && !DECL_CONV_FN_P (decl
))
2268 /* Mangle the return type, if requested. */
2269 if (include_return_type_p
|| java_method_p
)
2270 write_type (TREE_TYPE (type
));
2272 /* Now mangle the types of the arguments. */
2273 write_method_parms (TYPE_ARG_TYPES (type
),
2274 TREE_CODE (type
) == METHOD_TYPE
,
2278 /* Write the mangled representation of a method parameter list of
2279 types given in PARM_TYPES. If METHOD_P is nonzero, the function is
2280 considered a non-static method, and the this parameter is omitted.
2281 If non-NULL, DECL is the FUNCTION_DECL for the function whose
2282 parameters are being emitted. */
2285 write_method_parms (tree parm_types
, const int method_p
, const tree decl
)
2287 tree first_parm_type
;
2288 tree parm_decl
= decl
? DECL_ARGUMENTS (decl
) : NULL_TREE
;
2290 /* Assume this parameter type list is variable-length. If it ends
2291 with a void type, then it's not. */
2294 /* If this is a member function, skip the first arg, which is the
2296 "Member functions do not encode the type of their implicit this
2299 Similarly, there's no need to mangle artificial parameters, like
2300 the VTT parameters for constructors and destructors. */
2303 parm_types
= TREE_CHAIN (parm_types
);
2304 parm_decl
= parm_decl
? DECL_CHAIN (parm_decl
) : NULL_TREE
;
2306 while (parm_decl
&& DECL_ARTIFICIAL (parm_decl
))
2308 parm_types
= TREE_CHAIN (parm_types
);
2309 parm_decl
= DECL_CHAIN (parm_decl
);
2313 for (first_parm_type
= parm_types
;
2315 parm_types
= TREE_CHAIN (parm_types
))
2317 tree parm
= TREE_VALUE (parm_types
);
2318 if (parm
== void_type_node
)
2320 /* "Empty parameter lists, whether declared as () or
2321 conventionally as (void), are encoded with a void parameter
2323 if (parm_types
== first_parm_type
)
2325 /* If the parm list is terminated with a void type, it's
2328 /* A void type better be the last one. */
2329 gcc_assert (TREE_CHAIN (parm_types
) == NULL
);
2336 /* <builtin-type> ::= z # ellipsis */
2340 /* <class-enum-type> ::= <name> */
2343 write_class_enum_type (const tree type
)
2345 write_name (TYPE_NAME (type
), /*ignore_local_scope=*/0);
2348 /* Non-terminal <template-args>. ARGS is a TREE_VEC of template
2351 <template-args> ::= I <template-arg>* E */
2354 write_template_args (tree args
)
2359 MANGLE_TRACE_TREE ("template-args", args
);
2364 length
= TREE_VEC_LENGTH (args
);
2366 if (args
&& TREE_CODE (TREE_VEC_ELT (args
, 0)) == TREE_VEC
)
2368 /* We have nested template args. We want the innermost template
2370 args
= TREE_VEC_ELT (args
, length
- 1);
2371 length
= TREE_VEC_LENGTH (args
);
2373 for (i
= 0; i
< length
; ++i
)
2374 write_template_arg (TREE_VEC_ELT (args
, i
));
2381 <unqualified-name> <template-args>
2382 part of SCOPE_REF or COMPONENT_REF mangling. */
2385 write_member_name (tree member
)
2387 if (TREE_CODE (member
) == IDENTIFIER_NODE
)
2388 write_unqualified_id (member
);
2389 else if (DECL_P (member
))
2390 write_unqualified_name (member
);
2391 else if (TREE_CODE (member
) == TEMPLATE_ID_EXPR
)
2393 tree name
= TREE_OPERAND (member
, 0);
2394 if (TREE_CODE (name
) == OVERLOAD
)
2395 name
= OVL_FUNCTION (name
);
2396 write_member_name (name
);
2397 write_template_args (TREE_OPERAND (member
, 1));
2400 write_expression (member
);
2403 /* <expression> ::= <unary operator-name> <expression>
2404 ::= <binary operator-name> <expression> <expression>
2407 <expr-primary> ::= <template-param>
2408 ::= L <type> <value number> E # literal
2409 ::= L <mangled-name> E # external name
2410 ::= st <type> # sizeof
2411 ::= sr <type> <unqualified-name> # dependent name
2412 ::= sr <type> <unqualified-name> <template-args> */
2415 write_expression (tree expr
)
2417 enum tree_code code
= TREE_CODE (expr
);
2419 /* Skip NOP_EXPRs. They can occur when (say) a pointer argument
2420 is converted (via qualification conversions) to another
2422 while (TREE_CODE (expr
) == NOP_EXPR
2423 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
2425 expr
= TREE_OPERAND (expr
, 0);
2426 code
= TREE_CODE (expr
);
2429 if (code
== BASELINK
)
2431 expr
= BASELINK_FUNCTIONS (expr
);
2432 code
= TREE_CODE (expr
);
2435 /* Handle pointers-to-members by making them look like expression
2437 if (code
== PTRMEM_CST
)
2439 expr
= build_nt (ADDR_EXPR
,
2440 build_qualified_name (/*type=*/NULL_TREE
,
2441 PTRMEM_CST_CLASS (expr
),
2442 PTRMEM_CST_MEMBER (expr
),
2443 /*template_p=*/false));
2444 code
= TREE_CODE (expr
);
2447 /* Handle template parameters. */
2448 if (code
== TEMPLATE_TYPE_PARM
2449 || code
== TEMPLATE_TEMPLATE_PARM
2450 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
2451 || code
== TEMPLATE_PARM_INDEX
)
2452 write_template_param (expr
);
2453 /* Handle literals. */
2454 else if (TREE_CODE_CLASS (code
) == tcc_constant
2455 || (abi_version_at_least (2) && code
== CONST_DECL
))
2456 write_template_arg_literal (expr
);
2457 else if (code
== PARM_DECL
)
2459 /* A function parameter used in a late-specified return type. */
2460 int index
= DECL_PARM_INDEX (expr
);
2461 gcc_assert (index
>= 1);
2462 write_string ("fp");
2463 write_compact_number (index
- 1);
2465 else if (DECL_P (expr
))
2467 /* G++ 3.2 incorrectly mangled non-type template arguments of
2468 enumeration type using their names. */
2469 if (code
== CONST_DECL
)
2470 G
.need_abi_warning
= 1;
2472 write_mangled_name (expr
, false);
2475 else if (TREE_CODE (expr
) == SIZEOF_EXPR
2476 && TYPE_P (TREE_OPERAND (expr
, 0)))
2478 write_string ("st");
2479 write_type (TREE_OPERAND (expr
, 0));
2481 else if (TREE_CODE (expr
) == ALIGNOF_EXPR
2482 && TYPE_P (TREE_OPERAND (expr
, 0)))
2484 write_string ("at");
2485 write_type (TREE_OPERAND (expr
, 0));
2487 else if (TREE_CODE (expr
) == SCOPE_REF
)
2489 tree scope
= TREE_OPERAND (expr
, 0);
2490 tree member
= TREE_OPERAND (expr
, 1);
2492 if (!abi_version_at_least (2) && DECL_P (member
))
2494 write_string ("sr");
2496 /* G++ 3.2 incorrectly put out both the "sr" code and
2497 the nested name of the qualified name. */
2498 G
.need_abi_warning
= 1;
2499 write_encoding (member
);
2502 /* If the MEMBER is a real declaration, then the qualifying
2503 scope was not dependent. Ideally, we would not have a
2504 SCOPE_REF in those cases, but sometimes we do. If the second
2505 argument is a DECL, then the name must not have been
2507 else if (DECL_P (member
))
2508 write_expression (member
);
2511 write_string ("sr");
2513 write_member_name (member
);
2516 else if (TREE_CODE (expr
) == INDIRECT_REF
2517 && TREE_TYPE (TREE_OPERAND (expr
, 0))
2518 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2520 write_expression (TREE_OPERAND (expr
, 0));
2522 else if (TREE_CODE (expr
) == IDENTIFIER_NODE
)
2524 /* An operator name appearing as a dependent name needs to be
2525 specially marked to disambiguate between a use of the operator
2526 name and a use of the operator in an expression. */
2527 if (IDENTIFIER_OPNAME_P (expr
))
2528 write_string ("on");
2529 write_unqualified_id (expr
);
2531 else if (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
2533 tree fn
= TREE_OPERAND (expr
, 0);
2534 if (is_overloaded_fn (fn
))
2535 fn
= DECL_NAME (get_first_fn (fn
));
2536 if (IDENTIFIER_OPNAME_P (fn
))
2537 write_string ("on");
2538 write_unqualified_id (fn
);
2539 write_template_args (TREE_OPERAND (expr
, 1));
2546 /* When we bind a variable or function to a non-type template
2547 argument with reference type, we create an ADDR_EXPR to show
2548 the fact that the entity's address has been taken. But, we
2549 don't actually want to output a mangling code for the `&'. */
2550 if (TREE_CODE (expr
) == ADDR_EXPR
2552 && TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
)
2554 expr
= TREE_OPERAND (expr
, 0);
2557 write_expression (expr
);
2561 code
= TREE_CODE (expr
);
2564 if (code
== COMPONENT_REF
)
2566 tree ob
= TREE_OPERAND (expr
, 0);
2568 if (TREE_CODE (ob
) == ARROW_EXPR
)
2570 write_string (operator_name_info
[(int)code
].mangled_name
);
2571 ob
= TREE_OPERAND (ob
, 0);
2574 write_string ("dt");
2576 write_expression (ob
);
2577 write_member_name (TREE_OPERAND (expr
, 1));
2581 /* If it wasn't any of those, recursively expand the expression. */
2582 name
= operator_name_info
[(int) code
].mangled_name
;
2585 sorry ("mangling %C", code
);
2589 write_string (name
);
2595 tree fn
= CALL_EXPR_FN (expr
);
2597 if (TREE_CODE (fn
) == ADDR_EXPR
)
2598 fn
= TREE_OPERAND (fn
, 0);
2600 /* Mangle a dependent name as the name, not whatever happens to
2601 be the first function in the overload set. */
2602 if ((TREE_CODE (fn
) == FUNCTION_DECL
2603 || TREE_CODE (fn
) == OVERLOAD
)
2604 && type_dependent_expression_p_push (expr
))
2605 fn
= DECL_NAME (get_first_fn (fn
));
2607 write_expression (fn
);
2610 for (i
= 0; i
< call_expr_nargs (expr
); ++i
)
2611 write_expression (CALL_EXPR_ARG (expr
, i
));
2616 write_type (TREE_TYPE (expr
));
2617 if (list_length (TREE_OPERAND (expr
, 0)) == 1)
2618 write_expression (TREE_VALUE (TREE_OPERAND (expr
, 0)));
2621 tree args
= TREE_OPERAND (expr
, 0);
2623 for (; args
; args
= TREE_CHAIN (args
))
2624 write_expression (TREE_VALUE (args
));
2629 /* FIXME these should have a distinct mangling. */
2630 case STATIC_CAST_EXPR
:
2631 case CONST_CAST_EXPR
:
2632 write_type (TREE_TYPE (expr
));
2633 write_expression (TREE_OPERAND (expr
, 0));
2637 sorry ("mangling new-expression");
2641 /* In the middle-end, some expressions have more operands than
2642 they do in templates (and mangling). */
2645 case PREINCREMENT_EXPR
:
2646 case PREDECREMENT_EXPR
:
2647 case POSTINCREMENT_EXPR
:
2648 case POSTDECREMENT_EXPR
:
2657 len
= TREE_OPERAND_LENGTH (expr
);
2661 for (i
= 0; i
< len
; ++i
)
2663 tree operand
= TREE_OPERAND (expr
, i
);
2664 /* As a GNU extension, the middle operand of a
2665 conditional may be omitted. Since expression
2666 manglings are supposed to represent the input token
2667 stream, there's no good way to mangle such an
2668 expression without extending the C++ ABI. */
2669 if (code
== COND_EXPR
&& i
== 1 && !operand
)
2671 error ("omitted middle operand to %<?:%> operand "
2672 "cannot be mangled");
2675 write_expression (operand
);
2681 /* Literal subcase of non-terminal <template-arg>.
2683 "Literal arguments, e.g. "A<42L>", are encoded with their type
2684 and value. Negative integer values are preceded with "n"; for
2685 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2686 encoded as 0, true as 1." */
2689 write_template_arg_literal (const tree value
)
2692 write_type (TREE_TYPE (value
));
2694 switch (TREE_CODE (value
))
2697 write_integer_cst (DECL_INITIAL (value
));
2701 gcc_assert (!same_type_p (TREE_TYPE (value
), boolean_type_node
)
2702 || integer_zerop (value
) || integer_onep (value
));
2703 write_integer_cst (value
);
2707 write_real_cst (value
);
2717 /* Non-terminal <template-arg>.
2719 <template-arg> ::= <type> # type
2720 ::= L <type> </value/ number> E # literal
2721 ::= LZ <name> E # external name
2722 ::= X <expression> E # expression */
2725 write_template_arg (tree node
)
2727 enum tree_code code
= TREE_CODE (node
);
2729 MANGLE_TRACE_TREE ("template-arg", node
);
2731 /* A template template parameter's argument list contains TREE_LIST
2732 nodes of which the value field is the actual argument. */
2733 if (code
== TREE_LIST
)
2735 node
= TREE_VALUE (node
);
2736 /* If it's a decl, deal with its type instead. */
2739 node
= TREE_TYPE (node
);
2740 code
= TREE_CODE (node
);
2744 if (TREE_CODE (node
) == NOP_EXPR
2745 && TREE_CODE (TREE_TYPE (node
)) == REFERENCE_TYPE
)
2747 /* Template parameters can be of reference type. To maintain
2748 internal consistency, such arguments use a conversion from
2749 address of object to reference type. */
2750 gcc_assert (TREE_CODE (TREE_OPERAND (node
, 0)) == ADDR_EXPR
);
2751 if (abi_version_at_least (2))
2752 node
= TREE_OPERAND (TREE_OPERAND (node
, 0), 0);
2754 G
.need_abi_warning
= 1;
2757 if (ARGUMENT_PACK_P (node
))
2759 /* Expand the template argument pack. */
2760 tree args
= ARGUMENT_PACK_ARGS (node
);
2761 int i
, length
= TREE_VEC_LENGTH (args
);
2763 for (i
= 0; i
< length
; ++i
)
2764 write_template_arg (TREE_VEC_ELT (args
, i
));
2767 else if (TYPE_P (node
))
2769 else if (code
== TEMPLATE_DECL
)
2770 /* A template appearing as a template arg is a template template arg. */
2771 write_template_template_arg (node
);
2772 else if ((TREE_CODE_CLASS (code
) == tcc_constant
&& code
!= PTRMEM_CST
)
2773 || (abi_version_at_least (2) && code
== CONST_DECL
))
2774 write_template_arg_literal (node
);
2775 else if (DECL_P (node
))
2777 /* Until ABI version 2, non-type template arguments of
2778 enumeration type were mangled using their names. */
2779 if (code
== CONST_DECL
&& !abi_version_at_least (2))
2780 G
.need_abi_warning
= 1;
2782 /* Until ABI version 3, the underscore before the mangled name
2783 was incorrectly omitted. */
2784 if (!abi_version_at_least (3))
2786 G
.need_abi_warning
= 1;
2790 write_string ("_Z");
2791 write_encoding (node
);
2796 /* Template arguments may be expressions. */
2798 write_expression (node
);
2803 /* <template-template-arg>
2805 ::= <substitution> */
2808 write_template_template_arg (const tree decl
)
2810 MANGLE_TRACE_TREE ("template-template-arg", decl
);
2812 if (find_substitution (decl
))
2814 write_name (decl
, /*ignore_local_scope=*/0);
2815 add_substitution (decl
);
2819 /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
2821 <array-type> ::= A [</dimension/ number>] _ </element/ type>
2822 ::= A <expression> _ </element/ type>
2824 "Array types encode the dimension (number of elements) and the
2825 element type. For variable length arrays, the dimension (but not
2826 the '_' separator) is omitted." */
2829 write_array_type (const tree type
)
2832 if (TYPE_DOMAIN (type
))
2837 index_type
= TYPE_DOMAIN (type
);
2838 /* The INDEX_TYPE gives the upper and lower bounds of the
2840 max
= TYPE_MAX_VALUE (index_type
);
2841 if (TREE_CODE (max
) == INTEGER_CST
)
2843 /* The ABI specifies that we should mangle the number of
2844 elements in the array, not the largest allowed index. */
2845 max
= size_binop (PLUS_EXPR
, max
, size_one_node
);
2846 write_unsigned_number (tree_low_cst (max
, 1));
2850 max
= TREE_OPERAND (max
, 0);
2851 if (!abi_version_at_least (2))
2853 /* value_dependent_expression_p presumes nothing is
2854 dependent when PROCESSING_TEMPLATE_DECL is zero. */
2855 ++processing_template_decl
;
2856 if (!value_dependent_expression_p (max
))
2857 G
.need_abi_warning
= 1;
2858 --processing_template_decl
;
2860 write_expression (max
);
2865 write_type (TREE_TYPE (type
));
2868 /* Non-terminal <pointer-to-member-type> for pointer-to-member
2869 variables. TYPE is a pointer-to-member POINTER_TYPE.
2871 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
2874 write_pointer_to_member_type (const tree type
)
2877 write_type (TYPE_PTRMEM_CLASS_TYPE (type
));
2878 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type
));
2881 /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
2882 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2883 TEMPLATE_PARM_INDEX.
2885 <template-param> ::= T </parameter/ number> _ */
2888 write_template_param (const tree parm
)
2892 MANGLE_TRACE_TREE ("template-parm", parm
);
2894 switch (TREE_CODE (parm
))
2896 case TEMPLATE_TYPE_PARM
:
2897 case TEMPLATE_TEMPLATE_PARM
:
2898 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2899 parm_index
= TEMPLATE_TYPE_IDX (parm
);
2902 case TEMPLATE_PARM_INDEX
:
2903 parm_index
= TEMPLATE_PARM_IDX (parm
);
2911 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2912 earliest template param denoted by `_'. */
2913 write_compact_number (parm_index
);
2916 /* <template-template-param>
2917 ::= <template-param>
2918 ::= <substitution> */
2921 write_template_template_param (const tree parm
)
2923 tree templ
= NULL_TREE
;
2925 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2926 template template parameter. The substitution candidate here is
2927 only the template. */
2928 if (TREE_CODE (parm
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
2931 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm
));
2932 if (find_substitution (templ
))
2936 /* <template-param> encodes only the template parameter position,
2937 not its template arguments, which is fine here. */
2938 write_template_param (parm
);
2940 add_substitution (templ
);
2943 /* Non-terminal <substitution>.
2945 <substitution> ::= S <seq-id> _
2949 write_substitution (const int seq_id
)
2951 MANGLE_TRACE ("substitution", "");
2955 write_number (seq_id
- 1, /*unsigned=*/1, 36);
2959 /* Start mangling ENTITY. */
2962 start_mangling (const tree entity
)
2965 G
.need_abi_warning
= false;
2966 obstack_free (&name_obstack
, name_base
);
2967 mangle_obstack
= &name_obstack
;
2968 name_base
= obstack_alloc (&name_obstack
, 0);
2971 /* Done with mangling. If WARN is true, and the name of G.entity will
2972 be mangled differently in a future version of the ABI, issue a
2976 finish_mangling_internal (const bool warn
)
2978 if (warn_abi
&& warn
&& G
.need_abi_warning
)
2979 warning (OPT_Wabi
, "the mangled name of %qD will change in a future "
2983 /* Clear all the substitutions. */
2984 VEC_truncate (tree
, G
.substitutions
, 0);
2986 /* Null-terminate the string. */
2991 /* Like finish_mangling_internal, but return the mangled string. */
2993 static inline const char *
2994 finish_mangling (const bool warn
)
2996 finish_mangling_internal (warn
);
2997 return (const char *) obstack_finish (mangle_obstack
);
3000 /* Like finish_mangling_internal, but return an identifier. */
3003 finish_mangling_get_identifier (const bool warn
)
3005 finish_mangling_internal (warn
);
3006 /* Don't obstack_finish here, and the next start_mangling will
3007 remove the identifier. */
3008 return get_identifier ((const char *) obstack_base (mangle_obstack
));
3011 /* Initialize data structures for mangling. */
3016 gcc_obstack_init (&name_obstack
);
3017 name_base
= obstack_alloc (&name_obstack
, 0);
3018 G
.substitutions
= NULL
;
3020 /* Cache these identifiers for quick comparison when checking for
3021 standard substitutions. */
3022 subst_identifiers
[SUBID_ALLOCATOR
] = get_identifier ("allocator");
3023 subst_identifiers
[SUBID_BASIC_STRING
] = get_identifier ("basic_string");
3024 subst_identifiers
[SUBID_CHAR_TRAITS
] = get_identifier ("char_traits");
3025 subst_identifiers
[SUBID_BASIC_ISTREAM
] = get_identifier ("basic_istream");
3026 subst_identifiers
[SUBID_BASIC_OSTREAM
] = get_identifier ("basic_ostream");
3027 subst_identifiers
[SUBID_BASIC_IOSTREAM
] = get_identifier ("basic_iostream");
3030 /* Generate the mangled name of DECL. */
3033 mangle_decl_string (const tree decl
)
3036 location_t saved_loc
= input_location
;
3037 tree saved_fn
= NULL_TREE
;
3038 bool template_p
= false;
3040 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
3042 struct tinst_level
*tl
= current_instantiation ();
3043 if (!tl
|| tl
->decl
!= decl
)
3046 saved_fn
= current_function_decl
;
3047 push_tinst_level (decl
);
3048 current_function_decl
= NULL_TREE
;
3051 input_location
= DECL_SOURCE_LOCATION (decl
);
3053 start_mangling (decl
);
3055 if (TREE_CODE (decl
) == TYPE_DECL
)
3056 write_type (TREE_TYPE (decl
));
3058 write_mangled_name (decl
, true);
3060 result
= finish_mangling_get_identifier (/*warn=*/true);
3062 fprintf (stderr
, "mangle_decl_string = '%s'\n\n",
3063 IDENTIFIER_POINTER (result
));
3068 current_function_decl
= saved_fn
;
3070 input_location
= saved_loc
;
3075 /* Create an identifier for the external mangled name of DECL. */
3078 mangle_decl (const tree decl
)
3080 tree id
= mangle_decl_string (decl
);
3081 id
= targetm
.mangle_decl_assembler_name (decl
, id
);
3082 SET_DECL_ASSEMBLER_NAME (decl
, id
);
3084 if (G
.need_abi_warning
)
3086 #ifdef ASM_OUTPUT_DEF
3087 /* If the mangling will change in the future, emit an alias with the
3088 future mangled name for forward-compatibility. */
3093 SET_IDENTIFIER_GLOBAL_VALUE (id
, decl
);
3094 if (IDENTIFIER_GLOBAL_VALUE (id
) != decl
)
3095 inform (DECL_SOURCE_LOCATION (decl
), "-fabi-version=4 (or =0) "
3096 "avoids this error with a change in vector mangling");
3098 #ifdef ASM_OUTPUT_DEF
3099 save_ver
= flag_abi_version
;
3100 flag_abi_version
= 0;
3101 id2
= mangle_decl_string (decl
);
3102 id2
= targetm
.mangle_decl_assembler_name (decl
, id2
);
3103 flag_abi_version
= save_ver
;
3105 alias
= make_alias_for (decl
, id2
);
3106 DECL_IGNORED_P (alias
) = 1;
3107 TREE_PUBLIC (alias
) = TREE_PUBLIC (decl
);
3108 DECL_VISIBILITY (alias
) = DECL_VISIBILITY (decl
);
3109 if (vague_linkage_p (decl
))
3110 DECL_WEAK (alias
) = 1;
3111 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3112 cgraph_same_body_alias (alias
, decl
);
3114 varpool_extra_name_alias (alias
, decl
);
3119 /* Generate the mangled representation of TYPE. */
3122 mangle_type_string (const tree type
)
3126 start_mangling (type
);
3128 result
= finish_mangling (/*warn=*/false);
3130 fprintf (stderr
, "mangle_type_string = '%s'\n\n", result
);
3134 /* Create an identifier for the mangled name of a special component
3135 for belonging to TYPE. CODE is the ABI-specified code for this
3139 mangle_special_for_type (const tree type
, const char *code
)
3143 /* We don't have an actual decl here for the special component, so
3144 we can't just process the <encoded-name>. Instead, fake it. */
3145 start_mangling (type
);
3147 /* Start the mangling. */
3148 write_string ("_Z");
3149 write_string (code
);
3153 result
= finish_mangling_get_identifier (/*warn=*/false);
3156 fprintf (stderr
, "mangle_special_for_type = %s\n\n",
3157 IDENTIFIER_POINTER (result
));
3162 /* Create an identifier for the mangled representation of the typeinfo
3163 structure for TYPE. */
3166 mangle_typeinfo_for_type (const tree type
)
3168 return mangle_special_for_type (type
, "TI");
3171 /* Create an identifier for the mangled name of the NTBS containing
3172 the mangled name of TYPE. */
3175 mangle_typeinfo_string_for_type (const tree type
)
3177 return mangle_special_for_type (type
, "TS");
3180 /* Create an identifier for the mangled name of the vtable for TYPE. */
3183 mangle_vtbl_for_type (const tree type
)
3185 return mangle_special_for_type (type
, "TV");
3188 /* Returns an identifier for the mangled name of the VTT for TYPE. */
3191 mangle_vtt_for_type (const tree type
)
3193 return mangle_special_for_type (type
, "TT");
3196 /* Return an identifier for a construction vtable group. TYPE is
3197 the most derived class in the hierarchy; BINFO is the base
3198 subobject for which this construction vtable group will be used.
3200 This mangling isn't part of the ABI specification; in the ABI
3201 specification, the vtable group is dumped in the same COMDAT as the
3202 main vtable, and is referenced only from that vtable, so it doesn't
3203 need an external name. For binary formats without COMDAT sections,
3204 though, we need external names for the vtable groups.
3206 We use the production
3208 <special-name> ::= CT <type> <offset number> _ <base type> */
3211 mangle_ctor_vtbl_for_type (const tree type
, const tree binfo
)
3215 start_mangling (type
);
3217 write_string ("_Z");
3218 write_string ("TC");
3220 write_integer_cst (BINFO_OFFSET (binfo
));
3222 write_type (BINFO_TYPE (binfo
));
3224 result
= finish_mangling_get_identifier (/*warn=*/false);
3226 fprintf (stderr
, "mangle_ctor_vtbl_for_type = %s\n\n",
3227 IDENTIFIER_POINTER (result
));
3231 /* Mangle a this pointer or result pointer adjustment.
3233 <call-offset> ::= h <fixed offset number> _
3234 ::= v <fixed offset number> _ <virtual offset number> _ */
3237 mangle_call_offset (const tree fixed_offset
, const tree virtual_offset
)
3239 write_char (virtual_offset
? 'v' : 'h');
3241 /* For either flavor, write the fixed offset. */
3242 write_integer_cst (fixed_offset
);
3245 /* For a virtual thunk, add the virtual offset. */
3248 write_integer_cst (virtual_offset
);
3253 /* Return an identifier for the mangled name of a this-adjusting or
3254 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment
3255 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this
3256 is a virtual thunk, and it is the vtbl offset in
3257 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
3258 zero for a covariant thunk. Note, that FN_DECL might be a covariant
3259 thunk itself. A covariant thunk name always includes the adjustment
3260 for the this pointer, even if there is none.
3262 <special-name> ::= T <call-offset> <base encoding>
3263 ::= Tc <this_adjust call-offset> <result_adjust call-offset>
3267 mangle_thunk (tree fn_decl
, const int this_adjusting
, tree fixed_offset
,
3268 tree virtual_offset
)
3272 start_mangling (fn_decl
);
3274 write_string ("_Z");
3277 if (!this_adjusting
)
3279 /* Covariant thunk with no this adjustment */
3281 mangle_call_offset (integer_zero_node
, NULL_TREE
);
3282 mangle_call_offset (fixed_offset
, virtual_offset
);
3284 else if (!DECL_THUNK_P (fn_decl
))
3285 /* Plain this adjusting thunk. */
3286 mangle_call_offset (fixed_offset
, virtual_offset
);
3289 /* This adjusting thunk to covariant thunk. */
3291 mangle_call_offset (fixed_offset
, virtual_offset
);
3292 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn_decl
));
3293 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn_decl
);
3295 virtual_offset
= BINFO_VPTR_FIELD (virtual_offset
);
3296 mangle_call_offset (fixed_offset
, virtual_offset
);
3297 fn_decl
= THUNK_TARGET (fn_decl
);
3301 write_encoding (fn_decl
);
3303 result
= finish_mangling_get_identifier (/*warn=*/false);
3305 fprintf (stderr
, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result
));
3309 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
3310 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
3313 static GTY ((param_is (union tree_node
))) htab_t conv_type_names
;
3315 /* Hash a node (VAL1) in the table. */
3318 hash_type (const void *val
)
3320 return (hashval_t
) TYPE_UID (TREE_TYPE ((const_tree
) val
));
3323 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */
3326 compare_type (const void *val1
, const void *val2
)
3328 return TREE_TYPE ((const_tree
) val1
) == (const_tree
) val2
;
3331 /* Return an identifier for the mangled unqualified name for a
3332 conversion operator to TYPE. This mangling is not specified by the
3333 ABI spec; it is only used internally. */
3336 mangle_conv_op_name_for_type (const tree type
)
3341 if (type
== error_mark_node
)
3342 return error_mark_node
;
3344 if (conv_type_names
== NULL
)
3345 conv_type_names
= htab_create_ggc (31, &hash_type
, &compare_type
, NULL
);
3347 slot
= htab_find_slot_with_hash (conv_type_names
, type
,
3348 (hashval_t
) TYPE_UID (type
), INSERT
);
3349 identifier
= (tree
)*slot
;
3354 /* Create a unique name corresponding to TYPE. */
3355 sprintf (buffer
, "operator %lu",
3356 (unsigned long) htab_elements (conv_type_names
));
3357 identifier
= get_identifier (buffer
);
3360 /* Hang TYPE off the identifier so it can be found easily later
3361 when performing conversions. */
3362 TREE_TYPE (identifier
) = type
;
3364 /* Set bits on the identifier so we know later it's a conversion. */
3365 IDENTIFIER_OPNAME_P (identifier
) = 1;
3366 IDENTIFIER_TYPENAME_P (identifier
) = 1;
3372 /* Return an identifier for the name of an initialization guard
3373 variable for indicated VARIABLE. */
3376 mangle_guard_variable (const tree variable
)
3378 start_mangling (variable
);
3379 write_string ("_ZGV");
3380 if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable
)), "_ZGR", 4) == 0)
3381 /* The name of a guard variable for a reference temporary should refer
3382 to the reference, not the temporary. */
3383 write_string (IDENTIFIER_POINTER (DECL_NAME (variable
)) + 4);
3385 write_name (variable
, /*ignore_local_scope=*/0);
3386 return finish_mangling_get_identifier (/*warn=*/false);
3389 /* Return an identifier for the name of a temporary variable used to
3390 initialize a static reference. This isn't part of the ABI, but we might
3391 as well call them something readable. */
3394 mangle_ref_init_variable (const tree variable
)
3396 start_mangling (variable
);
3397 write_string ("_ZGR");
3398 write_name (variable
, /*ignore_local_scope=*/0);
3399 return finish_mangling_get_identifier (/*warn=*/false);
3403 /* Foreign language type mangling section. */
3405 /* How to write the type codes for the integer Java type. */
3408 write_java_integer_type_codes (const tree type
)
3410 if (type
== java_int_type_node
)
3412 else if (type
== java_short_type_node
)
3414 else if (type
== java_byte_type_node
)
3416 else if (type
== java_char_type_node
)
3418 else if (type
== java_long_type_node
)
3420 else if (type
== java_boolean_type_node
)
3426 #include "gt-cp-mangle.h"