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