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