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