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