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