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