Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / gcc-4.4 / gcc / cp / mangle.c
CommitLineData
c251ad9e
SS
1/* Name mangling for the 3.0 C++ ABI.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Written by Alex Samuel <samuel@codesourcery.com>
5
6 This file is part of GCC.
7
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)
11 any later version.
12
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.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
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
28 linkers.
29
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.
34
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:
40
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 */
47
48#include "config.h"
49#include "system.h"
50#include "coretypes.h"
51#include "tm.h"
52#include "tree.h"
53#include "tm_p.h"
54#include "cp-tree.h"
55#include "real.h"
56#include "obstack.h"
57#include "toplev.h"
58#include "varray.h"
59#include "flags.h"
60#include "target.h"
61
62/* Debugging support. */
63
64/* Define DEBUG_MANGLE to enable very verbose trace messages. */
65#ifndef DEBUG_MANGLE
66#define DEBUG_MANGLE 0
67#endif
68
69/* Macros for tracing the write_* functions. */
70#if DEBUG_MANGLE
71# define MANGLE_TRACE(FN, INPUT) \
72 fprintf (stderr, " %-24s: %-24s\n", (FN), (INPUT))
73# define MANGLE_TRACE_TREE(FN, NODE) \
74 fprintf (stderr, " %-24s: %-24s (%p)\n", \
75 (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE))
76#else
77# define MANGLE_TRACE(FN, INPUT)
78# define MANGLE_TRACE_TREE(FN, NODE)
79#endif
80
81/* Nonzero if NODE is a class template-id. We can't rely on
82 CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
83 that hard to distinguish A<T> from A, where A<T> is the type as
84 instantiated outside of the template, and A is the type used
85 without parameters inside the template. */
86#define CLASSTYPE_TEMPLATE_ID_P(NODE) \
87 (TYPE_LANG_SPECIFIC (NODE) != NULL \
88 && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \
89 || (CLASSTYPE_TEMPLATE_INFO (NODE) != NULL \
90 && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))))
91
92/* Things we only need one of. This module is not reentrant. */
93typedef struct globals GTY(())
94{
95 /* An array of the current substitution candidates, in the order
96 we've seen them. */
97 VEC(tree,gc) *substitutions;
98
99 /* The entity that is being mangled. */
100 tree GTY ((skip)) entity;
101
102 /* True if the mangling will be different in a future version of the
103 ABI. */
104 bool need_abi_warning;
105} globals;
106
107static GTY (()) globals G;
108
109/* The obstack on which we build mangled names. */
110static struct obstack *mangle_obstack;
111
112/* The obstack on which we build mangled names that are not going to
113 be IDENTIFIER_NODEs. */
114static struct obstack name_obstack;
115
116/* The first object on the name_obstack; we use this to free memory
117 allocated on the name_obstack. */
118static void *name_base;
119
120/* Indices into subst_identifiers. These are identifiers used in
121 special substitution rules. */
122typedef enum
123{
124 SUBID_ALLOCATOR,
125 SUBID_BASIC_STRING,
126 SUBID_CHAR_TRAITS,
127 SUBID_BASIC_ISTREAM,
128 SUBID_BASIC_OSTREAM,
129 SUBID_BASIC_IOSTREAM,
130 SUBID_MAX
131}
132substitution_identifier_index_t;
133
134/* For quick substitution checks, look up these common identifiers
135 once only. */
136static GTY(()) tree subst_identifiers[SUBID_MAX];
137
138/* Single-letter codes for builtin integer types, defined in
139 <builtin-type>. These are indexed by integer_type_kind values. */
140static const char
141integer_type_codes[itk_none] =
142{
143 'c', /* itk_char */
144 'a', /* itk_signed_char */
145 'h', /* itk_unsigned_char */
146 's', /* itk_short */
147 't', /* itk_unsigned_short */
148 'i', /* itk_int */
149 'j', /* itk_unsigned_int */
150 'l', /* itk_long */
151 'm', /* itk_unsigned_long */
152 'x', /* itk_long_long */
153 'y' /* itk_unsigned_long_long */
154};
155
156static int decl_is_template_id (const tree, tree* const);
157
158/* Functions for handling substitutions. */
159
160static inline tree canonicalize_for_substitution (tree);
161static void add_substitution (tree);
162static inline int is_std_substitution (const tree,
163 const substitution_identifier_index_t);
164static inline int is_std_substitution_char (const tree,
165 const substitution_identifier_index_t);
166static int find_substitution (tree);
167static void mangle_call_offset (const tree, const tree);
168
169/* Functions for emitting mangled representations of things. */
170
171static void write_mangled_name (const tree, bool);
172static void write_encoding (const tree);
173static void write_name (tree, const int);
174static void write_unscoped_name (const tree);
175static void write_unscoped_template_name (const tree);
176static void write_nested_name (const tree);
177static void write_prefix (const tree);
178static void write_template_prefix (const tree);
179static void write_unqualified_name (const tree);
180static void write_conversion_operator_name (const tree);
181static void write_source_name (tree);
182static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
183 const unsigned int);
184static void write_number (unsigned HOST_WIDE_INT, const int,
185 const unsigned int);
186static void write_integer_cst (const tree);
187static void write_real_cst (const tree);
188static void write_identifier (const char *);
189static void write_special_name_constructor (const tree);
190static void write_special_name_destructor (const tree);
191static void write_type (tree);
192static int write_CV_qualifiers_for_type (const tree);
193static void write_builtin_type (tree);
194static void write_function_type (const tree);
195static void write_bare_function_type (const tree, const int, const tree);
196static void write_method_parms (tree, const int, const tree);
197static void write_class_enum_type (const tree);
198static void write_template_args (tree);
199static void write_expression (tree);
200static void write_template_arg_literal (const tree);
201static void write_template_arg (tree);
202static void write_template_template_arg (const tree);
203static void write_array_type (const tree);
204static void write_pointer_to_member_type (const tree);
205static void write_template_param (const tree);
206static void write_template_template_param (const tree);
207static void write_substitution (const int);
208static int discriminator_for_local_entity (tree);
209static int discriminator_for_string_literal (tree, tree);
210static void write_discriminator (const int);
211static void write_local_name (const tree, const tree, const tree);
212static void dump_substitution_candidates (void);
213static tree mangle_decl_string (const tree);
214
215/* Control functions. */
216
217static inline void start_mangling (const tree);
218static inline const char *finish_mangling (const bool);
219static tree mangle_special_for_type (const tree, const char *);
220
221/* Foreign language functions. */
222
223static void write_java_integer_type_codes (const tree);
224
225/* Append a single character to the end of the mangled
226 representation. */
227#define write_char(CHAR) \
228 obstack_1grow (mangle_obstack, (CHAR))
229
230/* Append a sized buffer to the end of the mangled representation. */
231#define write_chars(CHAR, LEN) \
232 obstack_grow (mangle_obstack, (CHAR), (LEN))
233
234/* Append a NUL-terminated string to the end of the mangled
235 representation. */
236#define write_string(STRING) \
237 obstack_grow (mangle_obstack, (STRING), strlen (STRING))
238
239/* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
240 same purpose (context, which may be a type) and value (template
241 decl). See write_template_prefix for more information on what this
242 is used for. */
243#define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \
244 (TREE_CODE (NODE1) == TREE_LIST \
245 && TREE_CODE (NODE2) == TREE_LIST \
246 && ((TYPE_P (TREE_PURPOSE (NODE1)) \
247 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))) \
248 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \
249 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
250
251/* Write out an unsigned quantity in base 10. */
252#define write_unsigned_number(NUMBER) \
253 write_number ((NUMBER), /*unsigned_p=*/1, 10)
254
255/* If DECL is a template instance, return nonzero and, if
256 TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info.
257 Otherwise return zero. */
258
259static int
260decl_is_template_id (const tree decl, tree* const template_info)
261{
262 if (TREE_CODE (decl) == TYPE_DECL)
263 {
264 /* TYPE_DECLs are handled specially. Look at its type to decide
265 if this is a template instantiation. */
266 const tree type = TREE_TYPE (decl);
267
268 if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
269 {
270 if (template_info != NULL)
271 /* For a templated TYPE_DECL, the template info is hanging
272 off the type. */
273 *template_info = TYPE_TEMPLATE_INFO (type);
274 return 1;
275 }
276 }
277 else
278 {
279 /* Check if this is a primary template. */
280 if (DECL_LANG_SPECIFIC (decl) != NULL
281 && DECL_USE_TEMPLATE (decl)
282 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))
283 && TREE_CODE (decl) != TEMPLATE_DECL)
284 {
285 if (template_info != NULL)
286 /* For most templated decls, the template info is hanging
287 off the decl. */
288 *template_info = DECL_TEMPLATE_INFO (decl);
289 return 1;
290 }
291 }
292
293 /* It's not a template id. */
294 return 0;
295}
296
297/* Produce debugging output of current substitution candidates. */
298
299static void
300dump_substitution_candidates (void)
301{
302 unsigned i;
303 tree el;
304
305 fprintf (stderr, " ++ substitutions ");
306 for (i = 0; VEC_iterate (tree, G.substitutions, i, el); ++i)
307 {
308 const char *name = "???";
309
310 if (i > 0)
311 fprintf (stderr, " ");
312 if (DECL_P (el))
313 name = IDENTIFIER_POINTER (DECL_NAME (el));
314 else if (TREE_CODE (el) == TREE_LIST)
315 name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
316 else if (TYPE_NAME (el))
317 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el)));
318 fprintf (stderr, " S%d_ = ", i - 1);
319 if (TYPE_P (el) &&
320 (CP_TYPE_RESTRICT_P (el)
321 || CP_TYPE_VOLATILE_P (el)
322 || CP_TYPE_CONST_P (el)))
323 fprintf (stderr, "CV-");
324 fprintf (stderr, "%s (%s at %p)\n",
325 name, tree_code_name[TREE_CODE (el)], (void *) el);
326 }
327}
328
329/* Both decls and types can be substitution candidates, but sometimes
330 they refer to the same thing. For instance, a TYPE_DECL and
331 RECORD_TYPE for the same class refer to the same thing, and should
332 be treated accordingly in substitutions. This function returns a
333 canonicalized tree node representing NODE that is used when adding
334 and substitution candidates and finding matches. */
335
336static inline tree
337canonicalize_for_substitution (tree node)
338{
339 /* For a TYPE_DECL, use the type instead. */
340 if (TREE_CODE (node) == TYPE_DECL)
341 node = TREE_TYPE (node);
342 if (TYPE_P (node))
343 node = canonical_type_variant (node);
344
345 return node;
346}
347
348/* Add NODE as a substitution candidate. NODE must not already be on
349 the list of candidates. */
350
351static void
352add_substitution (tree node)
353{
354 tree c;
355
356 if (DEBUG_MANGLE)
357 fprintf (stderr, " ++ add_substitution (%s at %10p)\n",
358 tree_code_name[TREE_CODE (node)], (void *) node);
359
360 /* Get the canonicalized substitution candidate for NODE. */
361 c = canonicalize_for_substitution (node);
362 if (DEBUG_MANGLE && c != node)
363 fprintf (stderr, " ++ using candidate (%s at %10p)\n",
364 tree_code_name[TREE_CODE (node)], (void *) node);
365 node = c;
366
367#if ENABLE_CHECKING
368 /* Make sure NODE isn't already a candidate. */
369 {
370 int i;
371 tree candidate;
372
373 for (i = 0; VEC_iterate (tree, G.substitutions, i, candidate); i++)
374 {
375 gcc_assert (!(DECL_P (node) && node == candidate));
376 gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
377 && same_type_p (node, candidate)));
378 }
379 }
380#endif /* ENABLE_CHECKING */
381
382 /* Put the decl onto the varray of substitution candidates. */
383 VEC_safe_push (tree, gc, G.substitutions, node);
384
385 if (DEBUG_MANGLE)
386 dump_substitution_candidates ();
387}
388
389/* Helper function for find_substitution. Returns nonzero if NODE,
390 which may be a decl or a CLASS_TYPE, is a template-id with template
391 name of substitution_index[INDEX] in the ::std namespace. */
392
393static inline int
394is_std_substitution (const tree node,
395 const substitution_identifier_index_t index)
396{
397 tree type = NULL;
398 tree decl = NULL;
399
400 if (DECL_P (node))
401 {
402 type = TREE_TYPE (node);
403 decl = node;
404 }
405 else if (CLASS_TYPE_P (node))
406 {
407 type = node;
408 decl = TYPE_NAME (node);
409 }
410 else
411 /* These are not the droids you're looking for. */
412 return 0;
413
414 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))
415 && TYPE_LANG_SPECIFIC (type)
416 && TYPE_TEMPLATE_INFO (type)
417 && (DECL_NAME (TYPE_TI_TEMPLATE (type))
418 == subst_identifiers[index]));
419}
420
421/* Helper function for find_substitution. Returns nonzero if NODE,
422 which may be a decl or a CLASS_TYPE, is the template-id
423 ::std::identifier<char>, where identifier is
424 substitution_index[INDEX]. */
425
426static inline int
427is_std_substitution_char (const tree node,
428 const substitution_identifier_index_t index)
429{
430 tree args;
431 /* Check NODE's name is ::std::identifier. */
432 if (!is_std_substitution (node, index))
433 return 0;
434 /* Figure out its template args. */
435 if (DECL_P (node))
436 args = DECL_TI_ARGS (node);
437 else if (CLASS_TYPE_P (node))
438 args = CLASSTYPE_TI_ARGS (node);
439 else
440 /* Oops, not a template. */
441 return 0;
442 /* NODE's template arg list should be <char>. */
443 return
444 TREE_VEC_LENGTH (args) == 1
445 && TREE_VEC_ELT (args, 0) == char_type_node;
446}
447
448/* Check whether a substitution should be used to represent NODE in
449 the mangling.
450
451 First, check standard special-case substitutions.
452
453 <substitution> ::= St
454 # ::std
455
456 ::= Sa
457 # ::std::allocator
458
459 ::= Sb
460 # ::std::basic_string
461
462 ::= Ss
463 # ::std::basic_string<char,
464 ::std::char_traits<char>,
465 ::std::allocator<char> >
466
467 ::= Si
468 # ::std::basic_istream<char, ::std::char_traits<char> >
469
470 ::= So
471 # ::std::basic_ostream<char, ::std::char_traits<char> >
472
473 ::= Sd
474 # ::std::basic_iostream<char, ::std::char_traits<char> >
475
476 Then examine the stack of currently available substitution
477 candidates for entities appearing earlier in the same mangling
478
479 If a substitution is found, write its mangled representation and
480 return nonzero. If none is found, just return zero. */
481
482static int
483find_substitution (tree node)
484{
485 int i;
486 const int size = VEC_length (tree, G.substitutions);
487 tree decl;
488 tree type;
489
490 if (DEBUG_MANGLE)
491 fprintf (stderr, " ++ find_substitution (%s at %p)\n",
492 tree_code_name[TREE_CODE (node)], (void *) node);
493
494 /* Obtain the canonicalized substitution representation for NODE.
495 This is what we'll compare against. */
496 node = canonicalize_for_substitution (node);
497
498 /* Check for builtin substitutions. */
499
500 decl = TYPE_P (node) ? TYPE_NAME (node) : node;
501 type = TYPE_P (node) ? node : TREE_TYPE (node);
502
503 /* Check for std::allocator. */
504 if (decl
505 && is_std_substitution (decl, SUBID_ALLOCATOR)
506 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
507 {
508 write_string ("Sa");
509 return 1;
510 }
511
512 /* Check for std::basic_string. */
513 if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
514 {
515 if (TYPE_P (node))
516 {
517 /* If this is a type (i.e. a fully-qualified template-id),
518 check for
519 std::basic_string <char,
520 std::char_traits<char>,
521 std::allocator<char> > . */
522 if (cp_type_quals (type) == TYPE_UNQUALIFIED
523 && CLASSTYPE_USE_TEMPLATE (type))
524 {
525 tree args = CLASSTYPE_TI_ARGS (type);
526 if (TREE_VEC_LENGTH (args) == 3
527 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
528 && is_std_substitution_char (TREE_VEC_ELT (args, 1),
529 SUBID_CHAR_TRAITS)
530 && is_std_substitution_char (TREE_VEC_ELT (args, 2),
531 SUBID_ALLOCATOR))
532 {
533 write_string ("Ss");
534 return 1;
535 }
536 }
537 }
538 else
539 /* Substitute for the template name only if this isn't a type. */
540 {
541 write_string ("Sb");
542 return 1;
543 }
544 }
545
546 /* Check for basic_{i,o,io}stream. */
547 if (TYPE_P (node)
548 && cp_type_quals (type) == TYPE_UNQUALIFIED
549 && CLASS_TYPE_P (type)
550 && CLASSTYPE_USE_TEMPLATE (type)
551 && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
552 {
553 /* First, check for the template
554 args <char, std::char_traits<char> > . */
555 tree args = CLASSTYPE_TI_ARGS (type);
556 if (TREE_VEC_LENGTH (args) == 2
557 && TYPE_P (TREE_VEC_ELT (args, 0))
558 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node)
559 && is_std_substitution_char (TREE_VEC_ELT (args, 1),
560 SUBID_CHAR_TRAITS))
561 {
562 /* Got them. Is this basic_istream? */
563 if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
564 {
565 write_string ("Si");
566 return 1;
567 }
568 /* Or basic_ostream? */
569 else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
570 {
571 write_string ("So");
572 return 1;
573 }
574 /* Or basic_iostream? */
575 else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
576 {
577 write_string ("Sd");
578 return 1;
579 }
580 }
581 }
582
583 /* Check for namespace std. */
584 if (decl && DECL_NAMESPACE_STD_P (decl))
585 {
586 write_string ("St");
587 return 1;
588 }
589
590 /* Now check the list of available substitutions for this mangling
591 operation. */
592 for (i = 0; i < size; ++i)
593 {
594 tree candidate = VEC_index (tree, G.substitutions, i);
595 /* NODE is a matched to a candidate if it's the same decl node or
596 if it's the same type. */
597 if (decl == candidate
598 || (TYPE_P (candidate) && type && TYPE_P (type)
599 && same_type_p (type, candidate))
600 || NESTED_TEMPLATE_MATCH (node, candidate))
601 {
602 write_substitution (i);
603 return 1;
604 }
605 }
606
607 /* No substitution found. */
608 return 0;
609}
610
611
612/* TOP_LEVEL is true, if this is being called at outermost level of
613 mangling. It should be false when mangling a decl appearing in an
614 expression within some other mangling.
615
616 <mangled-name> ::= _Z <encoding> */
617
618static void
619write_mangled_name (const tree decl, bool top_level)
620{
621 MANGLE_TRACE_TREE ("mangled-name", decl);
622
623 if (/* The names of `extern "C"' functions are not mangled. */
624 DECL_EXTERN_C_FUNCTION_P (decl)
625 /* But overloaded operator names *are* mangled. */
626 && !DECL_OVERLOADED_OPERATOR_P (decl))
627 {
628 unmangled_name:;
629
630 if (top_level)
631 write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
632 else
633 {
634 /* The standard notes: "The <encoding> of an extern "C"
635 function is treated like global-scope data, i.e. as its
636 <source-name> without a type." We cannot write
637 overloaded operators that way though, because it contains
638 characters invalid in assembler. */
639 if (abi_version_at_least (2))
640 write_string ("_Z");
641 else
642 G.need_abi_warning = true;
643 write_source_name (DECL_NAME (decl));
644 }
645 }
646 else if (TREE_CODE (decl) == VAR_DECL
647 /* The names of non-static global variables aren't mangled. */
648 && DECL_EXTERNAL_LINKAGE_P (decl)
649 && (CP_DECL_CONTEXT (decl) == global_namespace
650 /* And neither are `extern "C"' variables. */
651 || DECL_EXTERN_C_P (decl)))
652 {
653 if (top_level || abi_version_at_least (2))
654 goto unmangled_name;
655 else
656 {
657 G.need_abi_warning = true;
658 goto mangled_name;
659 }
660 }
661 else
662 {
663 mangled_name:;
664 write_string ("_Z");
665 write_encoding (decl);
666 if (DECL_LANG_SPECIFIC (decl)
667 && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
668 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)))
669 /* We need a distinct mangled name for these entities, but
670 we should never actually output it. So, we append some
671 characters the assembler won't like. */
672 write_string (" *INTERNAL* ");
673 }
674}
675
676/* <encoding> ::= <function name> <bare-function-type>
677 ::= <data name> */
678
679static void
680write_encoding (const tree decl)
681{
682 MANGLE_TRACE_TREE ("encoding", decl);
683
684 if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
685 {
686 /* For overloaded operators write just the mangled name
687 without arguments. */
688 if (DECL_OVERLOADED_OPERATOR_P (decl))
689 write_name (decl, /*ignore_local_scope=*/0);
690 else
691 write_source_name (DECL_NAME (decl));
692 return;
693 }
694
695 write_name (decl, /*ignore_local_scope=*/0);
696 if (TREE_CODE (decl) == FUNCTION_DECL)
697 {
698 tree fn_type;
699 tree d;
700
701 if (decl_is_template_id (decl, NULL))
702 {
703 fn_type = get_mostly_instantiated_function_type (decl);
704 /* FN_TYPE will not have parameter types for in-charge or
705 VTT parameters. Therefore, we pass NULL_TREE to
706 write_bare_function_type -- otherwise, it will get
707 confused about which artificial parameters to skip. */
708 d = NULL_TREE;
709 }
710 else
711 {
712 fn_type = TREE_TYPE (decl);
713 d = decl;
714 }
715
716 write_bare_function_type (fn_type,
717 (!DECL_CONSTRUCTOR_P (decl)
718 && !DECL_DESTRUCTOR_P (decl)
719 && !DECL_CONV_FN_P (decl)
720 && decl_is_template_id (decl, NULL)),
721 d);
722 }
723}
724
725/* <name> ::= <unscoped-name>
726 ::= <unscoped-template-name> <template-args>
727 ::= <nested-name>
728 ::= <local-name>
729
730 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
731 called from <local-name>, which mangles the enclosing scope
732 elsewhere and then uses this function to mangle just the part
733 underneath the function scope. So don't use the <local-name>
734 production, to avoid an infinite recursion. */
735
736static void
737write_name (tree decl, const int ignore_local_scope)
738{
739 tree context;
740
741 MANGLE_TRACE_TREE ("name", decl);
742
743 if (TREE_CODE (decl) == TYPE_DECL)
744 {
745 /* In case this is a typedef, fish out the corresponding
746 TYPE_DECL for the main variant. */
747 decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
748 context = TYPE_CONTEXT (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
749 }
750 else
751 context = (DECL_CONTEXT (decl) == NULL) ? NULL : CP_DECL_CONTEXT (decl);
752
753 /* A decl in :: or ::std scope is treated specially. The former is
754 mangled using <unscoped-name> or <unscoped-template-name>, the
755 latter with a special substitution. Also, a name that is
756 directly in a local function scope is also mangled with
757 <unscoped-name> rather than a full <nested-name>. */
758 if (context == NULL
759 || context == global_namespace
760 || DECL_NAMESPACE_STD_P (context)
761 || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL))
762 {
763 tree template_info;
764 /* Is this a template instance? */
765 if (decl_is_template_id (decl, &template_info))
766 {
767 /* Yes: use <unscoped-template-name>. */
768 write_unscoped_template_name (TI_TEMPLATE (template_info));
769 write_template_args (TI_ARGS (template_info));
770 }
771 else
772 /* Everything else gets an <unqualified-name>. */
773 write_unscoped_name (decl);
774 }
775 else
776 {
777 /* Handle local names, unless we asked not to (that is, invoked
778 under <local-name>, to handle only the part of the name under
779 the local scope). */
780 if (!ignore_local_scope)
781 {
782 /* Scan up the list of scope context, looking for a
783 function. If we find one, this entity is in local
784 function scope. local_entity tracks context one scope
785 level down, so it will contain the element that's
786 directly in that function's scope, either decl or one of
787 its enclosing scopes. */
788 tree local_entity = decl;
789 while (context != NULL && context != global_namespace)
790 {
791 /* Make sure we're always dealing with decls. */
792 if (context != NULL && TYPE_P (context))
793 context = TYPE_NAME (context);
794 /* Is this a function? */
795 if (TREE_CODE (context) == FUNCTION_DECL)
796 {
797 /* Yes, we have local scope. Use the <local-name>
798 production for the innermost function scope. */
799 write_local_name (context, local_entity, decl);
800 return;
801 }
802 /* Up one scope level. */
803 local_entity = context;
804 context = CP_DECL_CONTEXT (context);
805 }
806
807 /* No local scope found? Fall through to <nested-name>. */
808 }
809
810 /* Other decls get a <nested-name> to encode their scope. */
811 write_nested_name (decl);
812 }
813}
814
815/* <unscoped-name> ::= <unqualified-name>
816 ::= St <unqualified-name> # ::std:: */
817
818static void
819write_unscoped_name (const tree decl)
820{
821 tree context = CP_DECL_CONTEXT (decl);
822
823 MANGLE_TRACE_TREE ("unscoped-name", decl);
824
825 /* Is DECL in ::std? */
826 if (DECL_NAMESPACE_STD_P (context))
827 {
828 write_string ("St");
829 write_unqualified_name (decl);
830 }
831 else
832 {
833 /* If not, it should be either in the global namespace, or directly
834 in a local function scope. */
835 gcc_assert (context == global_namespace
836 || context == NULL
837 || TREE_CODE (context) == FUNCTION_DECL);
838
839 write_unqualified_name (decl);
840 }
841}
842
843/* <unscoped-template-name> ::= <unscoped-name>
844 ::= <substitution> */
845
846static void
847write_unscoped_template_name (const tree decl)
848{
849 MANGLE_TRACE_TREE ("unscoped-template-name", decl);
850
851 if (find_substitution (decl))
852 return;
853 write_unscoped_name (decl);
854 add_substitution (decl);
855}
856
857/* Write the nested name, including CV-qualifiers, of DECL.
858
859 <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
860 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
861
862 <CV-qualifiers> ::= [r] [V] [K] */
863
864static void
865write_nested_name (const tree decl)
866{
867 tree template_info;
868
869 MANGLE_TRACE_TREE ("nested-name", decl);
870
871 write_char ('N');
872
873 /* Write CV-qualifiers, if this is a member function. */
874 if (TREE_CODE (decl) == FUNCTION_DECL
875 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
876 {
877 if (DECL_VOLATILE_MEMFUNC_P (decl))
878 write_char ('V');
879 if (DECL_CONST_MEMFUNC_P (decl))
880 write_char ('K');
881 }
882
883 /* Is this a template instance? */
884 if (decl_is_template_id (decl, &template_info))
885 {
886 /* Yes, use <template-prefix>. */
887 write_template_prefix (decl);
888 write_template_args (TI_ARGS (template_info));
889 }
890 else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
891 {
892 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
893 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
894 {
895 write_template_prefix (decl);
896 write_template_args (TREE_OPERAND (name, 1));
897 }
898 else
899 {
900 write_prefix (CP_DECL_CONTEXT (decl));
901 write_unqualified_name (decl);
902 }
903 }
904 else
905 {
906 /* No, just use <prefix> */
907 write_prefix (DECL_CONTEXT (decl));
908 write_unqualified_name (decl);
909 }
910 write_char ('E');
911}
912
913/* <prefix> ::= <prefix> <unqualified-name>
914 ::= <template-param>
915 ::= <template-prefix> <template-args>
916 ::= # empty
917 ::= <substitution> */
918
919static void
920write_prefix (const tree node)
921{
922 tree decl;
923 /* Non-NULL if NODE represents a template-id. */
924 tree template_info = NULL;
925
926 MANGLE_TRACE_TREE ("prefix", node);
927
928 if (node == NULL
929 || node == global_namespace)
930 return;
931
932 if (find_substitution (node))
933 return;
934
935 if (DECL_P (node))
936 {
937 /* If this is a function decl, that means we've hit function
938 scope, so this prefix must be for a local name. In this
939 case, we're under the <local-name> production, which encodes
940 the enclosing function scope elsewhere. So don't continue
941 here. */
942 if (TREE_CODE (node) == FUNCTION_DECL)
943 return;
944
945 decl = node;
946 decl_is_template_id (decl, &template_info);
947 }
948 else
949 {
950 /* Node is a type. */
951 decl = TYPE_NAME (node);
952 if (CLASSTYPE_TEMPLATE_ID_P (node))
953 template_info = TYPE_TEMPLATE_INFO (node);
954 }
955
956 /* In G++ 3.2, the name of the template parameter was used. */
957 if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
958 && !abi_version_at_least (2))
959 G.need_abi_warning = true;
960
961 if (TREE_CODE (node) == TEMPLATE_TYPE_PARM
962 && abi_version_at_least (2))
963 write_template_param (node);
964 else if (template_info != NULL)
965 /* Templated. */
966 {
967 write_template_prefix (decl);
968 write_template_args (TI_ARGS (template_info));
969 }
970 else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
971 {
972 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
973 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
974 {
975 write_template_prefix (decl);
976 write_template_args (TREE_OPERAND (name, 1));
977 }
978 else
979 {
980 write_prefix (CP_DECL_CONTEXT (decl));
981 write_unqualified_name (decl);
982 }
983 }
984 else
985 /* Not templated. */
986 {
987 write_prefix (CP_DECL_CONTEXT (decl));
988 write_unqualified_name (decl);
989 }
990
991 add_substitution (node);
992}
993
994/* <template-prefix> ::= <prefix> <template component>
995 ::= <template-param>
996 ::= <substitution> */
997
998static void
999write_template_prefix (const tree node)
1000{
1001 tree decl = DECL_P (node) ? node : TYPE_NAME (node);
1002 tree type = DECL_P (node) ? TREE_TYPE (node) : node;
1003 tree context = CP_DECL_CONTEXT (decl);
1004 tree template_info;
1005 tree templ;
1006 tree substitution;
1007
1008 MANGLE_TRACE_TREE ("template-prefix", node);
1009
1010 /* Find the template decl. */
1011 if (decl_is_template_id (decl, &template_info))
1012 templ = TI_TEMPLATE (template_info);
1013 else if (TREE_CODE (type) == TYPENAME_TYPE)
1014 /* For a typename type, all we have is the name. */
1015 templ = DECL_NAME (decl);
1016 else
1017 {
1018 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
1019
1020 templ = TYPE_TI_TEMPLATE (type);
1021 }
1022
1023 /* For a member template, though, the template name for the
1024 innermost name must have all the outer template levels
1025 instantiated. For instance, consider
1026
1027 template<typename T> struct Outer {
1028 template<typename U> struct Inner {};
1029 };
1030
1031 The template name for `Inner' in `Outer<int>::Inner<float>' is
1032 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1033 levels separately, so there's no TEMPLATE_DECL available for this
1034 (there's only `Outer<T>::Inner<U>').
1035
1036 In order to get the substitutions right, we create a special
1037 TREE_LIST to represent the substitution candidate for a nested
1038 template. The TREE_PURPOSE is the template's context, fully
1039 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1040 template.
1041
1042 So, for the example above, `Outer<int>::Inner' is represented as a
1043 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1044 and whose value is `Outer<T>::Inner<U>'. */
1045 if (TYPE_P (context))
1046 substitution = build_tree_list (context, templ);
1047 else
1048 substitution = templ;
1049
1050 if (find_substitution (substitution))
1051 return;
1052
1053 /* In G++ 3.2, the name of the template template parameter was used. */
1054 if (TREE_TYPE (templ)
1055 && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
1056 && !abi_version_at_least (2))
1057 G.need_abi_warning = true;
1058
1059 if (TREE_TYPE (templ)
1060 && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
1061 && abi_version_at_least (2))
1062 write_template_param (TREE_TYPE (templ));
1063 else
1064 {
1065 write_prefix (context);
1066 write_unqualified_name (decl);
1067 }
1068
1069 add_substitution (substitution);
1070}
1071
1072/* We don't need to handle thunks, vtables, or VTTs here. Those are
1073 mangled through special entry points.
1074
1075 <unqualified-name> ::= <operator-name>
1076 ::= <special-name>
1077 ::= <source-name>
1078 ::= <local-source-name>
1079
1080 <local-source-name> ::= L <source-name> <discriminator> */
1081
1082static void
1083write_unqualified_name (const tree decl)
1084{
1085 MANGLE_TRACE_TREE ("unqualified-name", decl);
1086
1087 if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_CONSTRUCTOR_P (decl))
1088 write_special_name_constructor (decl);
1089 else if (DECL_LANG_SPECIFIC (decl) != NULL && DECL_DESTRUCTOR_P (decl))
1090 write_special_name_destructor (decl);
1091 else if (DECL_NAME (decl) == NULL_TREE)
1092 {
1093 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
1094 write_source_name (DECL_ASSEMBLER_NAME (decl));
1095 }
1096 else if (DECL_CONV_FN_P (decl))
1097 {
1098 /* Conversion operator. Handle it right here.
1099 <operator> ::= cv <type> */
1100 tree type;
1101 if (decl_is_template_id (decl, NULL))
1102 {
1103 tree fn_type;
1104 fn_type = get_mostly_instantiated_function_type (decl);
1105 type = TREE_TYPE (fn_type);
1106 }
1107 else
1108 type = DECL_CONV_FN_TYPE (decl);
1109 write_conversion_operator_name (type);
1110 }
1111 else if (DECL_OVERLOADED_OPERATOR_P (decl))
1112 {
1113 operator_name_info_t *oni;
1114 if (DECL_ASSIGNMENT_OPERATOR_P (decl))
1115 oni = assignment_operator_name_info;
1116 else
1117 oni = operator_name_info;
1118
1119 write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name);
1120 }
1121 else if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
1122 && DECL_NAMESPACE_SCOPE_P (decl)
1123 && decl_linkage (decl) == lk_internal)
1124 {
1125 MANGLE_TRACE_TREE ("local-source-name", decl);
1126 write_char ('L');
1127 write_source_name (DECL_NAME (decl));
1128 /* The default discriminator is 1, and that's all we ever use,
1129 so there's no code to output one here. */
1130 }
1131 else
1132 write_source_name (DECL_NAME (decl));
1133}
1134
1135/* Write the unqualified-name for a conversion operator to TYPE. */
1136
1137static void
1138write_conversion_operator_name (const tree type)
1139{
1140 write_string ("cv");
1141 write_type (type);
1142}
1143
1144/* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1145
1146 <source-name> ::= </length/ number> <identifier> */
1147
1148static void
1149write_source_name (tree identifier)
1150{
1151 MANGLE_TRACE_TREE ("source-name", identifier);
1152
1153 /* Never write the whole template-id name including the template
1154 arguments; we only want the template name. */
1155 if (IDENTIFIER_TEMPLATE (identifier))
1156 identifier = IDENTIFIER_TEMPLATE (identifier);
1157
1158 write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1159 write_identifier (IDENTIFIER_POINTER (identifier));
1160}
1161
1162/* Convert NUMBER to ascii using base BASE and generating at least
1163 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1164 into which to store the characters. Returns the number of
1165 characters generated (these will be layed out in advance of where
1166 BUFFER points). */
1167
1168static int
1169hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
1170 char *buffer, const unsigned int min_digits)
1171{
1172 static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1173 unsigned digits = 0;
1174
1175 while (number)
1176 {
1177 unsigned HOST_WIDE_INT d = number / base;
1178
1179 *--buffer = base_digits[number - d * base];
1180 digits++;
1181 number = d;
1182 }
1183 while (digits < min_digits)
1184 {
1185 *--buffer = base_digits[0];
1186 digits++;
1187 }
1188 return digits;
1189}
1190
1191/* Non-terminal <number>.
1192
1193 <number> ::= [n] </decimal integer/> */
1194
1195static void
1196write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
1197 const unsigned int base)
1198{
1199 char buffer[sizeof (HOST_WIDE_INT) * 8];
1200 unsigned count = 0;
1201
1202 if (!unsigned_p && (HOST_WIDE_INT) number < 0)
1203 {
1204 write_char ('n');
1205 number = -((HOST_WIDE_INT) number);
1206 }
1207 count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1208 write_chars (buffer + sizeof (buffer) - count, count);
1209}
1210
1211/* Write out an integral CST in decimal. Most numbers are small, and
1212 representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1213 bigger than that, which we must deal with. */
1214
1215static inline void
1216write_integer_cst (const tree cst)
1217{
1218 int sign = tree_int_cst_sgn (cst);
1219
1220 if (TREE_INT_CST_HIGH (cst) + (sign < 0))
1221 {
1222 /* A bignum. We do this in chunks, each of which fits in a
1223 HOST_WIDE_INT. */
1224 char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
1225 unsigned HOST_WIDE_INT chunk;
1226 unsigned chunk_digits;
1227 char *ptr = buffer + sizeof (buffer);
1228 unsigned count = 0;
1229 tree n, base, type;
1230 int done;
1231
1232 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1233 representable. */
1234 chunk = 1000000000;
1235 chunk_digits = 9;
1236
1237 if (sizeof (HOST_WIDE_INT) >= 8)
1238 {
1239 /* It is at least 64 bits, so 10^18 is representable. */
1240 chunk_digits = 18;
1241 chunk *= chunk;
1242 }
1243
1244 type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
1245 base = build_int_cstu (type, chunk);
1246 n = build_int_cst_wide (type,
1247 TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
1248
1249 if (sign < 0)
1250 {
1251 write_char ('n');
1252 n = fold_build1 (NEGATE_EXPR, type, n);
1253 }
1254 do
1255 {
1256 tree d = fold_build2 (FLOOR_DIV_EXPR, type, n, base);
1257 tree tmp = fold_build2 (MULT_EXPR, type, d, base);
1258 unsigned c;
1259
1260 done = integer_zerop (d);
1261 tmp = fold_build2 (MINUS_EXPR, type, n, tmp);
1262 c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
1263 done ? 1 : chunk_digits);
1264 ptr -= c;
1265 count += c;
1266 n = d;
1267 }
1268 while (!done);
1269 write_chars (ptr, count);
1270 }
1271 else
1272 {
1273 /* A small num. */
1274 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
1275
1276 if (sign < 0)
1277 {
1278 write_char ('n');
1279 low = -low;
1280 }
1281 write_unsigned_number (low);
1282 }
1283}
1284
1285/* Write out a floating-point literal.
1286
1287 "Floating-point literals are encoded using the bit pattern of the
1288 target processor's internal representation of that number, as a
1289 fixed-length lowercase hexadecimal string, high-order bytes first
1290 (even if the target processor would store low-order bytes first).
1291 The "n" prefix is not used for floating-point literals; the sign
1292 bit is encoded with the rest of the number.
1293
1294 Here are some examples, assuming the IEEE standard representation
1295 for floating point numbers. (Spaces are for readability, not
1296 part of the encoding.)
1297
1298 1.0f Lf 3f80 0000 E
1299 -1.0f Lf bf80 0000 E
1300 1.17549435e-38f Lf 0080 0000 E
1301 1.40129846e-45f Lf 0000 0001 E
1302 0.0f Lf 0000 0000 E"
1303
1304 Caller is responsible for the Lx and the E. */
1305static void
1306write_real_cst (const tree value)
1307{
1308 if (abi_version_at_least (2))
1309 {
1310 long target_real[4]; /* largest supported float */
1311 char buffer[9]; /* eight hex digits in a 32-bit number */
1312 int i, limit, dir;
1313
1314 tree type = TREE_TYPE (value);
1315 int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32;
1316
1317 real_to_target (target_real, &TREE_REAL_CST (value),
1318 TYPE_MODE (type));
1319
1320 /* The value in target_real is in the target word order,
1321 so we must write it out backward if that happens to be
1322 little-endian. write_number cannot be used, it will
1323 produce uppercase. */
1324 if (FLOAT_WORDS_BIG_ENDIAN)
1325 i = 0, limit = words, dir = 1;
1326 else
1327 i = words - 1, limit = -1, dir = -1;
1328
1329 for (; i != limit; i += dir)
1330 {
1331 sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
1332 write_chars (buffer, 8);
1333 }
1334 }
1335 else
1336 {
1337 /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out
1338 literally. Note that compatibility with 3.2 is impossible,
1339 because the old floating-point emulator used a different
1340 format for REAL_VALUE_TYPE. */
1341 size_t i;
1342 for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i)
1343 write_number (((unsigned char *) &TREE_REAL_CST (value))[i],
1344 /*unsigned_p*/ 1,
1345 /*base*/ 16);
1346 G.need_abi_warning = 1;
1347 }
1348}
1349
1350/* Non-terminal <identifier>.
1351
1352 <identifier> ::= </unqualified source code identifier> */
1353
1354static void
1355write_identifier (const char *identifier)
1356{
1357 MANGLE_TRACE ("identifier", identifier);
1358 write_string (identifier);
1359}
1360
1361/* Handle constructor productions of non-terminal <special-name>.
1362 CTOR is a constructor FUNCTION_DECL.
1363
1364 <special-name> ::= C1 # complete object constructor
1365 ::= C2 # base object constructor
1366 ::= C3 # complete object allocating constructor
1367
1368 Currently, allocating constructors are never used.
1369
1370 We also need to provide mangled names for the maybe-in-charge
1371 constructor, so we treat it here too. mangle_decl_string will
1372 append *INTERNAL* to that, to make sure we never emit it. */
1373
1374static void
1375write_special_name_constructor (const tree ctor)
1376{
1377 if (DECL_BASE_CONSTRUCTOR_P (ctor))
1378 write_string ("C2");
1379 else
1380 {
1381 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor)
1382 /* Even though we don't ever emit a definition of
1383 the old-style destructor, we still have to
1384 consider entities (like static variables) nested
1385 inside it. */
1386 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor));
1387 write_string ("C1");
1388 }
1389}
1390
1391/* Handle destructor productions of non-terminal <special-name>.
1392 DTOR is a destructor FUNCTION_DECL.
1393
1394 <special-name> ::= D0 # deleting (in-charge) destructor
1395 ::= D1 # complete object (in-charge) destructor
1396 ::= D2 # base object (not-in-charge) destructor
1397
1398 We also need to provide mangled names for the maybe-incharge
1399 destructor, so we treat it here too. mangle_decl_string will
1400 append *INTERNAL* to that, to make sure we never emit it. */
1401
1402static void
1403write_special_name_destructor (const tree dtor)
1404{
1405 if (DECL_DELETING_DESTRUCTOR_P (dtor))
1406 write_string ("D0");
1407 else if (DECL_BASE_DESTRUCTOR_P (dtor))
1408 write_string ("D2");
1409 else
1410 {
1411 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor)
1412 /* Even though we don't ever emit a definition of
1413 the old-style destructor, we still have to
1414 consider entities (like static variables) nested
1415 inside it. */
1416 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor));
1417 write_string ("D1");
1418 }
1419}
1420
1421/* Return the discriminator for ENTITY appearing inside
1422 FUNCTION. The discriminator is the lexical ordinal of VAR among
1423 entities with the same name in the same FUNCTION. */
1424
1425static int
1426discriminator_for_local_entity (tree entity)
1427{
1428 /* Assume this is the only local entity with this name. */
1429 int discriminator = 0;
1430
1431 if (DECL_DISCRIMINATOR_P (entity) && DECL_LANG_SPECIFIC (entity))
1432 discriminator = DECL_DISCRIMINATOR (entity);
1433 else if (TREE_CODE (entity) == TYPE_DECL)
1434 {
1435 int ix;
1436
1437 /* Scan the list of local classes. */
1438 entity = TREE_TYPE (entity);
1439 for (ix = 0; ; ix++)
1440 {
1441 tree type = VEC_index (tree, local_classes, ix);
1442 if (type == entity)
1443 break;
1444 if (TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (entity)
1445 && TYPE_CONTEXT (type) == TYPE_CONTEXT (entity))
1446 ++discriminator;
1447 }
1448 }
1449
1450 return discriminator;
1451}
1452
1453/* Return the discriminator for STRING, a string literal used inside
1454 FUNCTION. The discriminator is the lexical ordinal of STRING among
1455 string literals used in FUNCTION. */
1456
1457static int
1458discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED,
1459 tree string ATTRIBUTE_UNUSED)
1460{
1461 /* For now, we don't discriminate amongst string literals. */
1462 return 0;
1463}
1464
1465/* <discriminator> := _ <number>
1466
1467 The discriminator is used only for the second and later occurrences
1468 of the same name within a single function. In this case <number> is
1469 n - 2, if this is the nth occurrence, in lexical order. */
1470
1471static void
1472write_discriminator (const int discriminator)
1473{
1474 /* If discriminator is zero, don't write anything. Otherwise... */
1475 if (discriminator > 0)
1476 {
1477 write_char ('_');
1478 write_unsigned_number (discriminator - 1);
1479 }
1480}
1481
1482/* Mangle the name of a function-scope entity. FUNCTION is the
1483 FUNCTION_DECL for the enclosing function. ENTITY is the decl for
1484 the entity itself. LOCAL_ENTITY is the entity that's directly
1485 scoped in FUNCTION_DECL, either ENTITY itself or an enclosing scope
1486 of ENTITY.
1487
1488 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
1489 := Z <function encoding> E s [<discriminator>] */
1490
1491static void
1492write_local_name (const tree function, const tree local_entity,
1493 const tree entity)
1494{
1495 MANGLE_TRACE_TREE ("local-name", entity);
1496
1497 write_char ('Z');
1498 write_encoding (function);
1499 write_char ('E');
1500 if (TREE_CODE (entity) == STRING_CST)
1501 {
1502 write_char ('s');
1503 write_discriminator (discriminator_for_string_literal (function,
1504 entity));
1505 }
1506 else
1507 {
1508 /* Now the <entity name>. Let write_name know its being called
1509 from <local-name>, so it doesn't try to process the enclosing
1510 function scope again. */
1511 write_name (entity, /*ignore_local_scope=*/1);
1512 write_discriminator (discriminator_for_local_entity (local_entity));
1513 }
1514}
1515
1516/* Non-terminals <type> and <CV-qualifier>.
1517
1518 <type> ::= <builtin-type>
1519 ::= <function-type>
1520 ::= <class-enum-type>
1521 ::= <array-type>
1522 ::= <pointer-to-member-type>
1523 ::= <template-param>
1524 ::= <substitution>
1525 ::= <CV-qualifier>
1526 ::= P <type> # pointer-to
1527 ::= R <type> # reference-to
1528 ::= C <type> # complex pair (C 2000)
1529 ::= G <type> # imaginary (C 2000) [not supported]
1530 ::= U <source-name> <type> # vendor extended type qualifier
1531
1532 C++0x extensions
1533
1534 <type> ::= RR <type> # rvalue reference-to
1535 <type> ::= Dt <expression> # decltype of an id-expression or
1536 # class member access
1537 <type> ::= DT <expression> # decltype of an expression
1538
1539 TYPE is a type node. */
1540
1541static void
1542write_type (tree type)
1543{
1544 /* This gets set to nonzero if TYPE turns out to be a (possibly
1545 CV-qualified) builtin type. */
1546 int is_builtin_type = 0;
1547
1548 MANGLE_TRACE_TREE ("type", type);
1549
1550 if (type == error_mark_node)
1551 return;
1552
1553 if (find_substitution (type))
1554 return;
1555
1556 if (write_CV_qualifiers_for_type (type) > 0)
1557 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
1558 mangle the unqualified type. The recursive call is needed here
1559 since both the qualified and unqualified types are substitution
1560 candidates. */
1561 write_type (TYPE_MAIN_VARIANT (type));
1562 else if (TREE_CODE (type) == ARRAY_TYPE)
1563 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
1564 so that the cv-qualification of the element type is available
1565 in write_array_type. */
1566 write_array_type (type);
1567 else
1568 {
1569 tree type_orig = type;
1570
1571 /* See through any typedefs. */
1572 type = TYPE_MAIN_VARIANT (type);
1573
1574 if (TYPE_PTRMEM_P (type))
1575 write_pointer_to_member_type (type);
1576 else
1577 {
1578 /* Handle any target-specific fundamental types. */
1579 const char *target_mangling
1580 = targetm.mangle_type (type_orig);
1581
1582 if (target_mangling)
1583 {
1584 write_string (target_mangling);
1585 /* Add substitutions for types other than fundamental
1586 types. */
1587 if (TREE_CODE (type) != VOID_TYPE
1588 && TREE_CODE (type) != INTEGER_TYPE
1589 && TREE_CODE (type) != REAL_TYPE
1590 && TREE_CODE (type) != BOOLEAN_TYPE)
1591 add_substitution (type);
1592 return;
1593 }
1594
1595 switch (TREE_CODE (type))
1596 {
1597 case VOID_TYPE:
1598 case BOOLEAN_TYPE:
1599 case INTEGER_TYPE: /* Includes wchar_t. */
1600 case REAL_TYPE:
1601 case FIXED_POINT_TYPE:
1602 {
1603 /* If this is a typedef, TYPE may not be one of
1604 the standard builtin type nodes, but an alias of one. Use
1605 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
1606 write_builtin_type (TYPE_MAIN_VARIANT (type));
1607 ++is_builtin_type;
1608 }
1609 break;
1610
1611 case COMPLEX_TYPE:
1612 write_char ('C');
1613 write_type (TREE_TYPE (type));
1614 break;
1615
1616 case FUNCTION_TYPE:
1617 case METHOD_TYPE:
1618 write_function_type (type);
1619 break;
1620
1621 case UNION_TYPE:
1622 case RECORD_TYPE:
1623 case ENUMERAL_TYPE:
1624 /* A pointer-to-member function is represented as a special
1625 RECORD_TYPE, so check for this first. */
1626 if (TYPE_PTRMEMFUNC_P (type))
1627 write_pointer_to_member_type (type);
1628 else
1629 write_class_enum_type (type);
1630 break;
1631
1632 case TYPENAME_TYPE:
1633 case UNBOUND_CLASS_TEMPLATE:
1634 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
1635 ordinary nested names. */
1636 write_nested_name (TYPE_STUB_DECL (type));
1637 break;
1638
1639 case POINTER_TYPE:
1640 write_char ('P');
1641 write_type (TREE_TYPE (type));
1642 break;
1643
1644 case REFERENCE_TYPE:
1645 if (TYPE_REF_IS_RVALUE (type))
1646 write_char('O');
1647 else
1648 write_char ('R');
1649 write_type (TREE_TYPE (type));
1650 break;
1651
1652 case TEMPLATE_TYPE_PARM:
1653 case TEMPLATE_PARM_INDEX:
1654 write_template_param (type);
1655 break;
1656
1657 case TEMPLATE_TEMPLATE_PARM:
1658 write_template_template_param (type);
1659 break;
1660
1661 case BOUND_TEMPLATE_TEMPLATE_PARM:
1662 write_template_template_param (type);
1663 write_template_args
1664 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
1665 break;
1666
1667 case VECTOR_TYPE:
1668 write_string ("U8__vector");
1669 write_type (TREE_TYPE (type));
1670 break;
1671
1672 case TYPE_PACK_EXPANSION:
1673 write_string ("Dp");
1674 write_type (PACK_EXPANSION_PATTERN (type));
1675 break;
1676
1677 case DECLTYPE_TYPE:
1678 write_char ('D');
1679 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
1680 write_char ('t');
1681 else
1682 write_char ('T');
1683 ++skip_evaluation;
1684 write_expression (DECLTYPE_TYPE_EXPR (type));
1685 --skip_evaluation;
1686 write_char ('E');
1687 break;
1688
1689 case TYPEOF_TYPE:
1690 sorry ("mangling typeof, use decltype instead");
1691 break;
1692
1693 default:
1694 gcc_unreachable ();
1695 }
1696 }
1697 }
1698
1699 /* Types other than builtin types are substitution candidates. */
1700 if (!is_builtin_type)
1701 add_substitution (type);
1702}
1703
1704/* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
1705 CV-qualifiers written for TYPE.
1706
1707 <CV-qualifiers> ::= [r] [V] [K] */
1708
1709static int
1710write_CV_qualifiers_for_type (const tree type)
1711{
1712 int num_qualifiers = 0;
1713
1714 /* The order is specified by:
1715
1716 "In cases where multiple order-insensitive qualifiers are
1717 present, they should be ordered 'K' (closest to the base type),
1718 'V', 'r', and 'U' (farthest from the base type) ..."
1719
1720 Note that we do not use cp_type_quals below; given "const
1721 int[3]", the "const" is emitted with the "int", not with the
1722 array. */
1723
1724 if (TYPE_QUALS (type) & TYPE_QUAL_RESTRICT)
1725 {
1726 write_char ('r');
1727 ++num_qualifiers;
1728 }
1729 if (TYPE_QUALS (type) & TYPE_QUAL_VOLATILE)
1730 {
1731 write_char ('V');
1732 ++num_qualifiers;
1733 }
1734 if (TYPE_QUALS (type) & TYPE_QUAL_CONST)
1735 {
1736 write_char ('K');
1737 ++num_qualifiers;
1738 }
1739
1740 return num_qualifiers;
1741}
1742
1743/* Non-terminal <builtin-type>.
1744
1745 <builtin-type> ::= v # void
1746 ::= b # bool
1747 ::= w # wchar_t
1748 ::= c # char
1749 ::= a # signed char
1750 ::= h # unsigned char
1751 ::= s # short
1752 ::= t # unsigned short
1753 ::= i # int
1754 ::= j # unsigned int
1755 ::= l # long
1756 ::= m # unsigned long
1757 ::= x # long long, __int64
1758 ::= y # unsigned long long, __int64
1759 ::= n # __int128
1760 ::= o # unsigned __int128
1761 ::= f # float
1762 ::= d # double
1763 ::= e # long double, __float80
1764 ::= g # __float128 [not supported]
1765 ::= u <source-name> # vendor extended type */
1766
1767static void
1768write_builtin_type (tree type)
1769{
1770 if (TYPE_CANONICAL (type))
1771 type = TYPE_CANONICAL (type);
1772
1773 switch (TREE_CODE (type))
1774 {
1775 case VOID_TYPE:
1776 write_char ('v');
1777 break;
1778
1779 case BOOLEAN_TYPE:
1780 write_char ('b');
1781 break;
1782
1783 case INTEGER_TYPE:
1784 /* TYPE may still be wchar_t, char16_t, or char32_t, since that
1785 isn't in integer_type_nodes. */
1786 if (type == wchar_type_node)
1787 write_char ('w');
1788 else if (type == char16_type_node)
1789 write_string ("Ds");
1790 else if (type == char32_type_node)
1791 write_string ("Di");
1792 else if (TYPE_FOR_JAVA (type))
1793 write_java_integer_type_codes (type);
1794 else
1795 {
1796 size_t itk;
1797 /* Assume TYPE is one of the shared integer type nodes. Find
1798 it in the array of these nodes. */
1799 iagain:
1800 for (itk = 0; itk < itk_none; ++itk)
1801 if (type == integer_types[itk])
1802 {
1803 /* Print the corresponding single-letter code. */
1804 write_char (integer_type_codes[itk]);
1805 break;
1806 }
1807
1808 if (itk == itk_none)
1809 {
1810 tree t = c_common_type_for_mode (TYPE_MODE (type),
1811 TYPE_UNSIGNED (type));
1812 if (type != t)
1813 {
1814 type = t;
1815 goto iagain;
1816 }
1817
1818 if (TYPE_PRECISION (type) == 128)
1819 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
1820 else
1821 {
1822 /* Allow for cases where TYPE is not one of the shared
1823 integer type nodes and write a "vendor extended builtin
1824 type" with a name the form intN or uintN, respectively.
1825 Situations like this can happen if you have an
1826 __attribute__((__mode__(__SI__))) type and use exotic
1827 switches like '-mint8' on AVR. Of course, this is
1828 undefined by the C++ ABI (and '-mint8' is not even
1829 Standard C conforming), but when using such special
1830 options you're pretty much in nowhere land anyway. */
1831 const char *prefix;
1832 char prec[11]; /* up to ten digits for an unsigned */
1833
1834 prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
1835 sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
1836 write_char ('u'); /* "vendor extended builtin type" */
1837 write_unsigned_number (strlen (prefix) + strlen (prec));
1838 write_string (prefix);
1839 write_string (prec);
1840 }
1841 }
1842 }
1843 break;
1844
1845 case REAL_TYPE:
1846 if (type == float_type_node
1847 || type == java_float_type_node)
1848 write_char ('f');
1849 else if (type == double_type_node
1850 || type == java_double_type_node)
1851 write_char ('d');
1852 else if (type == long_double_type_node)
1853 write_char ('e');
1854 else
1855 gcc_unreachable ();
1856 break;
1857
1858 case FIXED_POINT_TYPE:
1859 write_string ("DF");
1860 if (GET_MODE_IBIT (TYPE_MODE (type)) > 0)
1861 write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type)));
1862 if (type == fract_type_node
1863 || type == sat_fract_type_node
1864 || type == accum_type_node
1865 || type == sat_accum_type_node)
1866 write_char ('i');
1867 else if (type == unsigned_fract_type_node
1868 || type == sat_unsigned_fract_type_node
1869 || type == unsigned_accum_type_node
1870 || type == sat_unsigned_accum_type_node)
1871 write_char ('j');
1872 else if (type == short_fract_type_node
1873 || type == sat_short_fract_type_node
1874 || type == short_accum_type_node
1875 || type == sat_short_accum_type_node)
1876 write_char ('s');
1877 else if (type == unsigned_short_fract_type_node
1878 || type == sat_unsigned_short_fract_type_node
1879 || type == unsigned_short_accum_type_node
1880 || type == sat_unsigned_short_accum_type_node)
1881 write_char ('t');
1882 else if (type == long_fract_type_node
1883 || type == sat_long_fract_type_node
1884 || type == long_accum_type_node
1885 || type == sat_long_accum_type_node)
1886 write_char ('l');
1887 else if (type == unsigned_long_fract_type_node
1888 || type == sat_unsigned_long_fract_type_node
1889 || type == unsigned_long_accum_type_node
1890 || type == sat_unsigned_long_accum_type_node)
1891 write_char ('m');
1892 else if (type == long_long_fract_type_node
1893 || type == sat_long_long_fract_type_node
1894 || type == long_long_accum_type_node
1895 || type == sat_long_long_accum_type_node)
1896 write_char ('x');
1897 else if (type == unsigned_long_long_fract_type_node
1898 || type == sat_unsigned_long_long_fract_type_node
1899 || type == unsigned_long_long_accum_type_node
1900 || type == sat_unsigned_long_long_accum_type_node)
1901 write_char ('y');
1902 else
1903 sorry ("mangling unknown fixed point type");
1904 write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type)));
1905 if (TYPE_SATURATING (type))
1906 write_char ('s');
1907 else
1908 write_char ('n');
1909 break;
1910
1911 default:
1912 gcc_unreachable ();
1913 }
1914}
1915
1916/* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
1917 METHOD_TYPE. The return type is mangled before the parameter
1918 types.
1919
1920 <function-type> ::= F [Y] <bare-function-type> E */
1921
1922static void
1923write_function_type (const tree type)
1924{
1925 MANGLE_TRACE_TREE ("function-type", type);
1926
1927 /* For a pointer to member function, the function type may have
1928 cv-qualifiers, indicating the quals for the artificial 'this'
1929 parameter. */
1930 if (TREE_CODE (type) == METHOD_TYPE)
1931 {
1932 /* The first parameter must be a POINTER_TYPE pointing to the
1933 `this' parameter. */
1934 tree this_type = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
1935 write_CV_qualifiers_for_type (this_type);
1936 }
1937
1938 write_char ('F');
1939 /* We don't track whether or not a type is `extern "C"'. Note that
1940 you can have an `extern "C"' function that does not have
1941 `extern "C"' type, and vice versa:
1942
1943 extern "C" typedef void function_t();
1944 function_t f; // f has C++ linkage, but its type is
1945 // `extern "C"'
1946
1947 typedef void function_t();
1948 extern "C" function_t f; // Vice versa.
1949
1950 See [dcl.link]. */
1951 write_bare_function_type (type, /*include_return_type_p=*/1,
1952 /*decl=*/NULL);
1953 write_char ('E');
1954}
1955
1956/* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
1957 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
1958 is mangled before the parameter types. If non-NULL, DECL is
1959 FUNCTION_DECL for the function whose type is being emitted.
1960
1961 If DECL is a member of a Java type, then a literal 'J'
1962 is output and the return type is mangled as if INCLUDE_RETURN_TYPE
1963 were nonzero.
1964
1965 <bare-function-type> ::= [J]</signature/ type>+ */
1966
1967static void
1968write_bare_function_type (const tree type, const int include_return_type_p,
1969 const tree decl)
1970{
1971 int java_method_p;
1972
1973 MANGLE_TRACE_TREE ("bare-function-type", type);
1974
1975 /* Detect Java methods and emit special encoding. */
1976 if (decl != NULL
1977 && DECL_FUNCTION_MEMBER_P (decl)
1978 && TYPE_FOR_JAVA (DECL_CONTEXT (decl))
1979 && !DECL_CONSTRUCTOR_P (decl)
1980 && !DECL_DESTRUCTOR_P (decl)
1981 && !DECL_CONV_FN_P (decl))
1982 {
1983 java_method_p = 1;
1984 write_char ('J');
1985 }
1986 else
1987 {
1988 java_method_p = 0;
1989 }
1990
1991 /* Mangle the return type, if requested. */
1992 if (include_return_type_p || java_method_p)
1993 write_type (TREE_TYPE (type));
1994
1995 /* Now mangle the types of the arguments. */
1996 write_method_parms (TYPE_ARG_TYPES (type),
1997 TREE_CODE (type) == METHOD_TYPE,
1998 decl);
1999}
2000
2001/* Write the mangled representation of a method parameter list of
2002 types given in PARM_TYPES. If METHOD_P is nonzero, the function is
2003 considered a non-static method, and the this parameter is omitted.
2004 If non-NULL, DECL is the FUNCTION_DECL for the function whose
2005 parameters are being emitted. */
2006
2007static void
2008write_method_parms (tree parm_types, const int method_p, const tree decl)
2009{
2010 tree first_parm_type;
2011 tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
2012
2013 /* Assume this parameter type list is variable-length. If it ends
2014 with a void type, then it's not. */
2015 int varargs_p = 1;
2016
2017 /* If this is a member function, skip the first arg, which is the
2018 this pointer.
2019 "Member functions do not encode the type of their implicit this
2020 parameter."
2021
2022 Similarly, there's no need to mangle artificial parameters, like
2023 the VTT parameters for constructors and destructors. */
2024 if (method_p)
2025 {
2026 parm_types = TREE_CHAIN (parm_types);
2027 parm_decl = parm_decl ? TREE_CHAIN (parm_decl) : NULL_TREE;
2028
2029 while (parm_decl && DECL_ARTIFICIAL (parm_decl))
2030 {
2031 parm_types = TREE_CHAIN (parm_types);
2032 parm_decl = TREE_CHAIN (parm_decl);
2033 }
2034 }
2035
2036 for (first_parm_type = parm_types;
2037 parm_types;
2038 parm_types = TREE_CHAIN (parm_types))
2039 {
2040 tree parm = TREE_VALUE (parm_types);
2041 if (parm == void_type_node)
2042 {
2043 /* "Empty parameter lists, whether declared as () or
2044 conventionally as (void), are encoded with a void parameter
2045 (v)." */
2046 if (parm_types == first_parm_type)
2047 write_type (parm);
2048 /* If the parm list is terminated with a void type, it's
2049 fixed-length. */
2050 varargs_p = 0;
2051 /* A void type better be the last one. */
2052 gcc_assert (TREE_CHAIN (parm_types) == NULL);
2053 }
2054 else
2055 write_type (parm);
2056 }
2057
2058 if (varargs_p)
2059 /* <builtin-type> ::= z # ellipsis */
2060 write_char ('z');
2061}
2062
2063/* <class-enum-type> ::= <name> */
2064
2065static void
2066write_class_enum_type (const tree type)
2067{
2068 write_name (TYPE_NAME (type), /*ignore_local_scope=*/0);
2069}
2070
2071/* Non-terminal <template-args>. ARGS is a TREE_VEC of template
2072 arguments.
2073
4b1e227d 2074 <template-args> ::= I <template-arg>* E */
c251ad9e
SS
2075
2076static void
2077write_template_args (tree args)
2078{
2079 int i;
4b1e227d 2080 int length = 0;
c251ad9e
SS
2081
2082 MANGLE_TRACE_TREE ("template-args", args);
2083
2084 write_char ('I');
2085
4b1e227d
SW
2086 if (args)
2087 length = TREE_VEC_LENGTH (args);
c251ad9e 2088
4b1e227d 2089 if (args && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
c251ad9e
SS
2090 {
2091 /* We have nested template args. We want the innermost template
2092 argument list. */
2093 args = TREE_VEC_ELT (args, length - 1);
2094 length = TREE_VEC_LENGTH (args);
2095 }
2096 for (i = 0; i < length; ++i)
2097 write_template_arg (TREE_VEC_ELT (args, i));
2098
2099 write_char ('E');
2100}
2101
2102/* Write out the
2103 <unqualified-name>
2104 <unqualified-name> <template-args>
2105 part of SCOPE_REF or COMPONENT_REF mangling. */
2106
2107static void
2108write_member_name (tree member)
2109{
2110 if (TREE_CODE (member) == IDENTIFIER_NODE)
2111 write_source_name (member);
2112 else if (DECL_P (member))
4b1e227d 2113 write_unqualified_name (member);
c251ad9e
SS
2114 else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2115 {
2116 tree name = TREE_OPERAND (member, 0);
2117 if (TREE_CODE (name) == OVERLOAD)
2118 name = OVL_FUNCTION (name);
2119 write_member_name (name);
2120 write_template_args (TREE_OPERAND (member, 1));
2121 }
2122 else
2123 write_expression (member);
2124}
2125
2126/* <expression> ::= <unary operator-name> <expression>
2127 ::= <binary operator-name> <expression> <expression>
2128 ::= <expr-primary>
2129
2130 <expr-primary> ::= <template-param>
2131 ::= L <type> <value number> E # literal
2132 ::= L <mangled-name> E # external name
2133 ::= st <type> # sizeof
2134 ::= sr <type> <unqualified-name> # dependent name
2135 ::= sr <type> <unqualified-name> <template-args> */
2136
2137static void
2138write_expression (tree expr)
2139{
2140 enum tree_code code = TREE_CODE (expr);
2141
2142 /* Skip NOP_EXPRs. They can occur when (say) a pointer argument
2143 is converted (via qualification conversions) to another
2144 type. */
2145 while (TREE_CODE (expr) == NOP_EXPR
2146 || TREE_CODE (expr) == NON_LVALUE_EXPR)
2147 {
2148 expr = TREE_OPERAND (expr, 0);
2149 code = TREE_CODE (expr);
2150 }
2151
2152 if (code == BASELINK)
2153 {
2154 expr = BASELINK_FUNCTIONS (expr);
2155 code = TREE_CODE (expr);
2156 }
2157
2158 /* Handle pointers-to-members by making them look like expression
2159 nodes. */
2160 if (code == PTRMEM_CST)
2161 {
2162 expr = build_nt (ADDR_EXPR,
2163 build_qualified_name (/*type=*/NULL_TREE,
2164 PTRMEM_CST_CLASS (expr),
2165 PTRMEM_CST_MEMBER (expr),
2166 /*template_p=*/false));
2167 code = TREE_CODE (expr);
2168 }
2169
2170 /* Handle template parameters. */
2171 if (code == TEMPLATE_TYPE_PARM
2172 || code == TEMPLATE_TEMPLATE_PARM
2173 || code == BOUND_TEMPLATE_TEMPLATE_PARM
2174 || code == TEMPLATE_PARM_INDEX)
2175 write_template_param (expr);
2176 /* Handle literals. */
2177 else if (TREE_CODE_CLASS (code) == tcc_constant
2178 || (abi_version_at_least (2) && code == CONST_DECL))
2179 write_template_arg_literal (expr);
2180 else if (code == PARM_DECL)
2181 {
2182 /* A function parameter used in a late-specified return type. */
2183 int index = parm_index (expr);
2184 write_string ("fp");
2185 if (index > 1)
2186 write_unsigned_number (index - 2);
2187 write_char ('_');
2188 }
2189 else if (DECL_P (expr))
2190 {
2191 /* G++ 3.2 incorrectly mangled non-type template arguments of
2192 enumeration type using their names. */
2193 if (code == CONST_DECL)
2194 G.need_abi_warning = 1;
2195 write_char ('L');
2196 write_mangled_name (expr, false);
2197 write_char ('E');
2198 }
2199 else if (TREE_CODE (expr) == SIZEOF_EXPR
2200 && TYPE_P (TREE_OPERAND (expr, 0)))
2201 {
2202 write_string ("st");
2203 write_type (TREE_OPERAND (expr, 0));
2204 }
2205 else if (TREE_CODE (expr) == ALIGNOF_EXPR
2206 && TYPE_P (TREE_OPERAND (expr, 0)))
2207 {
2208 write_string ("at");
2209 write_type (TREE_OPERAND (expr, 0));
2210 }
4b1e227d 2211 else if (TREE_CODE (expr) == SCOPE_REF)
c251ad9e
SS
2212 {
2213 tree scope = TREE_OPERAND (expr, 0);
2214 tree member = TREE_OPERAND (expr, 1);
2215
4b1e227d
SW
2216 if (!abi_version_at_least (2))
2217 {
2218 write_string ("sr");
2219 write_type (scope);
2220 /* G++ 3.2 incorrectly put out both the "sr" code and
2221 the nested name of the qualified name. */
2222 G.need_abi_warning = 1;
2223 write_encoding (member);
2224 }
2225
c251ad9e
SS
2226 /* If the MEMBER is a real declaration, then the qualifying
2227 scope was not dependent. Ideally, we would not have a
2228 SCOPE_REF in those cases, but sometimes we do. If the second
2229 argument is a DECL, then the name must not have been
2230 dependent. */
4b1e227d 2231 else if (DECL_P (member))
c251ad9e
SS
2232 write_expression (member);
2233 else
2234 {
2235 tree template_args;
2236
2237 write_string ("sr");
2238 write_type (scope);
2239 /* If MEMBER is a template-id, separate the template
2240 from the arguments. */
2241 if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
2242 {
2243 template_args = TREE_OPERAND (member, 1);
2244 member = TREE_OPERAND (member, 0);
2245 }
2246 else
2247 template_args = NULL_TREE;
2248 /* Write out the name of the MEMBER. */
2249 if (IDENTIFIER_TYPENAME_P (member))
2250 write_conversion_operator_name (TREE_TYPE (member));
2251 else if (IDENTIFIER_OPNAME_P (member))
2252 {
2253 int i;
2254 const char *mangled_name = NULL;
2255
2256 /* Unfortunately, there is no easy way to go from the
2257 name of the operator back to the corresponding tree
2258 code. */
2259 for (i = 0; i < MAX_TREE_CODES; ++i)
2260 if (operator_name_info[i].identifier == member)
2261 {
2262 /* The ABI says that we prefer binary operator
2263 names to unary operator names. */
2264 if (operator_name_info[i].arity == 2)
2265 {
2266 mangled_name = operator_name_info[i].mangled_name;
2267 break;
2268 }
2269 else if (!mangled_name)
2270 mangled_name = operator_name_info[i].mangled_name;
2271 }
2272 else if (assignment_operator_name_info[i].identifier
2273 == member)
2274 {
2275 mangled_name
2276 = assignment_operator_name_info[i].mangled_name;
2277 break;
2278 }
2279 write_string (mangled_name);
2280 }
2281 else
2282 write_source_name (member);
2283 /* Write out the template arguments. */
2284 if (template_args)
2285 write_template_args (template_args);
2286 }
2287 }
2288 else if (TREE_CODE (expr) == INDIRECT_REF
2289 && TREE_TYPE (TREE_OPERAND (expr, 0))
2290 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2291 {
2292 write_expression (TREE_OPERAND (expr, 0));
2293 }
2294 else
2295 {
2296 int i;
2297 const char *name;
2298
2299 /* When we bind a variable or function to a non-type template
2300 argument with reference type, we create an ADDR_EXPR to show
2301 the fact that the entity's address has been taken. But, we
2302 don't actually want to output a mangling code for the `&'. */
2303 if (TREE_CODE (expr) == ADDR_EXPR
2304 && TREE_TYPE (expr)
2305 && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE)
2306 {
2307 expr = TREE_OPERAND (expr, 0);
2308 if (DECL_P (expr))
2309 {
2310 write_expression (expr);
2311 return;
2312 }
2313
2314 code = TREE_CODE (expr);
2315 }
2316
2317 if (code == COMPONENT_REF)
2318 {
2319 tree ob = TREE_OPERAND (expr, 0);
2320
2321 if (TREE_CODE (ob) == ARROW_EXPR)
2322 {
2323 write_string (operator_name_info[(int)code].mangled_name);
2324 ob = TREE_OPERAND (ob, 0);
2325 }
2326 else
2327 write_string ("dt");
2328
2329 write_expression (ob);
2330 write_member_name (TREE_OPERAND (expr, 1));
2331 return;
2332 }
2333
2334 /* If it wasn't any of those, recursively expand the expression. */
2335 name = operator_name_info[(int) code].mangled_name;
2336 if (name == NULL)
2337 {
2338 sorry ("mangling %C", code);
2339 return;
2340 }
2341 else
2342 write_string (name);
2343
2344 switch (code)
2345 {
2346 case CALL_EXPR:
2347 {
2348 tree fn = CALL_EXPR_FN (expr);
2349
2350 if (TREE_CODE (fn) == ADDR_EXPR)
2351 fn = TREE_OPERAND (fn, 0);
2352
2353 /* Mangle a dependent name as the name, not whatever happens to
2354 be the first function in the overload set. */
2355 if ((TREE_CODE (fn) == FUNCTION_DECL
2356 || TREE_CODE (fn) == OVERLOAD)
2357 && type_dependent_expression_p_push (expr))
2358 fn = DECL_NAME (get_first_fn (fn));
2359
2360 if (TREE_CODE (fn) == IDENTIFIER_NODE)
2361 write_source_name (fn);
2362 else
2363 write_expression (fn);
2364 }
2365
2366 for (i = 0; i < call_expr_nargs (expr); ++i)
2367 write_expression (CALL_EXPR_ARG (expr, i));
2368 write_char ('E');
2369 break;
2370
2371 case CAST_EXPR:
2372 write_type (TREE_TYPE (expr));
2373 if (list_length (TREE_OPERAND (expr, 0)) == 1)
2374 write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
2375 else
2376 {
2377 tree args = TREE_OPERAND (expr, 0);
2378 write_char ('_');
2379 for (; args; args = TREE_CHAIN (args))
2380 write_expression (TREE_VALUE (args));
2381 write_char ('E');
2382 }
2383 break;
2384
2385 /* FIXME these should have a distinct mangling. */
2386 case STATIC_CAST_EXPR:
2387 case CONST_CAST_EXPR:
2388 write_type (TREE_TYPE (expr));
2389 write_expression (TREE_OPERAND (expr, 0));
2390 break;
2391
2392 case NEW_EXPR:
2393 sorry ("mangling new-expression");
2394 break;
2395
c251ad9e
SS
2396 default:
2397 for (i = 0; i < TREE_OPERAND_LENGTH (expr); ++i)
2398 {
2399 tree operand = TREE_OPERAND (expr, i);
2400 /* As a GNU extension, the middle operand of a
2401 conditional may be omitted. Since expression
2402 manglings are supposed to represent the input token
2403 stream, there's no good way to mangle such an
2404 expression without extending the C++ ABI. */
2405 if (code == COND_EXPR && i == 1 && !operand)
2406 {
2407 error ("omitted middle operand to %<?:%> operand "
2408 "cannot be mangled");
2409 continue;
2410 }
2411 write_expression (operand);
2412 }
2413 }
2414 }
2415}
2416
2417/* Literal subcase of non-terminal <template-arg>.
2418
2419 "Literal arguments, e.g. "A<42L>", are encoded with their type
2420 and value. Negative integer values are preceded with "n"; for
2421 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
2422 encoded as 0, true as 1." */
2423
2424static void
2425write_template_arg_literal (const tree value)
2426{
2427 write_char ('L');
2428 write_type (TREE_TYPE (value));
2429
2430 switch (TREE_CODE (value))
2431 {
2432 case CONST_DECL:
2433 write_integer_cst (DECL_INITIAL (value));
2434 break;
2435
2436 case INTEGER_CST:
2437 gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
2438 || integer_zerop (value) || integer_onep (value));
2439 write_integer_cst (value);
2440 break;
2441
2442 case REAL_CST:
2443 write_real_cst (value);
2444 break;
2445
2446 default:
2447 gcc_unreachable ();
2448 }
2449
2450 write_char ('E');
2451}
2452
2453/* Non-terminal <template-arg>.
2454
2455 <template-arg> ::= <type> # type
2456 ::= L <type> </value/ number> E # literal
2457 ::= LZ <name> E # external name
2458 ::= X <expression> E # expression */
2459
2460static void
2461write_template_arg (tree node)
2462{
2463 enum tree_code code = TREE_CODE (node);
2464
2465 MANGLE_TRACE_TREE ("template-arg", node);
2466
2467 /* A template template parameter's argument list contains TREE_LIST
2468 nodes of which the value field is the actual argument. */
2469 if (code == TREE_LIST)
2470 {
2471 node = TREE_VALUE (node);
2472 /* If it's a decl, deal with its type instead. */
2473 if (DECL_P (node))
2474 {
2475 node = TREE_TYPE (node);
2476 code = TREE_CODE (node);
2477 }
2478 }
2479
2480 if (TREE_CODE (node) == NOP_EXPR
2481 && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE)
2482 {
2483 /* Template parameters can be of reference type. To maintain
2484 internal consistency, such arguments use a conversion from
2485 address of object to reference type. */
2486 gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
2487 if (abi_version_at_least (2))
2488 node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
2489 else
2490 G.need_abi_warning = 1;
2491 }
2492
2493 if (ARGUMENT_PACK_P (node))
2494 {
2495 /* Expand the template argument pack. */
2496 tree args = ARGUMENT_PACK_ARGS (node);
2497 int i, length = TREE_VEC_LENGTH (args);
2498 write_char ('I');
2499 for (i = 0; i < length; ++i)
2500 write_template_arg (TREE_VEC_ELT (args, i));
2501 write_char ('E');
2502 }
2503 else if (TYPE_P (node))
2504 write_type (node);
2505 else if (code == TEMPLATE_DECL)
2506 /* A template appearing as a template arg is a template template arg. */
2507 write_template_template_arg (node);
2508 else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
2509 || (abi_version_at_least (2) && code == CONST_DECL))
2510 write_template_arg_literal (node);
2511 else if (DECL_P (node))
2512 {
2513 /* Until ABI version 2, non-type template arguments of
2514 enumeration type were mangled using their names. */
2515 if (code == CONST_DECL && !abi_version_at_least (2))
2516 G.need_abi_warning = 1;
2517 write_char ('L');
2518 /* Until ABI version 3, the underscore before the mangled name
2519 was incorrectly omitted. */
2520 if (!abi_version_at_least (3))
2521 {
2522 G.need_abi_warning = 1;
2523 write_char ('Z');
2524 }
2525 else
2526 write_string ("_Z");
2527 write_encoding (node);
2528 write_char ('E');
2529 }
2530 else
2531 {
2532 /* Template arguments may be expressions. */
2533 write_char ('X');
2534 write_expression (node);
2535 write_char ('E');
2536 }
2537}
2538
2539/* <template-template-arg>
2540 ::= <name>
2541 ::= <substitution> */
2542
2543static void
2544write_template_template_arg (const tree decl)
2545{
2546 MANGLE_TRACE_TREE ("template-template-arg", decl);
2547
2548 if (find_substitution (decl))
2549 return;
2550 write_name (decl, /*ignore_local_scope=*/0);
2551 add_substitution (decl);
2552}
2553
2554
2555/* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
2556
2557 <array-type> ::= A [</dimension/ number>] _ </element/ type>
2558 ::= A <expression> _ </element/ type>
2559
2560 "Array types encode the dimension (number of elements) and the
2561 element type. For variable length arrays, the dimension (but not
2562 the '_' separator) is omitted." */
2563
2564static void
2565write_array_type (const tree type)
2566{
2567 write_char ('A');
2568 if (TYPE_DOMAIN (type))
2569 {
2570 tree index_type;
2571 tree max;
2572
2573 index_type = TYPE_DOMAIN (type);
2574 /* The INDEX_TYPE gives the upper and lower bounds of the
2575 array. */
2576 max = TYPE_MAX_VALUE (index_type);
2577 if (TREE_CODE (max) == INTEGER_CST)
2578 {
2579 /* The ABI specifies that we should mangle the number of
2580 elements in the array, not the largest allowed index. */
2581 max = size_binop (PLUS_EXPR, max, size_one_node);
2582 write_unsigned_number (tree_low_cst (max, 1));
2583 }
2584 else
2585 {
2586 max = TREE_OPERAND (max, 0);
2587 if (!abi_version_at_least (2))
2588 {
2589 /* value_dependent_expression_p presumes nothing is
2590 dependent when PROCESSING_TEMPLATE_DECL is zero. */
2591 ++processing_template_decl;
2592 if (!value_dependent_expression_p (max))
2593 G.need_abi_warning = 1;
2594 --processing_template_decl;
2595 }
2596 write_expression (max);
2597 }
2598
2599 }
2600 write_char ('_');
2601 write_type (TREE_TYPE (type));
2602}
2603
2604/* Non-terminal <pointer-to-member-type> for pointer-to-member
2605 variables. TYPE is a pointer-to-member POINTER_TYPE.
2606
2607 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
2608
2609static void
2610write_pointer_to_member_type (const tree type)
2611{
2612 write_char ('M');
2613 write_type (TYPE_PTRMEM_CLASS_TYPE (type));
2614 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
2615}
2616
2617/* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
2618 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
2619 TEMPLATE_PARM_INDEX.
2620
2621 <template-param> ::= T </parameter/ number> _ */
2622
2623static void
2624write_template_param (const tree parm)
2625{
2626 int parm_index;
2627 int parm_level;
2628 tree parm_type = NULL_TREE;
2629
2630 MANGLE_TRACE_TREE ("template-parm", parm);
2631
2632 switch (TREE_CODE (parm))
2633 {
2634 case TEMPLATE_TYPE_PARM:
2635 case TEMPLATE_TEMPLATE_PARM:
2636 case BOUND_TEMPLATE_TEMPLATE_PARM:
2637 parm_index = TEMPLATE_TYPE_IDX (parm);
2638 parm_level = TEMPLATE_TYPE_LEVEL (parm);
2639 break;
2640
2641 case TEMPLATE_PARM_INDEX:
2642 parm_index = TEMPLATE_PARM_IDX (parm);
2643 parm_level = TEMPLATE_PARM_LEVEL (parm);
2644 parm_type = TREE_TYPE (TEMPLATE_PARM_DECL (parm));
2645 break;
2646
2647 default:
2648 gcc_unreachable ();
2649 }
2650
2651 write_char ('T');
2652 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
2653 earliest template param denoted by `_'. */
2654 if (parm_index > 0)
2655 write_unsigned_number (parm_index - 1);
2656 write_char ('_');
2657}
2658
2659/* <template-template-param>
2660 ::= <template-param>
2661 ::= <substitution> */
2662
2663static void
2664write_template_template_param (const tree parm)
2665{
2666 tree templ = NULL_TREE;
2667
2668 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
2669 template template parameter. The substitution candidate here is
2670 only the template. */
2671 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
2672 {
2673 templ
2674 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
2675 if (find_substitution (templ))
2676 return;
2677 }
2678
2679 /* <template-param> encodes only the template parameter position,
2680 not its template arguments, which is fine here. */
2681 write_template_param (parm);
2682 if (templ)
2683 add_substitution (templ);
2684}
2685
2686/* Non-terminal <substitution>.
2687
2688 <substitution> ::= S <seq-id> _
2689 ::= S_ */
2690
2691static void
2692write_substitution (const int seq_id)
2693{
2694 MANGLE_TRACE ("substitution", "");
2695
2696 write_char ('S');
2697 if (seq_id > 0)
2698 write_number (seq_id - 1, /*unsigned=*/1, 36);
2699 write_char ('_');
2700}
2701
2702/* Start mangling ENTITY. */
2703
2704static inline void
2705start_mangling (const tree entity)
2706{
2707 G.entity = entity;
2708 G.need_abi_warning = false;
2709 obstack_free (&name_obstack, name_base);
2710 mangle_obstack = &name_obstack;
2711 name_base = obstack_alloc (&name_obstack, 0);
2712}
2713
2714/* Done with mangling. If WARN is true, and the name of G.entity will
2715 be mangled differently in a future version of the ABI, issue a
2716 warning. */
2717
2718static void
2719finish_mangling_internal (const bool warn)
2720{
2721 if (warn_abi && warn && G.need_abi_warning)
2722 warning (OPT_Wabi, "the mangled name of %qD will change in a future "
2723 "version of GCC",
2724 G.entity);
2725
2726 /* Clear all the substitutions. */
2727 VEC_truncate (tree, G.substitutions, 0);
2728
2729 /* Null-terminate the string. */
2730 write_char ('\0');
2731}
2732
2733
2734/* Like finish_mangling_internal, but return the mangled string. */
2735
2736static inline const char *
2737finish_mangling (const bool warn)
2738{
2739 finish_mangling_internal (warn);
2740 return (const char *) obstack_finish (mangle_obstack);
2741}
2742
2743/* Like finish_mangling_internal, but return an identifier. */
2744
2745static tree
2746finish_mangling_get_identifier (const bool warn)
2747{
2748 finish_mangling_internal (warn);
2749 /* Don't obstack_finish here, and the next start_mangling will
2750 remove the identifier. */
4b1e227d 2751 return get_identifier ((const char *) obstack_base (mangle_obstack));
c251ad9e
SS
2752}
2753
2754/* Initialize data structures for mangling. */
2755
2756void
2757init_mangle (void)
2758{
2759 gcc_obstack_init (&name_obstack);
2760 name_base = obstack_alloc (&name_obstack, 0);
2761 G.substitutions = NULL;
2762
2763 /* Cache these identifiers for quick comparison when checking for
2764 standard substitutions. */
2765 subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
2766 subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
2767 subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
2768 subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
2769 subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
2770 subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
2771}
2772
2773/* Generate the mangled name of DECL. */
2774
2775static tree
2776mangle_decl_string (const tree decl)
2777{
2778 tree result;
2779
2780 start_mangling (decl);
2781
2782 if (TREE_CODE (decl) == TYPE_DECL)
2783 write_type (TREE_TYPE (decl));
2784 else
2785 write_mangled_name (decl, true);
2786
2787 result = finish_mangling_get_identifier (/*warn=*/true);
2788 if (DEBUG_MANGLE)
2789 fprintf (stderr, "mangle_decl_string = '%s'\n\n",
2790 IDENTIFIER_POINTER (result));
2791 return result;
2792}
2793
2794/* Create an identifier for the external mangled name of DECL. */
2795
2796void
2797mangle_decl (const tree decl)
2798{
2799 tree id = mangle_decl_string (decl);
2800 id = targetm.mangle_decl_assembler_name (decl, id);
2801 SET_DECL_ASSEMBLER_NAME (decl, id);
2802}
2803
2804/* Generate the mangled representation of TYPE. */
2805
2806const char *
2807mangle_type_string (const tree type)
2808{
2809 const char *result;
2810
2811 start_mangling (type);
2812 write_type (type);
2813 result = finish_mangling (/*warn=*/false);
2814 if (DEBUG_MANGLE)
2815 fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
2816 return result;
2817}
2818
2819/* Create an identifier for the mangled name of a special component
2820 for belonging to TYPE. CODE is the ABI-specified code for this
2821 component. */
2822
2823static tree
2824mangle_special_for_type (const tree type, const char *code)
2825{
2826 tree result;
2827
2828 /* We don't have an actual decl here for the special component, so
2829 we can't just process the <encoded-name>. Instead, fake it. */
2830 start_mangling (type);
2831
2832 /* Start the mangling. */
2833 write_string ("_Z");
2834 write_string (code);
2835
2836 /* Add the type. */
2837 write_type (type);
2838 result = finish_mangling_get_identifier (/*warn=*/false);
2839
2840 if (DEBUG_MANGLE)
2841 fprintf (stderr, "mangle_special_for_type = %s\n\n",
2842 IDENTIFIER_POINTER (result));
2843
2844 return result;
2845}
2846
2847/* Create an identifier for the mangled representation of the typeinfo
2848 structure for TYPE. */
2849
2850tree
2851mangle_typeinfo_for_type (const tree type)
2852{
2853 return mangle_special_for_type (type, "TI");
2854}
2855
2856/* Create an identifier for the mangled name of the NTBS containing
2857 the mangled name of TYPE. */
2858
2859tree
2860mangle_typeinfo_string_for_type (const tree type)
2861{
2862 return mangle_special_for_type (type, "TS");
2863}
2864
2865/* Create an identifier for the mangled name of the vtable for TYPE. */
2866
2867tree
2868mangle_vtbl_for_type (const tree type)
2869{
2870 return mangle_special_for_type (type, "TV");
2871}
2872
2873/* Returns an identifier for the mangled name of the VTT for TYPE. */
2874
2875tree
2876mangle_vtt_for_type (const tree type)
2877{
2878 return mangle_special_for_type (type, "TT");
2879}
2880
2881/* Return an identifier for a construction vtable group. TYPE is
2882 the most derived class in the hierarchy; BINFO is the base
2883 subobject for which this construction vtable group will be used.
2884
2885 This mangling isn't part of the ABI specification; in the ABI
2886 specification, the vtable group is dumped in the same COMDAT as the
2887 main vtable, and is referenced only from that vtable, so it doesn't
2888 need an external name. For binary formats without COMDAT sections,
2889 though, we need external names for the vtable groups.
2890
2891 We use the production
2892
2893 <special-name> ::= CT <type> <offset number> _ <base type> */
2894
2895tree
2896mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
2897{
2898 tree result;
2899
2900 start_mangling (type);
2901
2902 write_string ("_Z");
2903 write_string ("TC");
2904 write_type (type);
2905 write_integer_cst (BINFO_OFFSET (binfo));
2906 write_char ('_');
2907 write_type (BINFO_TYPE (binfo));
2908
2909 result = finish_mangling_get_identifier (/*warn=*/false);
2910 if (DEBUG_MANGLE)
2911 fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
2912 IDENTIFIER_POINTER (result));
2913 return result;
2914}
2915
2916/* Mangle a this pointer or result pointer adjustment.
2917
2918 <call-offset> ::= h <fixed offset number> _
2919 ::= v <fixed offset number> _ <virtual offset number> _ */
2920
2921static void
2922mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
2923{
2924 write_char (virtual_offset ? 'v' : 'h');
2925
2926 /* For either flavor, write the fixed offset. */
2927 write_integer_cst (fixed_offset);
2928 write_char ('_');
2929
2930 /* For a virtual thunk, add the virtual offset. */
2931 if (virtual_offset)
2932 {
2933 write_integer_cst (virtual_offset);
2934 write_char ('_');
2935 }
2936}
2937
2938/* Return an identifier for the mangled name of a this-adjusting or
2939 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment
2940 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this
2941 is a virtual thunk, and it is the vtbl offset in
2942 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
2943 zero for a covariant thunk. Note, that FN_DECL might be a covariant
2944 thunk itself. A covariant thunk name always includes the adjustment
2945 for the this pointer, even if there is none.
2946
2947 <special-name> ::= T <call-offset> <base encoding>
2948 ::= Tc <this_adjust call-offset> <result_adjust call-offset>
2949 <base encoding> */
2950
2951tree
2952mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
2953 tree virtual_offset)
2954{
2955 tree result;
2956
2957 start_mangling (fn_decl);
2958
2959 write_string ("_Z");
2960 write_char ('T');
2961
2962 if (!this_adjusting)
2963 {
2964 /* Covariant thunk with no this adjustment */
2965 write_char ('c');
2966 mangle_call_offset (integer_zero_node, NULL_TREE);
2967 mangle_call_offset (fixed_offset, virtual_offset);
2968 }
2969 else if (!DECL_THUNK_P (fn_decl))
2970 /* Plain this adjusting thunk. */
2971 mangle_call_offset (fixed_offset, virtual_offset);
2972 else
2973 {
2974 /* This adjusting thunk to covariant thunk. */
2975 write_char ('c');
2976 mangle_call_offset (fixed_offset, virtual_offset);
2977 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
2978 virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
2979 if (virtual_offset)
2980 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
2981 mangle_call_offset (fixed_offset, virtual_offset);
2982 fn_decl = THUNK_TARGET (fn_decl);
2983 }
2984
2985 /* Scoped name. */
2986 write_encoding (fn_decl);
2987
2988 result = finish_mangling_get_identifier (/*warn=*/false);
2989 if (DEBUG_MANGLE)
2990 fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
2991 return result;
2992}
2993
2994/* This hash table maps TYPEs to the IDENTIFIER for a conversion
2995 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
2996 TYPE. */
2997
2998static GTY ((param_is (union tree_node))) htab_t conv_type_names;
2999
3000/* Hash a node (VAL1) in the table. */
3001
3002static hashval_t
3003hash_type (const void *val)
3004{
3005 return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val));
3006}
3007
3008/* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */
3009
3010static int
3011compare_type (const void *val1, const void *val2)
3012{
3013 return TREE_TYPE ((const_tree) val1) == (const_tree) val2;
3014}
3015
3016/* Return an identifier for the mangled unqualified name for a
3017 conversion operator to TYPE. This mangling is not specified by the
3018 ABI spec; it is only used internally. */
3019
3020tree
3021mangle_conv_op_name_for_type (const tree type)
3022{
3023 void **slot;
3024 tree identifier;
3025
3026 if (type == error_mark_node)
3027 return error_mark_node;
3028
3029 if (conv_type_names == NULL)
3030 conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL);
3031
3032 slot = htab_find_slot_with_hash (conv_type_names, type,
3033 (hashval_t) TYPE_UID (type), INSERT);
3034 identifier = (tree)*slot;
3035 if (!identifier)
3036 {
3037 char buffer[64];
3038
3039 /* Create a unique name corresponding to TYPE. */
3040 sprintf (buffer, "operator %lu",
3041 (unsigned long) htab_elements (conv_type_names));
3042 identifier = get_identifier (buffer);
3043 *slot = identifier;
3044
3045 /* Hang TYPE off the identifier so it can be found easily later
3046 when performing conversions. */
3047 TREE_TYPE (identifier) = type;
3048
3049 /* Set bits on the identifier so we know later it's a conversion. */
3050 IDENTIFIER_OPNAME_P (identifier) = 1;
3051 IDENTIFIER_TYPENAME_P (identifier) = 1;
3052 }
3053
3054 return identifier;
3055}
3056
3057/* Return an identifier for the name of an initialization guard
3058 variable for indicated VARIABLE. */
3059
3060tree
3061mangle_guard_variable (const tree variable)
3062{
3063 start_mangling (variable);
3064 write_string ("_ZGV");
3065 if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0)
3066 /* The name of a guard variable for a reference temporary should refer
3067 to the reference, not the temporary. */
3068 write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
3069 else
3070 write_name (variable, /*ignore_local_scope=*/0);
3071 return finish_mangling_get_identifier (/*warn=*/false);
3072}
3073
3074/* Return an identifier for the name of a temporary variable used to
3075 initialize a static reference. This isn't part of the ABI, but we might
3076 as well call them something readable. */
3077
3078tree
3079mangle_ref_init_variable (const tree variable)
3080{
3081 start_mangling (variable);
3082 write_string ("_ZGR");
3083 write_name (variable, /*ignore_local_scope=*/0);
3084 return finish_mangling_get_identifier (/*warn=*/false);
3085}
3086\f
3087
3088/* Foreign language type mangling section. */
3089
3090/* How to write the type codes for the integer Java type. */
3091
3092static void
3093write_java_integer_type_codes (const tree type)
3094{
3095 if (type == java_int_type_node)
3096 write_char ('i');
3097 else if (type == java_short_type_node)
3098 write_char ('s');
3099 else if (type == java_byte_type_node)
3100 write_char ('c');
3101 else if (type == java_char_type_node)
3102 write_char ('w');
3103 else if (type == java_long_type_node)
3104 write_char ('x');
3105 else if (type == java_boolean_type_node)
3106 write_char ('b');
3107 else
3108 gcc_unreachable ();
3109}
3110
3111#include "gt-cp-mangle.h"