Line data Source code
1 : /* Name mangling for the 3.0 C++ ABI.
2 : Copyright (C) 2000-2026 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 : #include "contracts.h"
59 :
60 : /* Debugging support. */
61 :
62 : /* Define DEBUG_MANGLE to enable very verbose trace messages. */
63 : #ifndef DEBUG_MANGLE
64 : #define DEBUG_MANGLE 0
65 : #endif
66 :
67 : /* Macros for tracing the write_* functions. */
68 : #if DEBUG_MANGLE
69 : # define MANGLE_TRACE(FN, INPUT) \
70 : fprintf (stderr, " %-24s: %-24s\n", (FN), (INPUT))
71 : # define MANGLE_TRACE_TREE(FN, NODE) \
72 : fprintf (stderr, " %-24s: %-24s (%p)\n", \
73 : (FN), get_tree_code_name (TREE_CODE (NODE)), (void *) (NODE))
74 : #else
75 : # define MANGLE_TRACE(FN, INPUT)
76 : # define MANGLE_TRACE_TREE(FN, NODE)
77 : #endif
78 :
79 : /* Nonzero if NODE is a class template-id. We can't rely on
80 : CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser
81 : that hard to distinguish A<T> from A, where A<T> is the type as
82 : instantiated outside of the template, and A is the type used
83 : without parameters inside the template. */
84 : #define CLASSTYPE_TEMPLATE_ID_P(NODE) \
85 : (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \
86 : || (CLASS_TYPE_P (NODE) \
87 : && CLASSTYPE_TEMPLATE_INFO (NODE) != NULL \
88 : && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))))
89 :
90 : /* For deciding whether to set G.need_abi_warning, we need to consider both
91 : warn_abi_version and flag_abi_compat_version. */
92 : #define abi_warn_or_compat_version_crosses(N) \
93 : (abi_version_crosses (N) || abi_compat_version_crosses (N))
94 :
95 : /* And sometimes we can simplify the code path if we don't need to worry about
96 : previous ABIs. */
97 : #define abi_flag_at_least(flag,N) (flag == 0 || flag >= N)
98 : #define any_abi_below(N) \
99 : (!abi_version_at_least (N) \
100 : || !abi_flag_at_least (warn_abi_version, (N)) \
101 : || !abi_flag_at_least (flag_abi_compat_version, (N)))
102 :
103 : /* Things we only need one of. This module is not reentrant. */
104 : struct GTY(()) globals {
105 : /* An array of the current substitution candidates, in the order
106 : we've seen them. Contains NULLS, which correspond to module
107 : substitutions. */
108 : vec<tree, va_gc> *substitutions;
109 :
110 : /* The entity that is being mangled. */
111 : tree GTY ((skip)) entity;
112 :
113 : /* How many parameter scopes we are inside. */
114 : int parm_depth;
115 :
116 : /* True if the mangling will be different in a future version of the
117 : ABI. */
118 : bool need_abi_warning;
119 :
120 : /* True if the mangling will be different in C++17 mode. */
121 : bool need_cxx17_warning;
122 :
123 : /* True if we mangled a module name. */
124 : bool mod;
125 : };
126 :
127 : static GTY (()) globals G;
128 :
129 : /* The obstack on which we build mangled names. */
130 : static struct obstack *mangle_obstack;
131 :
132 : /* The obstack on which we build mangled names that are not going to
133 : be IDENTIFIER_NODEs. */
134 : static struct obstack name_obstack;
135 :
136 : /* The first object on the name_obstack; we use this to free memory
137 : allocated on the name_obstack. */
138 : static void *name_base;
139 :
140 : /* Indices into subst_identifiers. These are identifiers used in
141 : special substitution rules. */
142 : typedef enum
143 : {
144 : SUBID_ALLOCATOR,
145 : SUBID_BASIC_STRING,
146 : SUBID_CHAR_TRAITS,
147 : SUBID_BASIC_ISTREAM,
148 : SUBID_BASIC_OSTREAM,
149 : SUBID_BASIC_IOSTREAM,
150 : SUBID_MAX
151 : }
152 : substitution_identifier_index_t;
153 :
154 : /* For quick substitution checks, look up these common identifiers
155 : once only. */
156 : static GTY(()) tree subst_identifiers[SUBID_MAX];
157 :
158 : /* Single-letter codes for builtin integer types, defined in
159 : <builtin-type>. These are indexed by integer_type_kind values. */
160 : static const char
161 : integer_type_codes[itk_none] =
162 : {
163 : 'c', /* itk_char */
164 : 'a', /* itk_signed_char */
165 : 'h', /* itk_unsigned_char */
166 : 's', /* itk_short */
167 : 't', /* itk_unsigned_short */
168 : 'i', /* itk_int */
169 : 'j', /* itk_unsigned_int */
170 : 'l', /* itk_long */
171 : 'm', /* itk_unsigned_long */
172 : 'x', /* itk_long_long */
173 : 'y', /* itk_unsigned_long_long */
174 : /* __intN types are handled separately */
175 : '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
176 : };
177 :
178 : static tree maybe_template_info (const tree);
179 :
180 : /* Functions for handling substitutions. */
181 :
182 : static inline tree canonicalize_for_substitution (tree);
183 : static void add_substitution (tree);
184 : static inline bool is_std_substitution (const tree,
185 : const substitution_identifier_index_t);
186 : static inline bool is_std_substitution_char (const tree,
187 : const substitution_identifier_index_t);
188 : static int find_substitution (tree);
189 : static void mangle_call_offset (const tree, const tree);
190 :
191 : /* Functions for emitting mangled representations of things. */
192 :
193 : static void write_mangled_name (const tree, bool);
194 : static void write_encoding (const tree);
195 : static void write_name (tree, const bool = false);
196 : static void write_abi_tags (tree);
197 : static void write_unscoped_name (const tree);
198 : static void write_unscoped_template_name (const tree);
199 : static void write_nested_name (const tree);
200 : static void write_prefix (const tree);
201 : static void write_template_prefix (const tree);
202 : static void write_unqualified_name (tree);
203 : static void write_conversion_operator_name (const tree);
204 : static void write_source_name (tree);
205 : static void write_literal_operator_name (tree);
206 : static void write_unnamed_type_name (const tree);
207 : static void write_unnamed_enum_name (const tree);
208 : static void write_closure_type_name (const tree);
209 : static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *,
210 : const unsigned int);
211 : static void write_number (unsigned HOST_WIDE_INT, const int,
212 : const unsigned int);
213 : static void write_compact_number (int num);
214 : static void write_integer_cst (const tree);
215 : static void write_real_cst (const tree);
216 : static void write_identifier (const char *);
217 : static void write_special_name_constructor (const tree);
218 : static void write_special_name_destructor (const tree);
219 : static void write_type (tree);
220 : static int write_CV_qualifiers_for_type (const tree);
221 : static void write_builtin_type (tree);
222 : static void write_function_type (const tree);
223 : static void write_bare_function_type (const tree, const int, const tree);
224 : static void write_method_parms (tree, const int, const tree);
225 : static void write_class_enum_type (const tree);
226 : static void write_template_args (tree, tree = NULL_TREE);
227 : static void write_expression (tree);
228 : static void write_template_arg_literal (const tree);
229 : static void write_template_arg (tree);
230 : static void write_template_template_arg (const tree);
231 : static void write_array_type (const tree);
232 : static void write_pointer_to_member_type (const tree);
233 : static void write_template_param (const tree);
234 : static void write_template_template_param (const tree);
235 : static void write_substitution (const int);
236 : static int discriminator_for_local_entity (tree);
237 : static int discriminator_for_string_literal (tree, tree);
238 : static void write_discriminator (const int);
239 : static void write_local_name (tree, const tree, const tree);
240 : static void dump_substitution_candidates (void);
241 : static tree mangle_decl_string (const tree);
242 : static void maybe_check_abi_tags (tree, tree = NULL_TREE, int = 10);
243 : static void write_splice (tree);
244 :
245 : /* Control functions. */
246 :
247 : static inline void start_mangling (const tree);
248 : static tree mangle_special_for_type (const tree, const char *);
249 :
250 : /* Append a single character to the end of the mangled
251 : representation. */
252 : #define write_char(CHAR) \
253 : obstack_1grow (mangle_obstack, (CHAR))
254 :
255 : /* Append a sized buffer to the end of the mangled representation. */
256 : #define write_chars(CHAR, LEN) \
257 : obstack_grow (mangle_obstack, (CHAR), (LEN))
258 :
259 : /* Append a NUL-terminated string to the end of the mangled
260 : representation. */
261 : #define write_string(STRING) \
262 : obstack_grow (mangle_obstack, (STRING), strlen (STRING))
263 :
264 : /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
265 : same purpose (context, which may be a type) and value (template
266 : decl). See write_template_prefix for more information on what this
267 : is used for. */
268 : #define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \
269 : (TREE_CODE (NODE1) == TREE_LIST \
270 : && TREE_CODE (NODE2) == TREE_LIST \
271 : && ((TYPE_P (TREE_PURPOSE (NODE1)) \
272 : && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))) \
273 : || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \
274 : && TREE_VALUE (NODE1) == TREE_VALUE (NODE2))
275 :
276 : /* Write out an unsigned quantity in base 10. */
277 : #define write_unsigned_number(NUMBER) \
278 : write_number ((NUMBER), /*unsigned_p=*/1, 10)
279 :
280 : /* Check for -fabi-version dependent mangling and also set the need_abi_warning
281 : flag as appropriate. */
282 :
283 : static bool
284 14496765 : abi_check (int ver)
285 : {
286 72313130 : if (abi_warn_or_compat_version_crosses (ver))
287 90563 : G.need_abi_warning = true;
288 14496765 : return abi_version_at_least (ver);
289 : }
290 :
291 : /* If DECL is a template instance (including the uninstantiated template
292 : itself), return its TEMPLATE_INFO. Otherwise return NULL. */
293 :
294 : static tree
295 1393397762 : maybe_template_info (const tree decl)
296 : {
297 1393397762 : if (TREE_CODE (decl) == TYPE_DECL)
298 : {
299 : /* TYPE_DECLs are handled specially. Look at its type to decide
300 : if this is a template instantiation. */
301 531438880 : const tree type = TREE_TYPE (decl);
302 :
303 531438880 : if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type))
304 422449576 : return TYPE_TEMPLATE_INFO (type);
305 : }
306 : else
307 : {
308 : /* Check if the template is a primary template. */
309 861958882 : if (DECL_LANG_SPECIFIC (decl) != NULL
310 860656273 : && VAR_OR_FUNCTION_DECL_P (decl)
311 732129125 : && DECL_TEMPLATE_INFO (decl)
312 1434813260 : && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
313 89166546 : return DECL_TEMPLATE_INFO (decl);
314 : }
315 :
316 : /* It's not a template id. */
317 : return NULL_TREE;
318 : }
319 :
320 : /* Produce debugging output of current substitution candidates. */
321 :
322 : static void
323 0 : dump_substitution_candidates (void)
324 : {
325 0 : unsigned i;
326 0 : tree el;
327 :
328 0 : fprintf (stderr, " ++ substitutions ");
329 0 : FOR_EACH_VEC_ELT (*G.substitutions, i, el)
330 : {
331 0 : const char *name = "???";
332 :
333 0 : if (i > 0)
334 0 : fprintf (stderr, " ");
335 0 : if (!el)
336 : name = "module";
337 0 : else if (DECL_P (el))
338 0 : name = IDENTIFIER_POINTER (DECL_NAME (el));
339 0 : else if (TREE_CODE (el) == TREE_LIST)
340 0 : name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)));
341 0 : else if (TYPE_NAME (el))
342 0 : name = TYPE_NAME_STRING (el);
343 0 : fprintf (stderr, " S%d_ = ", i - 1);
344 0 : if (el)
345 : {
346 0 : if (TYPE_P (el) &&
347 0 : (CP_TYPE_RESTRICT_P (el)
348 0 : || CP_TYPE_VOLATILE_P (el)
349 0 : || CP_TYPE_CONST_P (el)))
350 0 : fprintf (stderr, "CV-");
351 0 : fprintf (stderr, "%s (%s at %p)",
352 0 : name, get_tree_code_name (TREE_CODE (el)), (void *) el);
353 : }
354 0 : fprintf (stderr, "\n");
355 : }
356 0 : }
357 :
358 : /* <exception-spec> ::=
359 : Do -- non-throwing exception specification
360 : DO <expression> E -- computed (instantiation-dependent) noexcept
361 : Dw <type>* E -- throw (types) */
362 :
363 : static void
364 3251312 : write_exception_spec (tree spec)
365 : {
366 :
367 3251312 : if (!spec || spec == noexcept_false_spec)
368 : /* Nothing. */
369 : return;
370 :
371 37381 : if (!flag_noexcept_type)
372 : {
373 17 : G.need_cxx17_warning = true;
374 17 : return;
375 : }
376 :
377 37364 : if (spec == noexcept_true_spec || spec == empty_except_spec)
378 37349 : write_string ("Do");
379 15 : else if (tree expr = TREE_PURPOSE (spec))
380 : {
381 : /* noexcept (expr) */
382 15 : gcc_assert (uses_template_parms (expr));
383 15 : write_string ("DO");
384 15 : write_expression (expr);
385 15 : write_char ('E');
386 : }
387 : else
388 : {
389 : /* throw (type-list) */
390 0 : write_string ("Dw");
391 0 : for (tree t = spec; t; t = TREE_CHAIN (t))
392 0 : write_type (TREE_VALUE (t));
393 0 : write_char ('E');
394 : }
395 : }
396 :
397 : /* Both decls and types can be substitution candidates, but sometimes
398 : they refer to the same thing. For instance, a TYPE_DECL and
399 : RECORD_TYPE for the same class refer to the same thing, and should
400 : be treated accordingly in substitutions. This function returns a
401 : canonicalized tree node representing NODE that is used when adding
402 : and substitution candidates and finding matches. */
403 :
404 : static inline tree
405 4883257054 : canonicalize_for_substitution (tree node)
406 : {
407 : /* For a TYPE_DECL, use the type instead. */
408 4883257054 : if (TREE_CODE (node) == TYPE_DECL)
409 5104 : node = TREE_TYPE (node);
410 4883257054 : if (TYPE_P (node)
411 3588782291 : && TYPE_CANONICAL (node) != node
412 5288756070 : && TYPE_MAIN_VARIANT (node) != node)
413 : {
414 114972741 : tree orig = node;
415 : /* Here we want to strip the topmost typedef only.
416 : We need to do that so is_std_substitution can do proper
417 : name matching. */
418 114972741 : if (TREE_CODE (node) == FUNCTION_TYPE)
419 : /* Use build_qualified_type and TYPE_QUALS here to preserve
420 : the old buggy mangling of attribute noreturn with abi<5. */
421 28282 : node = build_qualified_type (TYPE_MAIN_VARIANT (node),
422 28282 : TYPE_QUALS (node));
423 : else
424 114944459 : node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node),
425 : cp_type_quals (node));
426 114972741 : if (FUNC_OR_METHOD_TYPE_P (node))
427 : {
428 28291 : node = build_ref_qualified_type (node, type_memfn_rqual (orig));
429 28291 : tree r = canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (orig));
430 28291 : if (flag_noexcept_type)
431 28247 : node = build_exception_variant (node, r);
432 : else
433 : /* Set the warning flag if appropriate. */
434 44 : write_exception_spec (r);
435 : }
436 : }
437 4883257054 : return node;
438 : }
439 :
440 : /* Add NODE as a substitution candidate. NODE must not already be on
441 : the list of candidates. */
442 :
443 : static void
444 1266269973 : add_substitution (tree node)
445 : {
446 1266269973 : tree c;
447 :
448 1266269973 : if (DEBUG_MANGLE)
449 : fprintf (stderr, " ++ add_substitution (%s at %10p)\n",
450 : get_tree_code_name (TREE_CODE (node)), (void *) node);
451 :
452 : /* Get the canonicalized substitution candidate for NODE. */
453 1266269973 : c = canonicalize_for_substitution (node);
454 1266269973 : if (DEBUG_MANGLE && c != node)
455 : fprintf (stderr, " ++ using candidate (%s at %10p)\n",
456 : get_tree_code_name (TREE_CODE (node)), (void *) node);
457 1266269973 : node = c;
458 :
459 : /* Make sure NODE isn't already a candidate. */
460 1266269973 : if (flag_checking)
461 : {
462 : int i;
463 : tree candidate;
464 :
465 6572390075 : FOR_EACH_VEC_SAFE_ELT (G.substitutions, i, candidate)
466 5306120218 : if (candidate)
467 : {
468 5306112698 : gcc_assert (!(DECL_P (node) && node == candidate));
469 5306112698 : gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
470 : && same_type_p (node, candidate)));
471 : }
472 : }
473 :
474 : /* Put the decl onto the varray of substitution candidates. */
475 1266269973 : vec_safe_push (G.substitutions, node);
476 :
477 1266269973 : if (DEBUG_MANGLE)
478 : dump_substitution_candidates ();
479 1266269973 : }
480 :
481 : /* Helper function for find_substitution. Returns nonzero if NODE,
482 : which may be a class or a class template, is a template-id with template
483 : name of substitution_index[INDEX] in the ::std namespace, with
484 : global module attachment. */
485 :
486 : static bool
487 4285853259 : is_std_substitution (const tree node,
488 : const substitution_identifier_index_t index)
489 : {
490 4285853259 : tree type = NULL_TREE;
491 4285853259 : tree decl = NULL_TREE;
492 :
493 8546873906 : auto std_substitution_p = [&] (tree decl, tree type)
494 : {
495 4261020647 : if (!DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl)))
496 : return false;
497 :
498 1645896720 : if (!(TYPE_LANG_SPECIFIC (type) && TYPE_TEMPLATE_INFO (type)))
499 : return false;
500 :
501 1222388766 : tree tmpl = TYPE_TI_TEMPLATE (type);
502 1222388766 : if (DECL_NAME (tmpl) != subst_identifiers[index])
503 : return false;
504 :
505 145310257 : if (modules_p () && get_originating_module (tmpl, true) >= 0)
506 27 : return false;
507 :
508 : return true;
509 4285853259 : };
510 :
511 4285853259 : if (TREE_CODE (node) == TYPE_DECL || DECL_CLASS_TEMPLATE_P (node))
512 : {
513 3384739003 : type = TREE_TYPE (node);
514 3384739003 : decl = node;
515 : }
516 901114256 : else if (CLASS_TYPE_P (node))
517 : {
518 4765769 : type = node;
519 4765769 : decl = TYPE_NAME (node);
520 : }
521 : else
522 : {
523 : /* We used to accept all _DECL nodes in this function but now we
524 : only accept classes or class templates. Verify that we don't
525 : return false for something that used to yield true. */
526 896348487 : gcc_checking_assert (!DECL_P (node)
527 : || !std_substitution_p (node, TREE_TYPE (node)));
528 : /* These are not the droids you're looking for. */
529 : return false;
530 : }
531 :
532 3389504772 : return std_substitution_p (decl, type);
533 : }
534 :
535 : /* Return the ABI tags (the TREE_VALUE of the "abi_tag" attribute entry) for T,
536 : which can be a decl or type. */
537 :
538 : static tree
539 1879135609 : get_abi_tags (tree t)
540 : {
541 1879135609 : if (!t || TREE_CODE (t) == NAMESPACE_DECL)
542 : return NULL_TREE;
543 :
544 1751459372 : if (DECL_P (t) && DECL_DECLARES_TYPE_P (t))
545 471231665 : t = TREE_TYPE (t);
546 :
547 1751459372 : if (TREE_CODE (t) == TEMPLATE_DECL && DECL_TEMPLATE_RESULT (t))
548 : {
549 17398188 : tree tags = get_abi_tags (DECL_TEMPLATE_RESULT (t));
550 : /* We used to overlook abi_tag on function and variable templates. */
551 17398188 : if (tags && abi_check (19))
552 10 : return tags;
553 : else
554 : return NULL_TREE;
555 : }
556 :
557 1734061184 : tree attrs;
558 1734061184 : if (TYPE_P (t))
559 1507557623 : attrs = TYPE_ATTRIBUTES (t);
560 : else
561 226503561 : attrs = DECL_ATTRIBUTES (t);
562 :
563 1734061184 : tree tags = lookup_attribute ("abi_tag", attrs);
564 1734061184 : if (tags)
565 11829286 : tags = TREE_VALUE (tags);
566 : return tags;
567 : }
568 :
569 : /* Helper function for find_substitution. Returns nonzero if NODE,
570 : which may be a decl or a CLASS_TYPE, is the template-id
571 : ::std::identifier<char>, where identifier is
572 : substitution_index[INDEX]. */
573 :
574 : static bool
575 6840626 : is_std_substitution_char (const tree node,
576 : const substitution_identifier_index_t index)
577 : {
578 6840626 : tree args;
579 : /* Check NODE's name is ::std::identifier. */
580 6840626 : if (!is_std_substitution (node, index))
581 : return 0;
582 : /* Figure out its template args. */
583 4310349 : if (DECL_P (node))
584 0 : args = DECL_TI_ARGS (node);
585 4310349 : else if (CLASS_TYPE_P (node))
586 4310349 : args = CLASSTYPE_TI_ARGS (node);
587 : else
588 : /* Oops, not a template. */
589 : return 0;
590 : /* NODE's template arg list should be <char>. */
591 4310349 : return
592 4310349 : TREE_VEC_LENGTH (args) == 1
593 4310349 : && TREE_VEC_ELT (args, 0) == char_type_node;
594 : }
595 :
596 : /* Check whether a substitution should be used to represent NODE in
597 : the mangling.
598 :
599 : First, check standard special-case substitutions.
600 :
601 : <substitution> ::= St
602 : # ::std
603 :
604 : ::= Sa
605 : # ::std::allocator
606 :
607 : ::= Sb
608 : # ::std::basic_string
609 :
610 : ::= Ss
611 : # ::std::basic_string<char,
612 : ::std::char_traits<char>,
613 : ::std::allocator<char> >
614 :
615 : ::= Si
616 : # ::std::basic_istream<char, ::std::char_traits<char> >
617 :
618 : ::= So
619 : # ::std::basic_ostream<char, ::std::char_traits<char> >
620 :
621 : ::= Sd
622 : # ::std::basic_iostream<char, ::std::char_traits<char> >
623 :
624 : Then examine the stack of currently available substitution
625 : candidates for entities appearing earlier in the same mangling
626 :
627 : If a substitution is found, write its mangled representation and
628 : return nonzero. If none is found, just return zero. */
629 :
630 : static int
631 2332505809 : find_substitution (tree node)
632 : {
633 2332505809 : int i;
634 2332505809 : const int size = vec_safe_length (G.substitutions);
635 2332505809 : tree decl;
636 2332505809 : tree type;
637 2332505809 : const char *abbr = NULL;
638 :
639 2332505809 : if (DEBUG_MANGLE)
640 : fprintf (stderr, " ++ find_substitution (%s at %p)\n",
641 : get_tree_code_name (TREE_CODE (node)), (void *) node);
642 :
643 : /* Obtain the canonicalized substitution representation for NODE.
644 : This is what we'll compare against. */
645 2332505809 : node = canonicalize_for_substitution (node);
646 :
647 : /* Check for builtin substitutions. */
648 :
649 2332505809 : decl = TYPE_P (node) ? TYPE_NAME (node) : node;
650 2332505809 : type = TYPE_P (node) ? node : TREE_TYPE (node);
651 :
652 : /* Check for std::allocator. */
653 2332505809 : if (decl
654 2165649721 : && is_std_substitution (decl, SUBID_ALLOCATOR)
655 2472420702 : && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl)))
656 : abbr = "Sa";
657 :
658 : /* Check for std::basic_string. */
659 2268524939 : else if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
660 : {
661 155877 : if (TYPE_P (node))
662 : {
663 : /* If this is a type (i.e. a fully-qualified template-id),
664 : check for
665 : std::basic_string <char,
666 : std::char_traits<char>,
667 : std::allocator<char> > . */
668 108764 : if (cp_type_quals (type) == TYPE_UNQUALIFIED
669 108764 : && CLASSTYPE_USE_TEMPLATE (type))
670 : {
671 97215 : tree args = CLASSTYPE_TI_ARGS (type);
672 97215 : if (TREE_VEC_LENGTH (args) == 3
673 97197 : && template_args_equal (TREE_VEC_ELT (args, 0), char_type_node)
674 39521 : && is_std_substitution_char (TREE_VEC_ELT (args, 1),
675 : SUBID_CHAR_TRAITS)
676 136725 : && is_std_substitution_char (TREE_VEC_ELT (args, 2),
677 : SUBID_ALLOCATOR))
678 : abbr = "Ss";
679 : }
680 : }
681 : else
682 : /* Substitute for the template name only if this isn't a type. */
683 : abbr = "Sb";
684 : }
685 :
686 : /* Check for basic_{i,o,io}stream. */
687 2268369062 : else if (TYPE_P (node)
688 1506732395 : && cp_type_quals (type) == TYPE_UNQUALIFIED
689 1420325754 : && CLASS_TYPE_P (type)
690 598515085 : && CLASSTYPE_USE_TEMPLATE (type)
691 2708992015 : && CLASSTYPE_TEMPLATE_INFO (type) != NULL)
692 : {
693 : /* First, check for the template
694 : args <char, std::char_traits<char> > . */
695 440622953 : tree args = CLASSTYPE_TI_ARGS (type);
696 440622953 : if (TREE_VEC_LENGTH (args) == 2
697 138277731 : && template_args_equal (TREE_VEC_ELT (args, 0), char_type_node)
698 447384548 : && is_std_substitution_char (TREE_VEC_ELT (args, 1),
699 : SUBID_CHAR_TRAITS))
700 : {
701 : /* Got them. Is this basic_istream? */
702 4231324 : if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
703 : abbr = "Si";
704 : /* Or basic_ostream? */
705 3926444 : else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
706 : abbr = "So";
707 : /* Or basic_iostream? */
708 3536293 : else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
709 2105725061 : abbr = "Sd";
710 : }
711 : }
712 :
713 : /* Check for namespace std. */
714 1827746109 : else if (decl && DECL_NAMESPACE_STD_P (decl))
715 : {
716 226780748 : write_string ("St");
717 226780748 : return 1;
718 : }
719 :
720 2105725061 : tree tags = NULL_TREE;
721 2105725061 : if (OVERLOAD_TYPE_P (node) || DECL_CLASS_TEMPLATE_P (node))
722 1036325958 : tags = get_abi_tags (type);
723 : /* Now check the list of available substitutions for this mangling
724 : operation. */
725 2105725061 : if (!abbr || tags)
726 9143582164 : for (i = 0; i < size; ++i)
727 7282290071 : if (tree candidate = (*G.substitutions)[i])
728 : {
729 : /* NODE is a matched to a candidate if it's the same decl node or
730 : if it's the same type. */
731 7282279950 : if (decl == candidate
732 7219727045 : || (TYPE_P (candidate) && type && TYPE_P (node)
733 3185669755 : && same_type_p (type, candidate))
734 14386186506 : || NESTED_TEMPLATE_MATCH (node, candidate))
735 : {
736 179436373 : write_substitution (i);
737 179436373 : return 1;
738 : }
739 : }
740 :
741 1861292093 : if (!abbr)
742 : /* No substitution found. */
743 : return 0;
744 :
745 64996601 : write_string (abbr);
746 64996601 : if (tags)
747 : {
748 : /* If there are ABI tags on the abbreviation, it becomes
749 : a substitution candidate. */
750 6 : write_abi_tags (tags);
751 6 : add_substitution (node);
752 : }
753 : return 1;
754 : }
755 :
756 : /* Returns whether DECL's symbol name should be the plain unqualified-id
757 : rather than a more complicated mangled name. */
758 :
759 : static bool
760 221411261 : unmangled_name_p (const tree decl)
761 : {
762 221411261 : if (TREE_CODE (decl) == FUNCTION_DECL)
763 : {
764 : /* The names of `extern "C"' functions are not mangled. */
765 187761936 : return (DECL_EXTERN_C_FUNCTION_P (decl)
766 : /* But overloaded operator names *are* mangled. */
767 2239598 : && !DECL_OVERLOADED_OPERATOR_P (decl));
768 : }
769 33649325 : else if (VAR_P (decl))
770 : {
771 : /* extern "C" declarations aren't mangled. */
772 33645942 : if (DECL_NAMESPACE_SCOPE_P (decl) && DECL_EXTERN_C_P (decl))
773 : return true;
774 :
775 : /* static variables are mangled. */
776 33438570 : if (!DECL_EXTERNAL_LINKAGE_P (decl))
777 : return false;
778 :
779 : /* Other variables at non-global scope are mangled. */
780 33220215 : if (CP_DECL_CONTEXT (decl) != global_namespace)
781 : return false;
782 :
783 : /* Variable template instantiations are mangled. */
784 124610 : if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
785 123156 : && variable_template_p (DECL_TI_TEMPLATE (decl)))
786 : return false;
787 :
788 : /* Declarations with ABI tags are mangled. */
789 113788 : if (get_abi_tags (decl))
790 : return false;
791 :
792 : // Declarations attached to a named module are mangled
793 113436 : if (modules_p () && get_originating_module (decl, true) >= 0)
794 121 : return false;
795 :
796 : /* The names of non-static global variables aren't mangled. */
797 : return true;
798 : }
799 :
800 : return false;
801 : }
802 :
803 : /* TOP_LEVEL is true, if this is being called at outermost level of
804 : mangling. It should be false when mangling a decl appearing in an
805 : expression within some other mangling.
806 :
807 : <mangled-name> ::= _Z <encoding> */
808 :
809 : static void
810 221411261 : write_mangled_name (const tree decl, bool top_level)
811 : {
812 221411261 : MANGLE_TRACE_TREE ("mangled-name", decl);
813 :
814 221411261 : check_abi_tags (decl);
815 :
816 221411261 : if (unmangled_name_p (decl))
817 : {
818 2560282 : if (top_level)
819 2559995 : write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
820 : else
821 : {
822 : /* The standard notes: "The <encoding> of an extern "C"
823 : function is treated like global-scope data, i.e. as its
824 : <source-name> without a type." We cannot write
825 : overloaded operators that way though, because it contains
826 : characters invalid in assembler. */
827 287 : write_string ("_Z");
828 287 : write_source_name (DECL_NAME (decl));
829 : }
830 : }
831 : else
832 : {
833 218850979 : write_string ("_Z");
834 218850979 : write_encoding (decl);
835 : }
836 :
837 : /* If this is a coroutine helper, then append an appropriate string to
838 : identify which. */
839 221411261 : if (tree ramp = DECL_RAMP_FN (decl))
840 : {
841 3082 : if (DECL_ACTOR_FN (ramp) == decl)
842 1541 : write_string (JOIN_STR "actor");
843 1541 : else if (DECL_DESTROY_FN (ramp) == decl)
844 1541 : write_string (JOIN_STR "destroy");
845 : else
846 0 : gcc_unreachable ();
847 : }
848 221411261 : }
849 :
850 : /* Returns true if the return type of DECL is part of its signature, and
851 : therefore its mangling. */
852 :
853 : bool
854 376178079 : mangle_return_type_p (tree decl)
855 : {
856 376178079 : return (!DECL_CONSTRUCTOR_P (decl)
857 315483021 : && !DECL_DESTRUCTOR_P (decl)
858 301247770 : && !DECL_CONV_FN_P (decl)
859 674695543 : && maybe_template_info (decl));
860 : }
861 :
862 : /* <constraint-expression> ::= <expression> */
863 :
864 : static void
865 3280673 : write_constraint_expression (tree expr)
866 : {
867 0 : write_expression (expr);
868 0 : }
869 :
870 : /* Mangle a requires-clause following a template-head, if any.
871 :
872 : Q <constraint_expression> E */
873 :
874 : static void
875 417872485 : write_tparms_constraints (tree constraints)
876 : {
877 : /* In a declaration with shorthand constraints in the template-head, followed
878 : by a requires-clause, followed by shorthand constraints in the
879 : function-parameter-list, the full constraints will be some && with the
880 : parameter constraints on the RHS, around an && with the requires-clause on
881 : the RHS. Find the requires-clause, if any.
882 :
883 : This logic relies on the && and ... from combine_constraint_expressions,
884 : finish_shorthand_constraint, and convert_generic_types_to_packs having
885 : UNKNOWN_LOCATION. If they need to have an actual location, we could move
886 : to using a TREE_LANG_FLAG. */
887 417872485 : if (constraints && abi_check (19))
888 : {
889 : tree probe = constraints;
890 : while (probe
891 344062 : && !cp_expr_location (probe)
892 381254 : && TREE_CODE (probe) == TRUTH_ANDIF_EXPR)
893 : {
894 372 : tree op1 = TREE_OPERAND (probe, 1);
895 715 : probe = (cp_expr_location (op1) ? op1
896 343 : : TREE_OPERAND (probe, 0));
897 : }
898 343690 : if (probe && cp_expr_location (probe))
899 : {
900 306870 : write_char ('Q');
901 306870 : write_constraint_expression (probe);
902 : }
903 : }
904 417872485 : }
905 :
906 : /* <type-constraint> ::= <name> */
907 :
908 : static void
909 145093 : write_type_constraint (tree cnst)
910 : {
911 145093 : if (!cnst)
912 : return;
913 :
914 145093 : gcc_checking_assert (TREE_CODE (cnst) == TEMPLATE_ID_EXPR);
915 :
916 145093 : tree concept_decl = get_concept_check_template (cnst);
917 145093 : write_name (concept_decl);
918 145093 : tree args = TREE_OPERAND (cnst, 1);
919 145093 : if (TREE_VEC_LENGTH (args) > 1)
920 : {
921 52533 : TEMPLATE_ARGS_TYPE_CONSTRAINT_P (args) = true;
922 52533 : write_template_args (args);
923 : }
924 : }
925 :
926 : /* <encoding> ::= <function name> <bare-function-type>
927 : ::= <data name> */
928 :
929 : static void
930 224397881 : write_encoding (const tree decl)
931 : {
932 224397881 : MANGLE_TRACE_TREE ("encoding", decl);
933 :
934 224397881 : if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl))
935 : {
936 : /* For overloaded operators write just the mangled name
937 : without arguments. */
938 11199 : if (DECL_OVERLOADED_OPERATOR_P (decl))
939 3 : write_name (decl);
940 : else
941 11196 : write_source_name (DECL_NAME (decl));
942 : return;
943 : }
944 :
945 224386682 : write_name (decl);
946 224386682 : if (TREE_CODE (decl) == FUNCTION_DECL)
947 : {
948 191057841 : tree fn_type;
949 191057841 : tree d;
950 :
951 191057841 : if (maybe_template_info (decl))
952 : {
953 17349819 : fn_type = get_mostly_instantiated_function_type (decl);
954 : /* FN_TYPE will not have parameter types for in-charge or
955 : VTT parameters. Therefore, we pass NULL_TREE to
956 : write_bare_function_type -- otherwise, it will get
957 : confused about which artificial parameters to skip. */
958 17349819 : d = NULL_TREE;
959 : }
960 : else
961 : {
962 173708022 : fn_type = TREE_TYPE (decl);
963 173708022 : d = decl;
964 : }
965 :
966 191057841 : write_bare_function_type (fn_type,
967 191057841 : mangle_return_type_p (decl),
968 : d);
969 :
970 191057841 : if (tree c = get_trailing_function_requirements (decl))
971 2993440 : if (abi_check (19))
972 : {
973 2973797 : ++G.parm_depth;
974 2973797 : write_char ('Q');
975 2973797 : write_constraint_expression (c);
976 2973797 : --G.parm_depth;
977 : }
978 : }
979 : }
980 :
981 : /* Interface to substitution and identifier mangling, used by the
982 : module name mangler. */
983 :
984 : void
985 425 : mangle_module_substitution (int v)
986 : {
987 425 : write_substitution (v - 1);
988 425 : }
989 :
990 : int
991 8601 : mangle_module_component (tree comp, bool partition_p)
992 : {
993 8601 : write_char ('W');
994 8601 : if (partition_p)
995 226 : write_char ('P');
996 8601 : write_source_name (comp);
997 :
998 : // Module substitutions use the same number-space as entity
999 : // substitutions, but are orthogonal.
1000 8601 : vec_safe_push (G.substitutions, NULL_TREE);
1001 8601 : return G.substitutions->length ();
1002 : }
1003 :
1004 : /* If the outermost non-namespace context (including DECL itself) is
1005 : a module-linkage decl, mangle the module information. For module
1006 : global initializers we need to include the partition part.
1007 :
1008 : <module-name> ::= <module-sub>
1009 : || <subst>
1010 : || <module-name> <module-sub>
1011 : <module-sub> :: W [P] <unqualified-name>
1012 : */
1013 :
1014 : static void
1015 8344 : write_module (int m, bool include_partition)
1016 : {
1017 8344 : G.mod = true;
1018 0 : mangle_module (m, include_partition);
1019 0 : }
1020 :
1021 : static void
1022 1858544 : maybe_write_module (tree decl)
1023 : {
1024 1858544 : if (!DECL_NAMESPACE_SCOPE_P (decl))
1025 : return;
1026 :
1027 1325513 : if (!TREE_PUBLIC (STRIP_TEMPLATE (decl)))
1028 : return;
1029 :
1030 1316270 : if (TREE_CODE (decl) == NAMESPACE_DECL)
1031 : return;
1032 :
1033 999972 : int m = get_originating_module (decl, true);
1034 999972 : if (m >= 0)
1035 6242 : write_module (m, false);
1036 : }
1037 :
1038 : /* Lambdas can have a bit more context for mangling, specifically VAR_DECL
1039 : or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */
1040 :
1041 : static tree
1042 2080137892 : decl_mangling_context (tree decl)
1043 : {
1044 2080138040 : tree tcontext = targetm.cxx.decl_mangling_context (decl);
1045 :
1046 2080138040 : if (tcontext != NULL_TREE)
1047 : return tcontext;
1048 :
1049 2080138040 : if (TREE_CODE (decl) == TEMPLATE_DECL
1050 2080138040 : && DECL_TEMPLATE_RESULT (decl))
1051 : decl = DECL_TEMPLATE_RESULT (decl);
1052 :
1053 2080138040 : if (TREE_CODE (decl) == TYPE_DECL
1054 3059793382 : && LAMBDA_TYPE_P (TREE_TYPE (decl)))
1055 : {
1056 6032003 : tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl));
1057 6032003 : if (extra)
1058 : return extra;
1059 6081 : tcontext = CP_DECL_CONTEXT (decl);
1060 6251 : if (LAMBDA_TYPE_P (tcontext))
1061 : /* Lambda type context means this lambda appears between the
1062 : lambda-introducer and the open brace of another lambda (c++/119175).
1063 : That isn't a real scope; look further into the enclosing scope. */
1064 60 : return decl_mangling_context (TYPE_NAME (tcontext));
1065 : }
1066 2074106037 : else if (template_type_parameter_p (decl))
1067 : /* template type parms have no mangling context. */
1068 : return NULL_TREE;
1069 :
1070 2074111072 : tcontext = CP_DECL_CONTEXT (decl);
1071 :
1072 2074111072 : if (member_like_constrained_friend_p (decl))
1073 90024 : tcontext = DECL_FRIEND_CONTEXT (decl);
1074 :
1075 : /* Ignore the artificial declare reduction functions. */
1076 2074111072 : if (tcontext
1077 2074111072 : && TREE_CODE (tcontext) == FUNCTION_DECL
1078 2079927068 : && DECL_OMP_DECLARE_REDUCTION_P (tcontext))
1079 : return decl_mangling_context (tcontext);
1080 :
1081 : return tcontext;
1082 : }
1083 :
1084 : /* <name> ::= <unscoped-name>
1085 : ::= <unscoped-template-name> <template-args>
1086 : ::= <nested-name>
1087 : ::= <local-name>
1088 :
1089 : If IGNORE_LOCAL_SCOPE is true, this production of <name> is
1090 : called from <local-name>, which mangles the enclosing scope
1091 : elsewhere and then uses this function to mangle just the part
1092 : underneath the function scope. So don't use the <local-name>
1093 : production, to avoid an infinite recursion. */
1094 :
1095 : static void
1096 553889001 : write_name (tree decl, const bool ignore_local_scope/*=false*/)
1097 : {
1098 553889001 : tree context;
1099 :
1100 553889001 : MANGLE_TRACE_TREE ("name", decl);
1101 :
1102 553889001 : if (TREE_CODE (decl) == TYPE_DECL)
1103 : {
1104 : /* In case this is a typedef, fish out the corresponding
1105 : TYPE_DECL for the main variant. */
1106 324985485 : decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)));
1107 : }
1108 :
1109 553889001 : context = decl_mangling_context (decl);
1110 :
1111 553889001 : gcc_assert (context != NULL_TREE);
1112 :
1113 2768964064 : if (abi_warn_or_compat_version_crosses (7)
1114 160059 : && ignore_local_scope
1115 40 : && TREE_CODE (context) == PARM_DECL)
1116 0 : G.need_abi_warning = 1;
1117 :
1118 : /* A decl in :: or ::std scope is treated specially. The former is
1119 : mangled using <unscoped-name> or <unscoped-template-name>, the
1120 : latter with a special substitution. Also, a name that is
1121 : directly in a local function scope is also mangled with
1122 : <unscoped-name> rather than a full <nested-name>. */
1123 553889001 : if (context == global_namespace
1124 542196718 : || DECL_NAMESPACE_STD_P (context)
1125 323187332 : || (ignore_local_scope
1126 5063933 : && (TREE_CODE (context) == FUNCTION_DECL
1127 3488732 : || (abi_version_at_least (7)
1128 3488732 : && TREE_CODE (context) == PARM_DECL))))
1129 : {
1130 : /* Is this a template instance? */
1131 232276900 : if (tree info = maybe_template_info (decl))
1132 : {
1133 : /* Yes: use <unscoped-template-name>. */
1134 193568038 : write_unscoped_template_name (TI_TEMPLATE (info));
1135 : /* Pass down the parms of a function template in case we need to
1136 : mangle them; we don't mangle the parms of a non-overloadable
1137 : template. */
1138 193568038 : tree parms = (TREE_CODE (decl) == FUNCTION_DECL
1139 198490991 : ? DECL_TEMPLATE_PARMS (TI_TEMPLATE (info))
1140 4922953 : : NULL_TREE);
1141 193568038 : write_template_args (TI_ARGS (info), parms);
1142 : }
1143 : else
1144 : /* Everything else gets an <unqualified-name>. */
1145 38708862 : write_unscoped_name (decl);
1146 : }
1147 : else
1148 : {
1149 : /* Handle local names, unless we asked not to (that is, invoked
1150 : under <local-name>, to handle only the part of the name under
1151 : the local scope). */
1152 321612101 : if (!ignore_local_scope)
1153 : {
1154 : /* Scan up the list of scope context, looking for a
1155 : function. If we find one, this entity is in local
1156 : function scope. local_entity tracks context one scope
1157 : level down, so it will contain the element that's
1158 : directly in that function's scope, either decl or one of
1159 : its enclosing scopes. */
1160 : tree local_entity = decl;
1161 1014751311 : while (context != global_namespace)
1162 : {
1163 : /* Make sure we're always dealing with decls. */
1164 701691845 : if (TYPE_P (context))
1165 222355706 : context = TYPE_NAME (context);
1166 : /* Is this a function? */
1167 701691845 : if (TREE_CODE (context) == FUNCTION_DECL
1168 696628278 : || TREE_CODE (context) == PARM_DECL)
1169 : {
1170 : /* Yes, we have local scope. Use the <local-name>
1171 : production for the innermost function scope. */
1172 5063933 : write_local_name (context, local_entity, decl);
1173 5063933 : return;
1174 : }
1175 : /* Up one scope level. */
1176 696627912 : local_entity = context;
1177 696627912 : context = decl_mangling_context (context);
1178 : }
1179 :
1180 : /* No local scope found? Fall through to <nested-name>. */
1181 : }
1182 :
1183 : /* Other decls get a <nested-name> to encode their scope. */
1184 316548168 : write_nested_name (decl);
1185 : }
1186 : }
1187 :
1188 : /* <unscoped-name> ::= <unqualified-name>
1189 : ::= St <unqualified-name> # ::std:: */
1190 :
1191 : static void
1192 165706266 : write_unscoped_name (const tree decl)
1193 : {
1194 165706266 : tree context = decl_mangling_context (decl);
1195 :
1196 165706266 : MANGLE_TRACE_TREE ("unscoped-name", decl);
1197 :
1198 : /* Is DECL in ::std? */
1199 165706266 : if (DECL_NAMESPACE_STD_P (context))
1200 : {
1201 155392413 : write_string ("St");
1202 155392413 : write_unqualified_name (decl);
1203 : }
1204 : else
1205 : {
1206 : /* If not, it should be either in the global namespace, or directly
1207 : in a local function scope. A lambda can also be mangled in the
1208 : scope of a default argument. */
1209 10313853 : gcc_assert (context == global_namespace
1210 : || TREE_CODE (context) == PARM_DECL
1211 : || TREE_CODE (context) == FUNCTION_DECL);
1212 :
1213 10313853 : write_unqualified_name (decl);
1214 : }
1215 165706266 : }
1216 :
1217 : /* <unscoped-template-name> ::= <unscoped-name>
1218 : ::= <substitution> */
1219 :
1220 : static void
1221 193568038 : write_unscoped_template_name (const tree decl)
1222 : {
1223 193568038 : MANGLE_TRACE_TREE ("unscoped-template-name", decl);
1224 :
1225 193568038 : if (find_substitution (decl))
1226 : return;
1227 126997404 : write_unscoped_name (decl);
1228 126997404 : add_substitution (decl);
1229 : }
1230 :
1231 : /* Write the nested name, including CV-qualifiers, of DECL.
1232 :
1233 : <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1234 : ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1235 :
1236 : <ref-qualifier> ::= R # & ref-qualifier
1237 : ::= O # && ref-qualifier
1238 : <CV-qualifiers> ::= [r] [V] [K] */
1239 :
1240 : static void
1241 319249197 : write_nested_name (const tree decl)
1242 : {
1243 319249197 : MANGLE_TRACE_TREE ("nested-name", decl);
1244 :
1245 319249197 : write_char ('N');
1246 :
1247 : /* Write CV-qualifiers, if this is an iobj member function. */
1248 319249197 : if (TREE_CODE (decl) == FUNCTION_DECL
1249 319249197 : && DECL_IOBJ_MEMBER_FUNCTION_P (decl))
1250 : {
1251 150717822 : if (DECL_VOLATILE_MEMFUNC_P (decl))
1252 8813968 : write_char ('V');
1253 150717822 : if (DECL_CONST_MEMFUNC_P (decl))
1254 45604461 : write_char ('K');
1255 150717822 : if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl)))
1256 : {
1257 155504 : if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
1258 97227 : write_char ('O');
1259 : else
1260 58277 : write_char ('R');
1261 : }
1262 : }
1263 139951939 : else if (DECL_DECLARES_FUNCTION_P (decl)
1264 168531375 : && DECL_XOBJ_MEMBER_FUNCTION_P (decl))
1265 5471 : write_char ('H');
1266 :
1267 : /* Is this a template instance? */
1268 319249197 : if (tree info = maybe_template_info (decl))
1269 : {
1270 : /* Yes, use <template-prefix>. */
1271 55437896 : write_template_prefix (decl);
1272 55437896 : write_template_args (TI_ARGS (info));
1273 : }
1274 263811301 : else if ((!abi_version_at_least (10) || TREE_CODE (decl) == TYPE_DECL)
1275 341977237 : && TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
1276 : {
1277 2701026 : tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
1278 2701026 : if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1279 : {
1280 50656 : write_template_prefix (decl);
1281 50656 : write_template_args (TREE_OPERAND (name, 1));
1282 : }
1283 : else
1284 : {
1285 2650370 : write_prefix (decl_mangling_context (decl));
1286 2650370 : write_unqualified_name (decl);
1287 : }
1288 : }
1289 : else
1290 : {
1291 : /* No, just use <prefix> */
1292 261110275 : write_prefix (decl_mangling_context (decl));
1293 261110275 : write_unqualified_name (decl);
1294 : }
1295 319249197 : write_char ('E');
1296 319249197 : }
1297 :
1298 : /* <prefix> ::= <prefix> <unqualified-name>
1299 : ::= <template-param>
1300 : ::= <template-prefix> <template-args>
1301 : ::= <decltype>
1302 : ::= # empty
1303 : ::= <substitution>
1304 : ::= <splice> # C++26 dependent splice [proposed] */
1305 :
1306 : static void
1307 657807804 : write_prefix (const tree node)
1308 : {
1309 657807804 : tree decl;
1310 :
1311 657807804 : if (node == NULL
1312 657807804 : || node == global_namespace)
1313 : return;
1314 :
1315 634198865 : MANGLE_TRACE_TREE ("prefix", node);
1316 :
1317 634198865 : if (TREE_CODE (node) == DECLTYPE_TYPE
1318 634198757 : || TREE_CODE (node) == TRAIT_TYPE)
1319 : {
1320 111 : write_type (node);
1321 111 : return;
1322 : }
1323 :
1324 634198754 : if (TREE_CODE (node) == SPLICE_SCOPE)
1325 : {
1326 10 : write_splice (node);
1327 10 : return;
1328 : }
1329 :
1330 634198744 : if (find_substitution (node))
1331 : return;
1332 :
1333 348164399 : tree template_info = NULL_TREE;
1334 348164399 : if (DECL_P (node))
1335 : {
1336 : /* If this is a function or parm decl, that means we've hit function
1337 : scope, so this prefix must be for a local name. In this
1338 : case, we're under the <local-name> production, which encodes
1339 : the enclosing function scope elsewhere. So don't continue
1340 : here. */
1341 131233564 : if (TREE_CODE (node) == FUNCTION_DECL
1342 127745836 : || TREE_CODE (node) == PARM_DECL)
1343 : return;
1344 :
1345 127745500 : decl = node;
1346 127745500 : template_info = maybe_template_info (decl);
1347 : }
1348 : else
1349 : {
1350 : /* Node is a type. */
1351 216930835 : decl = TYPE_NAME (node);
1352 : /* The DECL might not point at the node. */
1353 216930835 : if (CLASSTYPE_TEMPLATE_ID_P (node))
1354 163825463 : template_info = TYPE_TEMPLATE_INFO (node);
1355 : }
1356 :
1357 344676335 : if (TREE_CODE (node) == TEMPLATE_TYPE_PARM)
1358 12438 : write_template_param (node);
1359 344663897 : else if (template_info)
1360 : /* Templated. */
1361 : {
1362 163867794 : write_template_prefix (decl);
1363 163867794 : write_template_args (TI_ARGS (template_info));
1364 : }
1365 180796103 : else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE)
1366 : {
1367 136814 : tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl));
1368 136814 : if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1369 : {
1370 118231 : write_template_prefix (decl);
1371 118231 : write_template_args (TREE_OPERAND (name, 1));
1372 : }
1373 : else
1374 : {
1375 18583 : write_prefix (decl_mangling_context (decl));
1376 18583 : write_unqualified_name (decl);
1377 : }
1378 : }
1379 : else
1380 : /* Not templated. */
1381 : {
1382 180659289 : write_prefix (decl_mangling_context (decl));
1383 180659289 : write_unqualified_name (decl);
1384 180659289 : if (VAR_P (decl)
1385 180659289 : || TREE_CODE (decl) == FIELD_DECL)
1386 : {
1387 : /* <data-member-prefix> := <member source-name> M */
1388 26885 : write_char ('M');
1389 :
1390 : /* Before ABI 18, we did not count these as substitution
1391 : candidates. This leads to incorrect demanglings (and
1392 : ABI divergence to other compilers). */
1393 26885 : if (!abi_check (18))
1394 : return;
1395 : }
1396 : }
1397 :
1398 344676203 : add_substitution (node);
1399 : }
1400 :
1401 : /* <template-prefix> ::= <prefix> <template component>
1402 : ::= <template-param>
1403 : ::= <substitution> */
1404 :
1405 : static void
1406 219474577 : write_template_prefix (const tree node)
1407 : {
1408 219474577 : tree decl = DECL_P (node) ? node : TYPE_NAME (node);
1409 219474577 : tree type = DECL_P (node) ? TREE_TYPE (node) : node;
1410 219474577 : tree context = decl_mangling_context (decl);
1411 219474577 : tree templ;
1412 219474577 : tree substitution;
1413 :
1414 219474577 : MANGLE_TRACE_TREE ("template-prefix", node);
1415 :
1416 : /* Find the template decl. */
1417 219474577 : if (tree info = maybe_template_info (decl))
1418 219304704 : templ = TI_TEMPLATE (info);
1419 169873 : else if (TREE_CODE (type) == TYPENAME_TYPE)
1420 : /* For a typename type, all we have is the name. */
1421 168887 : templ = DECL_NAME (decl);
1422 : else
1423 : {
1424 986 : gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
1425 :
1426 986 : templ = TYPE_TI_TEMPLATE (type);
1427 : }
1428 :
1429 : /* For a member template, though, the template name for the
1430 : innermost name must have all the outer template levels
1431 : instantiated. For instance, consider
1432 :
1433 : template<typename T> struct Outer {
1434 : template<typename U> struct Inner {};
1435 : };
1436 :
1437 : The template name for `Inner' in `Outer<int>::Inner<float>' is
1438 : `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1439 : levels separately, so there's no TEMPLATE_DECL available for this
1440 : (there's only `Outer<T>::Inner<U>').
1441 :
1442 : In order to get the substitutions right, we create a special
1443 : TREE_LIST to represent the substitution candidate for a nested
1444 : template. The TREE_PURPOSE is the template's context, fully
1445 : instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1446 : template.
1447 :
1448 : So, for the example above, `Outer<int>::Inner' is represented as a
1449 : substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1450 : and whose value is `Outer<T>::Inner<U>'. */
1451 219474577 : if (context && TYPE_P (context))
1452 11386712 : substitution = build_tree_list (context, templ);
1453 : else
1454 : substitution = templ;
1455 :
1456 219474577 : if (find_substitution (substitution))
1457 : return;
1458 :
1459 213369459 : if (TREE_TYPE (templ)
1460 213369459 : && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM)
1461 986 : write_template_param (TREE_TYPE (templ));
1462 : else
1463 : {
1464 213368473 : write_prefix (context);
1465 213368473 : write_unqualified_name (decl);
1466 : }
1467 :
1468 213369459 : add_substitution (substitution);
1469 : }
1470 :
1471 : /* "For the purposes of mangling, the name of an anonymous union is considered
1472 : to be the name of the first named data member found by a pre-order,
1473 : depth-first, declaration-order walk of the data members of the anonymous
1474 : union. If there is no such data member (i.e., if all of the data members in
1475 : the union are unnamed), then there is no way for a program to refer to the
1476 : anonymous union, and there is therefore no need to mangle its name." */
1477 :
1478 : static tree
1479 51 : anon_aggr_naming_decl (tree type)
1480 : {
1481 51 : tree field = next_aggregate_field (TYPE_FIELDS (type));
1482 102 : for (; field; field = next_aggregate_field (DECL_CHAIN (field)))
1483 : {
1484 21 : if (DECL_NAME (field))
1485 : return field;
1486 0 : if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1487 0 : if (tree sub = anon_aggr_naming_decl (TREE_TYPE (field)))
1488 : return sub;
1489 : }
1490 : return NULL_TREE;
1491 : }
1492 :
1493 : /* We don't need to handle thunks, vtables, or VTTs here. Those are
1494 : mangled through special entry points.
1495 :
1496 : <unqualified-name> ::= [<module-name>] <operator-name>
1497 : ::= <special-name>
1498 : ::= [<module-name>] <source-name>
1499 : ::= [<module-name>] <unnamed-type-name>
1500 : ::= <local-source-name>
1501 : ::= F <source-name> # member-like constrained friend
1502 :
1503 : <local-source-name> ::= L <source-name> <discriminator> */
1504 :
1505 : static void
1506 5005722 : write_unqualified_id (tree identifier)
1507 : {
1508 5005722 : if (IDENTIFIER_CONV_OP_P (identifier))
1509 15 : write_conversion_operator_name (TREE_TYPE (identifier));
1510 5005707 : else if (IDENTIFIER_OVL_OP_P (identifier))
1511 : {
1512 53499 : const ovl_op_info_t *ovl_op = IDENTIFIER_OVL_OP_INFO (identifier);
1513 53499 : write_string (ovl_op->mangled_name);
1514 53499 : }
1515 4952208 : else if (UDLIT_OPER_P (identifier))
1516 0 : write_literal_operator_name (identifier);
1517 : else
1518 4952208 : write_source_name (identifier);
1519 5005722 : }
1520 :
1521 : static void
1522 823517324 : write_unqualified_name (tree decl)
1523 : {
1524 823517324 : MANGLE_TRACE_TREE ("unqualified-name", decl);
1525 :
1526 823517324 : if (modules_p ())
1527 1858544 : maybe_write_module (decl);
1528 :
1529 823517324 : if (identifier_p (decl))
1530 : {
1531 0 : write_unqualified_id (decl);
1532 0 : return;
1533 : }
1534 :
1535 823517324 : bool found = false;
1536 :
1537 823517324 : if (DECL_NAME (decl) == NULL_TREE
1538 823517324 : && ANON_AGGR_TYPE_P (TREE_TYPE (decl)))
1539 21 : decl = anon_aggr_naming_decl (TREE_TYPE (decl));
1540 823517303 : else if (DECL_NAME (decl) == NULL_TREE)
1541 : {
1542 11643 : found = true;
1543 11643 : gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
1544 11643 : write_source_name (DECL_ASSEMBLER_NAME (decl));
1545 : }
1546 823505660 : else if (DECL_DECLARES_FUNCTION_P (decl))
1547 : {
1548 191057305 : found = true;
1549 :
1550 : /* A constrained hidden friend is mangled like a member function, with
1551 : the name prefixed by 'F'. */
1552 191057305 : if (member_like_constrained_friend_p (decl))
1553 22506 : write_char ('F');
1554 :
1555 382114610 : if (DECL_CONSTRUCTOR_P (decl))
1556 30461952 : write_special_name_constructor (decl);
1557 160595353 : else if (DECL_DESTRUCTOR_P (decl))
1558 7357084 : write_special_name_destructor (decl);
1559 153238269 : else if (DECL_CONV_FN_P (decl))
1560 : {
1561 : /* Conversion operator. Handle it right here.
1562 : <operator> ::= cv <type> */
1563 2725029 : tree type;
1564 2725029 : if (maybe_template_info (decl))
1565 : {
1566 588 : tree fn_type;
1567 588 : fn_type = get_mostly_instantiated_function_type (decl);
1568 588 : type = TREE_TYPE (fn_type);
1569 : }
1570 2724441 : else if (FNDECL_USED_AUTO (decl))
1571 60 : type = DECL_SAVED_AUTO_RETURN_TYPE (decl);
1572 : else
1573 2724381 : type = DECL_CONV_FN_TYPE (decl);
1574 2725029 : write_conversion_operator_name (type);
1575 : }
1576 150513240 : else if (DECL_OVERLOADED_OPERATOR_P (decl))
1577 : {
1578 34489300 : tree t;
1579 34489300 : if (!(t = DECL_RAMP_FN (decl)))
1580 34488908 : t = decl;
1581 34489300 : const char *mangled_name
1582 34489300 : = (ovl_op_info[DECL_ASSIGNMENT_OPERATOR_P (t)]
1583 34489300 : [DECL_OVERLOADED_OPERATOR_CODE_RAW (t)].mangled_name);
1584 34489300 : write_string (mangled_name);
1585 : }
1586 116023940 : else if (UDLIT_OPER_P (DECL_NAME (decl)))
1587 303207 : write_literal_operator_name (DECL_NAME (decl));
1588 : else
1589 : found = false;
1590 : }
1591 :
1592 75348236 : if (found)
1593 : /* OK */;
1594 748169109 : else if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl)
1595 125739 : && DECL_NAMESPACE_SCOPE_P (decl)
1596 748241008 : && decl_linkage (decl) == lk_internal)
1597 : {
1598 60528 : MANGLE_TRACE_TREE ("local-source-name", decl);
1599 60528 : write_char ('L');
1600 60528 : write_source_name (DECL_NAME (decl));
1601 : /* The default discriminator is 1, and that's all we ever use,
1602 : so there's no code to output one here. */
1603 : }
1604 : else
1605 : {
1606 748108581 : tree type = TREE_TYPE (decl);
1607 :
1608 748108581 : if (TREE_CODE (decl) == TYPE_DECL
1609 748108581 : && enum_with_enumerator_for_linkage_p (type))
1610 20 : write_unnamed_enum_name (type);
1611 1111248646 : else if (TREE_CODE (decl) == TYPE_DECL && TYPE_UNNAMED_P (type))
1612 1553 : write_unnamed_type_name (type);
1613 1084612543 : else if (TREE_CODE (decl) == TYPE_DECL && LAMBDA_TYPE_P (type))
1614 2351226 : write_closure_type_name (type);
1615 : else
1616 745755782 : write_source_name (DECL_NAME (decl));
1617 : }
1618 :
1619 : /* We use the ABI tags from the primary class template, ignoring tags on any
1620 : specializations. This is necessary because C++ doesn't require a
1621 : specialization to be declared before it is used unless the use requires a
1622 : complete type, but we need to get the tags right on incomplete types as
1623 : well. */
1624 823517324 : if (tree tmpl = most_general_template (decl))
1625 : {
1626 483890024 : tree res = DECL_TEMPLATE_RESULT (tmpl);
1627 483890024 : if (res == NULL_TREE)
1628 : /* UNBOUND_CLASS_TEMPLATE. */;
1629 483890021 : else if (DECL_DECLARES_TYPE_P (decl))
1630 : decl = res;
1631 167646982 : else if (any_abi_below (11))
1632 : {
1633 : /* ABI v10 implicit tags on the template. */
1634 81578 : tree mtags = missing_abi_tags (res);
1635 : /* Explicit tags on the template. */
1636 81578 : tree ttags = get_abi_tags (res);
1637 : /* Tags on the instantiation. */
1638 81578 : tree dtags = get_abi_tags (decl);
1639 :
1640 81656 : if (mtags && abi_warn_or_compat_version_crosses (10))
1641 6 : G.need_abi_warning = 1;
1642 :
1643 : /* Add the v10 tags to the explicit tags now. */
1644 81578 : mtags = chainon (mtags, ttags);
1645 :
1646 81578 : if (!G.need_abi_warning
1647 163058 : && abi_warn_or_compat_version_crosses (11)
1648 163062 : && !equal_abi_tags (dtags, mtags, /*ignore_inherited_p=*/false))
1649 6 : G.need_abi_warning = 1;
1650 :
1651 81578 : if (!abi_version_at_least (10))
1652 : /* In abi <10, we only got the explicit tags. */
1653 : decl = res;
1654 911 : else if (flag_abi_version == 10)
1655 : {
1656 : /* In ABI 10, we want explicit and implicit tags. */
1657 72 : write_abi_tags (mtags);
1658 72 : return;
1659 : }
1660 : }
1661 : }
1662 :
1663 823517252 : tree tags = get_abi_tags (decl);
1664 186134594 : if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CONV_FN_P (decl)
1665 826242281 : && any_abi_below (11))
1666 2731 : if (tree mtags = missing_abi_tags (decl))
1667 : {
1668 9 : if (!abi_check (11))
1669 6 : tags = chainon (mtags, tags);
1670 : }
1671 823517252 : write_abi_tags (tags);
1672 : }
1673 :
1674 : /* Write the unqualified-name for a conversion operator to TYPE. */
1675 :
1676 : static void
1677 2725044 : write_conversion_operator_name (const tree type)
1678 : {
1679 2725044 : write_string ("cv");
1680 2725044 : write_type (type);
1681 2725044 : }
1682 :
1683 : /* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1684 :
1685 : <source-name> ::= </length/ number> <identifier> */
1686 :
1687 : static void
1688 750800655 : write_source_name (tree identifier)
1689 : {
1690 750800655 : MANGLE_TRACE_TREE ("source-name", identifier);
1691 :
1692 750800655 : write_unsigned_number (IDENTIFIER_LENGTH (identifier));
1693 750800655 : write_identifier (IDENTIFIER_POINTER (identifier));
1694 750800655 : }
1695 :
1696 : /* Compare two TREE_STRINGs like strcmp. */
1697 :
1698 : static int
1699 306 : tree_string_cmp (const void *p1, const void *p2)
1700 : {
1701 306 : if (p1 == p2)
1702 : return 0;
1703 306 : tree s1 = *(const tree*)p1;
1704 306 : tree s2 = *(const tree*)p2;
1705 306 : return strcmp (TREE_STRING_POINTER (s1),
1706 306 : TREE_STRING_POINTER (s2));
1707 : }
1708 :
1709 : /* Return the TREE_LIST of TAGS as a sorted VEC. */
1710 :
1711 : static vec<tree, va_gc> *
1712 502095 : sorted_abi_tags (tree tags, bool ignore_inherited_p)
1713 : {
1714 502095 : vec<tree, va_gc> * vec = make_tree_vector();
1715 :
1716 841288 : for (tree t = tags; t; t = TREE_CHAIN (t))
1717 : {
1718 339193 : if (ABI_TAG_NOT_MANGLED (t)
1719 339193 : || (ignore_inherited_p && ABI_TAG_INHERITED (t)))
1720 6 : continue;
1721 339187 : tree str = TREE_VALUE (t);
1722 339187 : vec_safe_push (vec, str);
1723 : }
1724 :
1725 502095 : vec->qsort (tree_string_cmp);
1726 :
1727 502095 : return vec;
1728 : }
1729 :
1730 : /* ID is the name of a function or type with abi_tags attribute TAGS.
1731 : Write out the name, suitably decorated. */
1732 :
1733 : static void
1734 823517360 : write_abi_tags (tree tags)
1735 : {
1736 823517360 : if (tags == NULL_TREE)
1737 823517360 : return;
1738 :
1739 339061 : vec<tree, va_gc> * vec = sorted_abi_tags (tags, /*ignore_inherited_p=*/false);
1740 :
1741 339061 : unsigned i; tree str;
1742 1017210 : FOR_EACH_VEC_ELT (*vec, i, str)
1743 : {
1744 339088 : write_string ("B");
1745 339088 : write_unsigned_number (TREE_STRING_LENGTH (str) - 1);
1746 339088 : write_identifier (TREE_STRING_POINTER (str));
1747 : }
1748 :
1749 339061 : release_tree_vector (vec);
1750 : }
1751 :
1752 : /* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent. */
1753 :
1754 : bool
1755 81517 : equal_abi_tags (tree t1, tree t2, bool ignore_inherited_p)
1756 : {
1757 81517 : releasing_vec v1 = sorted_abi_tags (t1, ignore_inherited_p);
1758 81517 : releasing_vec v2 = sorted_abi_tags (t2, ignore_inherited_p);
1759 :
1760 81517 : unsigned len1 = v1->length();
1761 81517 : if (len1 != v2->length())
1762 : return false;
1763 81511 : for (unsigned i = 0; i < len1; ++i)
1764 21 : if (strcmp (TREE_STRING_POINTER (v1[i]),
1765 21 : TREE_STRING_POINTER (v2[i])) != 0)
1766 : return false;
1767 : return true;
1768 81517 : }
1769 :
1770 : /* Write a user-defined literal operator.
1771 : ::= li <source-name> # "" <source-name>
1772 : IDENTIFIER is an LITERAL_IDENTIFIER_NODE. */
1773 :
1774 : static void
1775 303207 : write_literal_operator_name (tree identifier)
1776 : {
1777 303207 : const char* suffix = UDLIT_OP_SUFFIX (identifier);
1778 303207 : write_identifier (UDLIT_OP_MANGLED_PREFIX);
1779 303207 : write_unsigned_number (strlen (suffix));
1780 303207 : write_identifier (suffix);
1781 303207 : }
1782 :
1783 : /* Encode 0 as _, and 1+ as n-1_. */
1784 :
1785 : static void
1786 31731154 : write_compact_number (int num)
1787 : {
1788 31731154 : gcc_checking_assert (num >= 0);
1789 31731154 : if (num > 0)
1790 12236331 : write_unsigned_number (num - 1);
1791 31731154 : write_char ('_');
1792 31731154 : }
1793 :
1794 : /* Return how many unnamed types precede TYPE in its enclosing class. */
1795 :
1796 : static int
1797 839 : nested_anon_class_index (tree type)
1798 : {
1799 839 : int index = 0;
1800 839 : tree member = TYPE_FIELDS (TYPE_CONTEXT (type));
1801 22181 : for (; member; member = DECL_CHAIN (member))
1802 22181 : if (DECL_IMPLICIT_TYPEDEF_P (member))
1803 : {
1804 1299 : tree memtype = TREE_TYPE (member);
1805 1299 : if (memtype == type)
1806 : return index;
1807 1124 : else if (TYPE_UNNAMED_P (memtype))
1808 204 : ++index;
1809 : }
1810 :
1811 0 : if (seen_error ())
1812 : return -1;
1813 :
1814 0 : gcc_unreachable ();
1815 : }
1816 :
1817 : /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1818 :
1819 : static void
1820 1553 : write_unnamed_type_name (const tree type)
1821 : {
1822 1553 : int discriminator;
1823 1553 : MANGLE_TRACE_TREE ("unnamed-type-name", type);
1824 :
1825 1553 : if (TYPE_FUNCTION_SCOPE_P (type))
1826 358 : discriminator = discriminator_for_local_entity (TYPE_NAME (type));
1827 1195 : else if (TYPE_CLASS_SCOPE_P (type))
1828 839 : discriminator = nested_anon_class_index (type);
1829 : else
1830 : {
1831 356 : gcc_assert (no_linkage_check (type, /*relaxed_p=*/true));
1832 : /* Just use the old mangling at namespace scope. */
1833 356 : write_source_name (TYPE_IDENTIFIER (type));
1834 356 : return;
1835 : }
1836 :
1837 1197 : write_string ("Ut");
1838 1197 : write_compact_number (discriminator);
1839 : }
1840 :
1841 : /* <unnamed-enum-name> ::= Ue <underlying type> <enumerator source-name> */
1842 :
1843 : static void
1844 20 : write_unnamed_enum_name (const tree type)
1845 : {
1846 20 : MANGLE_TRACE_TREE ("unnamed-enum-name", type);
1847 20 : write_string ("Ue");
1848 20 : write_type (ENUM_UNDERLYING_TYPE (type));
1849 20 : write_source_name (DECL_NAME (TREE_VALUE (TYPE_VALUES (type))));
1850 20 : }
1851 :
1852 : /* ABI issue #47: if a function template parameter is not "natural" for its
1853 : argument we must mangle the parameter. */
1854 :
1855 : static bool
1856 8521693 : template_parm_natural_p (tree arg, tree parm)
1857 : {
1858 8521693 : tree decl = TREE_VALUE (parm);
1859 :
1860 : /* A template parameter is "natural" if: */
1861 :
1862 8521693 : if (template_parameter_pack_p (decl))
1863 : {
1864 834141 : tree args = ARGUMENT_PACK_ARGS (arg);
1865 834141 : if (TREE_VEC_LENGTH (args) == 0)
1866 : {
1867 : #if 0
1868 : /* the argument is an empty pack and the parameter is an
1869 : unconstrained template type parameter pack; */
1870 : if (TREE_CODE (decl) != TYPE_DECL)
1871 : return false;
1872 : #else
1873 : /* Defer changing the mangling of C++11 code like
1874 : template <int i> int max();
1875 : template <int i, int j, int... rest> int max(); */
1876 : return true;
1877 : #endif
1878 : }
1879 : else
1880 : /* the argument is a non-empty pack and a non-pack variant of the
1881 : parameter would be natural for the first element of the pack; */
1882 652872 : arg = TREE_VEC_ELT (args, 0);
1883 : }
1884 :
1885 : /* the argument is a template and the parameter has the exact
1886 : same template head; */
1887 8340424 : if (TREE_CODE (decl) == TEMPLATE_DECL)
1888 9144 : return template_heads_equivalent_p (arg, decl);
1889 :
1890 : /* the argument is a type and the parameter is unconstrained; or */
1891 8331280 : else if (TREE_CODE (decl) == TYPE_DECL)
1892 7308357 : return !TEMPLATE_PARM_CONSTRAINTS (parm);
1893 :
1894 : /* the argument is a non-type template argument and the declared parameter
1895 : type neither is instantiation dependent nor contains deduced types. */
1896 1022923 : else if (TREE_CODE (decl) == PARM_DECL)
1897 : {
1898 : #if 0
1899 : return !uses_template_parms (TREE_TYPE (decl));
1900 : #else
1901 : /* Defer changing the mangling of C++98 code like
1902 : template <class T, T V> .... */
1903 1022923 : return !type_uses_auto (TREE_TYPE (decl));
1904 : #endif
1905 : }
1906 :
1907 0 : gcc_unreachable ();
1908 : }
1909 :
1910 : /* Used for lambda template head and non-natural function template parameters.
1911 :
1912 : <template-param-decl> ::= Ty # template type parameter
1913 : ::= Tk <type-constraint> # constrained type parameter
1914 : ::= Tn <type> # template non-type parameter
1915 : ::= Tt <template-param-decl>* [Q <constraint-expression] E # ttp
1916 : ::= Tp <non-pack template-param-decl> # template parameter pack */
1917 :
1918 : static void
1919 115488 : write_template_param_decl (tree parm)
1920 : {
1921 115488 : tree decl = TREE_VALUE (parm);
1922 :
1923 115488 : if (template_parameter_pack_p (decl))
1924 41221 : write_string ("Tp");
1925 :
1926 115488 : switch (TREE_CODE (decl))
1927 : {
1928 48236 : case PARM_DECL:
1929 48236 : {
1930 48236 : write_string ("Tn");
1931 :
1932 48236 : tree type = TREE_TYPE (decl);
1933 : /* TODO: We need to also mangle constrained auto*, auto&, etc, but
1934 : it's not clear how. See finish_constrained_parameter. */
1935 48236 : if (tree c = (is_auto (type)
1936 52700 : ? TEMPLATE_PARM_CONSTRAINTS (parm)
1937 4464 : : NULL_TREE))
1938 : {
1939 22 : if (TREE_CODE (c) == UNARY_LEFT_FOLD_EXPR)
1940 : {
1941 3 : c = FOLD_EXPR_PACK (c);
1942 3 : c = PACK_EXPANSION_PATTERN (c);
1943 : }
1944 22 : if (AUTO_IS_DECLTYPE (type))
1945 0 : write_string ("DK");
1946 : else
1947 22 : write_string ("Dk");
1948 22 : write_type_constraint (c);
1949 : }
1950 : else
1951 48214 : write_type (type);
1952 : }
1953 : break;
1954 :
1955 351 : case TEMPLATE_DECL:
1956 351 : {
1957 351 : write_string ("Tt");
1958 351 : tree parms = DECL_INNERMOST_TEMPLATE_PARMS (decl);
1959 812 : for (tree node : tree_vec_range (parms))
1960 461 : write_template_param_decl (node);
1961 351 : write_char ('E');
1962 : }
1963 351 : break;
1964 :
1965 66901 : case TYPE_DECL:
1966 66901 : if (tree c = TEMPLATE_PARM_CONSTRAINTS (parm))
1967 : {
1968 37167 : if (TREE_CODE (c) == UNARY_LEFT_FOLD_EXPR)
1969 : {
1970 70 : c = FOLD_EXPR_PACK (c);
1971 70 : c = PACK_EXPANSION_PATTERN (c);
1972 : }
1973 37167 : if (TREE_CODE (decl) == TYPE_DECL)
1974 : {
1975 37167 : write_string ("Tk");
1976 37167 : write_type_constraint (c);
1977 : }
1978 : }
1979 : else
1980 29734 : write_string ("Ty");
1981 : break;
1982 :
1983 0 : default:
1984 0 : gcc_unreachable ();
1985 : }
1986 115488 : }
1987 :
1988 : // A template head, for templated lambdas.
1989 : // New in ABI=18. Returns true iff we emitted anything -- used for ABI
1990 : // version warning.
1991 :
1992 : static bool
1993 517205 : write_closure_template_head (tree tmpl)
1994 : {
1995 517205 : bool any = false;
1996 :
1997 : // We only need one level of template parms
1998 517205 : tree parms = DECL_TEMPLATE_PARMS (tmpl);
1999 517205 : tree inner = INNERMOST_TEMPLATE_PARMS (parms);
2000 :
2001 590694 : for (int ix = 0, len = TREE_VEC_LENGTH (inner); ix != len; ix++)
2002 : {
2003 535593 : tree parm = TREE_VEC_ELT (inner, ix);
2004 535593 : if (parm == error_mark_node)
2005 0 : continue;
2006 :
2007 535593 : if (DECL_IMPLICIT_TEMPLATE_PARM_P (TREE_VALUE (parm)))
2008 : // A synthetic parm, we're done.
2009 : break;
2010 :
2011 73489 : any = true;
2012 73489 : if (abi_version_at_least (18))
2013 73249 : write_template_param_decl (parm);
2014 : }
2015 :
2016 517205 : write_tparms_constraints (TEMPLATE_PARMS_CONSTRAINTS (parms));
2017 :
2018 517205 : return any;
2019 : }
2020 :
2021 : /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
2022 : <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters */
2023 :
2024 : static void
2025 2351226 : write_closure_type_name (const tree type)
2026 : {
2027 2351226 : tree fn = lambda_function (type);
2028 2351226 : tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
2029 2351226 : tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn));
2030 :
2031 2351226 : MANGLE_TRACE_TREE ("closure-type-name", type);
2032 :
2033 2351226 : write_string ("Ul");
2034 :
2035 2351226 : if (auto ti = maybe_template_info (fn))
2036 517205 : if (write_closure_template_head (TI_TEMPLATE (ti)))
2037 : // If there were any explicit template parms, we may need to
2038 : // issue a mangling diagnostic.
2039 361005 : if (abi_warn_or_compat_version_crosses (18))
2040 198 : G.need_abi_warning = true;
2041 :
2042 2351226 : write_method_parms (parms, TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE, fn);
2043 2351226 : write_char ('E');
2044 2351226 : if ((LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR (lambda)
2045 2351226 : != LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR (lambda))
2046 3196898 : && abi_warn_or_compat_version_crosses (18))
2047 288 : G.need_abi_warning = true;
2048 4702452 : write_compact_number (abi_version_at_least (18)
2049 2350704 : ? LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR (lambda)
2050 522 : : LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR (lambda));
2051 2351226 : }
2052 :
2053 : /* Convert NUMBER to ascii using base BASE and generating at least
2054 : MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
2055 : into which to store the characters. Returns the number of
2056 : characters generated (these will be laid out in advance of where
2057 : BUFFER points). */
2058 :
2059 : static int
2060 1016160653 : hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base,
2061 : char *buffer, const unsigned int min_digits)
2062 : {
2063 1016160653 : static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
2064 1016160653 : unsigned digits = 0;
2065 :
2066 2528645111 : while (number)
2067 : {
2068 1512484458 : unsigned HOST_WIDE_INT d = number / base;
2069 :
2070 1512484458 : *--buffer = base_digits[number - d * base];
2071 1512484458 : digits++;
2072 1512484458 : number = d;
2073 : }
2074 1070224358 : while (digits < min_digits)
2075 : {
2076 54063705 : *--buffer = base_digits[0];
2077 54063705 : digits++;
2078 : }
2079 1016160653 : return digits;
2080 : }
2081 :
2082 : /* Non-terminal <number>.
2083 :
2084 : <number> ::= [n] </decimal integer/> */
2085 :
2086 : static void
2087 1016160353 : write_number (unsigned HOST_WIDE_INT number, const int unsigned_p,
2088 : const unsigned int base)
2089 : {
2090 1016160353 : char buffer[sizeof (HOST_WIDE_INT) * 8];
2091 1016160353 : unsigned count = 0;
2092 :
2093 1016160353 : if (!unsigned_p && (HOST_WIDE_INT) number < 0)
2094 : {
2095 0 : write_char ('n');
2096 0 : number = -((HOST_WIDE_INT) number);
2097 : }
2098 1016160353 : count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
2099 1016160353 : write_chars (buffer + sizeof (buffer) - count, count);
2100 1016160353 : }
2101 :
2102 : /* Write out an integral CST in decimal. Most numbers are small, and
2103 : representable in a HOST_WIDE_INT. Occasionally we'll have numbers
2104 : bigger than that, which we must deal with. */
2105 :
2106 : static inline void
2107 95866862 : write_integer_cst (const tree cst)
2108 : {
2109 95866862 : int sign = tree_int_cst_sgn (cst);
2110 95866862 : widest_int abs_value = wi::abs (wi::to_widest (cst));
2111 95866862 : if (!wi::fits_uhwi_p (abs_value))
2112 : {
2113 : /* A bignum. We do this in chunks, each of which fits in a
2114 : HOST_WIDE_INT. */
2115 100 : char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
2116 100 : unsigned HOST_WIDE_INT chunk;
2117 100 : unsigned chunk_digits;
2118 100 : char *ptr = buffer + sizeof (buffer);
2119 100 : unsigned count = 0;
2120 100 : tree n, base, type;
2121 100 : int done;
2122 :
2123 : /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
2124 : representable. */
2125 100 : chunk = 1000000000;
2126 100 : chunk_digits = 9;
2127 :
2128 100 : if (sizeof (HOST_WIDE_INT) >= 8)
2129 : {
2130 : /* It is at least 64 bits, so 10^18 is representable. */
2131 100 : chunk_digits = 18;
2132 100 : chunk *= chunk;
2133 : }
2134 :
2135 100 : type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
2136 100 : base = build_int_cstu (type, chunk);
2137 100 : n = wide_int_to_tree (type, wi::to_wide (cst));
2138 :
2139 100 : if (sign < 0)
2140 : {
2141 0 : write_char ('n');
2142 0 : n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
2143 : }
2144 300 : do
2145 : {
2146 300 : tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
2147 300 : tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
2148 300 : unsigned c;
2149 :
2150 300 : done = integer_zerop (d);
2151 300 : tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
2152 400 : c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr,
2153 : done ? 1 : chunk_digits);
2154 300 : ptr -= c;
2155 300 : count += c;
2156 300 : n = d;
2157 : }
2158 300 : while (!done);
2159 100 : write_chars (ptr, count);
2160 : }
2161 : else
2162 : {
2163 : /* A small num. */
2164 95866762 : if (sign < 0)
2165 488075 : write_char ('n');
2166 95866762 : write_unsigned_number (abs_value.to_uhwi ());
2167 : }
2168 95866862 : }
2169 :
2170 : /* Write out a floating-point literal.
2171 :
2172 : "Floating-point literals are encoded using the bit pattern of the
2173 : target processor's internal representation of that number, as a
2174 : fixed-length lowercase hexadecimal string, high-order bytes first
2175 : (even if the target processor would store low-order bytes first).
2176 : The "n" prefix is not used for floating-point literals; the sign
2177 : bit is encoded with the rest of the number.
2178 :
2179 : Here are some examples, assuming the IEEE standard representation
2180 : for floating point numbers. (Spaces are for readability, not
2181 : part of the encoding.)
2182 :
2183 : 1.0f Lf 3f80 0000 E
2184 : -1.0f Lf bf80 0000 E
2185 : 1.17549435e-38f Lf 0080 0000 E
2186 : 1.40129846e-45f Lf 0000 0001 E
2187 : 0.0f Lf 0000 0000 E"
2188 :
2189 : Caller is responsible for the Lx and the E. */
2190 : static void
2191 2549 : write_real_cst (const tree value)
2192 : {
2193 2549 : long target_real[4]; /* largest supported float */
2194 : /* Buffer for eight hex digits in a 32-bit number but big enough
2195 : even for 64-bit long to avoid warnings. */
2196 2549 : char buffer[17];
2197 2549 : int i, limit, dir;
2198 :
2199 2549 : tree type = TREE_TYPE (value);
2200 2549 : int bits = GET_MODE_BITSIZE (SCALAR_FLOAT_TYPE_MODE (type));
2201 2549 : int words = bits / 32;
2202 :
2203 2549 : real_to_target (target_real, &TREE_REAL_CST (value),
2204 2549 : TYPE_MODE (type));
2205 :
2206 2549 : if (words == 0)
2207 : {
2208 : /* _Float16 and std::bfloat16_t are the only supported types smaller than
2209 : 32 bits. */
2210 382 : gcc_assert (bits == 16);
2211 382 : sprintf (buffer, "%04lx", (unsigned long) target_real[0]);
2212 382 : write_chars (buffer, 4);
2213 382 : return;
2214 : }
2215 :
2216 2167 : gcc_assert (bits % 32 == 0);
2217 :
2218 : /* The value in target_real is in the target word order,
2219 : so we must write it out backward if that happens to be
2220 : little-endian. write_number cannot be used, it will
2221 : produce uppercase. */
2222 2167 : if (FLOAT_WORDS_BIG_ENDIAN)
2223 : i = 0, limit = words, dir = 1;
2224 : else
2225 2167 : i = words - 1, limit = -1, dir = -1;
2226 :
2227 2195 : if (GET_MODE_PRECISION (SCALAR_FLOAT_TYPE_MODE (type)) == 80
2228 2167 : && abi_check (21))
2229 : {
2230 : /* For -fabi-version=21 and above mangle
2231 : Intel/Motorola extended format 1.0L as
2232 : 3fff8000000000000000
2233 : rather than the previous
2234 : 0000000000003fff8000000000000000 (x86_64)
2235 : 00003fff8000000000000000 (ia32)
2236 : 3fff00008000000000000000 (m68k -mc68020)
2237 : i.e. without any embedded padding bits. */
2238 30 : if (words == 4)
2239 : i += dir;
2240 : else
2241 0 : gcc_assert (words == 3);
2242 30 : unsigned long val = (unsigned long) target_real[i];
2243 30 : if (REAL_MODE_FORMAT (SCALAR_FLOAT_TYPE_MODE (type))->signbit_ro == 95)
2244 0 : val >>= 16;
2245 30 : sprintf (buffer, "%04lx", val);
2246 30 : write_chars (buffer, 4);
2247 30 : i += dir;
2248 : }
2249 :
2250 6033 : for (; i != limit; i += dir)
2251 : {
2252 3866 : sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
2253 3866 : write_chars (buffer, 8);
2254 : }
2255 : }
2256 :
2257 : /* Non-terminal <identifier>.
2258 :
2259 : <identifier> ::= </unqualified source code identifier> */
2260 :
2261 : static void
2262 752624120 : write_identifier (const char *identifier)
2263 : {
2264 752624120 : MANGLE_TRACE ("identifier", identifier);
2265 752624120 : write_string (identifier);
2266 752624120 : }
2267 :
2268 : /* Handle constructor productions of non-terminal <special-name>.
2269 : CTOR is a constructor FUNCTION_DECL.
2270 :
2271 : <special-name> ::= C1 # complete object constructor
2272 : ::= C2 # base object constructor
2273 : ::= C3 # complete object allocating constructor
2274 :
2275 : Currently, allocating constructors are never used. */
2276 :
2277 : static void
2278 30461952 : write_special_name_constructor (const tree ctor)
2279 : {
2280 30461952 : write_char ('C');
2281 30461952 : bool new_inh = (flag_new_inheriting_ctors
2282 60908177 : && DECL_INHERITED_CTOR (ctor));
2283 161772 : if (new_inh)
2284 161772 : write_char ('I');
2285 30461952 : if (DECL_BASE_CONSTRUCTOR_P (ctor))
2286 6285297 : write_char ('2');
2287 : /* This is the old-style "[unified]" constructor.
2288 : In some cases, we may emit this function and call
2289 : it from the clones in order to share code and save space. */
2290 24176655 : else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor))
2291 17894449 : write_char ('4');
2292 : else
2293 : {
2294 6282206 : gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor));
2295 6282206 : write_char ('1');
2296 : }
2297 30461952 : if (new_inh)
2298 323544 : write_type (DECL_INHERITED_CTOR_BASE (ctor));
2299 30461952 : }
2300 :
2301 : /* Handle destructor productions of non-terminal <special-name>.
2302 : DTOR is a destructor FUNCTION_DECL.
2303 :
2304 : <special-name> ::= D0 # deleting (in-charge) destructor
2305 : ::= D1 # complete object (in-charge) destructor
2306 : ::= D2 # base object (not-in-charge) destructor */
2307 :
2308 : static void
2309 7357084 : write_special_name_destructor (const tree dtor)
2310 : {
2311 7357084 : if (DECL_DELETING_DESTRUCTOR_P (dtor))
2312 620050 : write_string ("D0");
2313 6737034 : else if (DECL_BASE_DESTRUCTOR_P (dtor))
2314 1606011 : write_string ("D2");
2315 5131023 : else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor))
2316 : /* This is the old-style "[unified]" destructor.
2317 : In some cases, we may emit this function and call
2318 : it from the clones in order to share code and save space. */
2319 2929516 : write_string ("D4");
2320 : else
2321 : {
2322 2201507 : gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor));
2323 2201507 : write_string ("D1");
2324 : }
2325 7357084 : }
2326 :
2327 : /* Return the discriminator for ENTITY appearing inside
2328 : FUNCTION. The discriminator is the lexical ordinal of VAR or TYPE among
2329 : entities with the same name and kind in the same FUNCTION. */
2330 :
2331 : static int
2332 2784914 : discriminator_for_local_entity (tree entity)
2333 : {
2334 2784914 : if (!DECL_LANG_SPECIFIC (entity))
2335 : {
2336 : /* Some decls, like __FUNCTION__, don't need a discriminator. */
2337 32156 : gcc_checking_assert (DECL_ARTIFICIAL (entity));
2338 : return 0;
2339 : }
2340 5360782 : else if (tree disc = DECL_DISCRIMINATOR (entity))
2341 511 : return TREE_INT_CST_LOW (disc);
2342 : else
2343 : /* The first entity with a particular name doesn't get
2344 : DECL_DISCRIMINATOR set up. */
2345 : return 0;
2346 : }
2347 :
2348 : /* Return the discriminator for STRING, a string literal used inside
2349 : FUNCTION. The discriminator is the lexical ordinal of STRING among
2350 : string literals used in FUNCTION. */
2351 :
2352 : static int
2353 0 : discriminator_for_string_literal (tree /*function*/,
2354 : tree /*string*/)
2355 : {
2356 : /* For now, we don't discriminate amongst string literals. */
2357 0 : return 0;
2358 : }
2359 :
2360 : /* <discriminator> := _ <number> # when number < 10
2361 : := __ <number> _ # when number >= 10
2362 :
2363 : The discriminator is used only for the second and later occurrences
2364 : of the same name within a single function. In this case <number> is
2365 : n - 2, if this is the nth occurrence, in lexical order. */
2366 :
2367 : static void
2368 2784556 : write_discriminator (const int discriminator)
2369 : {
2370 : /* If discriminator is zero, don't write anything. Otherwise... */
2371 2784556 : if (discriminator > 0)
2372 : {
2373 478 : write_char ('_');
2374 478 : if (discriminator - 1 >= 10)
2375 : {
2376 6 : if (abi_check (11))
2377 6 : write_char ('_');
2378 : }
2379 478 : write_unsigned_number (discriminator - 1);
2380 478 : if (abi_version_at_least (11) && discriminator - 1 >= 10)
2381 6 : write_char ('_');
2382 : }
2383 2784556 : }
2384 :
2385 : /* Mangle the name of a function-scope entity. FUNCTION is the
2386 : FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
2387 : default argument scope. ENTITY is the decl for the entity itself.
2388 : LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
2389 : either ENTITY itself or an enclosing scope of ENTITY.
2390 :
2391 : <local-name> := Z <function encoding> E <entity name> [<discriminator>]
2392 : := Z <function encoding> E s [<discriminator>]
2393 : := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
2394 :
2395 : static void
2396 5063933 : write_local_name (tree function, const tree local_entity,
2397 : const tree entity)
2398 : {
2399 5063933 : tree parm = NULL_TREE;
2400 :
2401 5063933 : MANGLE_TRACE_TREE ("local-name", entity);
2402 :
2403 5063933 : if (TREE_CODE (function) == PARM_DECL)
2404 : {
2405 366 : parm = function;
2406 366 : function = DECL_CONTEXT (parm);
2407 : }
2408 :
2409 5063933 : write_char ('Z');
2410 5063933 : write_encoding (function);
2411 5063933 : write_char ('E');
2412 :
2413 : /* For this purpose, parameters are numbered from right-to-left. */
2414 5063933 : if (parm)
2415 : {
2416 366 : int i = list_length (parm);
2417 366 : write_char ('d');
2418 366 : write_compact_number (i - 1);
2419 : }
2420 :
2421 5063933 : if (TREE_CODE (entity) == STRING_CST)
2422 : {
2423 0 : write_char ('s');
2424 0 : write_discriminator (discriminator_for_string_literal (function,
2425 : entity));
2426 : }
2427 : else
2428 : {
2429 : /* Now the <entity name>. Let write_name know its being called
2430 : from <local-name>, so it doesn't try to process the enclosing
2431 : function scope again. */
2432 5063933 : write_name (entity, /*ignore_local_scope=*/true);
2433 5063933 : if (DECL_DISCRIMINATOR_P (local_entity)
2434 15014236 : && !(TREE_CODE (local_entity) == TYPE_DECL
2435 14660523 : && TYPE_ANON_P (TREE_TYPE (local_entity))))
2436 2784287 : write_discriminator (discriminator_for_local_entity (local_entity));
2437 : }
2438 5063933 : }
2439 :
2440 : /* Non-terminals <type> and <CV-qualifier>.
2441 :
2442 : <type> ::= <builtin-type>
2443 : ::= <function-type>
2444 : ::= <class-enum-type>
2445 : ::= <array-type>
2446 : ::= <pointer-to-member-type>
2447 : ::= <template-param>
2448 : ::= <substitution>
2449 : ::= <CV-qualifier>
2450 : ::= P <type> # pointer-to
2451 : ::= R <type> # reference-to
2452 : ::= C <type> # complex pair (C 2000)
2453 : ::= G <type> # imaginary (C 2000) [not supported]
2454 : ::= U <source-name> <type> # vendor extended type qualifier
2455 :
2456 : C++11 extensions
2457 :
2458 : <type> ::= RR <type> # rvalue reference-to
2459 : <type> ::= Dt <expression> # decltype of an id-expression or
2460 : # class member access
2461 : <type> ::= DT <expression> # decltype of an expression
2462 : <type> ::= Dn # decltype of nullptr
2463 : <type> ::= Dm # decltype of ^^int
2464 : <type> ::= <splice> # C++26 dependent splice [proposed]
2465 :
2466 : TYPE is a type node. */
2467 :
2468 : static void
2469 1284481278 : write_type (tree type)
2470 : {
2471 : /* This gets set to nonzero if TYPE turns out to be a (possibly
2472 : CV-qualified) builtin type. */
2473 1284481287 : int is_builtin_type = 0;
2474 :
2475 1284481287 : MANGLE_TRACE_TREE ("type", type);
2476 :
2477 1284481287 : if (type == error_mark_node)
2478 : return;
2479 :
2480 1284481272 : type = canonicalize_for_substitution (type);
2481 1284481272 : if (find_substitution (type))
2482 : return;
2483 :
2484 :
2485 1172060397 : if (write_CV_qualifiers_for_type (type) > 0)
2486 : /* If TYPE was CV-qualified, we just wrote the qualifiers; now
2487 : mangle the unqualified type. The recursive call is needed here
2488 : since both the qualified and unqualified types are substitution
2489 : candidates. */
2490 : {
2491 82651794 : tree t = TYPE_MAIN_VARIANT (type);
2492 82651794 : if (TYPE_ATTRIBUTES (t) && !OVERLOAD_TYPE_P (t))
2493 : {
2494 99 : tree attrs = NULL_TREE;
2495 99 : if (tx_safe_fn_type_p (type))
2496 3 : attrs = tree_cons (get_identifier ("transaction_safe"),
2497 : NULL_TREE, attrs);
2498 99 : t = cp_build_type_attribute_variant (t, attrs);
2499 : }
2500 82651794 : gcc_assert (t != type);
2501 82651794 : if (FUNC_OR_METHOD_TYPE_P (t))
2502 : {
2503 6725 : t = build_ref_qualified_type (t, type_memfn_rqual (type));
2504 6725 : if (flag_noexcept_type)
2505 : {
2506 6704 : tree r = TYPE_RAISES_EXCEPTIONS (type);
2507 6704 : t = build_exception_variant (t, r);
2508 : }
2509 6725 : if (abi_version_at_least (8)
2510 6749 : || type == TYPE_MAIN_VARIANT (type))
2511 : /* Avoid adding the unqualified function type as a substitution. */
2512 6701 : write_function_type (t);
2513 : else
2514 24 : write_type (t);
2515 33508 : if (abi_warn_or_compat_version_crosses (8))
2516 39 : G.need_abi_warning = 1;
2517 : }
2518 : else
2519 82645069 : write_type (t);
2520 : }
2521 1089408603 : else if (TREE_CODE (type) == ARRAY_TYPE)
2522 : /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
2523 : so that the cv-qualification of the element type is available
2524 : in write_array_type. */
2525 1568769 : write_array_type (type);
2526 : else
2527 : {
2528 1087839834 : tree type_orig = type;
2529 :
2530 : /* See through any typedefs. */
2531 1087839834 : type = TYPE_MAIN_VARIANT (type);
2532 1087839834 : if (FUNC_OR_METHOD_TYPE_P (type))
2533 3244567 : type = cxx_copy_lang_qualifiers (type, type_orig);
2534 :
2535 : /* According to the C++ ABI, some library classes are passed the
2536 : same as the scalar type of their single member and use the same
2537 : mangling. */
2538 1087839834 : if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
2539 16206 : type = TREE_TYPE (first_field (type));
2540 :
2541 1087839834 : if (TYPE_PTRDATAMEM_P (type))
2542 17088 : write_pointer_to_member_type (type);
2543 : else
2544 : {
2545 : /* Handle any target-specific fundamental types. */
2546 1087822746 : const char *target_mangling
2547 1087822746 : = targetm.mangle_type (type_orig);
2548 :
2549 1087822746 : if (target_mangling)
2550 : {
2551 9757192 : write_string (target_mangling);
2552 : /* Add substitutions for types other than fundamental
2553 : types. */
2554 9757192 : if (!VOID_TYPE_P (type)
2555 : && TREE_CODE (type) != INTEGER_TYPE
2556 : && TREE_CODE (type) != REAL_TYPE
2557 : && TREE_CODE (type) != BOOLEAN_TYPE)
2558 0 : add_substitution (type);
2559 : return;
2560 : }
2561 :
2562 1078065554 : switch (TREE_CODE (type))
2563 : {
2564 579873976 : case VOID_TYPE:
2565 579873976 : case BOOLEAN_TYPE:
2566 579873976 : case INTEGER_TYPE: /* Includes wchar_t. */
2567 579873976 : case REAL_TYPE:
2568 579873976 : case FIXED_POINT_TYPE:
2569 579873976 : {
2570 : /* If this is a typedef, TYPE may not be one of
2571 : the standard builtin type nodes, but an alias of one. Use
2572 : TYPE_MAIN_VARIANT to get to the underlying builtin type. */
2573 579873976 : write_builtin_type (TYPE_MAIN_VARIANT (type));
2574 579873976 : ++is_builtin_type;
2575 : }
2576 579873976 : break;
2577 :
2578 687031 : case COMPLEX_TYPE:
2579 687031 : write_char ('C');
2580 687031 : write_type (TREE_TYPE (type));
2581 687031 : break;
2582 :
2583 3244567 : case FUNCTION_TYPE:
2584 3244567 : case METHOD_TYPE:
2585 3244567 : write_function_type (type);
2586 3244567 : break;
2587 :
2588 323852700 : case UNION_TYPE:
2589 323852700 : case RECORD_TYPE:
2590 323852700 : case ENUMERAL_TYPE:
2591 : /* A pointer-to-member function is represented as a special
2592 : RECORD_TYPE, so check for this first. */
2593 323852700 : if (TYPE_PTRMEMFUNC_P (type))
2594 266877 : write_pointer_to_member_type (type);
2595 : else
2596 323585823 : write_class_enum_type (type);
2597 : break;
2598 :
2599 2701029 : case TYPENAME_TYPE:
2600 2701029 : case UNBOUND_CLASS_TEMPLATE:
2601 : /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2602 : ordinary nested names. */
2603 2701029 : write_nested_name (TYPE_STUB_DECL (type));
2604 2701029 : break;
2605 :
2606 133718693 : case POINTER_TYPE:
2607 133718693 : case REFERENCE_TYPE:
2608 133718693 : if (TYPE_PTR_P (type))
2609 57347276 : write_char ('P');
2610 76371417 : else if (TYPE_REF_IS_RVALUE (type))
2611 12848989 : write_char ('O');
2612 : else
2613 63522428 : write_char ('R');
2614 133718693 : {
2615 133718693 : tree target = TREE_TYPE (type);
2616 : /* Attribute const/noreturn are not reflected in mangling.
2617 : We strip them here rather than at a lower level because
2618 : a typedef or template argument can have function type
2619 : with function-cv-quals (that use the same representation),
2620 : but you can't have a pointer/reference to such a type. */
2621 133718693 : if (TREE_CODE (target) == FUNCTION_TYPE)
2622 : {
2623 11078970 : if (abi_warn_or_compat_version_crosses (5)
2624 2216148 : && TYPE_QUALS (target) != TYPE_UNQUALIFIED)
2625 3 : G.need_abi_warning = 1;
2626 2216142 : if (abi_version_at_least (5))
2627 2215713 : target = build_qualified_type (target, TYPE_UNQUALIFIED);
2628 : }
2629 133718693 : write_type (target);
2630 : }
2631 133718693 : break;
2632 :
2633 29068007 : case TEMPLATE_TYPE_PARM:
2634 29068007 : if (is_auto (type))
2635 : {
2636 877996 : if (template_placeholder_p (type)
2637 877996 : && abi_check (19))
2638 : {
2639 : /* ABI #109: placeholder is mangled as its template. */
2640 33 : type = CLASS_PLACEHOLDER_TEMPLATE (type);
2641 33 : if (find_substitution (type))
2642 : return;
2643 33 : write_name (type);
2644 33 : break;
2645 : }
2646 877963 : if (AUTO_IS_DECLTYPE (type))
2647 22907 : write_identifier ("Dc");
2648 : else
2649 855056 : write_identifier ("Da");
2650 : ++is_builtin_type;
2651 : break;
2652 : }
2653 : /* fall through. */
2654 28190011 : case TEMPLATE_PARM_INDEX:
2655 28190011 : write_template_param (type);
2656 28190011 : break;
2657 :
2658 93 : case TEMPLATE_TEMPLATE_PARM:
2659 93 : write_template_template_param (type);
2660 93 : break;
2661 :
2662 536 : case BOUND_TEMPLATE_TEMPLATE_PARM:
2663 536 : write_template_template_param (type);
2664 536 : write_template_args
2665 536 : (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type)));
2666 536 : break;
2667 :
2668 35177 : case VECTOR_TYPE:
2669 35177 : if (abi_version_at_least (4))
2670 : {
2671 35162 : write_string ("Dv");
2672 : /* Non-constant vector size would be encoded with
2673 : _ expression, but we don't support that yet. */
2674 35162 : write_unsigned_number (TYPE_VECTOR_SUBPARTS (type)
2675 : .to_constant ());
2676 35162 : write_char ('_');
2677 35162 : }
2678 : else
2679 15 : write_string ("U8__vector");
2680 175840 : if (abi_warn_or_compat_version_crosses (4))
2681 15 : G.need_abi_warning = 1;
2682 35177 : write_type (TREE_TYPE (type));
2683 35177 : break;
2684 :
2685 3408618 : case TYPE_PACK_EXPANSION:
2686 3408618 : write_string ("Dp");
2687 3408618 : write_type (PACK_EXPANSION_PATTERN (type));
2688 3408618 : break;
2689 :
2690 450273 : case DECLTYPE_TYPE:
2691 : /* These shouldn't make it into mangling. */
2692 450273 : gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)
2693 : && !DECLTYPE_FOR_LAMBDA_PROXY (type));
2694 :
2695 : /* In ABI <5, we stripped decltype of a plain decl. */
2696 450273 : if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2697 : {
2698 555 : tree expr = DECLTYPE_TYPE_EXPR (type);
2699 555 : tree etype = NULL_TREE;
2700 555 : switch (TREE_CODE (expr))
2701 : {
2702 119 : case VAR_DECL:
2703 119 : case PARM_DECL:
2704 119 : case RESULT_DECL:
2705 119 : case FUNCTION_DECL:
2706 119 : case CONST_DECL:
2707 119 : case TEMPLATE_PARM_INDEX:
2708 119 : etype = TREE_TYPE (expr);
2709 119 : break;
2710 :
2711 : default:
2712 : break;
2713 : }
2714 :
2715 119 : if (etype && !type_uses_auto (etype))
2716 : {
2717 117 : if (!abi_check (5))
2718 : {
2719 : write_type (etype);
2720 : return;
2721 : }
2722 : }
2723 : }
2724 :
2725 450264 : write_char ('D');
2726 450264 : if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type))
2727 546 : write_char ('t');
2728 : else
2729 449718 : write_char ('T');
2730 450264 : ++cp_unevaluated_operand;
2731 450264 : write_expression (DECLTYPE_TYPE_EXPR (type));
2732 450264 : --cp_unevaluated_operand;
2733 450264 : write_char ('E');
2734 450264 : break;
2735 :
2736 797203 : case NULLPTR_TYPE:
2737 797203 : write_string ("Dn");
2738 797203 : if (abi_check (7))
2739 : ++is_builtin_type;
2740 : break;
2741 :
2742 48 : case SPLICE_SCOPE:
2743 48 : write_splice (type);
2744 48 : break;
2745 :
2746 3 : case TYPEOF_TYPE:
2747 3 : sorry ("mangling %<typeof%>, use %<decltype%> instead");
2748 3 : break;
2749 :
2750 21 : case TRAIT_TYPE:
2751 21 : error ("use of built-in trait %qT in function signature; "
2752 : "use library traits instead", type);
2753 21 : break;
2754 :
2755 29 : case PACK_INDEX_TYPE:
2756 : /* https://github.com/itanium-cxx-abi/cxx-abi/issues/175. */
2757 29 : write_string ("Dy");
2758 29 : if (TREE_CODE (PACK_INDEX_PACK (type)) == TREE_VEC)
2759 : {
2760 6 : write_char ('J');
2761 40 : for (int i = 0; i < TREE_VEC_LENGTH (PACK_INDEX_PACK (type));
2762 : ++i)
2763 14 : write_template_arg (TREE_VEC_ELT (PACK_INDEX_PACK (type),
2764 : i));
2765 6 : write_char ('E');
2766 : }
2767 : else
2768 : /* Dy rather than DyDp. */
2769 23 : write_type (PACK_EXPANSION_PATTERN (PACK_INDEX_PACK (type)));
2770 29 : write_expression (PACK_INDEX_INDEX (type));
2771 29 : break;
2772 :
2773 227550 : case OPAQUE_TYPE:
2774 227550 : if (REFLECTION_TYPE_P (type))
2775 : {
2776 227550 : write_string ("Dm");
2777 227550 : ++is_builtin_type;
2778 227550 : break;
2779 : }
2780 : /* fall through. */
2781 :
2782 0 : default:
2783 0 : gcc_unreachable ();
2784 : }
2785 : }
2786 : }
2787 :
2788 : /* Types other than builtin types are substitution candidates. */
2789 1161499307 : if (!is_builtin_type)
2790 580526506 : add_substitution (type);
2791 : }
2792 :
2793 : /* qsort callback for sorting a vector of attribute entries. */
2794 :
2795 : static int
2796 0 : attr_strcmp (const void *p1, const void *p2)
2797 : {
2798 0 : tree a1 = *(const tree*)p1;
2799 0 : tree a2 = *(const tree*)p2;
2800 :
2801 0 : const attribute_spec *as1 = lookup_attribute_spec (get_attribute_name (a1));
2802 0 : const attribute_spec *as2 = lookup_attribute_spec (get_attribute_name (a2));
2803 :
2804 0 : return strcmp (as1->name, as2->name);
2805 : }
2806 :
2807 : /* Return true if we should mangle a type attribute with name NAME. */
2808 :
2809 : static bool
2810 12128 : mangle_type_attribute_p (tree name)
2811 : {
2812 12128 : const attribute_spec *as = lookup_attribute_spec (name);
2813 12128 : if (!as || !as->affects_type_identity)
2814 : return false;
2815 :
2816 : /* Skip internal-only attributes, which are distinguished from others
2817 : by having a space. At present, all internal-only attributes that
2818 : affect type identity are target-specific and are handled by
2819 : targetm.mangle_type instead.
2820 :
2821 : Another reason to do this is that a space isn't a valid identifier
2822 : character for most file formats. */
2823 57 : if (strchr (IDENTIFIER_POINTER (name), ' '))
2824 : return false;
2825 :
2826 : /* The following attributes are mangled specially. */
2827 57 : if (is_attribute_p ("transaction_safe", name))
2828 : return false;
2829 33 : if (is_attribute_p ("abi_tag", name))
2830 0 : return false;
2831 :
2832 : return true;
2833 : }
2834 :
2835 : /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
2836 : CV-qualifiers written for TYPE.
2837 :
2838 : <CV-qualifiers> ::= [r] [V] [K] */
2839 :
2840 : static int
2841 1172327274 : write_CV_qualifiers_for_type (const tree type)
2842 : {
2843 1172327274 : int num_qualifiers = 0;
2844 :
2845 : /* The order is specified by:
2846 :
2847 : "In cases where multiple order-insensitive qualifiers are
2848 : present, they should be ordered 'K' (closest to the base type),
2849 : 'V', 'r', and 'U' (farthest from the base type) ..." */
2850 :
2851 : /* Mangle attributes that affect type identity as extended qualifiers.
2852 :
2853 : We don't do this with classes and enums because their attributes
2854 : are part of their definitions, not something added on. */
2855 :
2856 1172327274 : if (!OVERLOAD_TYPE_P (type))
2857 : {
2858 813380524 : auto_vec<tree> vec;
2859 813392652 : for (tree a = TYPE_ATTRIBUTES (type); a; a = TREE_CHAIN (a))
2860 12128 : if (mangle_type_attribute_p (get_attribute_name (a)))
2861 33 : vec.safe_push (a);
2862 4066142397 : if (abi_warn_or_compat_version_crosses (10) && !vec.is_empty ())
2863 0 : G.need_abi_warning = true;
2864 813380524 : if (abi_version_at_least (10))
2865 : {
2866 813131867 : vec.qsort (attr_strcmp);
2867 813380590 : while (!vec.is_empty())
2868 : {
2869 33 : tree a = vec.pop();
2870 33 : const attribute_spec *as
2871 33 : = lookup_attribute_spec (get_attribute_name (a));
2872 :
2873 33 : write_char ('U');
2874 33 : write_unsigned_number (strlen (as->name));
2875 33 : write_string (as->name);
2876 33 : if (TREE_VALUE (a))
2877 : {
2878 3 : write_char ('I');
2879 6 : for (tree args = TREE_VALUE (a); args;
2880 3 : args = TREE_CHAIN (args))
2881 : {
2882 3 : tree arg = TREE_VALUE (args);
2883 3 : write_template_arg (arg);
2884 : }
2885 3 : write_char ('E');
2886 : }
2887 :
2888 33 : ++num_qualifiers;
2889 : }
2890 : }
2891 813380524 : }
2892 :
2893 : /* Note that we do not use cp_type_quals below; given "const
2894 : int[3]", the "const" is emitted with the "int", not with the
2895 : array. */
2896 1172327274 : cv_qualifier quals;
2897 1172327274 : addr_space_t as;
2898 1172327274 : std::tie (quals, as) = TYPE_QUALS (type).split ();
2899 :
2900 : /* No address space support yet. */
2901 1172327274 : gcc_checking_assert (ADDR_SPACE_GENERIC_P (as));
2902 :
2903 1172327274 : if (quals & TYPE_QUAL_RESTRICT)
2904 : {
2905 43 : write_char ('r');
2906 43 : ++num_qualifiers;
2907 : }
2908 1172327274 : if (quals & TYPE_QUAL_VOLATILE)
2909 : {
2910 540181 : write_char ('V');
2911 540181 : ++num_qualifiers;
2912 : }
2913 1172327274 : if (quals & TYPE_QUAL_CONST)
2914 : {
2915 82582242 : write_char ('K');
2916 82582242 : ++num_qualifiers;
2917 : }
2918 :
2919 1172327274 : return num_qualifiers;
2920 : }
2921 :
2922 : /* Non-terminal <builtin-type>.
2923 :
2924 : <builtin-type> ::= v # void
2925 : ::= b # bool
2926 : ::= w # wchar_t
2927 : ::= c # char
2928 : ::= a # signed char
2929 : ::= h # unsigned char
2930 : ::= s # short
2931 : ::= t # unsigned short
2932 : ::= i # int
2933 : ::= j # unsigned int
2934 : ::= l # long
2935 : ::= m # unsigned long
2936 : ::= x # long long, __int64
2937 : ::= y # unsigned long long, __int64
2938 : ::= n # __int128
2939 : ::= o # unsigned __int128
2940 : ::= f # float
2941 : ::= d # double
2942 : ::= e # long double, __float80
2943 : ::= g # __float128 [not supported]
2944 : ::= u <source-name> # vendor extended type */
2945 :
2946 : static void
2947 579873976 : write_builtin_type (tree type)
2948 : {
2949 579873976 : if (TYPE_CANONICAL (type))
2950 579873976 : type = TYPE_CANONICAL (type);
2951 :
2952 579873976 : switch (TREE_CODE (type))
2953 : {
2954 78489118 : case VOID_TYPE:
2955 78489118 : write_char ('v');
2956 78489118 : break;
2957 :
2958 49926783 : case BOOLEAN_TYPE:
2959 49926783 : write_char ('b');
2960 49926783 : break;
2961 :
2962 433080905 : case INTEGER_TYPE:
2963 : /* TYPE may still be wchar_t, char8_t, char16_t, or char32_t, since that
2964 : isn't in integer_type_nodes. */
2965 433080905 : if (type == wchar_type_node)
2966 43349663 : write_char ('w');
2967 389731242 : else if (type == char8_type_node)
2968 22638684 : write_string ("Du");
2969 367092558 : else if (type == char16_type_node)
2970 22389183 : write_string ("Ds");
2971 344703375 : else if (type == char32_type_node)
2972 25062119 : write_string ("Di");
2973 : else
2974 : {
2975 319641270 : size_t itk;
2976 : /* Assume TYPE is one of the shared integer type nodes. Find
2977 : it in the array of these nodes. */
2978 319641256 : iagain:
2979 2032789402 : for (itk = 0; itk < itk_none; ++itk)
2980 2031196457 : if (integer_types[itk] != NULL_TREE
2981 2021638787 : && integer_type_codes[itk] != '\0'
2982 2018452897 : && type == integer_types[itk])
2983 : {
2984 : /* Print the corresponding single-letter code. */
2985 318048325 : write_char (integer_type_codes[itk]);
2986 318048325 : break;
2987 : }
2988 :
2989 319641270 : if (itk == itk_none)
2990 : {
2991 1592945 : tree t = c_common_type_for_mode (TYPE_MODE (type),
2992 1592945 : TYPE_UNSIGNED (type));
2993 1592945 : if (type != t)
2994 : {
2995 14 : type = t;
2996 14 : goto iagain;
2997 : }
2998 :
2999 1592931 : if (TYPE_PRECISION (type) == 128)
3000 2225071 : write_char (TYPE_UNSIGNED (type) ? 'o' : 'n');
3001 : else
3002 : {
3003 : /* Allow for cases where TYPE is not one of the shared
3004 : integer type nodes and write a "vendor extended builtin
3005 : type" with a name the form intN or uintN, respectively.
3006 : Situations like this can happen if you have an
3007 : __attribute__((__mode__(__SI__))) type and use exotic
3008 : switches like '-mint8' on AVR. Of course, this is
3009 : undefined by the C++ ABI (and '-mint8' is not even
3010 : Standard C conforming), but when using such special
3011 : options you're pretty much in nowhere land anyway. */
3012 0 : const char *prefix;
3013 0 : char prec[11]; /* up to ten digits for an unsigned */
3014 :
3015 0 : prefix = TYPE_UNSIGNED (type) ? "uint" : "int";
3016 0 : sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type));
3017 0 : write_char ('u'); /* "vendor extended builtin type" */
3018 0 : write_unsigned_number (strlen (prefix) + strlen (prec));
3019 0 : write_string (prefix);
3020 0 : write_string (prec);
3021 : }
3022 : }
3023 : }
3024 : break;
3025 :
3026 18377170 : case REAL_TYPE:
3027 18377170 : if (type == float_type_node)
3028 5965793 : write_char ('f');
3029 12411377 : else if (type == double_type_node)
3030 9954408 : write_char ('d');
3031 2456969 : else if (type == long_double_type_node)
3032 0 : write_char ('e');
3033 2456969 : else if (type == dfloat32_type_node)
3034 6152 : write_string ("Df");
3035 2450817 : else if (type == dfloat64_type_node)
3036 6041 : write_string ("Dd");
3037 2444776 : else if (type == dfloat128_type_node)
3038 6008 : write_string ("De");
3039 2438768 : else if (type == float16_type_node)
3040 0 : write_string ("DF16_");
3041 2438768 : else if (type == float32_type_node)
3042 806062 : write_string ("DF32_");
3043 1632706 : else if (type == float64_type_node)
3044 807806 : write_string ("DF64_");
3045 824900 : else if (type == float128_type_node)
3046 765714 : write_string ("DF128_");
3047 59186 : else if (type == float32x_type_node)
3048 29593 : write_string ("DF32x");
3049 29593 : else if (type == float64x_type_node)
3050 29593 : write_string ("DF64x");
3051 0 : else if (type == float128x_type_node)
3052 0 : write_string ("DF128x");
3053 0 : else if (type == bfloat16_type_node)
3054 0 : write_string ("DF16b");
3055 : else
3056 0 : gcc_unreachable ();
3057 : break;
3058 :
3059 0 : default:
3060 0 : gcc_unreachable ();
3061 : }
3062 579873976 : }
3063 :
3064 : /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
3065 : METHOD_TYPE. The return type is mangled before the parameter
3066 : types.
3067 :
3068 : <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E */
3069 :
3070 : static void
3071 3251268 : write_function_type (const tree type)
3072 : {
3073 3251268 : MANGLE_TRACE_TREE ("function-type", type);
3074 :
3075 : /* For a pointer to member function, the function type may have
3076 : cv-qualifiers, indicating the quals for the artificial 'this'
3077 : parameter. */
3078 3251268 : if (TREE_CODE (type) == METHOD_TYPE)
3079 : {
3080 : /* The first parameter must be a POINTER_TYPE pointing to the
3081 : `this' parameter. */
3082 266877 : tree this_type = class_of_this_parm (type);
3083 266877 : write_CV_qualifiers_for_type (this_type);
3084 : }
3085 :
3086 3251268 : write_exception_spec (TYPE_RAISES_EXCEPTIONS (type));
3087 :
3088 3251268 : if (tx_safe_fn_type_p (type))
3089 24 : write_string ("Dx");
3090 :
3091 3251268 : write_char ('F');
3092 : /* We don't track whether or not a type is `extern "C"'. Note that
3093 : you can have an `extern "C"' function that does not have
3094 : `extern "C"' type, and vice versa:
3095 :
3096 : extern "C" typedef void function_t();
3097 : function_t f; // f has C++ linkage, but its type is
3098 : // `extern "C"'
3099 :
3100 : typedef void function_t();
3101 : extern "C" function_t f; // Vice versa.
3102 :
3103 : See [dcl.link]. */
3104 3251268 : write_bare_function_type (type, /*include_return_type_p=*/1,
3105 : /*decl=*/NULL);
3106 3251268 : if (FUNCTION_REF_QUALIFIED (type))
3107 : {
3108 2156 : if (FUNCTION_RVALUE_QUALIFIED (type))
3109 865 : write_char ('O');
3110 : else
3111 1291 : write_char ('R');
3112 : }
3113 3251268 : write_char ('E');
3114 3251268 : }
3115 :
3116 : /* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
3117 : METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
3118 : is mangled before the parameter types. If non-NULL, DECL is
3119 : FUNCTION_DECL for the function whose type is being emitted. */
3120 :
3121 : static void
3122 194309109 : write_bare_function_type (const tree type, const int include_return_type_p,
3123 : const tree decl)
3124 : {
3125 194309109 : MANGLE_TRACE_TREE ("bare-function-type", type);
3126 :
3127 : /* Mangle the return type, if requested. */
3128 194309109 : if (include_return_type_p)
3129 17637395 : write_type (TREE_TYPE (type));
3130 :
3131 : /* Now mangle the types of the arguments. */
3132 194309109 : ++G.parm_depth;
3133 194309109 : write_method_parms (TYPE_ARG_TYPES (type),
3134 194309109 : TREE_CODE (type) == METHOD_TYPE,
3135 : decl);
3136 194309109 : --G.parm_depth;
3137 194309109 : }
3138 :
3139 : /* Write the mangled representation of a method parameter list of
3140 : types given in PARM_TYPES. If METHOD_P is nonzero, the function is
3141 : considered a non-static method, and the this parameter is omitted.
3142 : If non-NULL, DECL is the FUNCTION_DECL for the function whose
3143 : parameters are being emitted. */
3144 :
3145 : static void
3146 196660335 : write_method_parms (tree parm_types, const int method_p, const tree decl)
3147 : {
3148 196660335 : tree first_parm_type;
3149 372719583 : tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE;
3150 :
3151 : /* Assume this parameter type list is variable-length. If it ends
3152 : with a void type, then it's not. */
3153 196660335 : int varargs_p = 1;
3154 :
3155 : /* If this is a member function, skip the first arg, which is the
3156 : this pointer.
3157 : "Member functions do not encode the type of their implicit this
3158 : parameter."
3159 :
3160 : Similarly, there's no need to mangle artificial parameters, like
3161 : the VTT parameters for constructors and destructors. */
3162 196660335 : if (method_p)
3163 : {
3164 153333281 : parm_types = TREE_CHAIN (parm_types);
3165 153333281 : parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE;
3166 :
3167 153374277 : while (parm_decl && DECL_ARTIFICIAL (parm_decl))
3168 : {
3169 40996 : parm_types = TREE_CHAIN (parm_types);
3170 40996 : parm_decl = DECL_CHAIN (parm_decl);
3171 : }
3172 :
3173 153333281 : if (decl && ctor_omit_inherited_parms (decl))
3174 : /* Bring back parameters omitted from an inherited ctor. */
3175 54 : parm_types = FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (decl));
3176 : }
3177 :
3178 196660335 : for (first_parm_type = parm_types;
3179 614639247 : parm_types;
3180 417978912 : parm_types = TREE_CHAIN (parm_types))
3181 : {
3182 417978912 : tree parm = TREE_VALUE (parm_types);
3183 417978912 : if (parm == void_type_node)
3184 : {
3185 : /* "Empty parameter lists, whether declared as () or
3186 : conventionally as (void), are encoded with a void parameter
3187 : (v)." */
3188 196616015 : if (parm_types == first_parm_type)
3189 65929259 : write_type (parm);
3190 : /* If the parm list is terminated with a void type, it's
3191 : fixed-length. */
3192 196616015 : varargs_p = 0;
3193 : /* A void type better be the last one. */
3194 196616015 : gcc_assert (TREE_CHAIN (parm_types) == NULL);
3195 : }
3196 : else
3197 221362897 : write_type (parm);
3198 : }
3199 :
3200 196660335 : if (varargs_p)
3201 : /* <builtin-type> ::= z # ellipsis */
3202 44320 : write_char ('z');
3203 196660335 : }
3204 :
3205 : /* <class-enum-type> ::= <name> */
3206 :
3207 : static void
3208 323585823 : write_class_enum_type (const tree type)
3209 : {
3210 323585823 : write_name (TYPE_NAME (type));
3211 323585823 : }
3212 :
3213 : /* Mangle a requirement REQ in a requires-expression. */
3214 :
3215 : static void
3216 556482 : write_requirement (tree req)
3217 : {
3218 556482 : tree op = TREE_OPERAND (req, 0);
3219 :
3220 556482 : switch (tree_code code = TREE_CODE (req))
3221 : {
3222 : /* # simple-requirement or compound-requirement
3223 : <requirement> ::= X <expression> [ N ] [ R <type-constraint> ]
3224 : X <expression> C <expression>
3225 : [ R <type-constraint> ] */
3226 556049 : case SIMPLE_REQ:
3227 556049 : case COMPOUND_REQ:
3228 556049 : write_char ('X');
3229 556049 : write_expression (op);
3230 556049 : if (code == SIMPLE_REQ)
3231 : break;
3232 107919 : if (operand_equal_p (TREE_OPERAND (req, 2), boolean_true_node))
3233 15 : write_char ('N');
3234 107904 : else if (TREE_OPERAND (req, 2) != error_mark_node
3235 107904 : && !operand_equal_p (TREE_OPERAND (req, 2), boolean_false_node))
3236 : {
3237 6 : write_char ('C');
3238 6 : write_expression (TREE_OPERAND (req, 2));
3239 : }
3240 107919 : if (tree constr = TREE_OPERAND (req, 1))
3241 : {
3242 107904 : write_char ('R');
3243 107904 : write_type_constraint (PLACEHOLDER_TYPE_CONSTRAINTS (constr));
3244 : }
3245 : break;
3246 :
3247 : /* <requirement> ::= T <type> # type-requirement */
3248 427 : case TYPE_REQ:
3249 427 : write_char ('T');
3250 427 : write_type (op);
3251 427 : break;
3252 :
3253 : /* <requirement> ::= Q <constraint-expression> # nested-requirement */
3254 6 : case NESTED_REQ:
3255 6 : write_char ('Q');
3256 6 : write_constraint_expression (op);
3257 6 : break;
3258 :
3259 0 : default:
3260 0 : gcc_unreachable ();
3261 : }
3262 556482 : }
3263 :
3264 : /* # requires { ... }
3265 : <expression> ::= rq <requirement>+ E
3266 : # requires (...) { ... }
3267 : <expression> ::= rQ <bare-function-type> _ <requirement>+ E */
3268 :
3269 : static void
3270 528682 : write_requires_expr (tree expr)
3271 : {
3272 528682 : tree parms = REQUIRES_EXPR_PARMS (expr);
3273 528682 : if (parms)
3274 : {
3275 91190 : write_string ("rQ");
3276 91190 : ++G.parm_depth;
3277 182829 : for (; parms; parms = DECL_CHAIN (parms))
3278 91639 : write_type (cv_unqualified (TREE_TYPE (parms)));
3279 91190 : --G.parm_depth;
3280 91190 : write_char ('_');
3281 : }
3282 : else
3283 437492 : write_string ("rq");
3284 :
3285 1085164 : for (tree reqs = REQUIRES_EXPR_REQS (expr); reqs;
3286 556482 : reqs = TREE_CHAIN (reqs))
3287 556482 : write_requirement (TREE_VALUE (reqs));
3288 :
3289 528682 : write_char ('E');
3290 528682 : }
3291 :
3292 : /* Non-terminal <template-args>. ARGS is a TREE_VEC of template
3293 : arguments.
3294 :
3295 : <template-args> ::= I <template-arg>* [Q <constraint-expr>] E */
3296 :
3297 : static void
3298 417355280 : write_template_args (tree args, tree parms /*= NULL_TREE*/)
3299 : {
3300 417355280 : int i;
3301 417355280 : int length = 0;
3302 :
3303 417355280 : MANGLE_TRACE_TREE ("template-args", args);
3304 :
3305 417355280 : write_char ('I');
3306 :
3307 417355280 : if (args)
3308 417355280 : length = TREE_VEC_LENGTH (args);
3309 :
3310 417355280 : tree constraints = NULL_TREE;
3311 417355280 : if (parms)
3312 : {
3313 4922953 : constraints = TEMPLATE_PARMS_CONSTRAINTS (parms);
3314 4922953 : parms = INNERMOST_TEMPLATE_PARMS (parms);
3315 : }
3316 :
3317 417355280 : if (args && length && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC)
3318 : {
3319 : /* We have nested template args. We want the innermost template
3320 : argument list. */
3321 6183258 : args = TREE_VEC_ELT (args, length - 1);
3322 6183258 : length = TREE_VEC_LENGTH (args);
3323 : }
3324 417355280 : if (TEMPLATE_ARGS_TYPE_CONSTRAINT_P (args))
3325 : /* Skip the constrained type. */
3326 : i = 1;
3327 : else
3328 417302747 : i = 0;
3329 417355280 : bool implicit_parm_scope = false;
3330 1160134930 : for (; i < length; ++i)
3331 : {
3332 742779650 : tree arg = TREE_VEC_ELT (args, i);
3333 742779650 : if (parms)
3334 : {
3335 8521693 : tree parm = TREE_VEC_ELT (parms, i);
3336 8521693 : tree decl = TREE_VALUE (parm);
3337 8521693 : if (DECL_IMPLICIT_TEMPLATE_PARM_P (decl)
3338 8521693 : && !implicit_parm_scope)
3339 : {
3340 : /* The rest of the template parameters are based on generic
3341 : function parameters, so any expressions in their
3342 : type-constraints are in parameter scope. */
3343 9797 : implicit_parm_scope = true;
3344 9797 : ++G.parm_depth;
3345 : }
3346 8521693 : if (!template_parm_natural_p (arg, parm)
3347 8521693 : && abi_check (19))
3348 41778 : write_template_param_decl (parm);
3349 : }
3350 742779650 : write_template_arg (arg);
3351 : }
3352 417355280 : if (implicit_parm_scope)
3353 9797 : --G.parm_depth;
3354 :
3355 417355280 : write_tparms_constraints (constraints);
3356 :
3357 417355280 : write_char ('E');
3358 417355280 : }
3359 :
3360 : /* Write out the
3361 : <unqualified-name>
3362 : <unqualified-name> <template-args>
3363 : part of SCOPE_REF or COMPONENT_REF mangling. */
3364 :
3365 : static void
3366 509976 : write_member_name (tree member)
3367 : {
3368 509976 : if (identifier_p (member))
3369 : {
3370 371305 : if (IDENTIFIER_ANY_OP_P (member))
3371 : {
3372 53495 : if (abi_check (11))
3373 53471 : write_string ("on");
3374 : }
3375 371305 : write_unqualified_id (member);
3376 : }
3377 138671 : else if (DECL_P (member))
3378 : {
3379 1296 : if (ANON_AGGR_TYPE_P (TREE_TYPE (member)))
3380 : ;
3381 1290 : else if (DECL_OVERLOADED_OPERATOR_P (member))
3382 : {
3383 15 : if (abi_check (16))
3384 9 : write_string ("on");
3385 : }
3386 1296 : write_unqualified_name (member);
3387 : }
3388 137375 : else if (TREE_CODE (member) == TEMPLATE_ID_EXPR)
3389 : {
3390 271 : tree name = TREE_OPERAND (member, 0);
3391 271 : name = OVL_FIRST (name);
3392 271 : write_member_name (name);
3393 271 : write_template_args (TREE_OPERAND (member, 1));
3394 : }
3395 : else
3396 137104 : write_expression (member);
3397 509976 : }
3398 :
3399 : /* EXPR is a base COMPONENT_REF; write the minimized base conversion path for
3400 : converting to BASE, or just the conversion of EXPR if BASE is null.
3401 :
3402 : "Given a fully explicit base path P := C_n -> ... -> C_0, the minimized base
3403 : path Min(P) is defined as follows: let C_i be the last element for which the
3404 : conversion to C_0 is unambiguous; if that element is C_n, the minimized path
3405 : is C_n -> C_0; otherwise, the minimized path is Min(C_n -> ... -> C_i) ->
3406 : C_0."
3407 :
3408 : We mangle the conversion to C_i if it's different from C_n. */
3409 :
3410 : static bool
3411 199146 : write_base_ref (tree expr, tree base = NULL_TREE)
3412 : {
3413 199146 : if (TREE_CODE (expr) != COMPONENT_REF)
3414 : return false;
3415 :
3416 199140 : tree field = TREE_OPERAND (expr, 1);
3417 :
3418 199140 : if (TREE_CODE (field) != FIELD_DECL || !DECL_FIELD_IS_BASE (field))
3419 : return false;
3420 :
3421 18 : tree object = TREE_OPERAND (expr, 0);
3422 :
3423 18 : tree binfo = NULL_TREE;
3424 18 : if (base)
3425 : {
3426 9 : tree cur = TREE_TYPE (object);
3427 9 : binfo = lookup_base (cur, base, ba_unique, NULL, tf_none);
3428 : }
3429 : else
3430 : /* We're at the end of the base conversion chain, so it can't be
3431 : ambiguous. */
3432 9 : base = TREE_TYPE (field);
3433 :
3434 18 : if (binfo == error_mark_node)
3435 : {
3436 : /* cur->base is ambiguous, so make the conversion to
3437 : last explicit, expressed as a cast (last&)object. */
3438 3 : tree last = TREE_TYPE (expr);
3439 3 : write_string (OVL_OP_INFO (false, CAST_EXPR)->mangled_name);
3440 3 : write_type (build_reference_type (last));
3441 3 : write_expression (object);
3442 : }
3443 15 : else if (write_base_ref (object, base))
3444 : /* cur->base is unambiguous, but we had another base conversion
3445 : underneath and wrote it out. */;
3446 : else
3447 : /* No more base conversions, just write out the object. */
3448 6 : write_expression (object);
3449 :
3450 : return true;
3451 : }
3452 :
3453 : /* The number of elements spanned by a RANGE_EXPR. */
3454 :
3455 : unsigned HOST_WIDE_INT
3456 24 : range_expr_nelts (tree expr)
3457 : {
3458 24 : tree lo = TREE_OPERAND (expr, 0);
3459 24 : tree hi = TREE_OPERAND (expr, 1);
3460 24 : return tree_to_uhwi (hi) - tree_to_uhwi (lo) + 1;
3461 : }
3462 :
3463 : /* <expression> ::= <unary operator-name> <expression>
3464 : ::= <binary operator-name> <expression> <expression>
3465 : ::= <expr-primary>
3466 :
3467 : <expr-primary> ::= <template-param>
3468 : ::= L <type> <value number> E # literal
3469 : ::= L <mangled-name> E # external name
3470 : ::= st <type> # sizeof
3471 : ::= sr <type> <unqualified-name> # dependent name
3472 : ::= sr <type> <unqualified-name> <template-args>
3473 : ::= L Dm <value reflection> E # C++26 reflection
3474 : # value [proposed]
3475 : ::= <splice> # C++26 dependent splice [proposed] */
3476 :
3477 : static void
3478 12569932 : write_expression (tree expr)
3479 : {
3480 13001030 : enum tree_code code = TREE_CODE (expr);
3481 :
3482 13001030 : if (TREE_CODE (expr) == TARGET_EXPR)
3483 : {
3484 0 : expr = TARGET_EXPR_INITIAL (expr);
3485 0 : code = TREE_CODE (expr);
3486 : }
3487 :
3488 : /* Skip NOP_EXPR and CONVERT_EXPR. They can occur when (say) a pointer
3489 : argument is converted (via qualification conversions) to another type. */
3490 13565306 : while (CONVERT_EXPR_CODE_P (code)
3491 13442365 : || code == IMPLICIT_CONV_EXPR
3492 13442233 : || location_wrapper_p (expr)
3493 : /* Parentheses aren't mangled. */
3494 13001396 : || code == PAREN_EXPR
3495 13001396 : || code == NON_LVALUE_EXPR
3496 26566702 : || (code == VIEW_CONVERT_EXPR
3497 366 : && TREE_CODE (TREE_OPERAND (expr, 0)) == TEMPLATE_PARM_INDEX))
3498 : {
3499 564276 : expr = TREE_OPERAND (expr, 0);
3500 564276 : code = TREE_CODE (expr);
3501 : }
3502 :
3503 13001030 : if (code == BASELINK
3504 13001030 : && (!type_unknown_p (expr)
3505 766152 : || !BASELINK_QUALIFIED_P (expr)))
3506 : {
3507 783103 : expr = BASELINK_FUNCTIONS (expr);
3508 783103 : code = TREE_CODE (expr);
3509 : }
3510 :
3511 : /* Handle pointers-to-members by making them look like expression
3512 : nodes. */
3513 13001030 : if (code == PTRMEM_CST)
3514 : {
3515 7790 : expr = build_nt (ADDR_EXPR,
3516 : build_qualified_name (/*type=*/NULL_TREE,
3517 3895 : PTRMEM_CST_CLASS (expr),
3518 3895 : PTRMEM_CST_MEMBER (expr),
3519 : /*template_p=*/false));
3520 3895 : code = TREE_CODE (expr);
3521 : }
3522 :
3523 : /* Handle template parameters. */
3524 13001030 : if (code == TEMPLATE_TYPE_PARM
3525 13001030 : || code == TEMPLATE_TEMPLATE_PARM
3526 13001030 : || code == BOUND_TEMPLATE_TEMPLATE_PARM
3527 12997016 : || code == TEMPLATE_PARM_INDEX)
3528 785186 : write_template_param (expr);
3529 : /* Handle literals. */
3530 12215844 : else if (TREE_CODE_CLASS (code) == tcc_constant
3531 11836170 : || code == CONST_DECL
3532 11836170 : || code == REFLECT_EXPR)
3533 404234 : write_template_arg_literal (expr);
3534 11811610 : else if (code == EXCESS_PRECISION_EXPR
3535 11811610 : && TREE_CODE (TREE_OPERAND (expr, 0)) == REAL_CST)
3536 0 : write_template_arg_literal (fold_convert (TREE_TYPE (expr),
3537 : TREE_OPERAND (expr, 0)));
3538 11811610 : else if (code == PARM_DECL && DECL_ARTIFICIAL (expr))
3539 : {
3540 121575 : gcc_assert (id_equal (DECL_NAME (expr), "this"));
3541 121575 : write_string ("fpT");
3542 : }
3543 11690035 : else if (code == PARM_DECL)
3544 : {
3545 : /* A function parameter used in a late-specified return type. */
3546 359483 : int index = DECL_PARM_INDEX (expr);
3547 359483 : int level = DECL_PARM_LEVEL (expr);
3548 359483 : int delta = G.parm_depth - level + 1;
3549 359483 : gcc_assert (index >= 1);
3550 359483 : write_char ('f');
3551 359483 : if (delta != 0)
3552 : {
3553 172204 : gcc_checking_assert (delta > 0);
3554 172204 : if (abi_check (5))
3555 : {
3556 : /* Let L be the number of function prototype scopes from the
3557 : innermost one (in which the parameter reference occurs) up
3558 : to (and including) the one containing the declaration of
3559 : the referenced parameter. If the parameter declaration
3560 : clause of the innermost function prototype scope has been
3561 : completely seen, it is not counted (in that case -- which
3562 : is perhaps the most common -- L can be zero). */
3563 172201 : write_char ('L');
3564 172201 : write_unsigned_number (delta - 1);
3565 : }
3566 : }
3567 359483 : write_char ('p');
3568 359483 : write_compact_number (index - 1);
3569 : }
3570 11330552 : else if (DECL_P (expr))
3571 : {
3572 378087 : write_char ('L');
3573 378087 : write_mangled_name (expr, false);
3574 378087 : write_char ('E');
3575 : }
3576 10952465 : else if (TREE_CODE (expr) == SIZEOF_EXPR)
3577 : {
3578 6971 : tree op = TREE_OPERAND (expr, 0);
3579 :
3580 6971 : if (PACK_EXPANSION_P (op))
3581 : {
3582 5462 : sizeof_pack:
3583 5465 : if (abi_check (11))
3584 : {
3585 : /* sZ rather than szDp. */
3586 5456 : write_string ("sZ");
3587 5456 : write_expression (PACK_EXPANSION_PATTERN (op));
3588 : return;
3589 : }
3590 : }
3591 :
3592 1518 : if (SIZEOF_EXPR_TYPE_P (expr))
3593 : {
3594 0 : write_string ("st");
3595 0 : write_type (TREE_TYPE (op));
3596 : }
3597 1518 : else if (ARGUMENT_PACK_P (op))
3598 : {
3599 15 : tree args = ARGUMENT_PACK_ARGS (op);
3600 15 : int length = TREE_VEC_LENGTH (args);
3601 15 : if (abi_check (10))
3602 : {
3603 : /* Before v19 we wrongly mangled all single pack expansions with
3604 : sZ, but now only for expressions, as types ICEd (95298). */
3605 12 : if (length == 1)
3606 : {
3607 9 : tree arg = TREE_VEC_ELT (args, 0);
3608 9 : if (TREE_CODE (arg) == EXPR_PACK_EXPANSION
3609 9 : && !abi_check (19))
3610 : {
3611 3 : op = arg;
3612 3 : goto sizeof_pack;
3613 : }
3614 : }
3615 :
3616 : /* sP <template-arg>* E # sizeof...(T), size of a captured
3617 : template parameter pack from an alias template */
3618 9 : write_string ("sP");
3619 24 : for (int i = 0; i < length; ++i)
3620 15 : write_template_arg (TREE_VEC_ELT (args, i));
3621 9 : write_char ('E');
3622 : }
3623 : else
3624 : {
3625 : /* In GCC 5 we represented this sizeof wrong, with the effect
3626 : that we mangled it as the last element of the pack. */
3627 3 : tree arg = TREE_VEC_ELT (args, length-1);
3628 3 : if (TYPE_P (op))
3629 : {
3630 3 : write_string ("st");
3631 3 : write_type (arg);
3632 : }
3633 : else
3634 : {
3635 0 : write_string ("sz");
3636 0 : write_expression (arg);
3637 : }
3638 : }
3639 : }
3640 1503 : else if (TYPE_P (TREE_OPERAND (expr, 0)))
3641 : {
3642 1381 : write_string ("st");
3643 1381 : write_type (TREE_OPERAND (expr, 0));
3644 : }
3645 : else
3646 122 : goto normal_expr;
3647 : }
3648 10945494 : else if (code == PACK_INDEX_EXPR)
3649 : {
3650 : /* https://github.com/itanium-cxx-abi/cxx-abi/issues/175. */
3651 37 : write_string ("sy");
3652 37 : if (TREE_CODE (PACK_INDEX_PACK (expr)) == TREE_VEC)
3653 : {
3654 2 : write_char ('J');
3655 20 : for (int i = 0; i < TREE_VEC_LENGTH (PACK_INDEX_PACK (expr));
3656 : ++i)
3657 8 : write_template_arg (TREE_VEC_ELT (PACK_INDEX_PACK (expr), i));
3658 2 : write_char ('E');
3659 : }
3660 : else
3661 : /* sy rather than sysp. */
3662 35 : write_expression (PACK_EXPANSION_PATTERN (PACK_INDEX_PACK (expr)));
3663 37 : write_expression (PACK_INDEX_INDEX (expr));
3664 : }
3665 10945457 : else if (TREE_CODE (expr) == ALIGNOF_EXPR)
3666 : {
3667 36 : if (!ALIGNOF_EXPR_STD_P (expr))
3668 : {
3669 24 : if (abi_check (16))
3670 : {
3671 : /* We used to mangle __alignof__ like alignof. */
3672 18 : write_string ("u11__alignof__");
3673 18 : write_template_arg (TREE_OPERAND (expr, 0));
3674 18 : write_char ('E');
3675 18 : return;
3676 : }
3677 : }
3678 18 : if (TYPE_P (TREE_OPERAND (expr, 0)))
3679 : {
3680 9 : write_string ("at");
3681 9 : write_type (TREE_OPERAND (expr, 0));
3682 : }
3683 : else
3684 9 : goto normal_expr;
3685 : }
3686 10945421 : else if (code == SCOPE_REF
3687 10945421 : || code == BASELINK)
3688 : {
3689 314488 : tree scope, member;
3690 314488 : if (code == SCOPE_REF)
3691 : {
3692 314455 : scope = TREE_OPERAND (expr, 0);
3693 314455 : member = TREE_OPERAND (expr, 1);
3694 314455 : if (BASELINK_P (member))
3695 21 : member = BASELINK_FUNCTIONS (member);
3696 : }
3697 : else
3698 : {
3699 33 : scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr));
3700 33 : member = BASELINK_FUNCTIONS (expr);
3701 : }
3702 :
3703 : /* If the MEMBER is a real declaration, then the qualifying
3704 : scope was not dependent. Ideally, we would not have a
3705 : SCOPE_REF in those cases, but sometimes we do. If the second
3706 : argument is a DECL, then the name must not have been
3707 : dependent. */
3708 314488 : if (DECL_P (member))
3709 : write_expression (member);
3710 : else
3711 : {
3712 310290 : gcc_assert (code != BASELINK || BASELINK_QUALIFIED_P (expr));
3713 310257 : write_string ("sr");
3714 310257 : write_type (scope);
3715 310257 : write_member_name (member);
3716 : }
3717 : }
3718 10630933 : else if (INDIRECT_REF_P (expr)
3719 468529 : && TREE_TYPE (TREE_OPERAND (expr, 0))
3720 11016819 : && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0))))
3721 : {
3722 263199 : write_expression (TREE_OPERAND (expr, 0));
3723 : }
3724 10367734 : else if (identifier_p (expr))
3725 : {
3726 : /* An operator name appearing as a dependent name needs to be
3727 : specially marked to disambiguate between a use of the operator
3728 : name and a use of the operator in an expression. */
3729 254559 : if (IDENTIFIER_ANY_OP_P (expr))
3730 7 : write_string ("on");
3731 254559 : write_unqualified_id (expr);
3732 : }
3733 10113175 : else if (dependent_splice_p (expr))
3734 44 : write_splice (expr);
3735 10113131 : else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
3736 : {
3737 4259317 : tree fn = TREE_OPERAND (expr, 0);
3738 5627166 : if (!identifier_p (fn))
3739 4259314 : fn = OVL_NAME (fn);
3740 4259317 : if (IDENTIFIER_ANY_OP_P (fn))
3741 3 : write_string ("on");
3742 4259317 : write_unqualified_id (fn);
3743 4259317 : write_template_args (TREE_OPERAND (expr, 1));
3744 : }
3745 5853814 : else if (TREE_CODE (expr) == MODOP_EXPR)
3746 : {
3747 87 : enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1));
3748 87 : const char *name = OVL_OP_INFO (true, subop)->mangled_name;
3749 :
3750 87 : write_string (name);
3751 87 : write_expression (TREE_OPERAND (expr, 0));
3752 87 : write_expression (TREE_OPERAND (expr, 2));
3753 : }
3754 5853727 : else if (code == NEW_EXPR || code == VEC_NEW_EXPR)
3755 : {
3756 : /* ::= [gs] nw <expression>* _ <type> E
3757 : ::= [gs] nw <expression>* _ <type> <initializer>
3758 : ::= [gs] na <expression>* _ <type> E
3759 : ::= [gs] na <expression>* _ <type> <initializer>
3760 : <initializer> ::= pi <expression>* E */
3761 156109 : tree placement = TREE_OPERAND (expr, 0);
3762 156109 : tree type = TREE_OPERAND (expr, 1);
3763 156109 : tree nelts = TREE_OPERAND (expr, 2);
3764 156109 : tree init = TREE_OPERAND (expr, 3);
3765 156109 : tree t;
3766 :
3767 156109 : gcc_assert (code == NEW_EXPR);
3768 156109 : if (TREE_OPERAND (expr, 2))
3769 12 : code = VEC_NEW_EXPR;
3770 :
3771 156109 : if (NEW_EXPR_USE_GLOBAL (expr))
3772 156084 : write_string ("gs");
3773 :
3774 156109 : write_string (OVL_OP_INFO (false, code)->mangled_name);
3775 :
3776 312193 : for (t = placement; t; t = TREE_CHAIN (t))
3777 156084 : write_expression (TREE_VALUE (t));
3778 :
3779 156109 : write_char ('_');
3780 :
3781 156109 : if (nelts)
3782 : {
3783 12 : ++processing_template_decl;
3784 : /* Avoid compute_array_index_type complaints about
3785 : non-constant nelts. */
3786 12 : tree max = cp_build_binary_op (input_location, MINUS_EXPR,
3787 : fold_convert (sizetype, nelts),
3788 : size_one_node,
3789 : tf_warning_or_error);
3790 12 : max = maybe_constant_value (max);
3791 12 : tree domain = build_index_type (max);
3792 12 : type = build_cplus_array_type (type, domain);
3793 12 : --processing_template_decl;
3794 : }
3795 156109 : write_type (type);
3796 :
3797 156097 : if (init && TREE_CODE (init) == TREE_LIST
3798 312200 : && DIRECT_LIST_INIT_P (TREE_VALUE (init)))
3799 : write_expression (TREE_VALUE (init));
3800 : else
3801 : {
3802 156106 : if (init)
3803 156094 : write_string ("pi");
3804 156094 : if (init && init != void_node)
3805 312176 : for (t = init; t; t = TREE_CHAIN (t))
3806 156088 : write_expression (TREE_VALUE (t));
3807 156106 : write_char ('E');
3808 : }
3809 : }
3810 : else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR)
3811 : {
3812 12 : gcc_assert (code == DELETE_EXPR);
3813 12 : if (DELETE_EXPR_USE_VEC (expr))
3814 6 : code = VEC_DELETE_EXPR;
3815 :
3816 12 : if (DELETE_EXPR_USE_GLOBAL (expr))
3817 6 : write_string ("gs");
3818 :
3819 12 : write_string (OVL_OP_INFO (false, code)->mangled_name);
3820 :
3821 12 : write_expression (TREE_OPERAND (expr, 0));
3822 : }
3823 : else if (code == THROW_EXPR)
3824 : {
3825 8 : tree op = TREE_OPERAND (expr, 0);
3826 8 : if (op)
3827 : {
3828 5 : write_string ("tw");
3829 5 : write_expression (op);
3830 : }
3831 : else
3832 3 : write_string ("tr");
3833 : }
3834 : else if (code == NOEXCEPT_EXPR)
3835 : {
3836 6 : write_string ("nx");
3837 6 : write_expression (TREE_OPERAND (expr, 0));
3838 : }
3839 : else if (code == CONSTRUCTOR)
3840 : {
3841 177050 : bool braced_init = BRACE_ENCLOSED_INITIALIZER_P (expr);
3842 177050 : tree etype = TREE_TYPE (expr);
3843 :
3844 177050 : if (braced_init)
3845 98 : write_string ("il");
3846 : else
3847 : {
3848 176952 : write_string ("tl");
3849 176952 : write_type (etype);
3850 : }
3851 :
3852 : /* If this is an undigested initializer, mangle it as written.
3853 : COMPOUND_LITERAL_P doesn't actually distinguish between digested and
3854 : undigested braced casts, but it should work to use it to distinguish
3855 : between braced casts in a template signature (undigested) and template
3856 : parm object values (digested), and all CONSTRUCTORS that get here
3857 : should be one of those two cases. */
3858 177050 : bool undigested = braced_init || COMPOUND_LITERAL_P (expr);
3859 176647 : if (undigested || !zero_init_expr_p (expr))
3860 : {
3861 : /* Convert braced initializer lists to STRING_CSTs so that
3862 : A<"Foo"> mangles the same as A<{'F', 'o', 'o', 0}> while
3863 : still using the latter mangling for strings that
3864 : originated as braced initializer lists. */
3865 156203 : expr = braced_lists_to_strings (etype, expr);
3866 :
3867 156203 : if (TREE_CODE (expr) == CONSTRUCTOR)
3868 : {
3869 156195 : vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (expr);
3870 156195 : unsigned last_nonzero = UINT_MAX;
3871 156195 : constructor_elt *ce;
3872 :
3873 156195 : if (!undigested)
3874 376035 : for (HOST_WIDE_INT i = 0; vec_safe_iterate (elts, i, &ce); ++i)
3875 220243 : if ((TREE_CODE (etype) == UNION_TYPE
3876 37 : && ce->index != first_field (etype))
3877 220269 : || !zero_init_expr_p (ce->value))
3878 : last_nonzero = i;
3879 :
3880 156195 : tree prev_field = NULL_TREE;
3881 156195 : if (undigested || last_nonzero != UINT_MAX)
3882 374093 : for (HOST_WIDE_INT i = 0; vec_safe_iterate (elts, i, &ce); ++i)
3883 : {
3884 220214 : if (i > last_nonzero)
3885 : break;
3886 217733 : if (!undigested && !CONSTRUCTOR_NO_CLEARING (expr)
3887 217898 : && (TREE_CODE (etype) == RECORD_TYPE
3888 215861 : || TREE_CODE (etype) == ARRAY_TYPE))
3889 : {
3890 : /* Write out any implicit non-trailing zeros
3891 : (which we neglected to do before v21). */
3892 215824 : if (TREE_CODE (etype) == RECORD_TYPE)
3893 : {
3894 133486 : tree field;
3895 133486 : if (i == 0)
3896 120193 : field = first_field (etype);
3897 : else
3898 13293 : field = DECL_CHAIN (prev_field);
3899 133898 : for (;;)
3900 : {
3901 133692 : field = next_subobject_field (field);
3902 133692 : if (field == ce->index)
3903 : break;
3904 206 : if (abi_check (21))
3905 : {
3906 196 : tree type = TREE_TYPE (field), expr;
3907 196 : if (REFLECTION_TYPE_P (type))
3908 0 : expr = get_null_reflection ();
3909 : else
3910 196 : expr = build_zero_cst (type);
3911 196 : write_expression (expr);
3912 : }
3913 206 : field = DECL_CHAIN (field);
3914 206 : }
3915 : }
3916 82338 : else if (TREE_CODE (etype) == ARRAY_TYPE)
3917 : {
3918 82338 : unsigned HOST_WIDE_INT j;
3919 82338 : if (i == 0)
3920 : j = 0;
3921 : else
3922 47400 : j = 1 + tree_to_uhwi (prev_field);
3923 82338 : unsigned HOST_WIDE_INT k;
3924 82338 : if (TREE_CODE (ce->index) == RANGE_EXPR)
3925 12 : k = tree_to_uhwi (TREE_OPERAND (ce->index, 0));
3926 : else
3927 82326 : k = tree_to_uhwi (ce->index);
3928 82338 : tree zero = NULL_TREE;
3929 84108 : for (; j < k; ++j)
3930 1770 : if (abi_check (21))
3931 : {
3932 1188 : if (!zero)
3933 30 : zero = build_zero_cst (TREE_TYPE (etype));
3934 1188 : write_expression (zero);
3935 : }
3936 : }
3937 : }
3938 :
3939 217898 : if (!undigested && TREE_CODE (etype) == UNION_TYPE)
3940 : {
3941 : /* Express the active member as a designator. */
3942 37 : write_string ("di");
3943 37 : write_unqualified_name (ce->index);
3944 : }
3945 217898 : unsigned reps = 1;
3946 217898 : if (ce->index && TREE_CODE (ce->index) == RANGE_EXPR)
3947 12 : reps = range_expr_nelts (ce->index);
3948 217898 : if (TREE_CODE (ce->value) == RAW_DATA_CST)
3949 : {
3950 30 : gcc_assert (reps == 1);
3951 30 : unsigned int len = RAW_DATA_LENGTH (ce->value);
3952 : /* If this is the last non-zero element, skip
3953 : zeros at the end. */
3954 30 : if (i == last_nonzero)
3955 282 : while (len)
3956 : {
3957 282 : if (RAW_DATA_POINTER (ce->value)[len - 1])
3958 : break;
3959 : --len;
3960 : }
3961 30 : tree valtype = TREE_TYPE (ce->value);
3962 3906 : for (unsigned int i = 0; i < len; ++i)
3963 : {
3964 3876 : write_char ('L');
3965 3876 : write_type (valtype);
3966 3876 : unsigned HOST_WIDE_INT v;
3967 3876 : if (!TYPE_UNSIGNED (valtype)
3968 780 : && TYPE_PRECISION (valtype) == BITS_PER_UNIT
3969 4656 : && RAW_DATA_SCHAR_ELT (ce->value, i) < 0)
3970 : {
3971 0 : write_char ('n');
3972 0 : v = -RAW_DATA_SCHAR_ELT (ce->value, i);
3973 : }
3974 : else
3975 3876 : v = RAW_DATA_UCHAR_ELT (ce->value, i);
3976 3876 : write_unsigned_number (v);
3977 3876 : write_char ('E');
3978 : }
3979 : }
3980 : else
3981 435754 : for (unsigned j = 0; j < reps; ++j)
3982 217886 : write_expression (ce->value);
3983 217898 : prev_field = ce->index;
3984 217898 : if (prev_field && TREE_CODE (prev_field) == RANGE_EXPR)
3985 12 : prev_field = TREE_OPERAND (prev_field, 1);
3986 : }
3987 : }
3988 : else
3989 : {
3990 8 : gcc_assert (TREE_CODE (expr) == STRING_CST);
3991 8 : write_expression (expr);
3992 : }
3993 : }
3994 177050 : write_char ('E');
3995 : }
3996 : else if (code == LAMBDA_EXPR)
3997 : {
3998 : /* [temp.over.link] Two lambda-expressions are never considered
3999 : equivalent.
4000 :
4001 : So just use the closure type mangling. */
4002 1408 : write_char ('L');
4003 1408 : write_type (LAMBDA_EXPR_CLOSURE (expr));
4004 1408 : write_char ('E');
4005 : }
4006 : else if (code == REQUIRES_EXPR)
4007 528682 : write_requires_expr (expr);
4008 4990452 : else if (dependent_name (expr))
4009 : {
4010 120461 : tree name = dependent_name (expr);
4011 120461 : if (IDENTIFIER_ANY_OP_P (name))
4012 : {
4013 9 : if (abi_check (16))
4014 6 : write_string ("on");
4015 : }
4016 120461 : write_unqualified_id (name);
4017 : }
4018 : else
4019 : {
4020 4869991 : normal_expr:
4021 4870122 : int i, len;
4022 4870122 : const char *name;
4023 :
4024 : /* When we bind a variable or function to a non-type template
4025 : argument with reference type, we create an ADDR_EXPR to show
4026 : the fact that the entity's address has been taken. But, we
4027 : don't actually want to output a mangling code for the `&'. */
4028 4870122 : if (TREE_CODE (expr) == ADDR_EXPR
4029 7364 : && TREE_TYPE (expr)
4030 4873591 : && TYPE_REF_P (TREE_TYPE (expr)))
4031 : {
4032 0 : expr = TREE_OPERAND (expr, 0);
4033 0 : if (DECL_P (expr))
4034 : {
4035 : write_expression (expr);
4036 : return;
4037 : }
4038 :
4039 0 : code = TREE_CODE (expr);
4040 : }
4041 :
4042 4870122 : if (code == COMPONENT_REF)
4043 : {
4044 199457 : tree ob = TREE_OPERAND (expr, 0);
4045 :
4046 199457 : if (TREE_CODE (ob) == ARROW_EXPR)
4047 : {
4048 326 : write_string (OVL_OP_INFO (false, code)->mangled_name);
4049 326 : ob = TREE_OPERAND (ob, 0);
4050 326 : write_expression (ob);
4051 : }
4052 199131 : else if (write_base_ref (expr))
4053 : return;
4054 199122 : else if (!is_dummy_object (ob))
4055 : {
4056 199116 : write_string ("dt");
4057 199116 : write_expression (ob);
4058 : }
4059 : /* else, for a non-static data member with no associated object (in
4060 : unevaluated context), use the unresolved-name mangling. */
4061 :
4062 199448 : write_member_name (TREE_OPERAND (expr, 1));
4063 199448 : return;
4064 : }
4065 :
4066 : /* If it wasn't any of those, recursively expand the expression. */
4067 4670665 : name = OVL_OP_INFO (false, code)->mangled_name;
4068 :
4069 : /* We used to mangle const_cast and static_cast like a C cast. */
4070 4670665 : if (code == CONST_CAST_EXPR
4071 4670665 : || code == STATIC_CAST_EXPR)
4072 : {
4073 265 : if (!abi_check (6))
4074 15 : name = OVL_OP_INFO (false, CAST_EXPR)->mangled_name;
4075 : }
4076 :
4077 4670665 : if (name == NULL)
4078 : {
4079 3 : switch (code)
4080 : {
4081 3 : case TRAIT_EXPR:
4082 3 : error ("use of built-in trait %qE in function signature; "
4083 : "use library traits instead", expr);
4084 3 : break;
4085 :
4086 0 : case ERROR_MARK:
4087 0 : if (seen_error ())
4088 : break;
4089 : /* FALLTHROUGH */
4090 0 : default:
4091 0 : sorry ("mangling %C", code);
4092 0 : break;
4093 : }
4094 : return;
4095 : }
4096 : else
4097 4670662 : write_string (name);
4098 :
4099 4670662 : switch (code)
4100 : {
4101 2112793 : case CALL_EXPR:
4102 2112793 : if (tree fn = CALL_EXPR_FN (expr))
4103 : {
4104 2112787 : if (TREE_CODE (fn) == ADDR_EXPR)
4105 0 : fn = TREE_OPERAND (fn, 0);
4106 :
4107 : /* Mangle a dependent name as the name, not whatever happens to
4108 : be the first function in the overload set. */
4109 2112064 : if (OVL_P (fn)
4110 2367139 : && type_dependent_expression_p_push (expr))
4111 254456 : fn = OVL_NAME (fn);
4112 :
4113 2112787 : write_expression (fn);
4114 : }
4115 : else
4116 6 : switch (CALL_EXPR_IFN (expr))
4117 : {
4118 : /* Calls to __builtin_bswapg/__builtin_bitreverseg/__builtin_clmulg
4119 : are parsed as IFN_BSWAP/IFN_BITREVERSE/IFN_CLMUL calls because
4120 : we don't have those builtins but instead keywords. Pretend
4121 : they are builtin function template. */
4122 3 : case IFN_BSWAP:
4123 3 : write_source_name (get_identifier ("__builtin_bswapg"));
4124 3 : break;
4125 3 : case IFN_BITREVERSE:
4126 3 : write_source_name (get_identifier ("__builtin_bitreverseg"));
4127 3 : break;
4128 0 : case IFN_CLMUL:
4129 0 : write_source_name (get_identifier ("__builtin_clmulg"));
4130 0 : break;
4131 0 : default:
4132 0 : gcc_unreachable ();
4133 : }
4134 :
4135 2760472 : for (i = 0; i < call_expr_nargs (expr); ++i)
4136 647679 : write_expression (CALL_EXPR_ARG (expr, i));
4137 2112793 : write_char ('E');
4138 2112793 : break;
4139 :
4140 157969 : case CAST_EXPR:
4141 157969 : write_type (TREE_TYPE (expr));
4142 157969 : if (list_length (TREE_OPERAND (expr, 0)) == 1)
4143 157791 : write_expression (TREE_VALUE (TREE_OPERAND (expr, 0)));
4144 : else
4145 : {
4146 178 : tree args = TREE_OPERAND (expr, 0);
4147 178 : write_char ('_');
4148 190 : for (; args; args = TREE_CHAIN (args))
4149 12 : write_expression (TREE_VALUE (args));
4150 178 : write_char ('E');
4151 : }
4152 : break;
4153 :
4154 271 : case DYNAMIC_CAST_EXPR:
4155 271 : case REINTERPRET_CAST_EXPR:
4156 271 : case STATIC_CAST_EXPR:
4157 271 : case CONST_CAST_EXPR:
4158 271 : write_type (TREE_TYPE (expr));
4159 271 : write_expression (TREE_OPERAND (expr, 0));
4160 271 : break;
4161 :
4162 7551 : case PREINCREMENT_EXPR:
4163 7551 : case PREDECREMENT_EXPR:
4164 7551 : if (abi_check (6))
4165 7542 : write_char ('_');
4166 : /* Fall through. */
4167 :
4168 2399629 : default:
4169 : /* In the middle-end, some expressions have more operands than
4170 : they do in templates (and mangling). */
4171 2399629 : len = cp_tree_operand_length (expr);
4172 :
4173 8672390 : for (i = 0; i < len; ++i)
4174 : {
4175 3873132 : tree operand = TREE_OPERAND (expr, i);
4176 : /* As a GNU extension, the middle operand of a
4177 : conditional may be omitted. Since expression
4178 : manglings are supposed to represent the input token
4179 : stream, there's no good way to mangle such an
4180 : expression without extending the C++ ABI. */
4181 3873132 : if (code == COND_EXPR && i == 1 && !operand)
4182 : {
4183 3 : error ("omitted middle operand to %<?:%> operand "
4184 : "cannot be mangled");
4185 3 : continue;
4186 : }
4187 3873129 : else if (FOLD_EXPR_P (expr))
4188 : {
4189 : /* The first 'operand' of a fold-expression is the operator
4190 : that it folds over. */
4191 510396 : if (i == 0)
4192 : {
4193 255061 : int fcode = TREE_INT_CST_LOW (operand);
4194 255061 : write_string (OVL_OP_INFO (false, fcode)->mangled_name);
4195 255061 : continue;
4196 255061 : }
4197 255335 : else if (code == BINARY_LEFT_FOLD_EXPR)
4198 : {
4199 : /* The order of operands of the binary left and right
4200 : folds is the same, but we want to mangle them in
4201 : lexical order, i.e. non-pack first. */
4202 542 : if (i == 1)
4203 271 : operand = FOLD_EXPR_INIT (expr);
4204 : else
4205 271 : operand = FOLD_EXPR_PACK (expr);
4206 : }
4207 255335 : if (PACK_EXPANSION_P (operand))
4208 255061 : operand = PACK_EXPANSION_PATTERN (operand);
4209 : }
4210 3618068 : write_expression (operand);
4211 : }
4212 : }
4213 : }
4214 : }
4215 :
4216 : /* Non-terminal <reflection>.
4217 :
4218 : <reflection> ::= nu # null reflection
4219 : ::= vl <expression> # value
4220 : ::= ob <expression> # object
4221 : ::= vr <variable name> # variable
4222 : ::= sb <sb name> # structured binding
4223 : ::= fn <function encoding> # function
4224 : ::= pa [ <nonnegative number> ] _ <encoding> # fn param
4225 : ::= en <prefix> <unqualified-name> # enumerator
4226 : ::= an [ <nonnegative number> ] _ # annotation
4227 : ::= ta <alias prefix> <alias unqualified-name>
4228 : [ <alias template-args> ] _ <type> # type alias
4229 : ::= ty <type> # type
4230 : ::= dm <prefix> <unqualified-name> # ns data member
4231 : ::= da <prefix> [ <nonnegative number> ] _ # empty anon union
4232 : # data member
4233 : ::= un <prefix> [ <nonnegative number> ] _ # unnamed bitfld
4234 : ::= ct [ <prefix> ] <unqualified-name> # class template
4235 : ::= ft [ <prefix> ] <unqualified-name> # function template
4236 : ::= vt [ <prefix> ] <unqualified-name> # variable template
4237 : ::= at [ <prefix> ] <unqualified-name> # alias template
4238 : ::= co [ <prefix> ] <unqualified-name> # concept
4239 : ::= na [ <prefix> ] <unqualified-name> # namespace alias
4240 : ::= ns [ <prefix> ] <unqualified-name> # namespace
4241 : ::= gs # ^^::
4242 : ::= tt <template-template-param> # templ templ param
4243 : ::= de <expression> # dependent expr
4244 : ::= ba [ <nonnegative number> ] _ <type> # dir. base cls rel
4245 : ::= ds <type> _ [ <unqualified-name> ] _
4246 : [ <alignment number> ] _ [ <bit-width number> ] _
4247 : [ n ] [ <template-arg>* ] # data member spec */
4248 :
4249 : static void
4250 1750 : write_reflection (tree refl)
4251 : {
4252 1750 : char prefix[3];
4253 1750 : tree arg = reflection_mangle_prefix (refl, prefix);
4254 1750 : if (strcmp (prefix, "dm") == 0
4255 234 : && DECL_NAME (arg) == NULL_TREE
4256 12 : && ANON_AGGR_TYPE_P (TREE_TYPE (arg))
4257 1762 : && anon_aggr_naming_decl (TREE_TYPE (arg)) == NULL_TREE)
4258 12 : strcpy (prefix, "da");
4259 1750 : write_string (prefix);
4260 : /* If there is no argument, nothing further needs to be mangled. */
4261 1750 : if (arg == NULL_TREE)
4262 62 : return;
4263 1688 : if (strcmp (prefix, "vl") == 0 || strcmp (prefix, "ob") == 0)
4264 22 : write_expression (arg);
4265 1666 : else if (strcmp (prefix, "vr") == 0 || strcmp (prefix, "sb") == 0)
4266 234 : write_name (arg);
4267 1432 : else if (strcmp (prefix, "fn") == 0)
4268 196 : write_encoding (arg);
4269 1236 : else if (strcmp (prefix, "pa") == 0)
4270 : {
4271 82 : tree fn = DECL_CONTEXT (arg);
4272 : /* DECL_PARM_INDEX is 1-based but here we want a 0-based index. */
4273 82 : const int idx = DECL_PARM_INDEX (arg) - 1;
4274 82 : write_compact_number (idx);
4275 82 : write_encoding (fn);
4276 : }
4277 1154 : else if (strcmp (prefix, "en") == 0)
4278 : {
4279 26 : write_prefix (decl_mangling_context (arg));
4280 26 : write_unqualified_name (arg);
4281 : }
4282 1128 : else if (strcmp (prefix, "an") == 0)
4283 10 : write_compact_number (tree_to_uhwi (arg));
4284 1118 : else if (strcmp (prefix, "ta") == 0)
4285 : {
4286 28 : arg = TYPE_NAME (arg);
4287 : /* Can't use write_prefix (arg) here instead of
4288 : write_prefix + write_unqualified_name + optional
4289 : write_template_args, it shouldn't be
4290 : remembered among substitutions. */
4291 28 : write_prefix (decl_mangling_context (arg));
4292 28 : if (modules_p ())
4293 0 : maybe_write_module (arg);
4294 28 : write_source_name (DECL_NAME (arg));
4295 28 : tree template_info = maybe_template_info (arg);
4296 28 : if (template_info)
4297 4 : write_template_args (TI_ARGS (template_info));
4298 28 : write_char ('_');
4299 28 : write_type (DECL_ORIGINAL_TYPE (arg));
4300 : }
4301 1090 : else if (strcmp (prefix, "ty") == 0)
4302 314 : write_type (arg);
4303 776 : else if (strcmp (prefix, "dm") == 0)
4304 : {
4305 222 : tree ctx = decl_mangling_context (arg);
4306 452 : while (ctx && ANON_UNION_TYPE_P (ctx))
4307 8 : ctx = decl_mangling_context (TYPE_NAME (ctx));
4308 222 : write_prefix (ctx);
4309 222 : write_unqualified_name (arg);
4310 : }
4311 554 : else if (strcmp (prefix, "da") == 0)
4312 : {
4313 12 : int idx = 0;
4314 12 : tree ctx = decl_mangling_context (arg);
4315 198 : for (tree f = TYPE_FIELDS (ctx); f; f = DECL_CHAIN (f))
4316 198 : if (f == arg)
4317 : break;
4318 186 : else if (TREE_CODE (f) == FIELD_DECL
4319 18 : && DECL_NAME (f) == NULL_TREE
4320 18 : && ANON_AGGR_TYPE_P (TREE_TYPE (f))
4321 204 : && anon_aggr_naming_decl (TREE_TYPE (f)) == NULL_TREE)
4322 18 : ++idx;
4323 12 : write_prefix (ctx);
4324 12 : write_compact_number (idx);
4325 : }
4326 542 : else if (strcmp (prefix, "un") == 0)
4327 : {
4328 8 : tree ctx = DECL_CONTEXT (arg);
4329 8 : int idx = 0;
4330 142 : for (tree f = TYPE_FIELDS (ctx); f; f = DECL_CHAIN (f))
4331 142 : if (f == arg)
4332 : break;
4333 134 : else if (TREE_CODE (f) == FIELD_DECL && DECL_UNNAMED_BIT_FIELD (f))
4334 6 : ++idx;
4335 8 : write_prefix (decl_mangling_context (arg));
4336 8 : write_compact_number (idx);
4337 : }
4338 534 : else if (strcmp (prefix, "ct") == 0
4339 484 : || strcmp (prefix, "ft") == 0
4340 434 : || strcmp (prefix, "vt") == 0
4341 406 : || strcmp (prefix, "at") == 0
4342 380 : || strcmp (prefix, "co") == 0
4343 358 : || strcmp (prefix, "na") == 0
4344 320 : || strcmp (prefix, "ns") == 0)
4345 : {
4346 418 : write_prefix (decl_mangling_context (arg));
4347 418 : write_unqualified_name (STRIP_TEMPLATE (arg));
4348 : }
4349 116 : else if (strcmp (prefix, "ba") == 0)
4350 : {
4351 26 : gcc_assert (TREE_CODE (arg) == TREE_BINFO);
4352 : tree c = arg, base_binfo;
4353 52 : while (BINFO_INHERITANCE_CHAIN (c))
4354 : c = BINFO_INHERITANCE_CHAIN (c);
4355 :
4356 : unsigned idx;
4357 30 : for (idx = 0; BINFO_BASE_ITERATE (c, idx, base_binfo); idx++)
4358 30 : if (base_binfo == arg)
4359 : break;
4360 26 : write_compact_number (idx);
4361 26 : write_type (BINFO_TYPE (c));
4362 : }
4363 90 : else if (strcmp (prefix, "ds") == 0)
4364 : {
4365 84 : gcc_assert (TREE_CODE (arg) == TREE_VEC);
4366 84 : write_type (TREE_VEC_ELT (arg, 0));
4367 84 : write_char ('_');
4368 84 : if (TREE_VEC_ELT (arg, 1))
4369 80 : write_unqualified_id (TREE_VEC_ELT (arg, 1));
4370 84 : write_char ('_');
4371 84 : if (TREE_VEC_ELT (arg, 2))
4372 2 : write_number (tree_to_shwi (TREE_VEC_ELT (arg, 2)), 0, 10);
4373 84 : write_char ('_');
4374 84 : if (TREE_VEC_ELT (arg, 3))
4375 6 : write_number (tree_to_shwi (TREE_VEC_ELT (arg, 3)), 0, 10);
4376 84 : write_char ('_');
4377 84 : if (integer_nonzerop (TREE_VEC_ELT (arg, 4)))
4378 2 : write_char ('n');
4379 90 : for (int i = 5; i < TREE_VEC_LENGTH (arg); ++i)
4380 6 : write_template_arg (REFLECT_EXPR_HANDLE (TREE_VEC_ELT (arg, i)));
4381 : }
4382 6 : else if (strcmp (prefix, "tt") == 0)
4383 : {
4384 2 : gcc_assert (DECL_TEMPLATE_TEMPLATE_PARM_P (arg));
4385 2 : write_template_template_param (TREE_TYPE (arg));
4386 : }
4387 4 : else if (strcmp (prefix, "de") == 0)
4388 4 : write_expression (arg);
4389 : else
4390 0 : gcc_unreachable ();
4391 : }
4392 :
4393 : /* Mangle a dependent splice.
4394 :
4395 : <splice> ::= DS <expression> [ <template-args> ] E
4396 :
4397 : TODO: This is only a proposed mangling.
4398 : See <https://github.com/itanium-cxx-abi/cxx-abi/issues/208>. */
4399 :
4400 : static void
4401 102 : write_splice (tree sp)
4402 : {
4403 102 : write_string ("DS");
4404 :
4405 102 : if (TREE_CODE (sp) == SPLICE_SCOPE)
4406 58 : sp = SPLICE_SCOPE_EXPR (sp);
4407 102 : gcc_assert (dependent_splice_p (sp));
4408 102 : if (TREE_CODE (sp) == TEMPLATE_ID_EXPR)
4409 : {
4410 4 : write_expression (TREE_OPERAND (TREE_OPERAND (sp, 0), 0));
4411 4 : write_template_args (TREE_OPERAND (sp, 1));
4412 : }
4413 : else
4414 98 : write_expression (TREE_OPERAND (sp, 0));
4415 :
4416 102 : write_char ('E');
4417 102 : }
4418 :
4419 : /* Literal subcase of non-terminal <template-arg>.
4420 :
4421 : "Literal arguments, e.g. "A<42L>", are encoded with their type
4422 : and value. Negative integer values are preceded with "n"; for
4423 : example, "A<-42L>" becomes "1AILln42EE". The bool value false is
4424 : encoded as 0, true as 1." */
4425 :
4426 : static void
4427 94775931 : write_template_arg_literal (const tree value)
4428 : {
4429 94775931 : if (TREE_CODE (value) == STRING_CST)
4430 : /* Temporarily mangle strings as braced initializer lists. */
4431 1667 : write_string ("tl");
4432 : else
4433 94774264 : write_char ('L');
4434 :
4435 94775931 : tree valtype = TREE_TYPE (value);
4436 94775931 : write_type (valtype);
4437 :
4438 : /* Write a null member pointer value as (type)0, regardless of its
4439 : real representation. */
4440 94775931 : if (null_member_pointer_value_p (value))
4441 264 : write_integer_cst (integer_zero_node);
4442 : else
4443 94775667 : switch (TREE_CODE (value))
4444 : {
4445 24300 : case CONST_DECL:
4446 24300 : write_integer_cst (DECL_INITIAL (value));
4447 24300 : break;
4448 :
4449 94745401 : case INTEGER_CST:
4450 94745401 : gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)
4451 : || integer_zerop (value) || integer_onep (value));
4452 94745401 : if (!(abi_version_at_least (14)
4453 94738531 : && NULLPTR_TYPE_P (TREE_TYPE (value))))
4454 94745339 : write_integer_cst (value);
4455 : break;
4456 :
4457 2543 : case REAL_CST:
4458 2543 : write_real_cst (value);
4459 2543 : break;
4460 :
4461 6 : case COMPLEX_CST:
4462 6 : if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST
4463 6 : && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST)
4464 : {
4465 3 : write_integer_cst (TREE_REALPART (value));
4466 3 : write_char ('_');
4467 3 : write_integer_cst (TREE_IMAGPART (value));
4468 : }
4469 3 : else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST
4470 3 : && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST)
4471 : {
4472 3 : write_real_cst (TREE_REALPART (value));
4473 3 : write_char ('_');
4474 3 : write_real_cst (TREE_IMAGPART (value));
4475 : }
4476 : else
4477 0 : gcc_unreachable ();
4478 : break;
4479 :
4480 1667 : case STRING_CST:
4481 1667 : {
4482 : /* Mangle strings the same as braced initializer lists. */
4483 1667 : unsigned n = TREE_STRING_LENGTH (value);
4484 1667 : const char *str = TREE_STRING_POINTER (value);
4485 :
4486 : /* Count the number of trailing nuls and subtract them from
4487 : STRSIZE because they don't need to be mangled. */
4488 4638 : for (const char *p = str + n - 1; ; --p)
4489 : {
4490 4638 : if (*p || p == str)
4491 : {
4492 1667 : n -= str + n - !!*p - p;
4493 1667 : break;
4494 : }
4495 : }
4496 1667 : tree eltype = TREE_TYPE (valtype);
4497 11784 : for (const char *p = str; n--; ++p)
4498 : {
4499 10117 : write_char ('L');
4500 10117 : write_type (eltype);
4501 10117 : write_unsigned_number (*(const unsigned char*)p);
4502 10117 : write_string ("E");
4503 : }
4504 : break;
4505 : }
4506 :
4507 1750 : case REFLECT_EXPR:
4508 1750 : write_reflection (value);
4509 1750 : break;
4510 :
4511 0 : default:
4512 0 : gcc_unreachable ();
4513 : }
4514 :
4515 94775931 : write_char ('E');
4516 94775931 : }
4517 :
4518 : /* Non-terminal <template-arg>.
4519 :
4520 : <template-arg> ::= <type> # type
4521 : ::= L <type> </value/ number> E # literal
4522 : ::= LZ <name> E # external name
4523 : ::= X <expression> E # expression */
4524 :
4525 : static void
4526 757239258 : write_template_arg (tree node)
4527 : {
4528 757239258 : enum tree_code code = TREE_CODE (node);
4529 :
4530 757239258 : MANGLE_TRACE_TREE ("template-arg", node);
4531 :
4532 : /* A template template parameter's argument list contains TREE_LIST
4533 : nodes of which the value field is the actual argument. */
4534 757239258 : if (code == TREE_LIST)
4535 : {
4536 0 : node = TREE_VALUE (node);
4537 : /* If it's a decl, deal with its type instead. */
4538 0 : if (DECL_P (node))
4539 : {
4540 0 : node = TREE_TYPE (node);
4541 0 : code = TREE_CODE (node);
4542 : }
4543 : }
4544 :
4545 757239258 : if (VAR_P (node) && DECL_NTTP_OBJECT_P (node))
4546 : /* We want to mangle the argument, not the var we stored it in. */
4547 51639 : node = tparm_object_argument (node);
4548 :
4549 : /* Strip a conversion added by convert_nontype_argument. */
4550 757239258 : if (TREE_CODE (node) == IMPLICIT_CONV_EXPR)
4551 78 : node = TREE_OPERAND (node, 0);
4552 757239258 : if (REFERENCE_REF_P (node))
4553 282 : node = TREE_OPERAND (node, 0);
4554 757239258 : if (TREE_CODE (node) == NOP_EXPR
4555 757239258 : && TYPE_REF_P (TREE_TYPE (node)))
4556 : {
4557 : /* Template parameters can be of reference type. To maintain
4558 : internal consistency, such arguments use a conversion from
4559 : address of object to reference type. */
4560 276 : gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR);
4561 276 : node = TREE_OPERAND (TREE_OPERAND (node, 0), 0);
4562 : }
4563 :
4564 757239258 : if (TREE_CODE (node) == BASELINK
4565 757239258 : && !type_unknown_p (node))
4566 : {
4567 : /* Before v6 we wrongly wrapped a class-scope function in X/E. */
4568 18 : if (abi_check (6))
4569 12 : node = BASELINK_FUNCTIONS (node);
4570 : }
4571 :
4572 757239258 : if (ARGUMENT_PACK_P (node))
4573 : {
4574 : /* Expand the template argument pack. */
4575 10004301 : tree args = ARGUMENT_PACK_ARGS (node);
4576 10004301 : int i, length = TREE_VEC_LENGTH (args);
4577 10004301 : if (abi_check (6))
4578 10004283 : write_char ('J');
4579 : else
4580 18 : write_char ('I');
4581 24463845 : for (i = 0; i < length; ++i)
4582 14459544 : write_template_arg (TREE_VEC_ELT (args, i));
4583 10004301 : write_char ('E');
4584 : }
4585 747234957 : else if (TYPE_P (node))
4586 651274320 : write_type (node);
4587 95960637 : else if (code == TEMPLATE_DECL)
4588 : /* A template appearing as a template arg is a template template arg. */
4589 782609 : write_template_template_arg (node);
4590 94373793 : else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST)
4591 804235 : || code == CONST_DECL
4592 807969 : || null_member_pointer_value_p (node)
4593 95985849 : || code == REFLECT_EXPR)
4594 94371697 : write_template_arg_literal (node);
4595 806331 : else if (code == EXCESS_PRECISION_EXPR
4596 806331 : && TREE_CODE (TREE_OPERAND (node, 0)) == REAL_CST)
4597 0 : write_template_arg_literal (fold_convert (TREE_TYPE (node),
4598 : TREE_OPERAND (node, 0)));
4599 806331 : else if (DECL_P (node))
4600 : {
4601 295 : write_char ('L');
4602 : /* Until ABI version 3, the underscore before the mangled name
4603 : was incorrectly omitted. */
4604 295 : if (!abi_check (3))
4605 21 : write_char ('Z');
4606 : else
4607 274 : write_string ("_Z");
4608 295 : write_encoding (node);
4609 295 : write_char ('E');
4610 : }
4611 : else
4612 : {
4613 : /* Template arguments may be expressions. */
4614 806036 : write_char ('X');
4615 806036 : write_expression (node);
4616 806036 : write_char ('E');
4617 : }
4618 757239258 : }
4619 :
4620 : /* <template-template-arg>
4621 : ::= <name>
4622 : ::= <substitution> */
4623 :
4624 : static void
4625 782609 : write_template_template_arg (const tree decl)
4626 : {
4627 782609 : MANGLE_TRACE_TREE ("template-template-arg", decl);
4628 :
4629 782609 : if (find_substitution (decl))
4630 : return;
4631 699859 : write_name (decl);
4632 699859 : add_substitution (decl);
4633 : }
4634 :
4635 :
4636 : /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
4637 :
4638 : <array-type> ::= A [</dimension/ number>] _ </element/ type>
4639 : ::= A <expression> _ </element/ type>
4640 :
4641 : "Array types encode the dimension (number of elements) and the
4642 : element type. For variable length arrays, the dimension (but not
4643 : the '_' separator) is omitted."
4644 : Note that for flexible array members, like for other arrays of
4645 : unspecified size, the dimension is also omitted. */
4646 :
4647 : static void
4648 1568769 : write_array_type (const tree type)
4649 : {
4650 1568769 : write_char ('A');
4651 1568769 : if (TYPE_DOMAIN (type))
4652 : {
4653 399543 : tree index_type;
4654 :
4655 399543 : index_type = TYPE_DOMAIN (type);
4656 : /* The INDEX_TYPE gives the upper and lower bounds of the array.
4657 : It's null for flexible array members which have no upper bound
4658 : (this is a change from GCC 5 and prior where such members were
4659 : incorrectly mangled as zero-length arrays). */
4660 399543 : if (tree max = TYPE_MAX_VALUE (index_type))
4661 : {
4662 399543 : if (TREE_CODE (max) == INTEGER_CST)
4663 : {
4664 : /* The ABI specifies that we should mangle the number of
4665 : elements in the array, not the largest allowed index. */
4666 237299 : offset_int wmax = wi::to_offset (max) + 1;
4667 : /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
4668 : number of elements as zero. */
4669 237299 : wmax = wi::zext (wmax, TYPE_PRECISION (TREE_TYPE (max)));
4670 237299 : gcc_assert (wi::fits_uhwi_p (wmax));
4671 237299 : write_unsigned_number (wmax.to_uhwi ());
4672 : }
4673 : else
4674 : {
4675 162244 : gcc_checking_assert (TREE_CODE (max) == MINUS_EXPR
4676 : && integer_onep (TREE_OPERAND (max, 1)));
4677 162244 : max = TREE_OPERAND (max, 0);
4678 162244 : write_expression (max);
4679 : }
4680 : }
4681 : }
4682 1568769 : write_char ('_');
4683 1568769 : write_type (TREE_TYPE (type));
4684 1568769 : }
4685 :
4686 : /* Non-terminal <pointer-to-member-type> for pointer-to-member
4687 : variables. TYPE is a pointer-to-member POINTER_TYPE.
4688 :
4689 : <pointer-to-member-type> ::= M </class/ type> </member/ type> */
4690 :
4691 : static void
4692 283965 : write_pointer_to_member_type (const tree type)
4693 : {
4694 283965 : write_char ('M');
4695 283965 : write_type (TYPE_PTRMEM_CLASS_TYPE (type));
4696 283965 : write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type));
4697 283965 : }
4698 :
4699 : /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
4700 : TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
4701 : TEMPLATE_PARM_INDEX.
4702 :
4703 : <template-param> ::= T </parameter/ number> _ */
4704 :
4705 : static void
4706 28989252 : write_template_param (const tree parm)
4707 : {
4708 28989252 : int parm_index;
4709 28989252 : int level;
4710 :
4711 28989252 : MANGLE_TRACE_TREE ("template-parm", parm);
4712 :
4713 28989252 : switch (TREE_CODE (parm))
4714 : {
4715 28208080 : case TEMPLATE_TYPE_PARM:
4716 28208080 : case TEMPLATE_TEMPLATE_PARM:
4717 28208080 : case BOUND_TEMPLATE_TEMPLATE_PARM:
4718 28208080 : parm_index = TEMPLATE_TYPE_IDX (parm);
4719 28208080 : level = TEMPLATE_TYPE_LEVEL (parm);
4720 28208080 : break;
4721 :
4722 781172 : case TEMPLATE_PARM_INDEX:
4723 781172 : parm_index = TEMPLATE_PARM_IDX (parm);
4724 781172 : level = TEMPLATE_PARM_LEVEL (parm);
4725 781172 : break;
4726 :
4727 0 : default:
4728 0 : gcc_unreachable ();
4729 : }
4730 :
4731 28989252 : write_char ('T');
4732 28989252 : if (level > 1)
4733 : {
4734 28675 : if (abi_check (19))
4735 : {
4736 28663 : write_char ('L');
4737 28663 : write_compact_number (level - 1);
4738 : }
4739 : }
4740 : /* NUMBER as it appears in the mangling is (-1)-indexed, with the
4741 : earliest template param denoted by `_'. */
4742 28989252 : write_compact_number (parm_index);
4743 28989252 : }
4744 :
4745 : /* <template-template-param>
4746 : ::= <template-param>
4747 : ::= <substitution> */
4748 :
4749 : static void
4750 631 : write_template_template_param (const tree parm)
4751 : {
4752 631 : tree templ = NULL_TREE;
4753 :
4754 : /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
4755 : template template parameter. The substitution candidate here is
4756 : only the template. */
4757 631 : if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
4758 : {
4759 536 : templ
4760 536 : = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
4761 536 : if (find_substitution (templ))
4762 : return;
4763 : }
4764 :
4765 : /* <template-param> encodes only the template parameter position,
4766 : not its template arguments, which is fine here. */
4767 631 : write_template_param (parm);
4768 631 : if (templ)
4769 536 : add_substitution (templ);
4770 : }
4771 :
4772 : /* Non-terminal <substitution>.
4773 :
4774 : <substitution> ::= S <seq-id> _
4775 : ::= S_ */
4776 :
4777 : static void
4778 179436798 : write_substitution (const int seq_id)
4779 : {
4780 179436798 : MANGLE_TRACE ("substitution", "");
4781 :
4782 179436798 : write_char ('S');
4783 179436798 : if (seq_id > 0)
4784 156155136 : write_number (seq_id - 1, /*unsigned=*/1, 36);
4785 179436798 : write_char ('_');
4786 179436798 : }
4787 :
4788 : /* Start mangling ENTITY. */
4789 :
4790 : static inline void
4791 228364663 : start_mangling (const tree entity)
4792 : {
4793 228364663 : G = {};
4794 228364663 : G.entity = entity;
4795 228364663 : obstack_free (&name_obstack, name_base);
4796 228364663 : mangle_obstack = &name_obstack;
4797 228364663 : name_base = obstack_alloc (&name_obstack, 0);
4798 228364663 : }
4799 :
4800 : /* Done with mangling. Release the data. */
4801 :
4802 : static void
4803 228364663 : finish_mangling_internal (void)
4804 : {
4805 : /* Clear all the substitutions. */
4806 228364663 : vec_safe_truncate (G.substitutions, 0);
4807 :
4808 228364663 : if (G.mod)
4809 7873 : mangle_module_fini ();
4810 :
4811 : /* Null-terminate the string. */
4812 228364663 : write_char ('\0');
4813 228364663 : }
4814 :
4815 :
4816 : /* Like finish_mangling_internal, but return the mangled string. */
4817 :
4818 : static inline const char *
4819 451733 : finish_mangling (void)
4820 : {
4821 451733 : finish_mangling_internal ();
4822 451733 : return (const char *) obstack_finish (mangle_obstack);
4823 : }
4824 :
4825 : /* Like finish_mangling_internal, but return an identifier. */
4826 :
4827 : static tree
4828 227912930 : finish_mangling_get_identifier (void)
4829 : {
4830 227912930 : finish_mangling_internal ();
4831 : /* Don't obstack_finish here, and the next start_mangling will
4832 : remove the identifier. */
4833 227912930 : return get_identifier ((const char *) obstack_base (mangle_obstack));
4834 : }
4835 :
4836 : /* Initialize data structures for mangling. */
4837 :
4838 : void
4839 100969 : init_mangle (void)
4840 : {
4841 100969 : gcc_obstack_init (&name_obstack);
4842 100969 : name_base = obstack_alloc (&name_obstack, 0);
4843 100969 : vec_alloc (G.substitutions, 0);
4844 :
4845 : /* Cache these identifiers for quick comparison when checking for
4846 : standard substitutions. */
4847 100969 : subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator");
4848 100969 : subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string");
4849 100969 : subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits");
4850 100969 : subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream");
4851 100969 : subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream");
4852 100969 : subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream");
4853 100969 : }
4854 :
4855 : /* Generate a mangling for MODULE's global initializer fn. */
4856 :
4857 : tree
4858 2102 : mangle_module_global_init (int module)
4859 : {
4860 2102 : start_mangling (NULL_TREE);
4861 :
4862 2102 : write_string ("_ZGI");
4863 2102 : write_module (module, true);
4864 :
4865 2102 : return finish_mangling_get_identifier ();
4866 : }
4867 :
4868 : /* Generate the mangled name of DECL. */
4869 :
4870 : static tree
4871 221361797 : mangle_decl_string (const tree decl)
4872 : {
4873 221361797 : tree result;
4874 221361797 : tree saved_fn = current_function_decl;
4875 :
4876 : /* We shouldn't be trying to mangle an uninstantiated template. */
4877 221361797 : gcc_assert (!type_dependent_expression_p (decl));
4878 :
4879 221361797 : current_function_decl = NULL_TREE;
4880 221361797 : iloc_sentinel ils (DECL_SOURCE_LOCATION (decl));
4881 :
4882 221361797 : start_mangling (decl);
4883 :
4884 221361797 : if (TREE_CODE (decl) == TYPE_DECL)
4885 328623 : write_type (TREE_TYPE (decl));
4886 : else
4887 221033174 : write_mangled_name (decl, true);
4888 :
4889 221361797 : result = finish_mangling_get_identifier ();
4890 221361797 : if (DEBUG_MANGLE)
4891 : fprintf (stderr, "mangle_decl_string = '%s'\n\n",
4892 : IDENTIFIER_POINTER (result));
4893 :
4894 221361797 : current_function_decl = saved_fn;
4895 221361797 : return result;
4896 221361797 : }
4897 :
4898 : /* Return an identifier for the external mangled name of DECL. */
4899 :
4900 : static tree
4901 165644781 : get_mangled_id (tree decl)
4902 : {
4903 165644781 : tree id = mangle_decl_string (decl);
4904 165644781 : return targetm.mangle_decl_assembler_name (decl, id);
4905 : }
4906 :
4907 : /* Create an identifier for the external mangled name of DECL. */
4908 :
4909 : void
4910 165653526 : mangle_decl (const tree decl)
4911 : {
4912 165653526 : tree id;
4913 165653526 : bool dep;
4914 :
4915 : /* Don't bother mangling uninstantiated templates. */
4916 165653526 : ++processing_template_decl;
4917 165653526 : if (TREE_CODE (decl) == TYPE_DECL)
4918 329110 : dep = dependent_type_p (TREE_TYPE (decl));
4919 : else
4920 329329909 : dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
4921 275657957 : && any_dependent_template_arguments_p (DECL_TI_ARGS (decl)));
4922 165653526 : --processing_template_decl;
4923 165653526 : if (dep)
4924 : return;
4925 :
4926 : /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
4927 : It is not needed to assign names to anonymous namespace, but we use the
4928 : "<anon>" marker to be able to tell if type is C++ ODR type or type
4929 : produced by other language. */
4930 165645268 : if (TREE_CODE (decl) == TYPE_DECL
4931 329110 : && TYPE_STUB_DECL (TREE_TYPE (decl))
4932 165963656 : && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl))))
4933 487 : id = get_identifier ("<anon>");
4934 : else
4935 : {
4936 165644781 : gcc_assert (TREE_CODE (decl) != TYPE_DECL
4937 : || !no_linkage_check (TREE_TYPE (decl), true));
4938 165644781 : if (abi_version_at_least (10))
4939 165526743 : if (tree fn = decl_function_context (decl))
4940 3598746 : maybe_check_abi_tags (fn, decl);
4941 165644781 : id = get_mangled_id (decl);
4942 : }
4943 165645268 : SET_DECL_ASSEMBLER_NAME (decl, id);
4944 :
4945 165645268 : if (G.need_cxx17_warning
4946 165645268 : && (TREE_PUBLIC (decl) || DECL_REALLY_EXTERN (decl)))
4947 10 : warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wnoexcept_type,
4948 : "mangled name for %qD will change in C++17 because the "
4949 : "exception specification is part of a function type",
4950 : decl);
4951 :
4952 165645268 : if (id != DECL_NAME (decl)
4953 : /* Don't do this for a fake symbol we aren't going to emit anyway. */
4954 163085301 : && TREE_CODE (decl) != TYPE_DECL
4955 328401459 : && !DECL_MAYBE_IN_CHARGE_CDTOR_P (decl))
4956 : {
4957 142168736 : int save_ver = flag_abi_version;
4958 142168736 : tree id2 = NULL_TREE;
4959 :
4960 142168736 : if (!DECL_REALLY_EXTERN (decl))
4961 : {
4962 85707573 : record_mangling (decl, G.need_abi_warning);
4963 :
4964 85707573 : if (!G.need_abi_warning)
4965 : return;
4966 :
4967 38369 : flag_abi_version = flag_abi_compat_version;
4968 38369 : id2 = mangle_decl_string (decl);
4969 38369 : id2 = targetm.mangle_decl_assembler_name (decl, id2);
4970 38369 : flag_abi_version = save_ver;
4971 :
4972 38369 : if (id2 != id)
4973 38253 : note_mangling_alias (decl, id2);
4974 : }
4975 :
4976 56499532 : if (warn_abi)
4977 : {
4978 55678842 : const char fabi_version[] = "-fabi-version";
4979 :
4980 55678842 : if (flag_abi_compat_version != warn_abi_version
4981 55678115 : || id2 == NULL_TREE)
4982 : {
4983 55678647 : flag_abi_version = warn_abi_version;
4984 55678647 : id2 = mangle_decl_string (decl);
4985 55678647 : id2 = targetm.mangle_decl_assembler_name (decl, id2);
4986 : }
4987 55678842 : flag_abi_version = save_ver;
4988 :
4989 55678842 : if (id2 == id)
4990 : /* OK. */;
4991 266 : else if (warn_abi_version != 0
4992 266 : && abi_version_at_least (warn_abi_version))
4993 222 : warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
4994 : "the mangled name of %qD changed between "
4995 : "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
4996 : G.entity, fabi_version, warn_abi_version, id2,
4997 : fabi_version, save_ver, id);
4998 : else
4999 44 : warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
5000 : "the mangled name of %qD changes between "
5001 : "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
5002 : G.entity, fabi_version, save_ver, id,
5003 : fabi_version, warn_abi_version, id2);
5004 : }
5005 :
5006 56499532 : flag_abi_version = save_ver;
5007 : }
5008 : }
5009 :
5010 : /* Generate the mangled representation of TYPE. */
5011 :
5012 : const char *
5013 451733 : mangle_type_string (const tree type)
5014 : {
5015 451733 : const char *result;
5016 :
5017 451733 : start_mangling (type);
5018 451733 : write_type (type);
5019 451733 : result = finish_mangling ();
5020 451733 : if (DEBUG_MANGLE)
5021 : fprintf (stderr, "mangle_type_string = '%s'\n\n", result);
5022 451733 : return result;
5023 : }
5024 :
5025 : /* Create an identifier for the mangled name of a special component
5026 : for belonging to TYPE. CODE is the ABI-specified code for this
5027 : component. */
5028 :
5029 : static tree
5030 5737394 : mangle_special_for_type (const tree type, const char *code)
5031 : {
5032 5737394 : tree result;
5033 :
5034 : /* We don't have an actual decl here for the special component, so
5035 : we can't just process the <encoded-name>. Instead, fake it. */
5036 5737394 : start_mangling (type);
5037 :
5038 : /* Start the mangling. */
5039 5737394 : write_string ("_Z");
5040 5737394 : write_string (code);
5041 :
5042 : /* Add the type. */
5043 5737394 : write_type (type);
5044 5737394 : result = finish_mangling_get_identifier ();
5045 :
5046 5737394 : if (DEBUG_MANGLE)
5047 : fprintf (stderr, "mangle_special_for_type = %s\n\n",
5048 : IDENTIFIER_POINTER (result));
5049 :
5050 5737394 : return result;
5051 : }
5052 :
5053 : /* Create an identifier for the mangled representation of the typeinfo
5054 : structure for TYPE. */
5055 :
5056 : tree
5057 3285007 : mangle_typeinfo_for_type (const tree type)
5058 : {
5059 3285007 : return mangle_special_for_type (type, "TI");
5060 : }
5061 :
5062 : /* Create an identifier for the mangled name of the NTBS containing
5063 : the mangled name of TYPE. */
5064 :
5065 : tree
5066 443286 : mangle_typeinfo_string_for_type (const tree type)
5067 : {
5068 443286 : return mangle_special_for_type (type, "TS");
5069 : }
5070 :
5071 : /* Create an identifier for the mangled name of the vtable for TYPE. */
5072 :
5073 : tree
5074 1824681 : mangle_vtbl_for_type (const tree type)
5075 : {
5076 1824681 : return mangle_special_for_type (type, "TV");
5077 : }
5078 :
5079 : /* Returns an identifier for the mangled name of the VTT for TYPE. */
5080 :
5081 : tree
5082 184420 : mangle_vtt_for_type (const tree type)
5083 : {
5084 184420 : return mangle_special_for_type (type, "TT");
5085 : }
5086 :
5087 : /* Returns an identifier for the mangled name of the decomposition
5088 : artificial variable DECL. DECLS is the vector of the VAR_DECLs
5089 : for the identifier-list. */
5090 :
5091 : tree
5092 897 : mangle_decomp (const tree decl, vec<tree> &decls)
5093 : {
5094 897 : gcc_assert (!type_dependent_expression_p (decl));
5095 :
5096 897 : location_t saved_loc = input_location;
5097 897 : input_location = DECL_SOURCE_LOCATION (decl);
5098 :
5099 897 : check_abi_tags (decl);
5100 897 : start_mangling (decl);
5101 897 : write_string ("_Z");
5102 :
5103 897 : tree context = decl_mangling_context (decl);
5104 897 : gcc_assert (context != NULL_TREE);
5105 :
5106 897 : bool nested = false;
5107 897 : bool local = false;
5108 897 : if (DECL_NAMESPACE_STD_P (context))
5109 9 : write_string ("St");
5110 888 : else if (TREE_CODE (context) == FUNCTION_DECL)
5111 : {
5112 269 : local = true;
5113 269 : write_char ('Z');
5114 269 : write_encoding (context);
5115 269 : write_char ('E');
5116 : }
5117 619 : else if (context != global_namespace)
5118 : {
5119 100 : nested = true;
5120 100 : write_char ('N');
5121 100 : write_prefix (context);
5122 : }
5123 :
5124 897 : write_string ("DC");
5125 897 : unsigned int i;
5126 897 : tree d;
5127 2966 : FOR_EACH_VEC_ELT (decls, i, d)
5128 2069 : write_unqualified_name (d);
5129 897 : write_char ('E');
5130 :
5131 897 : if (tree tags = get_abi_tags (decl))
5132 : {
5133 : /* We didn't emit ABI tags for structured bindings before ABI 19. */
5134 30 : if (!G.need_abi_warning
5135 30 : && TREE_PUBLIC (decl)
5136 120 : && abi_warn_or_compat_version_crosses (19))
5137 30 : G.need_abi_warning = 1;
5138 :
5139 30 : if (abi_version_at_least (19))
5140 30 : write_abi_tags (tags);
5141 : }
5142 :
5143 897 : if (nested)
5144 100 : write_char ('E');
5145 797 : else if (local && DECL_DISCRIMINATOR_P (decl))
5146 269 : write_discriminator (discriminator_for_local_entity (decl));
5147 :
5148 897 : tree id = finish_mangling_get_identifier ();
5149 897 : if (DEBUG_MANGLE)
5150 : fprintf (stderr, "mangle_decomp = '%s'\n\n",
5151 : IDENTIFIER_POINTER (id));
5152 :
5153 897 : input_location = saved_loc;
5154 :
5155 897 : if (warn_abi && G.need_abi_warning)
5156 : {
5157 0 : const char fabi_version[] = "-fabi-version";
5158 0 : tree id2 = id;
5159 0 : int save_ver = flag_abi_version;
5160 :
5161 0 : if (flag_abi_version != warn_abi_version)
5162 : {
5163 0 : flag_abi_version = warn_abi_version;
5164 0 : id2 = mangle_decomp (decl, decls);
5165 0 : flag_abi_version = save_ver;
5166 : }
5167 :
5168 0 : if (id2 == id)
5169 : /* OK. */;
5170 0 : else if (warn_abi_version != 0
5171 0 : && abi_version_at_least (warn_abi_version))
5172 0 : warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
5173 : "the mangled name of %qD changed between "
5174 : "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
5175 : G.entity, fabi_version, warn_abi_version, id2,
5176 : fabi_version, save_ver, id);
5177 : else
5178 0 : warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi,
5179 : "the mangled name of %qD changes between "
5180 : "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
5181 : G.entity, fabi_version, save_ver, id,
5182 : fabi_version, warn_abi_version, id2);
5183 : }
5184 :
5185 897 : return id;
5186 : }
5187 :
5188 : /* Return an identifier for a construction vtable group. TYPE is
5189 : the most derived class in the hierarchy; BINFO is the base
5190 : subobject for which this construction vtable group will be used.
5191 :
5192 : This mangling isn't part of the ABI specification; in the ABI
5193 : specification, the vtable group is dumped in the same COMDAT as the
5194 : main vtable, and is referenced only from that vtable, so it doesn't
5195 : need an external name. For binary formats without COMDAT sections,
5196 : though, we need external names for the vtable groups.
5197 :
5198 : We use the production
5199 :
5200 : <special-name> ::= TC <type> <offset number> _ <base type> */
5201 :
5202 : tree
5203 253179 : mangle_ctor_vtbl_for_type (const tree type, const tree binfo)
5204 : {
5205 253179 : tree result;
5206 :
5207 253179 : start_mangling (type);
5208 :
5209 253179 : write_string ("_Z");
5210 253179 : write_string ("TC");
5211 253179 : write_type (type);
5212 253179 : write_integer_cst (BINFO_OFFSET (binfo));
5213 253179 : write_char ('_');
5214 253179 : write_type (BINFO_TYPE (binfo));
5215 :
5216 253179 : result = finish_mangling_get_identifier ();
5217 253179 : if (DEBUG_MANGLE)
5218 : fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n",
5219 : IDENTIFIER_POINTER (result));
5220 253179 : return result;
5221 : }
5222 :
5223 : /* Mangle a this pointer or result pointer adjustment.
5224 :
5225 : <call-offset> ::= h <fixed offset number> _
5226 : ::= v <fixed offset number> _ <virtual offset number> _ */
5227 :
5228 : static void
5229 482514 : mangle_call_offset (const tree fixed_offset, const tree virtual_offset)
5230 : {
5231 482514 : write_char (virtual_offset ? 'v' : 'h');
5232 :
5233 : /* For either flavor, write the fixed offset. */
5234 482514 : write_integer_cst (fixed_offset);
5235 482514 : write_char ('_');
5236 :
5237 : /* For a virtual thunk, add the virtual offset. */
5238 482514 : if (virtual_offset)
5239 : {
5240 361260 : write_integer_cst (virtual_offset);
5241 361260 : write_char ('_');
5242 : }
5243 482514 : }
5244 :
5245 : /* Return an identifier for the mangled name of a this-adjusting or
5246 : covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment
5247 : to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this
5248 : is a virtual thunk, and it is the vtbl offset in
5249 : bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and
5250 : zero for a covariant thunk. Note, that FN_DECL might be a covariant
5251 : thunk itself. A covariant thunk name always includes the adjustment
5252 : for the this pointer, even if there is none.
5253 :
5254 : <special-name> ::= T <call-offset> <base encoding>
5255 : ::= Tc <this_adjust call-offset> <result_adjust call-offset>
5256 : <base encoding> */
5257 :
5258 : tree
5259 482127 : mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset,
5260 : tree virtual_offset, tree thunk)
5261 : {
5262 482127 : tree result;
5263 :
5264 482127 : if (abi_version_at_least (11))
5265 482124 : maybe_check_abi_tags (fn_decl, thunk, 11);
5266 :
5267 482127 : start_mangling (fn_decl);
5268 :
5269 482127 : write_string ("_Z");
5270 482127 : write_char ('T');
5271 :
5272 482127 : if (!this_adjusting)
5273 : {
5274 : /* Covariant thunk with no this adjustment */
5275 217 : write_char ('c');
5276 217 : mangle_call_offset (integer_zero_node, NULL_TREE);
5277 217 : mangle_call_offset (fixed_offset, virtual_offset);
5278 : }
5279 481910 : else if (!DECL_THUNK_P (fn_decl))
5280 : /* Plain this adjusting thunk. */
5281 481740 : mangle_call_offset (fixed_offset, virtual_offset);
5282 : else
5283 : {
5284 : /* This adjusting thunk to covariant thunk. */
5285 170 : write_char ('c');
5286 170 : mangle_call_offset (fixed_offset, virtual_offset);
5287 170 : fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl));
5288 170 : virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl);
5289 170 : if (virtual_offset)
5290 124 : virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
5291 170 : mangle_call_offset (fixed_offset, virtual_offset);
5292 170 : fn_decl = THUNK_TARGET (fn_decl);
5293 : }
5294 :
5295 : /* Scoped name. */
5296 482127 : write_encoding (fn_decl);
5297 :
5298 482127 : result = finish_mangling_get_identifier ();
5299 482127 : if (DEBUG_MANGLE)
5300 : fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result));
5301 482127 : return result;
5302 : }
5303 :
5304 : /* Handle ABI backwards compatibility for past bugs where we didn't call
5305 : check_abi_tags in places where it's needed: call check_abi_tags and warn if
5306 : it makes a difference. If FOR_DECL is non-null, it's the declaration
5307 : that we're actually trying to mangle; if it's null, we're mangling the
5308 : guard variable for T. */
5309 :
5310 : static void
5311 4085715 : maybe_check_abi_tags (tree t, tree for_decl, int ver)
5312 : {
5313 4085715 : if (DECL_ASSEMBLER_NAME_SET_P (t))
5314 : return;
5315 :
5316 808185 : tree oldtags = get_abi_tags (t);
5317 :
5318 808185 : mangle_decl (t);
5319 :
5320 808185 : tree newtags = get_abi_tags (t);
5321 808185 : if (newtags && newtags != oldtags
5322 48 : && abi_version_crosses (ver))
5323 : {
5324 12 : if (for_decl && DECL_THUNK_P (for_decl))
5325 3 : warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
5326 : "the mangled name of a thunk for %qD changes between "
5327 : "%<-fabi-version=%d%> and %<-fabi-version=%d%>",
5328 : t, flag_abi_version, warn_abi_version);
5329 9 : else if (for_decl)
5330 6 : warning_at (DECL_SOURCE_LOCATION (for_decl), OPT_Wabi,
5331 : "the mangled name of %qD changes between "
5332 : "%<-fabi-version=%d%> and %<-fabi-version=%d%>",
5333 : for_decl, flag_abi_version, warn_abi_version);
5334 : else
5335 3 : warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi,
5336 : "the mangled name of the initialization guard variable "
5337 : "for %qD changes between %<-fabi-version=%d%> and "
5338 : "%<-fabi-version=%d%>",
5339 : t, flag_abi_version, warn_abi_version);
5340 : }
5341 : }
5342 :
5343 : /* Write out the appropriate string for this variable when generating
5344 : another mangled name based on this one. */
5345 :
5346 : static void
5347 7619 : write_guarded_var_name (const tree variable)
5348 : {
5349 7619 : if (DECL_NAME (variable)
5350 7619 : && startswith (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR"))
5351 : /* The name of a guard variable for a reference temporary should refer
5352 : to the reference, not the temporary. */
5353 6 : write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4);
5354 7613 : else if (DECL_DECOMPOSITION_P (variable)
5355 751 : && DECL_NAME (variable) == NULL_TREE
5356 7885 : && startswith (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (variable)),
5357 : "_Z"))
5358 : /* The name of a guard variable for a structured binding needs special
5359 : casing. */
5360 272 : write_string (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (variable)) + 2);
5361 : else
5362 7341 : write_name (variable);
5363 7619 : }
5364 :
5365 : /* Return an identifier for the name of an initialization guard
5366 : variable for indicated VARIABLE. */
5367 :
5368 : tree
5369 4851 : mangle_guard_variable (const tree variable)
5370 : {
5371 4851 : if (abi_version_at_least (10))
5372 4845 : maybe_check_abi_tags (variable);
5373 4851 : start_mangling (variable);
5374 4851 : write_string ("_ZGV");
5375 4851 : write_guarded_var_name (variable);
5376 4851 : return finish_mangling_get_identifier ();
5377 : }
5378 :
5379 : /* Return an identifier for the name of a thread_local initialization
5380 : function for VARIABLE. */
5381 :
5382 : tree
5383 1190 : mangle_tls_init_fn (const tree variable)
5384 : {
5385 1190 : check_abi_tags (variable);
5386 1190 : start_mangling (variable);
5387 1190 : write_string ("_ZTH");
5388 1190 : write_guarded_var_name (variable);
5389 1190 : return finish_mangling_get_identifier ();
5390 : }
5391 :
5392 : /* Return an identifier for the name of a thread_local wrapper
5393 : function for VARIABLE. */
5394 :
5395 : #define TLS_WRAPPER_PREFIX "_ZTW"
5396 :
5397 : tree
5398 749 : mangle_tls_wrapper_fn (const tree variable)
5399 : {
5400 749 : check_abi_tags (variable);
5401 749 : start_mangling (variable);
5402 749 : write_string (TLS_WRAPPER_PREFIX);
5403 749 : write_guarded_var_name (variable);
5404 749 : return finish_mangling_get_identifier ();
5405 : }
5406 :
5407 : /* Return true iff FN is a thread_local wrapper function. */
5408 :
5409 : bool
5410 2515117 : decl_tls_wrapper_p (const tree fn)
5411 : {
5412 2515117 : if (TREE_CODE (fn) != FUNCTION_DECL)
5413 : return false;
5414 2141792 : tree name = DECL_NAME (fn);
5415 2141792 : return startswith (IDENTIFIER_POINTER (name), TLS_WRAPPER_PREFIX);
5416 : }
5417 :
5418 : /* Return an identifier for the name of a temporary variable used to
5419 : initialize a static reference. This is now part of the ABI. */
5420 :
5421 : tree
5422 829 : mangle_ref_init_variable (const tree variable)
5423 : {
5424 829 : start_mangling (variable);
5425 829 : write_string ("_ZGR");
5426 829 : check_abi_tags (variable);
5427 829 : write_guarded_var_name (variable);
5428 : /* Avoid name clashes with aggregate initialization of multiple
5429 : references at once. */
5430 829 : write_compact_number (current_ref_temp_count++);
5431 829 : return finish_mangling_get_identifier ();
5432 : }
5433 :
5434 : /* Return an identifier for the mangled name of a C++20 template parameter
5435 : object for template argument EXPR. */
5436 :
5437 : tree
5438 67815 : mangle_template_parm_object (tree expr)
5439 : {
5440 67815 : start_mangling (expr);
5441 67815 : write_string ("_ZTAX");
5442 67815 : write_expression (expr);
5443 67815 : write_char ('E');
5444 67815 : return finish_mangling_get_identifier ();
5445 : }
5446 :
5447 : /* Given a CLASS_TYPE, such as a record for std::bad_exception this
5448 : function generates a mangled name for the vtable map variable of
5449 : the class type. For example, if the class type is
5450 : "std::bad_exception", the mangled name for the class is
5451 : "St13bad_exception". This function would generate the name
5452 : "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as:
5453 : "_VTV<std::bad_exception>::__vtable_map". */
5454 :
5455 :
5456 : char *
5457 6 : get_mangled_vtable_map_var_name (tree class_type)
5458 : {
5459 6 : char *var_name = NULL;
5460 6 : const char *prefix = "_ZN4_VTVI";
5461 6 : const char *postfix = "E12__vtable_mapE";
5462 :
5463 6 : gcc_assert (TREE_CODE (class_type) == RECORD_TYPE);
5464 :
5465 6 : tree class_id = DECL_ASSEMBLER_NAME (TYPE_NAME (class_type));
5466 :
5467 6 : if (strstr (IDENTIFIER_POINTER (class_id), "<anon>") != NULL)
5468 : {
5469 0 : class_id = get_mangled_id (TYPE_NAME (class_type));
5470 0 : vtbl_register_mangled_name (TYPE_NAME (class_type), class_id);
5471 : }
5472 :
5473 6 : unsigned int len = strlen (IDENTIFIER_POINTER (class_id)) +
5474 : strlen (prefix) +
5475 6 : strlen (postfix) + 1;
5476 :
5477 6 : var_name = (char *) xmalloc (len);
5478 :
5479 6 : sprintf (var_name, "%s%s%s", prefix, IDENTIFIER_POINTER (class_id), postfix);
5480 :
5481 6 : return var_name;
5482 : }
5483 :
5484 : #include "gt-cp-mangle.h"
|