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