Bug Summary

File:build/gcc/cp/mangle.cc
Warning:line 1928, column 7
Value stored to 'chunk_digits' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name mangle.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC_FRONTEND -D IN_GCC -D HAVE_CONFIG_H -I . -I cp -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-3gmyFS.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc
1/* Name mangling for the 3.0 -*- C++ -*- ABI.
2 Copyright (C) 2000-2023 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
17You should have received a copy of the GNU General Public License
18along 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_MANGLE0
63#define DEBUG_MANGLE0 0
64#endif
65
66/* Macros for tracing the write_* functions. */
67#if DEBUG_MANGLE0
68# define MANGLE_TRACE(FN, INPUT) \
69 fprintf (stderrstderr, " %-24s: %-24s\n", (FN), (INPUT))
70# define MANGLE_TRACE_TREE(FN, NODE) \
71 fprintf (stderrstderr, " %-24s: %-24s (%p)\n", \
72 (FN), get_tree_code_name (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code)), (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)(((enum tree_code) (NODE)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| ((((((enum tree_code) (NODE)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (NODE)->base.code)) == UNION_TYPE) &&
((tree_class_check ((NODE), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__))->type_common.lang_flag_5)) &&
(((tree_class_check (((tree_check3 ((NODE), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__))->type_non_common.lang_1)) != nullptr &&
(((((contains_struct_check ((((tree_check ((((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((((struct
tree_template_info*)(tree_check (((((tree_class_check (((tree_check3
((NODE), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__))->typed.type))) == (((struct tree_template_info
*)(tree_check (((((tree_class_check (((tree_check3 ((NODE), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 83, __FUNCTION__, (TEMPLATE_INFO))))->tmpl)))) \
84 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM \
85 || (CLASS_TYPE_P (NODE)(((((enum tree_code) (NODE)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (NODE)->base.code)) == UNION_TYPE) &&
((tree_class_check ((NODE), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 85, __FUNCTION__))->type_common.lang_flag_5)) \
86 && CLASSTYPE_TEMPLATE_INFO (NODE)(((tree_class_check (((tree_check3 ((NODE), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 86, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 86, __FUNCTION__))->type_non_common.lang_1)) != NULLnullptr \
87 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE))(((((contains_struct_check ((((tree_check ((((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((((struct
tree_template_info*)(tree_check (((((tree_class_check (((tree_check3
((NODE), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 87, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 87, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 87, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 87, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 87, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 87, __FUNCTION__))->typed.type))) == (((struct tree_template_info
*)(tree_check (((((tree_class_check (((tree_check3 ((NODE), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 87, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 87, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 87, __FUNCTION__, (TEMPLATE_INFO))))->tmpl))))
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)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (N)) != (warn_abi_version == 0 || warn_abi_version >=
(N))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (N)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (N)))
) \
92 (abi_version_crosses (N)((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (N)) != (warn_abi_version == 0 || warn_abi_version >=
(N))) || abi_compat_version_crosses (N)((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (N)) != (global_options.x_flag_abi_compat_version == 0
|| global_options.x_flag_abi_compat_version >= (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) (flag == 0 || flag >= N)
97#define any_abi_below(N)(!(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (N)) || !(warn_abi_version == 0 || warn_abi_version >=
(N)) || !(global_options.x_flag_abi_compat_version == 0 || global_options
.x_flag_abi_compat_version >= (N))) \
98 (!abi_version_at_least (N)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (N)) \
99 || !abi_flag_at_least (warn_abi_version, (N))(warn_abi_version == 0 || warn_abi_version >= (N)) \
100 || !abi_flag_at_least (flag_abi_compat_version, (N))(global_options.x_flag_abi_compat_version == 0 || global_options
.x_flag_abi_compat_version >= (N)))
101
102/* Things we only need one of. This module is not reentrant. */
103struct GTY(()) globals {
104 /* An array of the current substitution candidates, in the order
105 we've seen them. Contains NULLS, which correspond to module
106 substitutions. */
107 vec<tree, va_gc> *substitutions;
108
109 /* The entity that is being mangled. */
110 tree GTY ((skip)) entity;
111
112 /* How many parameter scopes we are inside. */
113 int parm_depth;
114
115 /* True if the mangling will be different in a future version of the
116 ABI. */
117 bool need_abi_warning;
118
119 /* True if the mangling will be different in C++17 mode. */
120 bool need_cxx17_warning;
121
122 /* True if we mangled a module name. */
123 bool mod;
124};
125
126static GTY (()) globals G;
127
128/* The obstack on which we build mangled names. */
129static struct obstack *mangle_obstack;
130
131/* The obstack on which we build mangled names that are not going to
132 be IDENTIFIER_NODEs. */
133static struct obstack name_obstack;
134
135/* The first object on the name_obstack; we use this to free memory
136 allocated on the name_obstack. */
137static void *name_base;
138
139/* Indices into subst_identifiers. These are identifiers used in
140 special substitution rules. */
141typedef enum
142{
143 SUBID_ALLOCATOR,
144 SUBID_BASIC_STRING,
145 SUBID_CHAR_TRAITS,
146 SUBID_BASIC_ISTREAM,
147 SUBID_BASIC_OSTREAM,
148 SUBID_BASIC_IOSTREAM,
149 SUBID_MAX
150}
151substitution_identifier_index_t;
152
153/* For quick substitution checks, look up these common identifiers
154 once only. */
155static GTY(()) tree subst_identifiers[SUBID_MAX];
156
157/* Single-letter codes for builtin integer types, defined in
158 <builtin-type>. These are indexed by integer_type_kind values. */
159static const char
160integer_type_codes[itk_none] =
161{
162 'c', /* itk_char */
163 'a', /* itk_signed_char */
164 'h', /* itk_unsigned_char */
165 's', /* itk_short */
166 't', /* itk_unsigned_short */
167 'i', /* itk_int */
168 'j', /* itk_unsigned_int */
169 'l', /* itk_long */
170 'm', /* itk_unsigned_long */
171 'x', /* itk_long_long */
172 'y', /* itk_unsigned_long_long */
173 /* __intN types are handled separately */
174 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
175};
176
177static tree maybe_template_info (const tree);
178
179/* Functions for handling substitutions. */
180
181static inline tree canonicalize_for_substitution (tree);
182static void add_substitution (tree);
183static inline bool is_std_substitution (const tree,
184 const substitution_identifier_index_t);
185static inline bool is_std_substitution_char (const tree,
186 const substitution_identifier_index_t);
187static int find_substitution (tree);
188static void mangle_call_offset (const tree, const tree);
189
190/* Functions for emitting mangled representations of things. */
191
192static void write_mangled_name (const tree, bool);
193static void write_encoding (const tree);
194static void write_name (tree, const int);
195static void write_abi_tags (tree);
196static void write_unscoped_name (const tree);
197static void write_unscoped_template_name (const tree);
198static void write_nested_name (const tree);
199static void write_prefix (const tree);
200static void write_template_prefix (const tree);
201static void write_unqualified_name (tree);
202static void write_conversion_operator_name (const tree);
203static void write_source_name (tree);
204static void write_literal_operator_name (tree);
205static void write_unnamed_type_name (const tree);
206static void write_closure_type_name (const tree);
207static int hwint_to_ascii (unsigned HOST_WIDE_INTlong, const unsigned int, char *,
208 const unsigned int);
209static void write_number (unsigned HOST_WIDE_INTlong, const int,
210 const unsigned int);
211static void write_compact_number (int num);
212static void write_integer_cst (const tree);
213static void write_real_cst (const tree);
214static void write_identifier (const char *);
215static void write_special_name_constructor (const tree);
216static void write_special_name_destructor (const tree);
217static void write_type (tree);
218static int write_CV_qualifiers_for_type (const tree);
219static void write_builtin_type (tree);
220static void write_function_type (const tree);
221static void write_bare_function_type (const tree, const int, const tree);
222static void write_method_parms (tree, const int, const tree);
223static void write_class_enum_type (const tree);
224static void write_template_args (tree);
225static void write_expression (tree);
226static void write_template_arg_literal (const tree);
227static void write_template_arg (tree);
228static void write_template_template_arg (const tree);
229static void write_array_type (const tree);
230static void write_pointer_to_member_type (const tree);
231static void write_template_param (const tree);
232static void write_template_template_param (const tree);
233static void write_substitution (const int);
234static int discriminator_for_local_entity (tree);
235static int discriminator_for_string_literal (tree, tree);
236static void write_discriminator (const int);
237static void write_local_name (tree, const tree, const tree);
238static void dump_substitution_candidates (void);
239static tree mangle_decl_string (const tree);
240static void maybe_check_abi_tags (tree, tree = NULL_TREE(tree) nullptr, int = 10);
241static bool equal_abi_tags (tree, tree);
242
243/* Control functions. */
244
245static inline void start_mangling (const tree);
246static tree mangle_special_for_type (const tree, const char *);
247
248/* Append a single character to the end of the mangled
249 representation. */
250#define write_char(CHAR)__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ((CHAR)))); }) \
251 obstack_1grow (mangle_obstack, (CHAR))__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ((CHAR)))); })
252
253/* Append a sized buffer to the end of the mangled representation. */
254#define write_chars(CHAR, LEN)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = ((LEN)); if (__extension__ ({ struct obstack const *
__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, (CHAR), __len); __o->next_free += __len; (
void) 0; }) \
255 obstack_grow (mangle_obstack, (CHAR), (LEN))__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = ((LEN)); if (__extension__ ({ struct obstack const *
__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, (CHAR), __len); __o->next_free += __len; (
void) 0; })
256
257/* Append a NUL-terminated string to the end of the mangled
258 representation. */
259#define write_string(STRING)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (STRING)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (STRING), __len); __o->next_free += __len
; (void) 0; }) \
260 obstack_grow (mangle_obstack, (STRING), strlen (STRING))__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (STRING)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (STRING), __len); __o->next_free += __len
; (void) 0; })
261
262/* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the
263 same purpose (context, which may be a type) and value (template
264 decl). See write_template_prefix for more information on what this
265 is used for. */
266#define NESTED_TEMPLATE_MATCH(NODE1, NODE2)(((enum tree_code) (NODE1)->base.code) == TREE_LIST &&
((enum tree_code) (NODE2)->base.code) == TREE_LIST &&
(((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
tree_code) (((tree_check ((NODE1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 266, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code))] == tcc_type) && comptypes ((((tree_check ((NODE1
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 266, __FUNCTION__, (TREE_LIST)))->list.purpose)), (((tree_check
((NODE2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 266, __FUNCTION__, (TREE_LIST)))->list.purpose)), 0)) ||
((tree_check ((NODE1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 266, __FUNCTION__, (TREE_LIST)))->list.purpose) == ((tree_check
((NODE2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 266, __FUNCTION__, (TREE_LIST)))->list.purpose)) &&
((tree_check ((NODE1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 266, __FUNCTION__, (TREE_LIST)))->list.value) == ((tree_check
((NODE2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 266, __FUNCTION__, (TREE_LIST)))->list.value)) \
267 (TREE_CODE (NODE1)((enum tree_code) (NODE1)->base.code) == TREE_LIST \
268 && TREE_CODE (NODE2)((enum tree_code) (NODE2)->base.code) == TREE_LIST \
269 && ((TYPE_P (TREE_PURPOSE (NODE1))(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (((tree_check ((NODE1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 269, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code))] == tcc_type) \
270 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))comptypes ((((tree_check ((NODE1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 270, __FUNCTION__, (TREE_LIST)))->list.purpose)), (((tree_check
((NODE2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 270, __FUNCTION__, (TREE_LIST)))->list.purpose)), 0)) \
271 || TREE_PURPOSE (NODE1)((tree_check ((NODE1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 271, __FUNCTION__, (TREE_LIST)))->list.purpose) == TREE_PURPOSE (NODE2)((tree_check ((NODE2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 271, __FUNCTION__, (TREE_LIST)))->list.purpose)) \
272 && TREE_VALUE (NODE1)((tree_check ((NODE1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 272, __FUNCTION__, (TREE_LIST)))->list.value) == TREE_VALUE (NODE2)((tree_check ((NODE2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 272, __FUNCTION__, (TREE_LIST)))->list.value))
273
274/* Write out an unsigned quantity in base 10. */
275#define write_unsigned_number(NUMBER)write_number ((NUMBER), 1, 10) \
276 write_number ((NUMBER), /*unsigned_p=*/1, 10)
277
278/* If DECL is a template instance (including the uninstantiated template
279 itself), return its TEMPLATE_INFO. Otherwise return NULL. */
280
281static tree
282maybe_template_info (const tree decl)
283{
284 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL)
285 {
286 /* TYPE_DECLs are handled specially. Look at its type to decide
287 if this is a template instantiation. */
288 const tree type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 288, __FUNCTION__))->typed.type);
289
290 if (CLASS_TYPE_P (type)(((((enum tree_code) (type)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__))->type_common.lang_flag_5)) && CLASSTYPE_TEMPLATE_ID_P (type)(((enum tree_code) (type)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| ((((((enum tree_code) (type)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__))->type_common.lang_flag_5)) &&
(((tree_class_check (((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__))->type_non_common.lang_1)) != nullptr
&& (((((contains_struct_check ((((tree_check ((((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((((struct tree_template_info*)(tree_check (((((
tree_class_check (((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__))->typed.type))) == (((struct tree_template_info
*)(tree_check (((((tree_class_check (((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 290, __FUNCTION__, (TEMPLATE_INFO))))->tmpl)))))
291 return TYPE_TEMPLATE_INFO (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| (((enum tree_code) (type)->base.code) == RECORD_TYPE ||
((enum tree_code) (type)->base.code) == UNION_TYPE || ((enum
tree_code) (type)->base.code) == QUAL_UNION_TYPE) ? ((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 291, __FUNCTION__))->type_non_common.lang_1) : (tree) nullptr
);
292 }
293 else
294 {
295 /* Check if the template is a primary template. */
296 if (DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 296, __FUNCTION__))->decl_common.lang_specific) != NULLnullptr
297 && VAR_OR_FUNCTION_DECL_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL || ((enum
tree_code) (decl)->base.code) == FUNCTION_DECL)
298 && DECL_TEMPLATE_INFO (decl)(((contains_struct_check ((template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 298, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 298, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info)
299 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))(((((contains_struct_check ((((tree_check ((((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((((struct
tree_template_info*)(tree_check (((((contains_struct_check (
(template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 299, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 299, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 299, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 299, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 299, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 299, __FUNCTION__))->typed.type))) == (((struct tree_template_info
*)(tree_check (((((contains_struct_check ((template_info_decl_check
((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 299, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 299, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 299, __FUNCTION__, (TEMPLATE_INFO))))->tmpl)))
300 return DECL_TEMPLATE_INFO (decl)(((contains_struct_check ((template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 300, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 300, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info);
301 }
302
303 /* It's not a template id. */
304 return NULL_TREE(tree) nullptr;
305}
306
307/* Produce debugging output of current substitution candidates. */
308
309static void
310dump_substitution_candidates (void)
311{
312 unsigned i;
313 tree el;
314
315 fprintf (stderrstderr, " ++ substitutions ");
316 FOR_EACH_VEC_ELT (*G.substitutions, i, el)for (i = 0; (*G.substitutions).iterate ((i), &(el)); ++(i
))
317 {
318 const char *name = "???";
319
320 if (i > 0)
321 fprintf (stderrstderr, " ");
322 if (!el)
323 name = "module";
324 else if (DECL_P (el)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (el)->base.code))] == tcc_declaration))
325 name = IDENTIFIER_POINTER (DECL_NAME (el))((const char *) (tree_check ((((contains_struct_check ((el), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 325, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 325, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
326 else if (TREE_CODE (el)((enum tree_code) (el)->base.code) == TREE_LIST)
327 name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el)))((const char *) (tree_check ((((contains_struct_check ((((tree_check
((el), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 327, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 327, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 327, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
328 else if (TYPE_NAME (el)((tree_class_check ((el), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 328, __FUNCTION__))->type_common.name))
329 name = TYPE_NAME_STRING (el)(((const char *) (tree_check (((((tree_class_check ((el), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 329, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((el), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 329, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((el), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 329, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 329, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((el), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 329, __FUNCTION__))->type_common.name))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 329, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
330 fprintf (stderrstderr, " S%d_ = ", i - 1);
331 if (el)
332 {
333 if (TYPE_P (el)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (el)->base.code))] == tcc_type) &&
334 (CP_TYPE_RESTRICT_P (el)((cp_type_quals (el) & TYPE_QUAL_RESTRICT) != 0)
335 || CP_TYPE_VOLATILE_P (el)((cp_type_quals (el) & TYPE_QUAL_VOLATILE) != 0)
336 || CP_TYPE_CONST_P (el)((cp_type_quals (el) & TYPE_QUAL_CONST) != 0)))
337 fprintf (stderrstderr, "CV-");
338 fprintf (stderrstderr, "%s (%s at %p)",
339 name, get_tree_code_name (TREE_CODE (el)((enum tree_code) (el)->base.code)), (void *) el);
340 }
341 fprintf (stderrstderr, "\n");
342 }
343}
344
345/* <exception-spec> ::=
346 Do -- non-throwing exception specification
347 DO <expression> E -- computed (instantiation-dependent) noexcept
348 Dw <type>* E -- throw (types) */
349
350static void
351write_exception_spec (tree spec)
352{
353
354 if (!spec || spec == noexcept_false_speccp_global_trees[CPTI_NOEXCEPT_FALSE_SPEC])
355 /* Nothing. */
356 return;
357
358 if (!flag_noexcept_type)
359 {
360 G.need_cxx17_warning = true;
361 return;
362 }
363
364 if (spec == noexcept_true_speccp_global_trees[CPTI_NOEXCEPT_TRUE_SPEC] || spec == empty_except_speccp_global_trees[CPTI_EMPTY_EXCEPT_SPEC])
365 write_string ("Do")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Do")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Do"), __len); __o->next_free += __len
; (void) 0; });
366 else if (tree expr = TREE_PURPOSE (spec)((tree_check ((spec), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 366, __FUNCTION__, (TREE_LIST)))->list.purpose))
367 {
368 /* noexcept (expr) */
369 gcc_assert (uses_template_parms (expr))((void)(!(uses_template_parms (expr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 369, __FUNCTION__), 0 : 0));
370 write_string ("DO")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("DO")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("DO"), __len); __o->next_free += __len
; (void) 0; });
371 write_expression (expr);
372 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
373 }
374 else
375 {
376 /* throw (type-list) */
377 write_string ("Dw")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Dw")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Dw"), __len); __o->next_free += __len
; (void) 0; });
378 for (tree t = spec; t; t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 378, __FUNCTION__))->common.chain))
379 write_type (TREE_VALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 379, __FUNCTION__, (TREE_LIST)))->list.value));
380 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
381 }
382}
383
384/* Both decls and types can be substitution candidates, but sometimes
385 they refer to the same thing. For instance, a TYPE_DECL and
386 RECORD_TYPE for the same class refer to the same thing, and should
387 be treated accordingly in substitutions. This function returns a
388 canonicalized tree node representing NODE that is used when adding
389 and substitution candidates and finding matches. */
390
391static inline tree
392canonicalize_for_substitution (tree node)
393{
394 /* For a TYPE_DECL, use the type instead. */
395 if (TREE_CODE (node)((enum tree_code) (node)->base.code) == TYPE_DECL)
396 node = TREE_TYPE (node)((contains_struct_check ((node), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 396, __FUNCTION__))->typed.type);
397 if (TYPE_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_type)
398 && TYPE_CANONICAL (node)((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 398, __FUNCTION__))->type_common.canonical) != node
399 && TYPE_MAIN_VARIANT (node)((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 399, __FUNCTION__))->type_common.main_variant) != node)
400 {
401 tree orig = node;
402 /* Here we want to strip the topmost typedef only.
403 We need to do that so is_std_substitution can do proper
404 name matching. */
405 if (TREE_CODE (node)((enum tree_code) (node)->base.code) == FUNCTION_TYPE)
406 /* Use build_qualified_type and TYPE_QUALS here to preserve
407 the old buggy mangling of attribute noreturn with abi<5. */
408 node = build_qualified_type (TYPE_MAIN_VARIANT (node)((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 408, __FUNCTION__))->type_common.main_variant),
409 TYPE_QUALS (node)((int) ((((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 409, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 409, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 409, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 409, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 409, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8)))));
410 else
411 node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node)((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 411, __FUNCTION__))->type_common.main_variant),
412 cp_type_quals (node));
413 if (FUNC_OR_METHOD_TYPE_P (node)(((enum tree_code) (node)->base.code) == FUNCTION_TYPE || (
(enum tree_code) (node)->base.code) == METHOD_TYPE))
414 {
415 node = build_ref_qualified_type (node, type_memfn_rqual (orig));
416 tree r = canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (orig)((tree_class_check (((tree_check2 ((orig), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 416, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 416, __FUNCTION__))->type_non_common.lang_1));
417 if (flag_noexcept_type)
418 node = build_exception_variant (node, r);
419 else
420 /* Set the warning flag if appropriate. */
421 write_exception_spec (r);
422 }
423 }
424 return node;
425}
426
427/* Add NODE as a substitution candidate. NODE must not already be on
428 the list of candidates. */
429
430static void
431add_substitution (tree node)
432{
433 tree c;
434
435 if (DEBUG_MANGLE0)
436 fprintf (stderrstderr, " ++ add_substitution (%s at %10p)\n",
437 get_tree_code_name (TREE_CODE (node)((enum tree_code) (node)->base.code)), (void *) node);
438
439 /* Get the canonicalized substitution candidate for NODE. */
440 c = canonicalize_for_substitution (node);
441 if (DEBUG_MANGLE0 && c != node)
442 fprintf (stderrstderr, " ++ using candidate (%s at %10p)\n",
443 get_tree_code_name (TREE_CODE (node)((enum tree_code) (node)->base.code)), (void *) node);
444 node = c;
445
446 /* Make sure NODE isn't already a candidate. */
447 if (flag_checkingglobal_options.x_flag_checking)
448 {
449 int i;
450 tree candidate;
451
452 FOR_EACH_VEC_SAFE_ELT (G.substitutions, i, candidate)for (i = 0; vec_safe_iterate ((G.substitutions), (i), &(candidate
)); ++(i))
453 if (candidate)
454 {
455 gcc_assert (!(DECL_P (node) && node == candidate))((void)(!(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (node)->base.code))] == tcc_declaration
) && node == candidate)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 455, __FUNCTION__), 0 : 0));
456 gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)((void)(!(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (node)->base.code))] == tcc_type) &&
(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
tree_code) (candidate)->base.code))] == tcc_type) &&
comptypes ((node), (candidate), 0))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 457, __FUNCTION__), 0 : 0))
457 && same_type_p (node, candidate)))((void)(!(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (node)->base.code))] == tcc_type) &&
(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
tree_code) (candidate)->base.code))] == tcc_type) &&
comptypes ((node), (candidate), 0))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 457, __FUNCTION__), 0 : 0));
458 }
459 }
460
461 /* Put the decl onto the varray of substitution candidates. */
462 vec_safe_push (G.substitutions, node);
463
464 if (DEBUG_MANGLE0)
465 dump_substitution_candidates ();
466}
467
468/* Helper function for find_substitution. Returns nonzero if NODE,
469 which may be a decl or a CLASS_TYPE, is a template-id with template
470 name of substitution_index[INDEX] in the ::std namespace, with
471 global module attachment. */
472
473static bool
474is_std_substitution (const tree node,
475 const substitution_identifier_index_t index)
476{
477 tree type = NULLnullptr;
478 tree decl = NULLnullptr;
479
480 if (DECL_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_declaration))
481 {
482 type = TREE_TYPE (node)((contains_struct_check ((node), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 482, __FUNCTION__))->typed.type);
483 decl = node;
484 }
485 else if (CLASS_TYPE_P (node)(((((enum tree_code) (node)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (node)->base.code)) == UNION_TYPE) &&
((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 485, __FUNCTION__))->type_common.lang_flag_5)))
486 {
487 type = node;
488 decl = TYPE_NAME (node)((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 488, __FUNCTION__))->type_common.name);
489 }
490 else
491 /* These are not the droids you're looking for. */
492 return false;
493
494 if (!DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))(((!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 494, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 494, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 494, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])) == cp_global_trees[CPTI_STD]))
495 return false;
496
497 if (!(TYPE_LANG_SPECIFIC (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 497, __FUNCTION__))->type_with_lang_specific.lang_specific
) && TYPE_TEMPLATE_INFO (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| (((enum tree_code) (type)->base.code) == RECORD_TYPE ||
((enum tree_code) (type)->base.code) == UNION_TYPE || ((enum
tree_code) (type)->base.code) == QUAL_UNION_TYPE) ? ((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 497, __FUNCTION__))->type_non_common.lang_1) : (tree) nullptr
)))
498 return false;
499
500 tree tmpl = TYPE_TI_TEMPLATE (type)(((struct tree_template_info*)(tree_check (((((enum tree_code
) (type)->base.code) == ENUMERAL_TYPE || ((enum tree_code)
(type)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE) ? ((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 500, __FUNCTION__))->type_non_common.lang_1) : (tree) nullptr
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 500, __FUNCTION__, (TEMPLATE_INFO))))->tmpl);
501 if (DECL_NAME (tmpl)((contains_struct_check ((tmpl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 501, __FUNCTION__))->decl_minimal.name) != subst_identifiers[index])
502 return false;
503
504 if (modules_p () && get_originating_module (tmpl, true) >= 0)
505 return false;
506
507 return true;
508}
509
510/* Return the ABI tags (the TREE_VALUE of the "abi_tag" attribute entry) for T,
511 which can be a decl or type. */
512
513static tree
514get_abi_tags (tree t)
515{
516 if (!t || TREE_CODE (t)((enum tree_code) (t)->base.code) == NAMESPACE_DECL)
517 return NULL_TREE(tree) nullptr;
518
519 if (DECL_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_declaration) && DECL_DECLARES_TYPE_P (t)(((enum tree_code) (t)->base.code) == TYPE_DECL || (((enum
tree_code) (t)->base.code) == TEMPLATE_DECL && ((
struct tree_template_decl *)(const_cast<union tree_node *>
((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 519, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 519, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == TYPE_DECL)))
520 t = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 520, __FUNCTION__))->typed.type);
521
522 tree attrs;
523 if (TYPE_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_type))
524 attrs = TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 524, __FUNCTION__))->type_common.attributes);
525 else
526 attrs = DECL_ATTRIBUTES (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 526, __FUNCTION__))->decl_common.attributes);
527
528 tree tags = lookup_attribute ("abi_tag", attrs);
529 if (tags)
530 tags = TREE_VALUE (tags)((tree_check ((tags), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 530, __FUNCTION__, (TREE_LIST)))->list.value);
531 return tags;
532}
533
534/* Helper function for find_substitution. Returns nonzero if NODE,
535 which may be a decl or a CLASS_TYPE, is the template-id
536 ::std::identifier<char>, where identifier is
537 substitution_index[INDEX]. */
538
539static bool
540is_std_substitution_char (const tree node,
541 const substitution_identifier_index_t index)
542{
543 tree args;
544 /* Check NODE's name is ::std::identifier. */
545 if (!is_std_substitution (node, index))
546 return 0;
547 /* Figure out its template args. */
548 if (DECL_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_declaration))
549 args = DECL_TI_ARGS (node)((struct tree_template_info*)(tree_check (((((contains_struct_check
((template_info_decl_check ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 549, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 549, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 549, __FUNCTION__, (TEMPLATE_INFO))))->args;
550 else if (CLASS_TYPE_P (node)(((((enum tree_code) (node)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (node)->base.code)) == UNION_TYPE) &&
((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 550, __FUNCTION__))->type_common.lang_flag_5)))
551 args = CLASSTYPE_TI_ARGS (node)((struct tree_template_info*)(tree_check (((((tree_class_check
(((tree_check3 ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 551, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 551, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 551, __FUNCTION__, (TEMPLATE_INFO))))->args;
552 else
553 /* Oops, not a template. */
554 return 0;
555 /* NODE's template arg list should be <char>. */
556 return
557 TREE_VEC_LENGTH (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 557, __FUNCTION__, (TREE_VEC)))->base.u.length) == 1
558 && TREE_VEC_ELT (args, 0)(*((const_cast<tree *> (tree_vec_elt_check ((args), (0)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 558, __FUNCTION__))))) == char_type_nodeinteger_types[itk_char];
559}
560
561/* Check whether a substitution should be used to represent NODE in
562 the mangling.
563
564 First, check standard special-case substitutions.
565
566 <substitution> ::= St
567 # ::std
568
569 ::= Sa
570 # ::std::allocator
571
572 ::= Sb
573 # ::std::basic_string
574
575 ::= Ss
576 # ::std::basic_string<char,
577 ::std::char_traits<char>,
578 ::std::allocator<char> >
579
580 ::= Si
581 # ::std::basic_istream<char, ::std::char_traits<char> >
582
583 ::= So
584 # ::std::basic_ostream<char, ::std::char_traits<char> >
585
586 ::= Sd
587 # ::std::basic_iostream<char, ::std::char_traits<char> >
588
589 Then examine the stack of currently available substitution
590 candidates for entities appearing earlier in the same mangling
591
592 If a substitution is found, write its mangled representation and
593 return nonzero. If none is found, just return zero. */
594
595static int
596find_substitution (tree node)
597{
598 int i;
599 const int size = vec_safe_length (G.substitutions);
600 tree decl;
601 tree type;
602 const char *abbr = NULLnullptr;
603
604 if (DEBUG_MANGLE0)
605 fprintf (stderrstderr, " ++ find_substitution (%s at %p)\n",
606 get_tree_code_name (TREE_CODE (node)((enum tree_code) (node)->base.code)), (void *) node);
607
608 /* Obtain the canonicalized substitution representation for NODE.
609 This is what we'll compare against. */
610 node = canonicalize_for_substitution (node);
611
612 /* Check for builtin substitutions. */
613
614 decl = TYPE_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_type) ? TYPE_NAME (node)((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 614, __FUNCTION__))->type_common.name) : node;
615 type = TYPE_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_type) ? node : TREE_TYPE (node)((contains_struct_check ((node), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 615, __FUNCTION__))->typed.type);
616
617 /* Check for std::allocator. */
618 if (decl
619 && is_std_substitution (decl, SUBID_ALLOCATOR)
620 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl))((((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 620, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 620, __FUNCTION__))->type_with_lang_specific.lang_specific
))->use_template))
621 abbr = "Sa";
622
623 /* Check for std::basic_string. */
624 else if (decl && is_std_substitution (decl, SUBID_BASIC_STRING))
625 {
626 if (TYPE_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_type))
627 {
628 /* If this is a type (i.e. a fully-qualified template-id),
629 check for
630 std::basic_string <char,
631 std::char_traits<char>,
632 std::allocator<char> > . */
633 if (cp_type_quals (type) == TYPE_UNQUALIFIED
634 && CLASSTYPE_USE_TEMPLATE (type)((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 634, __FUNCTION__))->type_with_lang_specific.lang_specific
))->use_template))
635 {
636 tree args = CLASSTYPE_TI_ARGS (type)((struct tree_template_info*)(tree_check (((((tree_class_check
(((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 636, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 636, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 636, __FUNCTION__, (TEMPLATE_INFO))))->args;
637 if (TREE_VEC_LENGTH (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 637, __FUNCTION__, (TREE_VEC)))->base.u.length) == 3
638 && template_args_equal (TREE_VEC_ELT (args, 0)(*((const_cast<tree *> (tree_vec_elt_check ((args), (0)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 638, __FUNCTION__))))), char_type_nodeinteger_types[itk_char])
639 && is_std_substitution_char (TREE_VEC_ELT (args, 1)(*((const_cast<tree *> (tree_vec_elt_check ((args), (1)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 639, __FUNCTION__))))),
640 SUBID_CHAR_TRAITS)
641 && is_std_substitution_char (TREE_VEC_ELT (args, 2)(*((const_cast<tree *> (tree_vec_elt_check ((args), (2)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 641, __FUNCTION__))))),
642 SUBID_ALLOCATOR))
643 abbr = "Ss";
644 }
645 }
646 else
647 /* Substitute for the template name only if this isn't a type. */
648 abbr = "Sb";
649 }
650
651 /* Check for basic_{i,o,io}stream. */
652 else if (TYPE_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_type)
653 && cp_type_quals (type) == TYPE_UNQUALIFIED
654 && CLASS_TYPE_P (type)(((((enum tree_code) (type)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 654, __FUNCTION__))->type_common.lang_flag_5))
655 && CLASSTYPE_USE_TEMPLATE (type)((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 655, __FUNCTION__))->type_with_lang_specific.lang_specific
))->use_template)
656 && CLASSTYPE_TEMPLATE_INFO (type)(((tree_class_check (((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 656, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 656, __FUNCTION__))->type_non_common.lang_1)) != NULLnullptr)
657 {
658 /* First, check for the template
659 args <char, std::char_traits<char> > . */
660 tree args = CLASSTYPE_TI_ARGS (type)((struct tree_template_info*)(tree_check (((((tree_class_check
(((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 660, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 660, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 660, __FUNCTION__, (TEMPLATE_INFO))))->args;
661 if (TREE_VEC_LENGTH (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 661, __FUNCTION__, (TREE_VEC)))->base.u.length) == 2
662 && template_args_equal (TREE_VEC_ELT (args, 0)(*((const_cast<tree *> (tree_vec_elt_check ((args), (0)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 662, __FUNCTION__))))), char_type_nodeinteger_types[itk_char])
663 && is_std_substitution_char (TREE_VEC_ELT (args, 1)(*((const_cast<tree *> (tree_vec_elt_check ((args), (1)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 663, __FUNCTION__))))),
664 SUBID_CHAR_TRAITS))
665 {
666 /* Got them. Is this basic_istream? */
667 if (is_std_substitution (decl, SUBID_BASIC_ISTREAM))
668 abbr = "Si";
669 /* Or basic_ostream? */
670 else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM))
671 abbr = "So";
672 /* Or basic_iostream? */
673 else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM))
674 abbr = "Sd";
675 }
676 }
677
678 /* Check for namespace std. */
679 else if (decl && DECL_NAMESPACE_STD_P (decl)((decl) == cp_global_trees[CPTI_STD]))
680 {
681 write_string ("St")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("St")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("St"), __len); __o->next_free += __len
; (void) 0; });
682 return 1;
683 }
684
685 tree tags = NULL_TREE(tree) nullptr;
686 if (OVERLOAD_TYPE_P (node)((((((enum tree_code) (node)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (node)->base.code)) == UNION_TYPE) &&
((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 686, __FUNCTION__))->type_common.lang_flag_5)) || ((enum
tree_code) (node)->base.code) == ENUMERAL_TYPE) || DECL_CLASS_TEMPLATE_P (node)((((enum tree_code) (node)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 686, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((node
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 686, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == TYPE_DECL) && (((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((node
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 686, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == TYPE_DECL && ((contains_struct_check ((((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 686, __FUNCTION__, (TEMPLATE_DECL))))))))->result), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 686, __FUNCTION__))->decl_common.lang_flag_2))))
687 tags = get_abi_tags (type);
688 /* Now check the list of available substitutions for this mangling
689 operation. */
690 if (!abbr || tags)
691 for (i = 0; i < size; ++i)
692 if (tree candidate = (*G.substitutions)[i])
693 {
694 /* NODE is a matched to a candidate if it's the same decl node or
695 if it's the same type. */
696 if (decl == candidate
697 || (TYPE_P (candidate)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (candidate)->base.code))] == tcc_type) && type && TYPE_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_type)
698 && same_type_p (type, candidate)comptypes ((type), (candidate), 0))
699 || NESTED_TEMPLATE_MATCH (node, candidate)(((enum tree_code) (node)->base.code) == TREE_LIST &&
((enum tree_code) (candidate)->base.code) == TREE_LIST &&
(((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
tree_code) (((tree_check ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 699, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code))] == tcc_type) && comptypes ((((tree_check ((node
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 699, __FUNCTION__, (TREE_LIST)))->list.purpose)), (((tree_check
((candidate), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 699, __FUNCTION__, (TREE_LIST)))->list.purpose)), 0)) ||
((tree_check ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 699, __FUNCTION__, (TREE_LIST)))->list.purpose) == ((tree_check
((candidate), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 699, __FUNCTION__, (TREE_LIST)))->list.purpose)) &&
((tree_check ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 699, __FUNCTION__, (TREE_LIST)))->list.value) == ((tree_check
((candidate), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 699, __FUNCTION__, (TREE_LIST)))->list.value)))
700 {
701 write_substitution (i);
702 return 1;
703 }
704 }
705
706 if (!abbr)
707 /* No substitution found. */
708 return 0;
709
710 write_string (abbr)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (abbr)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (abbr), __len); __o->next_free += __len
; (void) 0; });
711 if (tags)
712 {
713 /* If there are ABI tags on the abbreviation, it becomes
714 a substitution candidate. */
715 write_abi_tags (tags);
716 add_substitution (node);
717 }
718 return 1;
719}
720
721/* Returns whether DECL's symbol name should be the plain unqualified-id
722 rather than a more complicated mangled name. */
723
724static bool
725unmangled_name_p (const tree decl)
726{
727 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FUNCTION_DECL)
728 {
729 /* The names of `extern "C"' functions are not mangled. */
730 return (DECL_EXTERN_C_FUNCTION_P (decl)((((enum tree_code) (decl)->base.code) == FUNCTION_DECL &&
!(((enum tree_code) (decl)->base.code) == FUNCTION_DECL &&
((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 730, __FUNCTION__))->decl_common.lang_specific) &&
__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (decl)->base.code) == TEMPLATE_DECL ?
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 730, __FUNCTION__, (TEMPLATE_DECL))))))))->result : decl
)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 730, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (decl)->base.code) == FUNCTION_DECL || ((
(enum tree_code) (decl)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 730, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((decl
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 730, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 730, __FUNCTION__); &lt->u.fn; })->thunk_p)) &&
((((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 730, __FUNCTION__))->decl_common.lang_specific) ? ((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 730, __FUNCTION__))->decl_common.lang_specific)->u.base
.language : (((enum tree_code) (decl)->base.code) == FUNCTION_DECL
? lang_c : lang_cplusplus)) == lang_c))
731 /* But overloaded operator names *are* mangled. */
732 && !DECL_OVERLOADED_OPERATOR_P (decl)(((tree_not_check2 (((tree_check ((((contains_struct_check ((
decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 732, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 732, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 732, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)));
733 }
734 else if (VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL))
735 {
736 /* static variables are mangled. */
737 if (!DECL_EXTERNAL_LINKAGE_P (decl)(decl_linkage (decl) == lk_external))
738 return false;
739
740 /* extern "C" declarations aren't mangled. */
741 if (DECL_EXTERN_C_P (decl)((((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 741, __FUNCTION__))->decl_common.lang_specific) ? ((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 741, __FUNCTION__))->decl_common.lang_specific)->u.base
.language : (((enum tree_code) (decl)->base.code) == FUNCTION_DECL
? lang_c : lang_cplusplus)) == lang_c))
742 return true;
743
744 /* Other variables at non-global scope are mangled. */
745 if (CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 745, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 745, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 745, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]) != global_namespacecp_global_trees[CPTI_GLOBAL])
746 return false;
747
748 /* Variable template instantiations are mangled. */
749 if (DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 749, __FUNCTION__))->decl_common.lang_specific) && DECL_TEMPLATE_INFO (decl)(((contains_struct_check ((template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 749, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 749, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info)
750 && variable_template_p (DECL_TI_TEMPLATE (decl)((struct tree_template_info*)(tree_check (((((contains_struct_check
((template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 750, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 750, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 750, __FUNCTION__, (TEMPLATE_INFO))))->tmpl))
751 return false;
752
753 /* Declarations with ABI tags are mangled. */
754 if (get_abi_tags (decl))
755 return false;
756
757 // Declarations attached to a named module are mangled
758 if (modules_p () && get_originating_module (decl, true) >= 0)
759 return false;
760
761 /* The names of non-static global variables aren't mangled. */
762 return true;
763 }
764
765 return false;
766}
767
768/* TOP_LEVEL is true, if this is being called at outermost level of
769 mangling. It should be false when mangling a decl appearing in an
770 expression within some other mangling.
771
772 <mangled-name> ::= _Z <encoding> */
773
774static void
775write_mangled_name (const tree decl, bool top_level)
776{
777 MANGLE_TRACE_TREE ("mangled-name", decl);
778
779 check_abi_tags (decl);
780
781 if (unmangled_name_p (decl))
782 {
783 if (top_level)
784 write_string (IDENTIFIER_POINTER (DECL_NAME (decl)))__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (((const char *) (tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 784, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 784, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
))); if (__extension__ ({ struct obstack const *__o1 = (__o);
(size_t) (__o1->chunk_limit - __o1->next_free); }) <
__len) _obstack_newchunk (__o, __len); memcpy (__o->next_free
, (((const char *) (tree_check ((((contains_struct_check ((decl
), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 784, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 784, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)), __len); __o->next_free += __len; (void) 0; });
785 else
786 {
787 /* The standard notes: "The <encoding> of an extern "C"
788 function is treated like global-scope data, i.e. as its
789 <source-name> without a type." We cannot write
790 overloaded operators that way though, because it contains
791 characters invalid in assembler. */
792 write_string ("_Z")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("_Z")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("_Z"), __len); __o->next_free += __len
; (void) 0; });
793 write_source_name (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 793, __FUNCTION__))->decl_minimal.name));
794 }
795 }
796 else
797 {
798 write_string ("_Z")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("_Z")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("_Z"), __len); __o->next_free += __len
; (void) 0; });
799 write_encoding (decl);
800 }
801
802 /* If this is the pre/post function for a guarded function, append
803 .pre/post, like something from create_virtual_clone. */
804 if (DECL_IS_PRE_FN_P (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 804, __FUNCTION__))->decl_common.abstract_origin) &&
(get_precondition_function ((((contains_struct_check ((decl)
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 804, __FUNCTION__))->decl_common.abstract_origin)))) == decl
))
805 write_string (".pre")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (".pre")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (".pre"), __len); __o->next_free += __len
; (void) 0; });
806 else if (DECL_IS_POST_FN_P (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 806, __FUNCTION__))->decl_common.abstract_origin) &&
(get_postcondition_function ((((contains_struct_check ((decl
), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 806, __FUNCTION__))->decl_common.abstract_origin)))) == decl
))
807 write_string (".post")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (".post")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (".post"), __len); __o->next_free += __len
; (void) 0; });
808
809 /* If this is a coroutine helper, then append an appropriate string to
810 identify which. */
811 if (tree ramp = DECL_RAMP_FN (decl)(coro_get_ramp_function (decl)))
812 {
813 if (DECL_ACTOR_FN (ramp)(coro_get_actor_function ((ramp))) == decl)
814 write_string (JOIN_STR "actor")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("." "actor")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("." "actor"), __len); __o->next_free
+= __len; (void) 0; });
815 else if (DECL_DESTROY_FN (ramp)(coro_get_destroy_function ((ramp))) == decl)
816 write_string (JOIN_STR "destroy")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("." "destroy")); if (__extension__ ({ struct
obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
__o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); memcpy (__o->next_free, ("." "destroy"), __len); __o->
next_free += __len; (void) 0; });
817 else
818 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 818, __FUNCTION__));
819 }
820}
821
822/* Returns true if the return type of DECL is part of its signature, and
823 therefore its mangling. */
824
825bool
826mangle_return_type_p (tree decl)
827{
828 return (!DECL_CONSTRUCTOR_P (decl)((tree_check (((((enum tree_code) (decl)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 828, __FUNCTION__, (TEMPLATE_DECL))))))))->result : decl
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 828, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)
829 && !DECL_DESTRUCTOR_P (decl)((tree_check (((((enum tree_code) (decl)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 829, __FUNCTION__, (TEMPLATE_DECL))))))))->result : decl
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 829, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_destructor
)
830 && !DECL_CONV_FN_P (decl)((((tree_not_check2 (((tree_check ((((contains_struct_check (
(decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 830, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 830, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 830, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 830, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 830, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 830, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 830, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 830, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 830, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))
831 && maybe_template_info (decl));
832}
833
834/* <encoding> ::= <function name> <bare-function-type>
835 ::= <data name> */
836
837static void
838write_encoding (const tree decl)
839{
840 MANGLE_TRACE_TREE ("encoding", decl);
841
842 if (DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 842, __FUNCTION__))->decl_common.lang_specific) && DECL_EXTERN_C_FUNCTION_P (decl)((((enum tree_code) (decl)->base.code) == FUNCTION_DECL &&
!(((enum tree_code) (decl)->base.code) == FUNCTION_DECL &&
((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 842, __FUNCTION__))->decl_common.lang_specific) &&
__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (decl)->base.code) == TEMPLATE_DECL ?
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 842, __FUNCTION__, (TEMPLATE_DECL))))))))->result : decl
)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 842, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (decl)->base.code) == FUNCTION_DECL || ((
(enum tree_code) (decl)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 842, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((decl
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 842, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 842, __FUNCTION__); &lt->u.fn; })->thunk_p)) &&
((((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 842, __FUNCTION__))->decl_common.lang_specific) ? ((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 842, __FUNCTION__))->decl_common.lang_specific)->u.base
.language : (((enum tree_code) (decl)->base.code) == FUNCTION_DECL
? lang_c : lang_cplusplus)) == lang_c)))
843 {
844 /* For overloaded operators write just the mangled name
845 without arguments. */
846 if (DECL_OVERLOADED_OPERATOR_P (decl)(((tree_not_check2 (((tree_check ((((contains_struct_check ((
decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 846, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 846, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 846, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)))
847 write_name (decl, /*ignore_local_scope=*/0);
848 else
849 write_source_name (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 849, __FUNCTION__))->decl_minimal.name));
850 return;
851 }
852
853 write_name (decl, /*ignore_local_scope=*/0);
854 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FUNCTION_DECL)
855 {
856 tree fn_type;
857 tree d;
858
859 if (maybe_template_info (decl))
860 {
861 fn_type = get_mostly_instantiated_function_type (decl);
862 /* FN_TYPE will not have parameter types for in-charge or
863 VTT parameters. Therefore, we pass NULL_TREE to
864 write_bare_function_type -- otherwise, it will get
865 confused about which artificial parameters to skip. */
866 d = NULL_TREE(tree) nullptr;
867 }
868 else
869 {
870 fn_type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 870, __FUNCTION__))->typed.type);
871 d = decl;
872 }
873
874 write_bare_function_type (fn_type,
875 mangle_return_type_p (decl),
876 d);
877
878 }
879}
880
881/* Interface to substitution and identifier mangling, used by the
882 module name mangler. */
883
884void
885mangle_module_substitution (int v)
886{
887 write_substitution (v - 1);
888}
889
890int
891mangle_module_component (tree comp, bool partition_p)
892{
893 write_char ('W')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('W')))); });
894 if (partition_p)
895 write_char ('P')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('P')))); });
896 write_source_name (comp);
897
898 // Module substitutions use the same number-space as entity
899 // substitutions, but are orthogonal.
900 vec_safe_push (G.substitutions, NULL_TREE(tree) nullptr);
901 return G.substitutions->length ();
902}
903
904/* If the outermost non-namespace context (including DECL itself) is
905 a module-linkage decl, mangle the module information. For module
906 global initializers we need to include the partition part.
907
908 <module-name> ::= <module-sub>
909 || <subst>
910 || <module-name> <module-sub>
911 <module-sub> :: W [P] <unqualified-name>
912*/
913
914static void
915write_module (int m, bool include_partition)
916{
917 G.mod = true;
918 mangle_module (m, include_partition);
919}
920
921static void
922maybe_write_module (tree decl)
923{
924 if (!DECL_NAMESPACE_SCOPE_P (decl)(!(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 924, __FUNCTION__))->decl_common.lang_flag_0) &&
(((enum tree_code) (decl)->base.code) == CONST_DECL || ((
enum tree_code) (decl)->base.code) == PARM_DECL || ((enum tree_code
) (decl)->base.code) == TYPE_DECL || ((enum tree_code) (decl
)->base.code) == TEMPLATE_DECL)) && ((enum tree_code
) ((!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 924, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 924, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 924, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]))->base.code) == NAMESPACE_DECL))
925 return;
926
927 if (!TREE_PUBLIC (STRIP_TEMPLATE (decl))(((((enum tree_code) (decl)->base.code) == TEMPLATE_DECL ?
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 927, __FUNCTION__, (TEMPLATE_DECL))))))))->result : decl
))->base.public_flag))
928 return;
929
930 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == NAMESPACE_DECL)
931 return;
932
933 int m = get_originating_module (decl, true);
934 if (m >= 0)
935 write_module (m, false);
936}
937
938/* Lambdas can have a bit more context for mangling, specifically VAR_DECL
939 or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */
940
941static tree
942decl_mangling_context (tree decl)
943{
944 tree tcontext = targetm.cxx.decl_mangling_context (decl);
945
946 if (tcontext != NULL_TREE(tree) nullptr)
947 return tcontext;
948
949 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TEMPLATE_DECL
950 && DECL_TEMPLATE_RESULT (decl)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 950, __FUNCTION__, (TEMPLATE_DECL))))))))->result)
951 decl = DECL_TEMPLATE_RESULT (decl)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 951, __FUNCTION__, (TEMPLATE_DECL))))))))->result;
952
953 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL
954 && LAMBDA_TYPE_P (TREE_TYPE (decl))(((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
&& ((((tree_class_check ((((tree_class_check ((((contains_struct_check
((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((((contains_struct_check
((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 954, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
)))
955 {
956 tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl))((((struct tree_lambda_expr *)(tree_check ((((((tree_class_check
((((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 956, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 956, __FUNCTION__))->type_with_lang_specific.lang_specific
))->lambda_expr)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 956, __FUNCTION__, (LAMBDA_EXPR))))->extra_scope));
957 if (extra)
958 return extra;
959 }
960 else if (template_type_parameter_p (decl))
961 /* template type parms have no mangling context. */
962 return NULL_TREE(tree) nullptr;
963
964 tcontext = CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 964, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 964, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 964, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]);
965
966 /* Ignore the artificial declare reduction functions. */
967 if (tcontext
968 && TREE_CODE (tcontext)((enum tree_code) (tcontext)->base.code) == FUNCTION_DECL
969 && DECL_OMP_DECLARE_REDUCTION_P (tcontext)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) ((contains_struct_check ((tcontext), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__)))->base.code) == TEMPLATE_DECL ? ((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check (((contains_struct_check ((tcontext), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__, (TEMPLATE_DECL))))))))->result : (contains_struct_check
((tcontext), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) ((contains_struct_check ((tcontext), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__)))->base.code) == FUNCTION_DECL || (((
enum tree_code) ((contains_struct_check ((tcontext), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__)))->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check (((contains_struct_check ((tcontext), (
TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check (((contains_struct_check
((tcontext), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 969, __FUNCTION__); &lt->u.fn; })->omp_declare_reduction_p
))
970 return decl_mangling_context (tcontext);
971
972 return tcontext;
973}
974
975/* <name> ::= <unscoped-name>
976 ::= <unscoped-template-name> <template-args>
977 ::= <nested-name>
978 ::= <local-name>
979
980 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is
981 called from <local-name>, which mangles the enclosing scope
982 elsewhere and then uses this function to mangle just the part
983 underneath the function scope. So don't use the <local-name>
984 production, to avoid an infinite recursion. */
985
986static void
987write_name (tree decl, const int ignore_local_scope)
988{
989 tree context;
990
991 MANGLE_TRACE_TREE ("name", decl);
992
993 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL)
994 {
995 /* In case this is a typedef, fish out the corresponding
996 TYPE_DECL for the main variant. */
997 decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl)))((tree_class_check ((((tree_class_check ((((contains_struct_check
((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 997, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 997, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 997, __FUNCTION__))->type_common.name);
998 }
999
1000 context = decl_mangling_context (decl);
1001
1002 gcc_assert (context != NULL_TREE)((void)(!(context != (tree) nullptr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1002, __FUNCTION__), 0 : 0));
1003
1004 if (abi_warn_or_compat_version_crosses (7)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (7)) != (warn_abi_version == 0 || warn_abi_version >=
(7))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (7)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (7)))
)
1005 && ignore_local_scope
1006 && TREE_CODE (context)((enum tree_code) (context)->base.code) == PARM_DECL)
1007 G.need_abi_warning = 1;
1008
1009 /* A decl in :: or ::std scope is treated specially. The former is
1010 mangled using <unscoped-name> or <unscoped-template-name>, the
1011 latter with a special substitution. Also, a name that is
1012 directly in a local function scope is also mangled with
1013 <unscoped-name> rather than a full <nested-name>. */
1014 if (context == global_namespacecp_global_trees[CPTI_GLOBAL]
1015 || DECL_NAMESPACE_STD_P (context)((context) == cp_global_trees[CPTI_STD])
1016 || (ignore_local_scope
1017 && (TREE_CODE (context)((enum tree_code) (context)->base.code) == FUNCTION_DECL
1018 || (abi_version_at_least (7)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (7))
1019 && TREE_CODE (context)((enum tree_code) (context)->base.code) == PARM_DECL))))
1020 {
1021 /* Is this a template instance? */
1022 if (tree info = maybe_template_info (decl))
1023 {
1024 /* Yes: use <unscoped-template-name>. */
1025 write_unscoped_template_name (TI_TEMPLATE (info)((struct tree_template_info*)(tree_check ((info), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1025, __FUNCTION__, (TEMPLATE_INFO))))->tmpl);
1026 write_template_args (TI_ARGS (info)((struct tree_template_info*)(tree_check ((info), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1026, __FUNCTION__, (TEMPLATE_INFO))))->args);
1027 }
1028 else
1029 /* Everything else gets an <unqualified-name>. */
1030 write_unscoped_name (decl);
1031 }
1032 else
1033 {
1034 /* Handle local names, unless we asked not to (that is, invoked
1035 under <local-name>, to handle only the part of the name under
1036 the local scope). */
1037 if (!ignore_local_scope)
1038 {
1039 /* Scan up the list of scope context, looking for a
1040 function. If we find one, this entity is in local
1041 function scope. local_entity tracks context one scope
1042 level down, so it will contain the element that's
1043 directly in that function's scope, either decl or one of
1044 its enclosing scopes. */
1045 tree local_entity = decl;
1046 while (context != global_namespacecp_global_trees[CPTI_GLOBAL])
1047 {
1048 /* Make sure we're always dealing with decls. */
1049 if (TYPE_P (context)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (context)->base.code))] == tcc_type))
1050 context = TYPE_NAME (context)((tree_class_check ((context), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1050, __FUNCTION__))->type_common.name);
1051 /* Is this a function? */
1052 if (TREE_CODE (context)((enum tree_code) (context)->base.code) == FUNCTION_DECL
1053 || TREE_CODE (context)((enum tree_code) (context)->base.code) == PARM_DECL)
1054 {
1055 /* Yes, we have local scope. Use the <local-name>
1056 production for the innermost function scope. */
1057 write_local_name (context, local_entity, decl);
1058 return;
1059 }
1060 /* Up one scope level. */
1061 local_entity = context;
1062 context = decl_mangling_context (context);
1063 }
1064
1065 /* No local scope found? Fall through to <nested-name>. */
1066 }
1067
1068 /* Other decls get a <nested-name> to encode their scope. */
1069 write_nested_name (decl);
1070 }
1071}
1072
1073/* <unscoped-name> ::= <unqualified-name>
1074 ::= St <unqualified-name> # ::std:: */
1075
1076static void
1077write_unscoped_name (const tree decl)
1078{
1079 tree context = decl_mangling_context (decl);
1080
1081 MANGLE_TRACE_TREE ("unscoped-name", decl);
1082
1083 /* Is DECL in ::std? */
1084 if (DECL_NAMESPACE_STD_P (context)((context) == cp_global_trees[CPTI_STD]))
1085 {
1086 write_string ("St")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("St")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("St"), __len); __o->next_free += __len
; (void) 0; });
1087 write_unqualified_name (decl);
1088 }
1089 else
1090 {
1091 /* If not, it should be either in the global namespace, or directly
1092 in a local function scope. A lambda can also be mangled in the
1093 scope of a default argument. */
1094 gcc_assert (context == global_namespace((void)(!(context == cp_global_trees[CPTI_GLOBAL] || ((enum tree_code
) (context)->base.code) == PARM_DECL || ((enum tree_code) (
context)->base.code) == FUNCTION_DECL) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1096, __FUNCTION__), 0 : 0))
1095 || TREE_CODE (context) == PARM_DECL((void)(!(context == cp_global_trees[CPTI_GLOBAL] || ((enum tree_code
) (context)->base.code) == PARM_DECL || ((enum tree_code) (
context)->base.code) == FUNCTION_DECL) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1096, __FUNCTION__), 0 : 0))
1096 || TREE_CODE (context) == FUNCTION_DECL)((void)(!(context == cp_global_trees[CPTI_GLOBAL] || ((enum tree_code
) (context)->base.code) == PARM_DECL || ((enum tree_code) (
context)->base.code) == FUNCTION_DECL) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1096, __FUNCTION__), 0 : 0));
1097
1098 write_unqualified_name (decl);
1099 }
1100}
1101
1102/* <unscoped-template-name> ::= <unscoped-name>
1103 ::= <substitution> */
1104
1105static void
1106write_unscoped_template_name (const tree decl)
1107{
1108 MANGLE_TRACE_TREE ("unscoped-template-name", decl);
1109
1110 if (find_substitution (decl))
1111 return;
1112 write_unscoped_name (decl);
1113 add_substitution (decl);
1114}
1115
1116/* Write the nested name, including CV-qualifiers, of DECL.
1117
1118 <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1119 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1120
1121 <ref-qualifier> ::= R # & ref-qualifier
1122 ::= O # && ref-qualifier
1123 <CV-qualifiers> ::= [r] [V] [K] */
1124
1125static void
1126write_nested_name (const tree decl)
1127{
1128 MANGLE_TRACE_TREE ("nested-name", decl);
1129
1130 write_char ('N')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('N')))); });
1131
1132 /* Write CV-qualifiers, if this is a member function. */
1133 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FUNCTION_DECL
1134 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)(((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1134, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
))
1135 {
1136 if (DECL_VOLATILE_MEMFUNC_P (decl)((((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1136, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
) && ((cp_type_quals (((contains_struct_check ((((tree_check
((((tree_check2 ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1136, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1136, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1136, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1136, __FUNCTION__))->typed.type)) & TYPE_QUAL_VOLATILE
) != 0)))
1137 write_char ('V')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('V')))); });
1138 if (DECL_CONST_MEMFUNC_P (decl)((((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1138, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
) && ((cp_type_quals (((contains_struct_check ((((tree_check
((((tree_check2 ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1138, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1138, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1138, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1138, __FUNCTION__))->typed.type)) & TYPE_QUAL_CONST
) != 0)))
1139 write_char ('K')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('K')))); });
1140 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))((tree_not_check2 (((tree_check2 ((((contains_struct_check ((
decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1140, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1140, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1140, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4))
1141 {
1142 if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl))((tree_not_check2 (((tree_check2 ((((contains_struct_check ((
decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1142, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1142, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1142, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5))
1143 write_char ('O')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('O')))); });
1144 else
1145 write_char ('R')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('R')))); });
1146 }
1147 }
1148
1149 /* Is this a template instance? */
1150 if (tree info = maybe_template_info (decl))
1151 {
1152 /* Yes, use <template-prefix>. */
1153 write_template_prefix (decl);
1154 write_template_args (TI_ARGS (info)((struct tree_template_info*)(tree_check ((info), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1154, __FUNCTION__, (TEMPLATE_INFO))))->args);
1155 }
1156 else if ((!abi_version_at_least (10)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (10)) || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL)
1157 && TREE_CODE (TREE_TYPE (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1157, __FUNCTION__))->typed.type))->base.code) == TYPENAME_TYPE)
1158 {
1159 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl))(((tree_class_check (((tree_check ((((contains_struct_check (
(decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1159, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1159, __FUNCTION__, (TYPENAME_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1159, __FUNCTION__))->type_non_common.values));
1160 if (TREE_CODE (name)((enum tree_code) (name)->base.code) == TEMPLATE_ID_EXPR)
1161 {
1162 write_template_prefix (decl);
1163 write_template_args (TREE_OPERAND (name, 1)(*((const_cast<tree*> (tree_operand_check ((name), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1163, __FUNCTION__))))));
1164 }
1165 else
1166 {
1167 write_prefix (decl_mangling_context (decl));
1168 write_unqualified_name (decl);
1169 }
1170 }
1171 else
1172 {
1173 /* No, just use <prefix> */
1174 write_prefix (decl_mangling_context (decl));
1175 write_unqualified_name (decl);
1176 }
1177 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
1178}
1179
1180/* <prefix> ::= <prefix> <unqualified-name>
1181 ::= <template-param>
1182 ::= <template-prefix> <template-args>
1183 ::= <decltype>
1184 ::= # empty
1185 ::= <substitution> */
1186
1187static void
1188write_prefix (const tree node)
1189{
1190 tree decl;
1191
1192 if (node == NULLnullptr
1193 || node == global_namespacecp_global_trees[CPTI_GLOBAL])
1194 return;
1195
1196 MANGLE_TRACE_TREE ("prefix", node);
1197
1198 if (TREE_CODE (node)((enum tree_code) (node)->base.code) == DECLTYPE_TYPE)
1199 {
1200 write_type (node);
1201 return;
1202 }
1203
1204 if (find_substitution (node))
1205 return;
1206
1207 tree template_info = NULL_TREE(tree) nullptr;
1208 if (DECL_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_declaration))
1209 {
1210 /* If this is a function or parm decl, that means we've hit function
1211 scope, so this prefix must be for a local name. In this
1212 case, we're under the <local-name> production, which encodes
1213 the enclosing function scope elsewhere. So don't continue
1214 here. */
1215 if (TREE_CODE (node)((enum tree_code) (node)->base.code) == FUNCTION_DECL
1216 || TREE_CODE (node)((enum tree_code) (node)->base.code) == PARM_DECL)
1217 return;
1218
1219 decl = node;
1220 template_info = maybe_template_info (decl);
1221 }
1222 else
1223 {
1224 /* Node is a type. */
1225 decl = TYPE_NAME (node)((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1225, __FUNCTION__))->type_common.name);
1226 /* The DECL might not point at the node. */
1227 if (CLASSTYPE_TEMPLATE_ID_P (node)(((enum tree_code) (node)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| ((((((enum tree_code) (node)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (node)->base.code)) == UNION_TYPE) &&
((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__))->type_common.lang_flag_5)) &&
(((tree_class_check (((tree_check3 ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__))->type_non_common.lang_1)) != nullptr
&& (((((contains_struct_check ((((tree_check ((((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((((struct tree_template_info*)(tree_check (((((
tree_class_check (((tree_check3 ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__))->typed.type))) == (((struct tree_template_info
*)(tree_check (((((tree_class_check (((tree_check3 ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1227, __FUNCTION__, (TEMPLATE_INFO))))->tmpl)))))
1228 template_info = TYPE_TEMPLATE_INFO (node)(((enum tree_code) (node)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (node)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| (((enum tree_code) (node)->base.code) == RECORD_TYPE ||
((enum tree_code) (node)->base.code) == UNION_TYPE || ((enum
tree_code) (node)->base.code) == QUAL_UNION_TYPE) ? ((tree_class_check
((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1228, __FUNCTION__))->type_non_common.lang_1) : (tree) nullptr
);
1229 }
1230
1231 if (TREE_CODE (node)((enum tree_code) (node)->base.code) == TEMPLATE_TYPE_PARM)
1232 write_template_param (node);
1233 else if (template_info)
1234 /* Templated. */
1235 {
1236 write_template_prefix (decl);
1237 write_template_args (TI_ARGS (template_info)((struct tree_template_info*)(tree_check ((template_info), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1237, __FUNCTION__, (TEMPLATE_INFO))))->args);
1238 }
1239 else if (TREE_CODE (TREE_TYPE (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1239, __FUNCTION__))->typed.type))->base.code) == TYPENAME_TYPE)
1240 {
1241 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl))(((tree_class_check (((tree_check ((((contains_struct_check (
(decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1241, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1241, __FUNCTION__, (TYPENAME_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1241, __FUNCTION__))->type_non_common.values));
1242 if (TREE_CODE (name)((enum tree_code) (name)->base.code) == TEMPLATE_ID_EXPR)
1243 {
1244 write_template_prefix (decl);
1245 write_template_args (TREE_OPERAND (name, 1)(*((const_cast<tree*> (tree_operand_check ((name), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1245, __FUNCTION__))))));
1246 }
1247 else
1248 {
1249 write_prefix (decl_mangling_context (decl));
1250 write_unqualified_name (decl);
1251 }
1252 }
1253 else
1254 /* Not templated. */
1255 {
1256 write_prefix (decl_mangling_context (decl));
1257 write_unqualified_name (decl);
1258 if (VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL)
1259 || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FIELD_DECL)
1260 {
1261 /* <data-member-prefix> := <member source-name> M */
1262 write_char ('M')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('M')))); });
1263
1264 /* Before ABI 18, we did not count these as substitution
1265 candidates. This leads to incorrect demanglings (and
1266 ABI divergence to other compilers). */
1267 if (abi_warn_or_compat_version_crosses (18)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (18)) != (warn_abi_version == 0 || warn_abi_version >=
(18))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (18)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (18))
)))
1268 G.need_abi_warning = true;
1269 if (!abi_version_at_least (18)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (18)))
1270 return;
1271 }
1272 }
1273
1274 add_substitution (node);
1275}
1276
1277/* <template-prefix> ::= <prefix> <template component>
1278 ::= <template-param>
1279 ::= <substitution> */
1280
1281static void
1282write_template_prefix (const tree node)
1283{
1284 tree decl = DECL_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_declaration) ? node : TYPE_NAME (node)((tree_class_check ((node), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1284, __FUNCTION__))->type_common.name);
1285 tree type = DECL_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_declaration) ? TREE_TYPE (node)((contains_struct_check ((node), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1285, __FUNCTION__))->typed.type) : node;
1286 tree context = decl_mangling_context (decl);
1287 tree templ;
1288 tree substitution;
1289
1290 MANGLE_TRACE_TREE ("template-prefix", node);
1291
1292 /* Find the template decl. */
1293 if (tree info = maybe_template_info (decl))
1294 templ = TI_TEMPLATE (info)((struct tree_template_info*)(tree_check ((info), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1294, __FUNCTION__, (TEMPLATE_INFO))))->tmpl;
1295 else if (TREE_CODE (type)((enum tree_code) (type)->base.code) == TYPENAME_TYPE)
1296 /* For a typename type, all we have is the name. */
1297 templ = DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1297, __FUNCTION__))->decl_minimal.name);
1298 else
1299 {
1300 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type))((void)(!((((enum tree_code) (type)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| ((((((enum tree_code) (type)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__))->type_common.lang_flag_5)) &&
(((tree_class_check (((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__))->type_non_common.lang_1)) != nullptr
&& (((((contains_struct_check ((((tree_check ((((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((((struct tree_template_info*)(tree_check (((((
tree_class_check (((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__))->typed.type))) == (((struct tree_template_info
*)(tree_check (((((tree_class_check (((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__, (TEMPLATE_INFO))))->tmpl))))) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1300, __FUNCTION__), 0 : 0));
1301
1302 templ = TYPE_TI_TEMPLATE (type)(((struct tree_template_info*)(tree_check (((((enum tree_code
) (type)->base.code) == ENUMERAL_TYPE || ((enum tree_code)
(type)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM || (((
enum tree_code) (type)->base.code) == RECORD_TYPE || ((enum
tree_code) (type)->base.code) == UNION_TYPE || ((enum tree_code
) (type)->base.code) == QUAL_UNION_TYPE) ? ((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1302, __FUNCTION__))->type_non_common.lang_1) : (tree) nullptr
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1302, __FUNCTION__, (TEMPLATE_INFO))))->tmpl);
1303 }
1304
1305 /* For a member template, though, the template name for the
1306 innermost name must have all the outer template levels
1307 instantiated. For instance, consider
1308
1309 template<typename T> struct Outer {
1310 template<typename U> struct Inner {};
1311 };
1312
1313 The template name for `Inner' in `Outer<int>::Inner<float>' is
1314 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template
1315 levels separately, so there's no TEMPLATE_DECL available for this
1316 (there's only `Outer<T>::Inner<U>').
1317
1318 In order to get the substitutions right, we create a special
1319 TREE_LIST to represent the substitution candidate for a nested
1320 template. The TREE_PURPOSE is the template's context, fully
1321 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner
1322 template.
1323
1324 So, for the example above, `Outer<int>::Inner' is represented as a
1325 substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
1326 and whose value is `Outer<T>::Inner<U>'. */
1327 if (context && TYPE_P (context)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (context)->base.code))] == tcc_type))
1328 substitution = build_tree_list (context, templ);
1329 else
1330 substitution = templ;
1331
1332 if (find_substitution (substitution))
1333 return;
1334
1335 if (TREE_TYPE (templ)((contains_struct_check ((templ), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1335, __FUNCTION__))->typed.type)
1336 && TREE_CODE (TREE_TYPE (templ))((enum tree_code) (((contains_struct_check ((templ), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1336, __FUNCTION__))->typed.type))->base.code) == TEMPLATE_TEMPLATE_PARM)
1337 write_template_param (TREE_TYPE (templ)((contains_struct_check ((templ), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1337, __FUNCTION__))->typed.type));
1338 else
1339 {
1340 write_prefix (context);
1341 write_unqualified_name (decl);
1342 }
1343
1344 add_substitution (substitution);
1345}
1346
1347/* As the list of identifiers for the structured binding declaration
1348 DECL is likely gone, try to recover the DC <source-name>+ E portion
1349 from its mangled name. Return pointer to the DC and set len to
1350 the length up to and including the terminating E. On failure
1351 return NULL. */
1352
1353static const char *
1354find_decomp_unqualified_name (tree decl, size_t *len)
1355{
1356 const char *p = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))((const char *) (tree_check ((decl_assembler_name (decl)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1356, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
1357 const char *end = p + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl))((tree_check ((decl_assembler_name (decl)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1357, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
);
1358 bool nested = false;
1359 if (!startswith (p, "_Z"))
1360 return NULLnullptr;
1361 p += 2;
1362 if (startswith (p, "St"))
1363 p += 2;
1364 else if (*p == 'N')
1365 {
1366 nested = true;
1367 ++p;
1368 while (ISDIGIT (p[0])(_sch_istable[(p[0]) & 0xff] & (unsigned short)(_sch_isdigit
)))
1369 {
1370 char *e;
1371 long num = strtol (p, &e, 10);
1372 if (num >= 1 && num < end - e)
1373 p = e + num;
1374 else
1375 break;
1376 }
1377 }
1378 if (!startswith (p, "DC"))
1379 return NULLnullptr;
1380 if (nested)
1381 {
1382 if (end[-1] != 'E')
1383 return NULLnullptr;
1384 --end;
1385 }
1386 if (end[-1] != 'E')
1387 return NULLnullptr;
1388 *len = end - p;
1389 return p;
1390}
1391
1392/* "For the purposes of mangling, the name of an anonymous union is considered
1393 to be the name of the first named data member found by a pre-order,
1394 depth-first, declaration-order walk of the data members of the anonymous
1395 union. If there is no such data member (i.e., if all of the data members in
1396 the union are unnamed), then there is no way for a program to refer to the
1397 anonymous union, and there is therefore no need to mangle its name." */
1398
1399static tree
1400anon_aggr_naming_decl (tree type)
1401{
1402 tree field = next_aggregate_field (TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1402, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values));
1403 for (; field; field = next_aggregate_field (DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1403, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1403, __FUNCTION__))->common.chain))))
1404 {
1405 if (DECL_NAME (field)((contains_struct_check ((field), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1405, __FUNCTION__))->decl_minimal.name))
1406 return field;
1407 if (ANON_AGGR_TYPE_P (TREE_TYPE (field))((((((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1407, __FUNCTION__))->typed.type))->base.code)) == RECORD_TYPE
|| (((enum tree_code) (((contains_struct_check ((field), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1407, __FUNCTION__))->typed.type))->base.code)) == UNION_TYPE
) && ((tree_class_check ((((contains_struct_check ((field
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1407, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1407, __FUNCTION__))->type_common.lang_flag_5)) &&
(((tree_class_check ((((contains_struct_check ((field), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1407, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1407, __FUNCTION__))->type_with_lang_specific.lang_specific
))->anon_aggr))
1408 if (tree sub = anon_aggr_naming_decl (TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1408, __FUNCTION__))->typed.type)))
1409 return sub;
1410 }
1411 return NULL_TREE(tree) nullptr;
1412}
1413
1414/* We don't need to handle thunks, vtables, or VTTs here. Those are
1415 mangled through special entry points.
1416
1417 <unqualified-name> ::= [<module-name>] <operator-name>
1418 ::= <special-name>
1419 ::= [<module-name>] <source-name>
1420 ::= [<module-name>] <unnamed-type-name>
1421 ::= <local-source-name>
1422
1423 <local-source-name> ::= L <source-name> <discriminator> */
1424
1425static void
1426write_unqualified_id (tree identifier)
1427{
1428 if (IDENTIFIER_CONV_OP_P (identifier)((((tree_not_check2 (((tree_check ((identifier), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1428, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1428, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((identifier
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1428, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1428, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((identifier
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1428, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1428, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))))
1429 write_conversion_operator_name (TREE_TYPE (identifier)((contains_struct_check ((identifier), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1429, __FUNCTION__))->typed.type));
1430 else if (IDENTIFIER_OVL_OP_P (identifier)((((tree_not_check2 (((tree_check ((identifier), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1430, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1430, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & (!((tree_not_check2 (((tree_check ((identifier
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1430, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1430, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1))))
1431 {
1432 const ovl_op_info_t *ovl_op = IDENTIFIER_OVL_OP_INFO (identifier)(&ovl_op_info[((tree_not_check2 (((tree_check ((identifier
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1432, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1432, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)][((tree_check ((identifier), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1432, __FUNCTION__, (IDENTIFIER_NODE)))->base.u.bits.address_space
)]);
1433 write_string (ovl_op->mangled_name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (ovl_op->mangled_name)); if (__extension__
({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit
- __o1->next_free); }) < __len) _obstack_newchunk (__o
, __len); memcpy (__o->next_free, (ovl_op->mangled_name
), __len); __o->next_free += __len; (void) 0; });
1434 }
1435 else if (UDLIT_OPER_P (identifier)(!strncmp (((const char *) (tree_check ((identifier), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1435, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), "operator\"\"", sizeof ("operator\"\"") - 1)))
1436 write_literal_operator_name (identifier);
1437 else
1438 write_source_name (identifier);
1439}
1440
1441static void
1442write_unqualified_name (tree decl)
1443{
1444 MANGLE_TRACE_TREE ("unqualified-name", decl);
1445
1446 if (modules_p ())
1447 maybe_write_module (decl);
1448
1449 if (identifier_p (decl))
1450 {
1451 write_unqualified_id (decl);
1452 return;
1453 }
1454
1455 bool found = false;
1456
1457 if (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1457, __FUNCTION__))->decl_minimal.name) == NULL_TREE(tree) nullptr
1458 && ANON_AGGR_TYPE_P (TREE_TYPE (decl))((((((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1458, __FUNCTION__))->typed.type))->base.code)) == RECORD_TYPE
|| (((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1458, __FUNCTION__))->typed.type))->base.code)) == UNION_TYPE
) && ((tree_class_check ((((contains_struct_check ((decl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1458, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1458, __FUNCTION__))->type_common.lang_flag_5)) &&
(((tree_class_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1458, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1458, __FUNCTION__))->type_with_lang_specific.lang_specific
))->anon_aggr))
1459 decl = anon_aggr_naming_decl (TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1459, __FUNCTION__))->typed.type));
1460 else if (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1460, __FUNCTION__))->decl_minimal.name) == NULL_TREE(tree) nullptr)
1461 {
1462 found = true;
1463 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl))((void)(!((((contains_struct_check ((decl), (TS_DECL_WITH_VIS
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1463, __FUNCTION__))->decl_with_vis.assembler_name) != (
tree) nullptr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1463, __FUNCTION__), 0 : 0));
1464 const char *decomp_str = NULLnullptr;
1465 size_t decomp_len = 0;
1466 if (VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL)
1467 && DECL_DECOMPOSITION_P (decl)((((enum tree_code) (decl)->base.code) == VAR_DECL) &&
((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1467, __FUNCTION__))->decl_common.lang_specific) ? ((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1467, __FUNCTION__))->decl_common.lang_specific)->u.base
.selector == lds_decomp : false)
1468 && DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1468, __FUNCTION__))->decl_minimal.name) == NULL_TREE(tree) nullptr
1469 && DECL_NAMESPACE_SCOPE_P (decl)(!(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1469, __FUNCTION__))->decl_common.lang_flag_0) &&
(((enum tree_code) (decl)->base.code) == CONST_DECL || ((
enum tree_code) (decl)->base.code) == PARM_DECL || ((enum tree_code
) (decl)->base.code) == TYPE_DECL || ((enum tree_code) (decl
)->base.code) == TEMPLATE_DECL)) && ((enum tree_code
) ((!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1469, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1469, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1469, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]))->base.code) == NAMESPACE_DECL))
1470 decomp_str = find_decomp_unqualified_name (decl, &decomp_len);
1471 if (decomp_str)
1472 write_chars (decomp_str, decomp_len)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = ((decomp_len)); if (__extension__ ({ struct obstack const
*__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, (decomp_str), __len); __o->next_free += __len
; (void) 0; });
1473 else
1474 write_source_name (DECL_ASSEMBLER_NAME (decl)decl_assembler_name (decl));
1475 }
1476 else if (DECL_DECLARES_FUNCTION_P (decl)(((enum tree_code) (decl)->base.code) == FUNCTION_DECL || (
((enum tree_code) (decl)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1476, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((decl
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1476, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)))
1477 {
1478 found = true;
1479 if (DECL_CONSTRUCTOR_P (decl)((tree_check (((((enum tree_code) (decl)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1479, __FUNCTION__, (TEMPLATE_DECL))))))))->result : decl
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1479, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
))
1480 write_special_name_constructor (decl);
1481 else if (DECL_DESTRUCTOR_P (decl)((tree_check (((((enum tree_code) (decl)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1481, __FUNCTION__, (TEMPLATE_DECL))))))))->result : decl
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1481, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_destructor
))
1482 write_special_name_destructor (decl);
1483 else if (DECL_CONV_FN_P (decl)((((tree_not_check2 (((tree_check ((((contains_struct_check (
(decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1483, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1483, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1483, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1483, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1483, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1483, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1483, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1483, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1483, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))))
1484 {
1485 /* Conversion operator. Handle it right here.
1486 <operator> ::= cv <type> */
1487 tree type;
1488 if (maybe_template_info (decl))
1489 {
1490 tree fn_type;
1491 fn_type = get_mostly_instantiated_function_type (decl);
1492 type = TREE_TYPE (fn_type)((contains_struct_check ((fn_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1492, __FUNCTION__))->typed.type);
1493 }
1494 else if (FNDECL_USED_AUTO (decl)((tree_not_check2 (((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1494, __FUNCTION__, (FUNCTION_DECL)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1494, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2))
1495 type = DECL_SAVED_AUTO_RETURN_TYPE (decl)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) ((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (FUNCTION_DECL))))->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check (((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (FUNCTION_DECL)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (TEMPLATE_DECL))))))))->result : (tree_check
((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (FUNCTION_DECL))))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) ((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (FUNCTION_DECL))))->base.code) == FUNCTION_DECL
|| (((enum tree_code) ((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (FUNCTION_DECL))))->base.code) == TEMPLATE_DECL
&& ((struct tree_template_decl *)(const_cast<union
tree_node *> ((((tree_check (((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (FUNCTION_DECL)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check (((tree_check
((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (FUNCTION_DECL)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1495, __FUNCTION__); &lt->u.fn; }) ->u.saved_auto_return_type
);
1496 else
1497 type = DECL_CONV_FN_TYPE (decl)((contains_struct_check (((((void)(!(((((tree_not_check2 (((tree_check
((((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__), 0 : 0)), ((contains_struct_check ((decl
), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__))->decl_minimal.name))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1497, __FUNCTION__))->typed.type);
1498 write_conversion_operator_name (type);
1499 }
1500 else if (DECL_OVERLOADED_OPERATOR_P (decl)(((tree_not_check2 (((tree_check ((((contains_struct_check ((
decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1500, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1500, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1500, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)))
1501 {
1502 tree t;
1503 if (!(t = DECL_RAMP_FN (decl)(coro_get_ramp_function (decl))))
1504 t = decl;
1505 const char *mangled_name
1506 = (ovl_op_info[DECL_ASSIGNMENT_OPERATOR_P (t)(((((tree_not_check2 (((tree_check ((((contains_struct_check (
(t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1506, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1506, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1506, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & (!((tree_not_check2 (((tree_check ((((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1506, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1506, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1506, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1))) & ((tree_not_check2 (((tree_check ((((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1506, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1506, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1506, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))]
1507 [DECL_OVERLOADED_OPERATOR_CODE_RAW (t)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (t)->base.code) == TEMPLATE_DECL ? (
(struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1507, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1507, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (t)->base.code) == FUNCTION_DECL || (((enum
tree_code) (t)->base.code) == TEMPLATE_DECL && ((
struct tree_template_decl *)(const_cast<union tree_node *>
((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1507, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1507, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1507, __FUNCTION__); &lt->u.fn; })->ovl_op_code)].mangled_name);
1508 write_string (mangled_name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (mangled_name)); if (__extension__ ({ struct
obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
__o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); memcpy (__o->next_free, (mangled_name), __len); __o->
next_free += __len; (void) 0; });
1509 }
1510 else if (UDLIT_OPER_P (DECL_NAME (decl))(!strncmp (((const char *) (tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1510, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1510, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), "operator\"\"", sizeof ("operator\"\"") - 1)))
1511 write_literal_operator_name (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1511, __FUNCTION__))->decl_minimal.name));
1512 else
1513 found = false;
1514 }
1515
1516 if (found)
1517 /* OK */;
1518 else if (VAR_OR_FUNCTION_DECL_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL || ((enum
tree_code) (decl)->base.code) == FUNCTION_DECL) && ! TREE_PUBLIC (decl)((decl)->base.public_flag)
1519 && DECL_NAMESPACE_SCOPE_P (decl)(!(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1519, __FUNCTION__))->decl_common.lang_flag_0) &&
(((enum tree_code) (decl)->base.code) == CONST_DECL || ((
enum tree_code) (decl)->base.code) == PARM_DECL || ((enum tree_code
) (decl)->base.code) == TYPE_DECL || ((enum tree_code) (decl
)->base.code) == TEMPLATE_DECL)) && ((enum tree_code
) ((!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1519, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1519, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((decl)
, (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1519, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]))->base.code) == NAMESPACE_DECL)
1520 && decl_linkage (decl) == lk_internal)
1521 {
1522 MANGLE_TRACE_TREE ("local-source-name", decl);
1523 write_char ('L')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('L')))); });
1524 write_source_name (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1524, __FUNCTION__))->decl_minimal.name));
1525 /* The default discriminator is 1, and that's all we ever use,
1526 so there's no code to output one here. */
1527 }
1528 else
1529 {
1530 tree type = TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1530, __FUNCTION__))->typed.type);
1531
1532 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL
1533 && TYPE_UNNAMED_P (type)((((((tree_class_check ((((tree_class_check ((type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__, (IDENTIFIER_NODE)))->base.private_flag
)) && !((tree_check ((((((tree_class_check ((((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1533, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
)))
1534 write_unnamed_type_name (type);
1535 else if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL && LAMBDA_TYPE_P (type)(((enum tree_code) (type)->base.code) == RECORD_TYPE &&
((((tree_class_check ((((tree_class_check ((type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1535, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
)))
1536 write_closure_type_name (type);
1537 else
1538 write_source_name (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1538, __FUNCTION__))->decl_minimal.name));
1539 }
1540
1541 /* We use the ABI tags from the primary class template, ignoring tags on any
1542 specializations. This is necessary because C++ doesn't require a
1543 specialization to be declared before it is used unless the use requires a
1544 complete type, but we need to get the tags right on incomplete types as
1545 well. */
1546 if (tree tmpl = most_general_template (decl))
1547 {
1548 tree res = DECL_TEMPLATE_RESULT (tmpl)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1548, __FUNCTION__, (TEMPLATE_DECL))))))))->result;
1549 if (res == NULL_TREE(tree) nullptr)
1550 /* UNBOUND_CLASS_TEMPLATE. */;
1551 else if (DECL_DECLARES_TYPE_P (decl)(((enum tree_code) (decl)->base.code) == TYPE_DECL || (((enum
tree_code) (decl)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1551, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((decl
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1551, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == TYPE_DECL)))
1552 decl = res;
1553 else if (any_abi_below (11)(!(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)) || !(warn_abi_version == 0 || warn_abi_version >=
(11)) || !(global_options.x_flag_abi_compat_version == 0 || global_options
.x_flag_abi_compat_version >= (11))))
1554 {
1555 /* ABI v10 implicit tags on the template. */
1556 tree mtags = missing_abi_tags (res);
1557 /* Explicit tags on the template. */
1558 tree ttags = get_abi_tags (res);
1559 /* Tags on the instantiation. */
1560 tree dtags = get_abi_tags (decl);
1561
1562 if (mtags && abi_warn_or_compat_version_crosses (10)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (10)) != (warn_abi_version == 0 || warn_abi_version >=
(10))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (10)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (10))
)))
1563 G.need_abi_warning = 1;
1564
1565 /* Add the v10 tags to the explicit tags now. */
1566 mtags = chainon (mtags, ttags);
1567
1568 if (!G.need_abi_warning
1569 && abi_warn_or_compat_version_crosses (11)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)) != (warn_abi_version == 0 || warn_abi_version >=
(11))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (11)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (11))
))
1570 && !equal_abi_tags (dtags, mtags))
1571 G.need_abi_warning = 1;
1572
1573 if (!abi_version_at_least (10)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (10)))
1574 /* In abi <10, we only got the explicit tags. */
1575 decl = res;
1576 else if (flag_abi_versionglobal_options.x_flag_abi_version == 10)
1577 {
1578 /* In ABI 10, we want explict and implicit tags. */
1579 write_abi_tags (mtags);
1580 return;
1581 }
1582 }
1583 }
1584
1585 tree tags = get_abi_tags (decl);
1586 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FUNCTION_DECL && DECL_CONV_FN_P (decl)((((tree_not_check2 (((tree_check ((((contains_struct_check (
(decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1586, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1586, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1586, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1586, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1586, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1586, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1586, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1586, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1586, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))
1587 && any_abi_below (11)(!(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)) || !(warn_abi_version == 0 || warn_abi_version >=
(11)) || !(global_options.x_flag_abi_compat_version == 0 || global_options
.x_flag_abi_compat_version >= (11))))
1588 if (tree mtags = missing_abi_tags (decl))
1589 {
1590 if (abi_warn_or_compat_version_crosses (11)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)) != (warn_abi_version == 0 || warn_abi_version >=
(11))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (11)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (11))
)))
1591 G.need_abi_warning = true;
1592 if (!abi_version_at_least (11)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)))
1593 tags = chainon (mtags, tags);
1594 }
1595 write_abi_tags (tags);
1596}
1597
1598/* Write the unqualified-name for a conversion operator to TYPE. */
1599
1600static void
1601write_conversion_operator_name (const tree type)
1602{
1603 write_string ("cv")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("cv")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("cv"), __len); __o->next_free += __len
; (void) 0; });
1604 write_type (type);
1605}
1606
1607/* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE.
1608
1609 <source-name> ::= </length/ number> <identifier> */
1610
1611static void
1612write_source_name (tree identifier)
1613{
1614 MANGLE_TRACE_TREE ("source-name", identifier);
1615
1616 write_unsigned_number (IDENTIFIER_LENGTH (identifier))write_number ((((tree_check ((identifier), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1616, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)), 1, 10);
1617 write_identifier (IDENTIFIER_POINTER (identifier)((const char *) (tree_check ((identifier), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1617, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
1618}
1619
1620/* Compare two TREE_STRINGs like strcmp. */
1621
1622int
1623tree_string_cmp (const void *p1, const void *p2)
1624{
1625 if (p1 == p2)
1626 return 0;
1627 tree s1 = *(const tree*)p1;
1628 tree s2 = *(const tree*)p2;
1629 return strcmp (TREE_STRING_POINTER (s1)((const char *)((tree_check ((s1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1629, __FUNCTION__, (STRING_CST)))->string.str)),
1630 TREE_STRING_POINTER (s2)((const char *)((tree_check ((s2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1630, __FUNCTION__, (STRING_CST)))->string.str)));
1631}
1632
1633/* Return the TREE_LIST of TAGS as a sorted VEC. */
1634
1635static vec<tree, va_gc> *
1636sorted_abi_tags (tree tags)
1637{
1638 vec<tree, va_gc> * vec = make_tree_vector();
1639
1640 for (tree t = tags; t; t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1640, __FUNCTION__))->common.chain))
1641 {
1642 if (ABI_TAG_IMPLICIT (t)((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1642, __FUNCTION__, (TREE_LIST)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1642, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
1643 continue;
1644 tree str = TREE_VALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1644, __FUNCTION__, (TREE_LIST)))->list.value);
1645 vec_safe_push (vec, str);
1646 }
1647
1648 vec->qsort (tree_string_cmp)qsort (tree_string_cmp);
1649
1650 return vec;
1651}
1652
1653/* ID is the name of a function or type with abi_tags attribute TAGS.
1654 Write out the name, suitably decorated. */
1655
1656static void
1657write_abi_tags (tree tags)
1658{
1659 if (tags == NULL_TREE(tree) nullptr)
1660 return;
1661
1662 vec<tree, va_gc> * vec = sorted_abi_tags (tags);
1663
1664 unsigned i; tree str;
1665 FOR_EACH_VEC_ELT (*vec, i, str)for (i = 0; (*vec).iterate ((i), &(str)); ++(i))
1666 {
1667 write_string ("B")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("B")); if (__extension__ ({ struct obstack const
*__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, ("B"), __len); __o->next_free += __len; (void
) 0; });
1668 write_unsigned_number (TREE_STRING_LENGTH (str) - 1)write_number ((((tree_check ((str), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1668, __FUNCTION__, (STRING_CST)))->string.length) - 1),
1, 10);
1669 write_identifier (TREE_STRING_POINTER (str)((const char *)((tree_check ((str), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1669, __FUNCTION__, (STRING_CST)))->string.str)));
1670 }
1671
1672 release_tree_vector (vec);
1673}
1674
1675/* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent. */
1676
1677static bool
1678equal_abi_tags (tree t1, tree t2)
1679{
1680 releasing_vec v1 = sorted_abi_tags (t1);
1681 releasing_vec v2 = sorted_abi_tags (t2);
1682
1683 unsigned len1 = v1->length();
1684 if (len1 != v2->length())
1685 return false;
1686 for (unsigned i = 0; i < len1; ++i)
1687 if (tree_string_cmp (v1[i], v2[i]) != 0)
1688 return false;
1689 return true;
1690}
1691
1692/* Write a user-defined literal operator.
1693 ::= li <source-name> # "" <source-name>
1694 IDENTIFIER is an LITERAL_IDENTIFIER_NODE. */
1695
1696static void
1697write_literal_operator_name (tree identifier)
1698{
1699 const char* suffix = UDLIT_OP_SUFFIX (identifier)(((const char *) (tree_check ((identifier), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1699, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
) + sizeof ("operator\"\"") - 1);
1700 write_identifier (UDLIT_OP_MANGLED_PREFIX"li");
1701 write_unsigned_number (strlen (suffix))write_number ((strlen (suffix)), 1, 10);
1702 write_identifier (suffix);
1703}
1704
1705/* Encode 0 as _, and 1+ as n-1_. */
1706
1707static void
1708write_compact_number (int num)
1709{
1710 gcc_checking_assert (num >= 0)((void)(!(num >= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1710, __FUNCTION__), 0 : 0));
1711 if (num > 0)
1712 write_unsigned_number (num - 1)write_number ((num - 1), 1, 10);
1713 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
1714}
1715
1716/* Return how many unnamed types precede TYPE in its enclosing class. */
1717
1718static int
1719nested_anon_class_index (tree type)
1720{
1721 int index = 0;
1722 tree member = TYPE_FIELDS (TYPE_CONTEXT (type))((tree_check3 ((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1722, __FUNCTION__))->type_common.context)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1722, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values);
1723 for (; member; member = DECL_CHAIN (member)(((contains_struct_check (((contains_struct_check ((member), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1723, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1723, __FUNCTION__))->common.chain)))
1724 if (DECL_IMPLICIT_TYPEDEF_P (member)(((enum tree_code) (member)->base.code) == TYPE_DECL &&
((contains_struct_check ((member), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1724, __FUNCTION__))->decl_common.lang_flag_2)))
1725 {
1726 tree memtype = TREE_TYPE (member)((contains_struct_check ((member), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1726, __FUNCTION__))->typed.type);
1727 if (memtype == type)
1728 return index;
1729 else if (TYPE_UNNAMED_P (memtype)((((((tree_class_check ((((tree_class_check ((memtype), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((memtype), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__, (IDENTIFIER_NODE)))->base.private_flag
)) && !((tree_check ((((((tree_class_check ((((tree_class_check
((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((memtype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1729, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
)))
1730 ++index;
1731 }
1732
1733 if (seen_error ())
1734 return -1;
1735
1736 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1736, __FUNCTION__));
1737}
1738
1739/* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
1740
1741static void
1742write_unnamed_type_name (const tree type)
1743{
1744 int discriminator;
1745 MANGLE_TRACE_TREE ("unnamed-type-name", type);
1746
1747 if (TYPE_FUNCTION_SCOPE_P (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1747, __FUNCTION__))->type_common.context) && ((
enum tree_code) (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1747, __FUNCTION__))->type_common.context))->base.code
) == FUNCTION_DECL))
1748 discriminator = discriminator_for_local_entity (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1748, __FUNCTION__))->type_common.name));
1749 else if (TYPE_CLASS_SCOPE_P (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1749, __FUNCTION__))->type_common.context) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1749, __FUNCTION__))->type_common.context))->base.code
))] == tcc_type)))
1750 discriminator = nested_anon_class_index (type);
1751 else
1752 {
1753 gcc_assert (no_linkage_check (type, /*relaxed_p=*/true))((void)(!(no_linkage_check (type, true)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1753, __FUNCTION__), 0 : 0));
1754 /* Just use the old mangling at namespace scope. */
1755 write_source_name (TYPE_IDENTIFIER (type)(((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1755, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1755, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1755, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1755, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1755, __FUNCTION__))->type_common.name)));
1756 return;
1757 }
1758
1759 write_string ("Ut")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Ut")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Ut"), __len); __o->next_free += __len
; (void) 0; });
1760 write_compact_number (discriminator);
1761}
1762
1763// A template head, for templated lambdas.
1764// <template-head> ::= Tp* Ty
1765// Tp* Tn <type>
1766// Tp* Tt <template-head> E
1767// New in ABI=18. Returns true iff we emitted anything -- used for ABI
1768// version warning.
1769
1770static bool
1771write_closure_template_head (tree tmpl)
1772{
1773 bool any = false;
1774
1775 // We only need one level of template parms
1776 tree inner = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl))((tree_check ((((struct tree_template_decl *)(const_cast<union
tree_node *> ((((tree_check ((tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1776, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1776, __FUNCTION__, (TREE_LIST)))->list.value);
1777
1778 for (int ix = 0, len = TREE_VEC_LENGTH (inner)((tree_check ((inner), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1778, __FUNCTION__, (TREE_VEC)))->base.u.length); ix != len; ix++)
1779 {
1780 tree parm = TREE_VEC_ELT (inner, ix)(*((const_cast<tree *> (tree_vec_elt_check ((inner), (ix
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1780, __FUNCTION__)))));
1781 if (parm == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1782 continue;
1783 parm = TREE_VALUE (parm)((tree_check ((parm), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1783, __FUNCTION__, (TREE_LIST)))->list.value);
1784
1785 if (DECL_VIRTUAL_P (parm)((contains_struct_check ((parm), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1785, __FUNCTION__))->decl_common.virtual_flag))
1786 // A synthetic parm, we're done.
1787 break;
1788
1789 any = true;
1790 if (abi_version_at_least (18)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (18)))
1791 {
1792 if (TREE_CODE (parm)((enum tree_code) (parm)->base.code) == PARM_DECL
1793 ? TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm))(((tree_not_check2 (((tree_check ((((contains_struct_check ((
parm), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1793, __FUNCTION__))->decl_common.initial)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1793, __FUNCTION__, (TEMPLATE_PARM_INDEX)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1793, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
1794 : TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (parm))((((tree_not_check2 (((tree_check (((((tree_class_check (((tree_check3
(((((contains_struct_check ((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1794, __FUNCTION__))->typed.type))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1794, __FUNCTION__, (TEMPLATE_TYPE_PARM), (TEMPLATE_TEMPLATE_PARM
), (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1794, __FUNCTION__))->type_non_common.values))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1794, __FUNCTION__, (TEMPLATE_PARM_INDEX)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1794, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))))
1795 write_string ("Tp")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Tp")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Tp"), __len); __o->next_free += __len
; (void) 0; });
1796
1797 switch (TREE_CODE (parm)((enum tree_code) (parm)->base.code))
1798 {
1799 default:
1800 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1800, __FUNCTION__));
1801
1802 case TYPE_DECL:
1803 write_string ("Ty")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Ty")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Ty"), __len); __o->next_free += __len
; (void) 0; });
1804 break;
1805
1806 case PARM_DECL:
1807 write_string ("Tn")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Tn")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Tn"), __len); __o->next_free += __len
; (void) 0; });
1808 write_type (TREE_TYPE (parm)((contains_struct_check ((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1808, __FUNCTION__))->typed.type));
1809 break;
1810
1811 case TEMPLATE_DECL:
1812 write_string ("Tt")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Tt")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Tt"), __len); __o->next_free += __len
; (void) 0; });
1813 write_closure_template_head (parm);
1814 write_string ("E")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("E")); if (__extension__ ({ struct obstack const
*__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, ("E"), __len); __o->next_free += __len; (void
) 0; });
1815 break;
1816 }
1817 }
1818 }
1819
1820 return any;
1821}
1822
1823/* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
1824 <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters */
1825
1826static void
1827write_closure_type_name (const tree type)
1828{
1829 tree fn = lambda_function (type);
1830 tree lambda = CLASSTYPE_LAMBDA_EXPR (type)((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1830, __FUNCTION__))->type_with_lang_specific.lang_specific
))->lambda_expr);
1831 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn))((tree_check2 ((((contains_struct_check ((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1831, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1831, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values);
1832
1833 MANGLE_TRACE_TREE ("closure-type-name", type);
1834
1835 write_string ("Ul")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Ul")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Ul"), __len); __o->next_free += __len
; (void) 0; });
1836
1837 if (auto ti = maybe_template_info (fn))
1838 if (write_closure_template_head (TI_TEMPLATE (ti)((struct tree_template_info*)(tree_check ((ti), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1838, __FUNCTION__, (TEMPLATE_INFO))))->tmpl))
1839 // If there were any explicit template parms, we may need to
1840 // issue a mangling diagnostic.
1841 if (abi_warn_or_compat_version_crosses (18)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (18)) != (warn_abi_version == 0 || warn_abi_version >=
(18))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (18)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (18))
)))
1842 G.need_abi_warning = true;
1843
1844 write_method_parms (parms, TREE_CODE (TREE_TYPE (fn))((enum tree_code) (((contains_struct_check ((fn), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1844, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE, fn);
1845 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
1846 if ((LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR (lambda)(((struct tree_lambda_expr *)(tree_check ((lambda), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1846, __FUNCTION__, (LAMBDA_EXPR))))->discriminator_sig)
1847 != LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR (lambda)(((struct tree_lambda_expr *)(tree_check ((lambda), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1847, __FUNCTION__, (LAMBDA_EXPR))))->discriminator_scope
))
1848 && abi_warn_or_compat_version_crosses (18)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (18)) != (warn_abi_version == 0 || warn_abi_version >=
(18))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (18)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (18))
)))
1849 G.need_abi_warning = true;
1850 write_compact_number (abi_version_at_least (18)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (18))
1851 ? LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR (lambda)(((struct tree_lambda_expr *)(tree_check ((lambda), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1851, __FUNCTION__, (LAMBDA_EXPR))))->discriminator_sig)
1852 : LAMBDA_EXPR_SCOPE_ONLY_DISCRIMINATOR (lambda)(((struct tree_lambda_expr *)(tree_check ((lambda), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1852, __FUNCTION__, (LAMBDA_EXPR))))->discriminator_scope
));
1853}
1854
1855/* Convert NUMBER to ascii using base BASE and generating at least
1856 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer
1857 into which to store the characters. Returns the number of
1858 characters generated (these will be laid out in advance of where
1859 BUFFER points). */
1860
1861static int
1862hwint_to_ascii (unsigned HOST_WIDE_INTlong number, const unsigned int base,
1863 char *buffer, const unsigned int min_digits)
1864{
1865 static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1866 unsigned digits = 0;
1867
1868 while (number)
1869 {
1870 unsigned HOST_WIDE_INTlong d = number / base;
1871
1872 *--buffer = base_digits[number - d * base];
1873 digits++;
1874 number = d;
1875 }
1876 while (digits < min_digits)
1877 {
1878 *--buffer = base_digits[0];
1879 digits++;
1880 }
1881 return digits;
1882}
1883
1884/* Non-terminal <number>.
1885
1886 <number> ::= [n] </decimal integer/> */
1887
1888static void
1889write_number (unsigned HOST_WIDE_INTlong number, const int unsigned_p,
1890 const unsigned int base)
1891{
1892 char buffer[sizeof (HOST_WIDE_INTlong) * 8];
1893 unsigned count = 0;
1894
1895 if (!unsigned_p && (HOST_WIDE_INTlong) number < 0)
1896 {
1897 write_char ('n')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('n')))); });
1898 number = -((HOST_WIDE_INTlong) number);
1899 }
1900 count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1);
1901 write_chars (buffer + sizeof (buffer) - count, count)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = ((count)); if (__extension__ ({ struct obstack const
*__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, (buffer + sizeof (buffer) - count), __len); __o
->next_free += __len; (void) 0; });
1902}
1903
1904/* Write out an integral CST in decimal. Most numbers are small, and
1905 representable in a HOST_WIDE_INT. Occasionally we'll have numbers
1906 bigger than that, which we must deal with. */
1907
1908static inline void
1909write_integer_cst (const tree cst)
1910{
1911 int sign = tree_int_cst_sgn (cst);
1912 widest_int abs_value = wi::abs (wi::to_widest (cst));
1913 if (!wi::fits_uhwi_p (abs_value))
1914 {
1915 /* A bignum. We do this in chunks, each of which fits in a
1916 HOST_WIDE_INT. */
1917 char buffer[sizeof (HOST_WIDE_INTlong) * 8 * 2];
1918 unsigned HOST_WIDE_INTlong chunk;
1919 unsigned chunk_digits;
1920 char *ptr = buffer + sizeof (buffer);
1921 unsigned count = 0;
1922 tree n, base, type;
1923 int done;
1924
1925 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
1926 representable. */
1927 chunk = 1000000000;
1928 chunk_digits = 9;
Value stored to 'chunk_digits' is never read
1929
1930 if (sizeof (HOST_WIDE_INTlong) >= 8)
1931 {
1932 /* It is at least 64 bits, so 10^18 is representable. */
1933 chunk_digits = 18;
1934 chunk *= chunk;
1935 }
1936
1937 type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst)((contains_struct_check ((cst), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1937, __FUNCTION__))->typed.type));
1938 base = build_int_cstu (type, chunk);
1939 n = wide_int_to_tree (type, wi::to_wide (cst));
1940
1941 if (sign < 0)
1942 {
1943 write_char ('n')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('n')))); });
1944 n = fold_build1_loc (input_location, NEGATE_EXPR, type, n);
1945 }
1946 do
1947 {
1948 tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base);
1949 tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base);
1950 unsigned c;
1951
1952 done = integer_zerop (d);
1953 tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp);
1954 c = hwint_to_ascii (TREE_INT_CST_LOW (tmp)((unsigned long) (*tree_int_cst_elt_check ((tmp), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 1954, __FUNCTION__))), 10, ptr,
1955 done ? 1 : chunk_digits);
1956 ptr -= c;
1957 count += c;
1958 n = d;
1959 }
1960 while (!done);
1961 write_chars (ptr, count)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = ((count)); if (__extension__ ({ struct obstack const
*__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, (ptr), __len); __o->next_free += __len; (void
) 0; });
1962 }
1963 else
1964 {
1965 /* A small num. */
1966 if (sign < 0)
1967 write_char ('n')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('n')))); });
1968 write_unsigned_number (abs_value.to_uhwi ())write_number ((abs_value.to_uhwi ()), 1, 10);
1969 }
1970}
1971
1972/* Write out a floating-point literal.
1973
1974 "Floating-point literals are encoded using the bit pattern of the
1975 target processor's internal representation of that number, as a
1976 fixed-length lowercase hexadecimal string, high-order bytes first
1977 (even if the target processor would store low-order bytes first).
1978 The "n" prefix is not used for floating-point literals; the sign
1979 bit is encoded with the rest of the number.
1980
1981 Here are some examples, assuming the IEEE standard representation
1982 for floating point numbers. (Spaces are for readability, not
1983 part of the encoding.)
1984
1985 1.0f Lf 3f80 0000 E
1986 -1.0f Lf bf80 0000 E
1987 1.17549435e-38f Lf 0080 0000 E
1988 1.40129846e-45f Lf 0000 0001 E
1989 0.0f Lf 0000 0000 E"
1990
1991 Caller is responsible for the Lx and the E. */
1992static void
1993write_real_cst (const tree value)
1994{
1995 long target_real[4]; /* largest supported float */
1996 /* Buffer for eight hex digits in a 32-bit number but big enough
1997 even for 64-bit long to avoid warnings. */
1998 char buffer[17];
1999 int i, limit, dir;
2000
2001 tree type = TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2001, __FUNCTION__))->typed.type);
2002 int words = GET_MODE_BITSIZE (SCALAR_FLOAT_TYPE_MODE (type)(as_a <scalar_float_mode> ((tree_class_check ((type), (
tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2002, __FUNCTION__))->type_common.mode))) / 32;
2003
2004 real_to_target (target_real, &TREE_REAL_CST (value)(*(&(tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2004, __FUNCTION__, (REAL_CST)))->real_cst.value)),
2005 TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2005, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode));
2006
2007 /* The value in target_real is in the target word order,
2008 so we must write it out backward if that happens to be
2009 little-endian. write_number cannot be used, it will
2010 produce uppercase. */
2011 if (FLOAT_WORDS_BIG_ENDIAN0)
2012 i = 0, limit = words, dir = 1;
2013 else
2014 i = words - 1, limit = -1, dir = -1;
2015
2016 for (; i != limit; i += dir)
2017 {
2018 sprintf (buffer, "%08lx", (unsigned long) target_real[i]);
2019 write_chars (buffer, 8)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = ((8)); if (__extension__ ({ struct obstack const *__o1
= (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, (buffer), __len); __o->next_free += __len;
(void) 0; });
2020 }
2021}
2022
2023/* Non-terminal <identifier>.
2024
2025 <identifier> ::= </unqualified source code identifier> */
2026
2027static void
2028write_identifier (const char *identifier)
2029{
2030 MANGLE_TRACE ("identifier", identifier);
2031 write_string (identifier)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (identifier)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (identifier), __len); __o->next_free +=
__len; (void) 0; });
2032}
2033
2034/* Handle constructor productions of non-terminal <special-name>.
2035 CTOR is a constructor FUNCTION_DECL.
2036
2037 <special-name> ::= C1 # complete object constructor
2038 ::= C2 # base object constructor
2039 ::= C3 # complete object allocating constructor
2040
2041 Currently, allocating constructors are never used. */
2042
2043static void
2044write_special_name_constructor (const tree ctor)
2045{
2046 write_char ('C')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('C')))); });
2047 bool new_inh = (flag_new_inheriting_ctorsglobal_options.x_flag_new_inheriting_ctors
2048 && DECL_INHERITED_CTOR (ctor)((((enum tree_code) (ctor)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (ctor)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2048, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((ctor
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2048, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) && ((tree_check (((((enum
tree_code) (ctor)->base.code) == TEMPLATE_DECL ? ((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2048, __FUNCTION__, (TEMPLATE_DECL))))))))->result : ctor
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2048, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
) ? __extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (ctor)->base.code) == TEMPLATE_DECL ?
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2048, __FUNCTION__, (TEMPLATE_DECL))))))))->result : ctor
)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2048, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (ctor)->base.code) == FUNCTION_DECL || (
((enum tree_code) (ctor)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2048, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((ctor
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2048, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2048, __FUNCTION__); &lt->u.fn; })->context : (tree
) nullptr));
2049 if (new_inh)
2050 write_char ('I')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('I')))); });
2051 if (DECL_BASE_CONSTRUCTOR_P (ctor)(((contains_struct_check ((ctor), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2051, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_BASE_CTOR_IDENTIFIER]))
2052 write_char ('2')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('2')))); });
2053 /* This is the old-style "[unified]" constructor.
2054 In some cases, we may emit this function and call
2055 it from the clones in order to share code and save space. */
2056 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor)(((contains_struct_check ((ctor), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2056, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_CTOR_IDENTIFIER]))
2057 write_char ('4')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('4')))); });
2058 else
2059 {
2060 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor))((void)(!((((contains_struct_check ((ctor), (TS_DECL_MINIMAL)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2060, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_COMPLETE_CTOR_IDENTIFIER])) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2060, __FUNCTION__), 0 : 0));
2061 write_char ('1')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('1')))); });
2062 }
2063 if (new_inh)
2064 write_type (DECL_INHERITED_CTOR_BASE (ctor)(((((enum tree_code) (ctor)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (ctor)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((ctor
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) && ((tree_check (((((enum
tree_code) (ctor)->base.code) == TEMPLATE_DECL ? ((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result : ctor
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
) ? __extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (ctor)->base.code) == TEMPLATE_DECL ?
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result : ctor
)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (ctor)->base.code) == FUNCTION_DECL || (
((enum tree_code) (ctor)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((ctor
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__); &lt->u.fn; })->context : (tree
) nullptr) ? ((contains_struct_check ((global_options.x_flag_new_inheriting_ctors
? strip_inheriting_ctors (ctor) : ((((enum tree_code) (ctor)
->base.code) == FUNCTION_DECL || (((enum tree_code) (ctor)
->base.code) == TEMPLATE_DECL && ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((ctor
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((ctor
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) && ((tree_check (((((enum
tree_code) (ctor)->base.code) == TEMPLATE_DECL ? ((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result : ctor
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
) ? __extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (ctor)->base.code) == TEMPLATE_DECL ?
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result : ctor
)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (ctor)->base.code) == FUNCTION_DECL || (
((enum tree_code) (ctor)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((ctor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) nullptr && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((ctor
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__); &lt->u.fn; })->context : (tree
) nullptr)), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2064, __FUNCTION__))->decl_minimal.context) : (tree) nullptr
));
2065}
2066
2067/* Handle destructor productions of non-terminal <special-name>.
2068 DTOR is a destructor FUNCTION_DECL.
2069
2070 <special-name> ::= D0 # deleting (in-charge) destructor
2071 ::= D1 # complete object (in-charge) destructor
2072 ::= D2 # base object (not-in-charge) destructor */
2073
2074static void
2075write_special_name_destructor (const tree dtor)
2076{
2077 if (DECL_DELETING_DESTRUCTOR_P (dtor)(((contains_struct_check ((dtor), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2077, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_DELETING_DTOR_IDENTIFIER]))
2078 write_string ("D0")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("D0")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("D0"), __len); __o->next_free += __len
; (void) 0; });
2079 else if (DECL_BASE_DESTRUCTOR_P (dtor)(((contains_struct_check ((dtor), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2079, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_BASE_DTOR_IDENTIFIER]))
2080 write_string ("D2")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("D2")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("D2"), __len); __o->next_free += __len
; (void) 0; });
2081 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor)(((contains_struct_check ((dtor), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2081, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_DTOR_IDENTIFIER]))
2082 /* This is the old-style "[unified]" destructor.
2083 In some cases, we may emit this function and call
2084 it from the clones in order to share code and save space. */
2085 write_string ("D4")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("D4")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("D4"), __len); __o->next_free += __len
; (void) 0; });
2086 else
2087 {
2088 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor))((void)(!((((contains_struct_check ((dtor), (TS_DECL_MINIMAL)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2088, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_COMPLETE_DTOR_IDENTIFIER])) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2088, __FUNCTION__), 0 : 0));
2089 write_string ("D1")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("D1")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("D1"), __len); __o->next_free += __len
; (void) 0; });
2090 }
2091}
2092
2093/* Return the discriminator for ENTITY appearing inside
2094 FUNCTION. The discriminator is the lexical ordinal of VAR or TYPE among
2095 entities with the same name and kind in the same FUNCTION. */
2096
2097static int
2098discriminator_for_local_entity (tree entity)
2099{
2100 if (!DECL_LANG_SPECIFIC (entity)((contains_struct_check ((entity), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2100, __FUNCTION__))->decl_common.lang_specific))
2101 {
2102 /* Some decls, like __FUNCTION__, don't need a discriminator. */
2103 gcc_checking_assert (DECL_ARTIFICIAL (entity))((void)(!(((contains_struct_check ((entity), (TS_DECL_COMMON)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2103, __FUNCTION__))->decl_common.artificial_flag)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2103, __FUNCTION__), 0 : 0));
2104 return 0;
2105 }
2106 else if (tree disc = DECL_DISCRIMINATOR (entity)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
((entity), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2106, __FUNCTION__))->decl_common.lang_specific); if (!(
(((enum tree_code) (entity)->base.code) == VAR_DECL || ((enum
tree_code) (entity)->base.code) == FUNCTION_DECL) || ((enum
tree_code) (entity)->base.code) == FIELD_DECL || ((enum tree_code
) (entity)->base.code) == CONST_DECL || ((enum tree_code) (
entity)->base.code) == TYPE_DECL || ((enum tree_code) (entity
)->base.code) == TEMPLATE_DECL || ((enum tree_code) (entity
)->base.code) == USING_DECL || ((enum tree_code) (entity)->
base.code) == CONCEPT_DECL)) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2106, __FUNCTION__); &lt->u.min; })->access))
2107 return TREE_INT_CST_LOW (disc)((unsigned long) (*tree_int_cst_elt_check ((disc), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2107, __FUNCTION__)));
2108 else
2109 /* The first entity with a particular name doesn't get
2110 DECL_DISCRIMINATOR set up. */
2111 return 0;
2112}
2113
2114/* Return the discriminator for STRING, a string literal used inside
2115 FUNCTION. The discriminator is the lexical ordinal of STRING among
2116 string literals used in FUNCTION. */
2117
2118static int
2119discriminator_for_string_literal (tree /*function*/,
2120 tree /*string*/)
2121{
2122 /* For now, we don't discriminate amongst string literals. */
2123 return 0;
2124}
2125
2126/* <discriminator> := _ <number> # when number < 10
2127 := __ <number> _ # when number >= 10
2128
2129 The discriminator is used only for the second and later occurrences
2130 of the same name within a single function. In this case <number> is
2131 n - 2, if this is the nth occurrence, in lexical order. */
2132
2133static void
2134write_discriminator (const int discriminator)
2135{
2136 /* If discriminator is zero, don't write anything. Otherwise... */
2137 if (discriminator > 0)
2138 {
2139 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
2140 if (discriminator - 1 >= 10)
2141 {
2142 if (abi_warn_or_compat_version_crosses (11)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)) != (warn_abi_version == 0 || warn_abi_version >=
(11))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (11)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (11))
)))
2143 G.need_abi_warning = 1;
2144 if (abi_version_at_least (11)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)))
2145 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
2146 }
2147 write_unsigned_number (discriminator - 1)write_number ((discriminator - 1), 1, 10);
2148 if (abi_version_at_least (11)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)) && discriminator - 1 >= 10)
2149 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
2150 }
2151}
2152
2153/* Mangle the name of a function-scope entity. FUNCTION is the
2154 FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in
2155 default argument scope. ENTITY is the decl for the entity itself.
2156 LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL,
2157 either ENTITY itself or an enclosing scope of ENTITY.
2158
2159 <local-name> := Z <function encoding> E <entity name> [<discriminator>]
2160 := Z <function encoding> E s [<discriminator>]
2161 := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */
2162
2163static void
2164write_local_name (tree function, const tree local_entity,
2165 const tree entity)
2166{
2167 tree parm = NULL_TREE(tree) nullptr;
2168
2169 MANGLE_TRACE_TREE ("local-name", entity);
2170
2171 if (TREE_CODE (function)((enum tree_code) (function)->base.code) == PARM_DECL)
2172 {
2173 parm = function;
2174 function = DECL_CONTEXT (parm)((contains_struct_check ((parm), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2174, __FUNCTION__))->decl_minimal.context);
2175 }
2176
2177 write_char ('Z')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('Z')))); });
2178 write_encoding (function);
2179 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
2180
2181 /* For this purpose, parameters are numbered from right-to-left. */
2182 if (parm)
2183 {
2184 int i = list_length (parm);
2185 write_char ('d')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('d')))); });
2186 write_compact_number (i - 1);
2187 }
2188
2189 if (TREE_CODE (entity)((enum tree_code) (entity)->base.code) == STRING_CST)
2190 {
2191 write_char ('s')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('s')))); });
2192 write_discriminator (discriminator_for_string_literal (function,
2193 entity));
2194 }
2195 else
2196 {
2197 /* Now the <entity name>. Let write_name know its being called
2198 from <local-name>, so it doesn't try to process the enclosing
2199 function scope again. */
2200 write_name (entity, /*ignore_local_scope=*/1);
2201 if (DECL_DISCRIMINATOR_P (local_entity)(((((enum tree_code) (local_entity)->base.code) == VAR_DECL
&& ((local_entity)->base.static_flag)) || (((enum
tree_code) (local_entity)->base.code) == TYPE_DECL &&
((contains_struct_check ((local_entity), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2201, __FUNCTION__))->decl_common.lang_flag_2))) &&
(((contains_struct_check ((local_entity), (TS_DECL_MINIMAL),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2201, __FUNCTION__))->decl_minimal.context) && (
(enum tree_code) (((contains_struct_check ((local_entity), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2201, __FUNCTION__))->decl_minimal.context))->base.code
) == FUNCTION_DECL))
2202 && !(TREE_CODE (local_entity)((enum tree_code) (local_entity)->base.code) == TYPE_DECL
2203 && TYPE_ANON_P (TREE_TYPE (local_entity))(((((tree_class_check ((((tree_class_check ((((contains_struct_check
((local_entity), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((((contains_struct_check ((local_entity
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((local_entity
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((local_entity
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((((contains_struct_check
((local_entity), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((((contains_struct_check ((local_entity
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((local_entity
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((local_entity
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2203, __FUNCTION__, (IDENTIFIER_NODE)))->base.private_flag
))))
2204 write_discriminator (discriminator_for_local_entity (local_entity));
2205 }
2206}
2207
2208/* Non-terminals <type> and <CV-qualifier>.
2209
2210 <type> ::= <builtin-type>
2211 ::= <function-type>
2212 ::= <class-enum-type>
2213 ::= <array-type>
2214 ::= <pointer-to-member-type>
2215 ::= <template-param>
2216 ::= <substitution>
2217 ::= <CV-qualifier>
2218 ::= P <type> # pointer-to
2219 ::= R <type> # reference-to
2220 ::= C <type> # complex pair (C 2000)
2221 ::= G <type> # imaginary (C 2000) [not supported]
2222 ::= U <source-name> <type> # vendor extended type qualifier
2223
2224 C++0x extensions
2225
2226 <type> ::= RR <type> # rvalue reference-to
2227 <type> ::= Dt <expression> # decltype of an id-expression or
2228 # class member access
2229 <type> ::= DT <expression> # decltype of an expression
2230 <type> ::= Dn # decltype of nullptr
2231
2232 TYPE is a type node. */
2233
2234static void
2235write_type (tree type)
2236{
2237 /* This gets set to nonzero if TYPE turns out to be a (possibly
2238 CV-qualified) builtin type. */
2239 int is_builtin_type = 0;
2240
2241 MANGLE_TRACE_TREE ("type", type);
2242
2243 if (type == error_mark_nodeglobal_trees[TI_ERROR_MARK])
2244 return;
2245
2246 type = canonicalize_for_substitution (type);
2247 if (find_substitution (type))
2248 return;
2249
2250
2251 if (write_CV_qualifiers_for_type (type) > 0)
2252 /* If TYPE was CV-qualified, we just wrote the qualifiers; now
2253 mangle the unqualified type. The recursive call is needed here
2254 since both the qualified and unqualified types are substitution
2255 candidates. */
2256 {
2257 tree t = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2257, __FUNCTION__))->type_common.main_variant);
2258 if (TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2258, __FUNCTION__))->type_common.attributes) && !OVERLOAD_TYPE_P (t)((((((enum tree_code) (t)->base.code)) == RECORD_TYPE || (
((enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2258, __FUNCTION__))->type_common.lang_flag_5)) || ((enum
tree_code) (t)->base.code) == ENUMERAL_TYPE))
2259 {
2260 tree attrs = NULL_TREE(tree) nullptr;
2261 if (tx_safe_fn_type_p (type))
2262 attrs = tree_cons (get_identifier ("transaction_safe")(__builtin_constant_p ("transaction_safe") ? get_identifier_with_length
(("transaction_safe"), strlen ("transaction_safe")) : get_identifier
("transaction_safe")),
2263 NULL_TREE(tree) nullptr, attrs);
2264 t = cp_build_type_attribute_variant (t, attrs);
2265 }
2266 gcc_assert (t != type)((void)(!(t != type) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2266, __FUNCTION__), 0 : 0));
2267 if (FUNC_OR_METHOD_TYPE_P (t)(((enum tree_code) (t)->base.code) == FUNCTION_TYPE || ((enum
tree_code) (t)->base.code) == METHOD_TYPE))
2268 {
2269 t = build_ref_qualified_type (t, type_memfn_rqual (type));
2270 if (flag_noexcept_type)
2271 {
2272 tree r = TYPE_RAISES_EXCEPTIONS (type)((tree_class_check (((tree_check2 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2272, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2272, __FUNCTION__))->type_non_common.lang_1);
2273 t = build_exception_variant (t, r);
2274 }
2275 if (abi_version_at_least (8)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (8))
2276 || type == TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2276, __FUNCTION__))->type_common.main_variant))
2277 /* Avoid adding the unqualified function type as a substitution. */
2278 write_function_type (t);
2279 else
2280 write_type (t);
2281 if (abi_warn_or_compat_version_crosses (8)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (8)) != (warn_abi_version == 0 || warn_abi_version >=
(8))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (8)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (8)))
))
2282 G.need_abi_warning = 1;
2283 }
2284 else
2285 write_type (t);
2286 }
2287 else if (TREE_CODE (type)((enum tree_code) (type)->base.code) == ARRAY_TYPE)
2288 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here
2289 so that the cv-qualification of the element type is available
2290 in write_array_type. */
2291 write_array_type (type);
2292 else
2293 {
2294 tree type_orig = type;
2295
2296 /* See through any typedefs. */
2297 type = TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2297, __FUNCTION__))->type_common.main_variant);
2298 if (FUNC_OR_METHOD_TYPE_P (type)(((enum tree_code) (type)->base.code) == FUNCTION_TYPE || (
(enum tree_code) (type)->base.code) == METHOD_TYPE))
2299 type = cxx_copy_lang_qualifiers (type, type_orig);
2300
2301 /* According to the C++ ABI, some library classes are passed the
2302 same as the scalar type of their single member and use the same
2303 mangling. */
2304 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2304, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_common.transparent_aggr_flag))
2305 type = TREE_TYPE (first_field (type))((contains_struct_check ((first_field (type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2305, __FUNCTION__))->typed.type);
2306
2307 if (TYPE_PTRDATAMEM_P (type)(((enum tree_code) (type)->base.code) == OFFSET_TYPE))
2308 write_pointer_to_member_type (type);
2309 else
2310 {
2311 /* Handle any target-specific fundamental types. */
2312 const char *target_mangling
2313 = targetm.mangle_type (type_orig);
2314
2315 if (target_mangling)
2316 {
2317 write_string (target_mangling)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (target_mangling)); if (__extension__ ({ struct
obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
__o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); memcpy (__o->next_free, (target_mangling), __len); __o->
next_free += __len; (void) 0; });
2318 /* Add substitutions for types other than fundamental
2319 types. */
2320 if (!VOID_TYPE_P (type)(((enum tree_code) (type)->base.code) == VOID_TYPE)
2321 && TREE_CODE (type)((enum tree_code) (type)->base.code) != INTEGER_TYPE
2322 && TREE_CODE (type)((enum tree_code) (type)->base.code) != REAL_TYPE
2323 && TREE_CODE (type)((enum tree_code) (type)->base.code) != BOOLEAN_TYPE)
2324 add_substitution (type);
2325 return;
2326 }
2327
2328 switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
2329 {
2330 case VOID_TYPE:
2331 case BOOLEAN_TYPE:
2332 case INTEGER_TYPE: /* Includes wchar_t. */
2333 case REAL_TYPE:
2334 case FIXED_POINT_TYPE:
2335 {
2336 /* If this is a typedef, TYPE may not be one of
2337 the standard builtin type nodes, but an alias of one. Use
2338 TYPE_MAIN_VARIANT to get to the underlying builtin type. */
2339 write_builtin_type (TYPE_MAIN_VARIANT (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2339, __FUNCTION__))->type_common.main_variant));
2340 ++is_builtin_type;
2341 }
2342 break;
2343
2344 case COMPLEX_TYPE:
2345 write_char ('C')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('C')))); });
2346 write_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2346, __FUNCTION__))->typed.type));
2347 break;
2348
2349 case FUNCTION_TYPE:
2350 case METHOD_TYPE:
2351 write_function_type (type);
2352 break;
2353
2354 case UNION_TYPE:
2355 case RECORD_TYPE:
2356 case ENUMERAL_TYPE:
2357 /* A pointer-to-member function is represented as a special
2358 RECORD_TYPE, so check for this first. */
2359 if (TYPE_PTRMEMFUNC_P (type)(((enum tree_code) (type)->base.code) == RECORD_TYPE &&
(((tree_class_check (((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2359, __FUNCTION__, (RECORD_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2359, __FUNCTION__))->type_common.lang_flag_2))))
2360 write_pointer_to_member_type (type);
2361 else
2362 write_class_enum_type (type);
2363 break;
2364
2365 case TYPENAME_TYPE:
2366 case UNBOUND_CLASS_TEMPLATE:
2367 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like
2368 ordinary nested names. */
2369 write_nested_name (TYPE_STUB_DECL (type)(((contains_struct_check (((tree_class_check ((type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2369, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2369, __FUNCTION__))->common.chain)));
2370 break;
2371
2372 case POINTER_TYPE:
2373 case REFERENCE_TYPE:
2374 if (TYPE_PTR_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE))
2375 write_char ('P')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('P')))); });
2376 else if (TYPE_REF_IS_RVALUE (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2376, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
))
2377 write_char ('O')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('O')))); });
2378 else
2379 write_char ('R')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('R')))); });
2380 {
2381 tree target = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2381, __FUNCTION__))->typed.type);
2382 /* Attribute const/noreturn are not reflected in mangling.
2383 We strip them here rather than at a lower level because
2384 a typedef or template argument can have function type
2385 with function-cv-quals (that use the same representation),
2386 but you can't have a pointer/reference to such a type. */
2387 if (TREE_CODE (target)((enum tree_code) (target)->base.code) == FUNCTION_TYPE)
2388 {
2389 if (abi_warn_or_compat_version_crosses (5)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (5)) != (warn_abi_version == 0 || warn_abi_version >=
(5))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (5)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (5)))
)
2390 && TYPE_QUALS (target)((int) ((((tree_class_check ((target), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2390, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((target), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2390, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((target), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2390, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((target), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2390, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((target), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2390, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8)))) != TYPE_UNQUALIFIED)
2391 G.need_abi_warning = 1;
2392 if (abi_version_at_least (5)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (5)))
2393 target = build_qualified_type (target, TYPE_UNQUALIFIED);
2394 }
2395 write_type (target);
2396 }
2397 break;
2398
2399 case TEMPLATE_TYPE_PARM:
2400 if (is_auto (type))
2401 {
2402 if (AUTO_IS_DECLTYPE (type)(((tree_class_check (((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2402, __FUNCTION__, (TEMPLATE_TYPE_PARM)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2402, __FUNCTION__))->type_common.lang_flag_5)))
2403 write_identifier ("Dc");
2404 else
2405 write_identifier ("Da");
2406 ++is_builtin_type;
2407 break;
2408 }
2409 /* fall through. */
2410 case TEMPLATE_PARM_INDEX:
2411 write_template_param (type);
2412 break;
2413
2414 case TEMPLATE_TEMPLATE_PARM:
2415 write_template_template_param (type);
2416 break;
2417
2418 case BOUND_TEMPLATE_TEMPLATE_PARM:
2419 write_template_template_param (type);
2420 write_template_args
2421 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type))((struct tree_template_info*)(tree_check (((((tree_class_check
(((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2421, __FUNCTION__, (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2421, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2421, __FUNCTION__, (TEMPLATE_INFO))))->args);
2422 break;
2423
2424 case VECTOR_TYPE:
2425 if (abi_version_at_least (4)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (4)))
2426 {
2427 write_string ("Dv")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Dv")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Dv"), __len); __o->next_free += __len
; (void) 0; });
2428 /* Non-constant vector size would be encoded with
2429 _ expression, but we don't support that yet. */
2430 write_unsigned_number (TYPE_VECTOR_SUBPARTS (type)write_number ((TYPE_VECTOR_SUBPARTS (type) .to_constant ()), 1
, 10)
2431 .to_constant ())write_number ((TYPE_VECTOR_SUBPARTS (type) .to_constant ()), 1
, 10);
2432 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
2433 }
2434 else
2435 write_string ("U8__vector")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("U8__vector")); if (__extension__ ({ struct
obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
__o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); memcpy (__o->next_free, ("U8__vector"), __len); __o->
next_free += __len; (void) 0; });
2436 if (abi_warn_or_compat_version_crosses (4)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (4)) != (warn_abi_version == 0 || warn_abi_version >=
(4))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (4)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (4)))
))
2437 G.need_abi_warning = 1;
2438 write_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2438, __FUNCTION__))->typed.type));
2439 break;
2440
2441 case TYPE_PACK_EXPANSION:
2442 write_string ("Dp")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Dp")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Dp"), __len); __o->next_free += __len
; (void) 0; });
2443 write_type (PACK_EXPANSION_PATTERN (type)(((enum tree_code) ((tree_check2 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2443, __FUNCTION__, (TYPE_PACK_EXPANSION), (EXPR_PACK_EXPANSION
))))->base.code) == TYPE_PACK_EXPANSION ? ((contains_struct_check
((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2443, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((type), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2443, __FUNCTION__)))))));
2444 break;
2445
2446 case DECLTYPE_TYPE:
2447 /* These shouldn't make it into mangling. */
2448 gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type)((void)(!(!((tree_not_check2 (((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2448, __FUNCTION__, (DECLTYPE_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2448, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0) && !((tree_not_check2 (((tree_check ((type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2449, __FUNCTION__, (DECLTYPE_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2449, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2449, __FUNCTION__), 0 : 0))
2449 && !DECLTYPE_FOR_LAMBDA_PROXY (type))((void)(!(!((tree_not_check2 (((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2448, __FUNCTION__, (DECLTYPE_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2448, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0) && !((tree_not_check2 (((tree_check ((type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2449, __FUNCTION__, (DECLTYPE_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2449, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2449, __FUNCTION__), 0 : 0));
2450
2451 /* In ABI <5, we stripped decltype of a plain decl. */
2452 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2452, __FUNCTION__, (DECLTYPE_TYPE))))->type_common.string_flag)
2453 {
2454 tree expr = DECLTYPE_TYPE_EXPR (type)(((tree_class_check (((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2454, __FUNCTION__, (DECLTYPE_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2454, __FUNCTION__))->type_non_common.values));
2455 tree etype = NULL_TREE(tree) nullptr;
2456 switch (TREE_CODE (expr)((enum tree_code) (expr)->base.code))
2457 {
2458 case VAR_DECL:
2459 case PARM_DECL:
2460 case RESULT_DECL:
2461 case FUNCTION_DECL:
2462 case CONST_DECL:
2463 case TEMPLATE_PARM_INDEX:
2464 etype = TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2464, __FUNCTION__))->typed.type);
2465 break;
2466
2467 default:
2468 break;
2469 }
2470
2471 if (etype && !type_uses_auto (etype))
2472 {
2473 if (abi_warn_or_compat_version_crosses (5)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (5)) != (warn_abi_version == 0 || warn_abi_version >=
(5))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (5)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (5)))
))
2474 G.need_abi_warning = 1;
2475 if (!abi_version_at_least (5)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (5)))
2476 {
2477 write_type (etype);
2478 return;
2479 }
2480 }
2481 }
2482
2483 write_char ('D')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('D')))); });
2484 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2484, __FUNCTION__, (DECLTYPE_TYPE))))->type_common.string_flag)
2485 write_char ('t')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('t')))); });
2486 else
2487 write_char ('T')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('T')))); });
2488 ++cp_unevaluated_operand;
2489 write_expression (DECLTYPE_TYPE_EXPR (type)(((tree_class_check (((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2489, __FUNCTION__, (DECLTYPE_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2489, __FUNCTION__))->type_non_common.values)));
2490 --cp_unevaluated_operand;
2491 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
2492 break;
2493
2494 case NULLPTR_TYPE:
2495 write_string ("Dn")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Dn")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Dn"), __len); __o->next_free += __len
; (void) 0; });
2496 if (abi_version_at_least (7)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (7)))
2497 ++is_builtin_type;
2498 if (abi_warn_or_compat_version_crosses (7)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (7)) != (warn_abi_version == 0 || warn_abi_version >=
(7))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (7)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (7)))
))
2499 G.need_abi_warning = 1;
2500 break;
2501
2502 case TYPEOF_TYPE:
2503 sorry ("mangling %<typeof%>, use %<decltype%> instead");
2504 break;
2505
2506 case TRAIT_TYPE:
2507 error ("use of built-in trait %qT in function signature; "
2508 "use library traits instead", type);
2509 break;
2510
2511 case LANG_TYPE:
2512 /* fall through. */
2513
2514 default:
2515 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2515, __FUNCTION__));
2516 }
2517 }
2518 }
2519
2520 /* Types other than builtin types are substitution candidates. */
2521 if (!is_builtin_type)
2522 add_substitution (type);
2523}
2524
2525/* qsort callback for sorting a vector of attribute entries. */
2526
2527static int
2528attr_strcmp (const void *p1, const void *p2)
2529{
2530 tree a1 = *(const tree*)p1;
2531 tree a2 = *(const tree*)p2;
2532
2533 const attribute_spec *as1 = lookup_attribute_spec (get_attribute_name (a1));
2534 const attribute_spec *as2 = lookup_attribute_spec (get_attribute_name (a2));
2535
2536 return strcmp (as1->name, as2->name);
2537}
2538
2539/* Return true if we should mangle a type attribute with name NAME. */
2540
2541static bool
2542mangle_type_attribute_p (tree name)
2543{
2544 const attribute_spec *as = lookup_attribute_spec (name);
2545 if (!as || !as->affects_type_identity)
2546 return false;
2547
2548 /* Skip internal-only attributes, which are distinguished from others
2549 by having a space. At present, all internal-only attributes that
2550 affect type identity are target-specific and are handled by
2551 targetm.mangle_type instead.
2552
2553 Another reason to do this is that a space isn't a valid identifier
2554 character for most file formats. */
2555 if (strchr (IDENTIFIER_POINTER (name)((const char *) (tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2555, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), ' '))
2556 return false;
2557
2558 /* The following attributes are mangled specially. */
2559 if (is_attribute_p ("transaction_safe", name))
2560 return false;
2561 if (is_attribute_p ("abi_tag", name))
2562 return false;
2563
2564 return true;
2565}
2566
2567/* Non-terminal <CV-qualifiers> for type nodes. Returns the number of
2568 CV-qualifiers written for TYPE.
2569
2570 <CV-qualifiers> ::= [r] [V] [K] */
2571
2572static int
2573write_CV_qualifiers_for_type (const tree type)
2574{
2575 int num_qualifiers = 0;
2576
2577 /* The order is specified by:
2578
2579 "In cases where multiple order-insensitive qualifiers are
2580 present, they should be ordered 'K' (closest to the base type),
2581 'V', 'r', and 'U' (farthest from the base type) ..." */
2582
2583 /* Mangle attributes that affect type identity as extended qualifiers.
2584
2585 We don't do this with classes and enums because their attributes
2586 are part of their definitions, not something added on. */
2587
2588 if (!OVERLOAD_TYPE_P (type)((((((enum tree_code) (type)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2588, __FUNCTION__))->type_common.lang_flag_5)) || ((enum
tree_code) (type)->base.code) == ENUMERAL_TYPE))
2589 {
2590 auto_vec<tree> vec;
2591 for (tree a = TYPE_ATTRIBUTES (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2591, __FUNCTION__))->type_common.attributes); a; a = TREE_CHAIN (a)((contains_struct_check ((a), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2591, __FUNCTION__))->common.chain))
2592 if (mangle_type_attribute_p (get_attribute_name (a)))
2593 vec.safe_push (a);
2594 if (abi_warn_or_compat_version_crosses (10)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (10)) != (warn_abi_version == 0 || warn_abi_version >=
(10))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (10)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (10))
)) && !vec.is_empty ())
2595 G.need_abi_warning = true;
2596 if (abi_version_at_least (10)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (10)))
2597 {
2598 vec.qsort (attr_strcmp)qsort (attr_strcmp);
2599 while (!vec.is_empty())
2600 {
2601 tree a = vec.pop();
2602 const attribute_spec *as
2603 = lookup_attribute_spec (get_attribute_name (a));
2604
2605 write_char ('U')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('U')))); });
2606 write_unsigned_number (strlen (as->name))write_number ((strlen (as->name)), 1, 10);
2607 write_string (as->name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (as->name)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (as->name), __len); __o->next_free
+= __len; (void) 0; });
2608 if (TREE_VALUE (a)((tree_check ((a), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2608, __FUNCTION__, (TREE_LIST)))->list.value))
2609 {
2610 write_char ('I')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('I')))); });
2611 for (tree args = TREE_VALUE (a)((tree_check ((a), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2611, __FUNCTION__, (TREE_LIST)))->list.value); args;
2612 args = TREE_CHAIN (args)((contains_struct_check ((args), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2612, __FUNCTION__))->common.chain))
2613 {
2614 tree arg = TREE_VALUE (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2614, __FUNCTION__, (TREE_LIST)))->list.value);
2615 write_template_arg (arg);
2616 }
2617 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
2618 }
2619
2620 ++num_qualifiers;
2621 }
2622 }
2623 }
2624
2625 /* Note that we do not use cp_type_quals below; given "const
2626 int[3]", the "const" is emitted with the "int", not with the
2627 array. */
2628 cp_cv_quals quals = TYPE_QUALS (type)((int) ((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2628, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2628, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2628, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2628, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2628, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8))));
2629
2630 if (quals & TYPE_QUAL_RESTRICT)
2631 {
2632 write_char ('r')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('r')))); });
2633 ++num_qualifiers;
2634 }
2635 if (quals & TYPE_QUAL_VOLATILE)
2636 {
2637 write_char ('V')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('V')))); });
2638 ++num_qualifiers;
2639 }
2640 if (quals & TYPE_QUAL_CONST)
2641 {
2642 write_char ('K')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('K')))); });
2643 ++num_qualifiers;
2644 }
2645
2646 return num_qualifiers;
2647}
2648
2649/* Non-terminal <builtin-type>.
2650
2651 <builtin-type> ::= v # void
2652 ::= b # bool
2653 ::= w # wchar_t
2654 ::= c # char
2655 ::= a # signed char
2656 ::= h # unsigned char
2657 ::= s # short
2658 ::= t # unsigned short
2659 ::= i # int
2660 ::= j # unsigned int
2661 ::= l # long
2662 ::= m # unsigned long
2663 ::= x # long long, __int64
2664 ::= y # unsigned long long, __int64
2665 ::= n # __int128
2666 ::= o # unsigned __int128
2667 ::= f # float
2668 ::= d # double
2669 ::= e # long double, __float80
2670 ::= g # __float128 [not supported]
2671 ::= u <source-name> # vendor extended type */
2672
2673static void
2674write_builtin_type (tree type)
2675{
2676 if (TYPE_CANONICAL (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2676, __FUNCTION__))->type_common.canonical))
2677 type = TYPE_CANONICAL (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2677, __FUNCTION__))->type_common.canonical);
2678
2679 switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
2680 {
2681 case VOID_TYPE:
2682 write_char ('v')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('v')))); });
2683 break;
2684
2685 case BOOLEAN_TYPE:
2686 write_char ('b')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('b')))); });
2687 break;
2688
2689 case INTEGER_TYPE:
2690 /* TYPE may still be wchar_t, char8_t, char16_t, or char32_t, since that
2691 isn't in integer_type_nodes. */
2692 if (type == wchar_type_nodec_global_trees[CTI_WCHAR_TYPE])
2693 write_char ('w')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('w')))); });
2694 else if (type == char8_type_nodec_global_trees[CTI_CHAR8_TYPE])
2695 write_string ("Du")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Du")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Du"), __len); __o->next_free += __len
; (void) 0; });
2696 else if (type == char16_type_nodec_global_trees[CTI_CHAR16_TYPE])
2697 write_string ("Ds")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Ds")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Ds"), __len); __o->next_free += __len
; (void) 0; });
2698 else if (type == char32_type_nodec_global_trees[CTI_CHAR32_TYPE])
2699 write_string ("Di")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Di")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Di"), __len); __o->next_free += __len
; (void) 0; });
2700 else
2701 {
2702 size_t itk;
2703 /* Assume TYPE is one of the shared integer type nodes. Find
2704 it in the array of these nodes. */
2705 iagain:
2706 for (itk = 0; itk < itk_none; ++itk)
2707 if (integer_types[itk] != NULL_TREE(tree) nullptr
2708 && integer_type_codes[itk] != '\0'
2709 && type == integer_types[itk])
2710 {
2711 /* Print the corresponding single-letter code. */
2712 write_char (integer_type_codes[itk])__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ((integer_type_codes
[itk])))); });
2713 break;
2714 }
2715
2716 if (itk == itk_none)
2717 {
2718 tree t = c_common_type_for_mode (TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2718, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode),
2719 TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2719, __FUNCTION__))->base.u.bits.unsigned_flag));
2720 if (type != t)
2721 {
2722 type = t;
2723 goto iagain;
2724 }
2725
2726 if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2726, __FUNCTION__))->type_common.precision) == 128)
2727 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = ((((tree_class_check
((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2727, __FUNCTION__))->base.u.bits.unsigned_flag) ? 'o' :
'n')))); });
2728 else
2729 {
2730 /* Allow for cases where TYPE is not one of the shared
2731 integer type nodes and write a "vendor extended builtin
2732 type" with a name the form intN or uintN, respectively.
2733 Situations like this can happen if you have an
2734 __attribute__((__mode__(__SI__))) type and use exotic
2735 switches like '-mint8' on AVR. Of course, this is
2736 undefined by the C++ ABI (and '-mint8' is not even
2737 Standard C conforming), but when using such special
2738 options you're pretty much in nowhere land anyway. */
2739 const char *prefix;
2740 char prec[11]; /* up to ten digits for an unsigned */
2741
2742 prefix = TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2742, __FUNCTION__))->base.u.bits.unsigned_flag) ? "uint" : "int";
2743 sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2743, __FUNCTION__))->type_common.precision));
2744 write_char ('u')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('u')))); }); /* "vendor extended builtin type" */
2745 write_unsigned_number (strlen (prefix) + strlen (prec))write_number ((strlen (prefix) + strlen (prec)), 1, 10);
2746 write_string (prefix)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (prefix)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (prefix), __len); __o->next_free += __len
; (void) 0; });
2747 write_string (prec)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (prec)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (prec), __len); __o->next_free += __len
; (void) 0; });
2748 }
2749 }
2750 }
2751 break;
2752
2753 case REAL_TYPE:
2754 if (type == float_type_nodeglobal_trees[TI_FLOAT_TYPE])
2755 write_char ('f')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('f')))); });
2756 else if (type == double_type_nodeglobal_trees[TI_DOUBLE_TYPE])
2757 write_char ('d')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('d')))); });
2758 else if (type == long_double_type_nodeglobal_trees[TI_LONG_DOUBLE_TYPE])
2759 write_char ('e')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('e')))); });
2760 else if (type == dfloat32_type_nodeglobal_trees[TI_DFLOAT32_TYPE])
2761 write_string ("Df")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Df")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Df"), __len); __o->next_free += __len
; (void) 0; });
2762 else if (type == dfloat64_type_nodeglobal_trees[TI_DFLOAT64_TYPE])
2763 write_string ("Dd")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Dd")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Dd"), __len); __o->next_free += __len
; (void) 0; });
2764 else if (type == dfloat128_type_nodeglobal_trees[TI_DFLOAT128_TYPE])
2765 write_string ("De")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("De")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("De"), __len); __o->next_free += __len
; (void) 0; });
2766 else if (type == float16_type_nodeglobal_trees[TI_FLOAT16_TYPE])
2767 write_string ("DF16_")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("DF16_")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("DF16_"), __len); __o->next_free += __len
; (void) 0; });
2768 else if (type == float32_type_nodeglobal_trees[TI_FLOAT32_TYPE])
2769 write_string ("DF32_")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("DF32_")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("DF32_"), __len); __o->next_free += __len
; (void) 0; });
2770 else if (type == float64_type_nodeglobal_trees[TI_FLOAT64_TYPE])
2771 write_string ("DF64_")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("DF64_")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("DF64_"), __len); __o->next_free += __len
; (void) 0; });
2772 else if (type == float128_type_nodeglobal_trees[TI_FLOAT128_TYPE])
2773 write_string ("DF128_")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("DF128_")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("DF128_"), __len); __o->next_free +=
__len; (void) 0; });
2774 else if (type == float32x_type_nodeglobal_trees[TI_FLOAT32X_TYPE])
2775 write_string ("DF32x")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("DF32x")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("DF32x"), __len); __o->next_free += __len
; (void) 0; });
2776 else if (type == float64x_type_nodeglobal_trees[TI_FLOAT64X_TYPE])
2777 write_string ("DF64x")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("DF64x")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("DF64x"), __len); __o->next_free += __len
; (void) 0; });
2778 else if (type == float128x_type_nodeglobal_trees[TI_FLOAT128X_TYPE])
2779 write_string ("DF128x")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("DF128x")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("DF128x"), __len); __o->next_free +=
__len; (void) 0; });
2780 else if (type == bfloat16_type_nodeglobal_trees[TI_BFLOAT16_TYPE])
2781 write_string ("DF16b")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("DF16b")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("DF16b"), __len); __o->next_free += __len
; (void) 0; });
2782 else
2783 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2783, __FUNCTION__));
2784 break;
2785
2786 default:
2787 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2787, __FUNCTION__));
2788 }
2789}
2790
2791/* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or
2792 METHOD_TYPE. The return type is mangled before the parameter
2793 types.
2794
2795 <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E */
2796
2797static void
2798write_function_type (const tree type)
2799{
2800 MANGLE_TRACE_TREE ("function-type", type);
2801
2802 /* For a pointer to member function, the function type may have
2803 cv-qualifiers, indicating the quals for the artificial 'this'
2804 parameter. */
2805 if (TREE_CODE (type)((enum tree_code) (type)->base.code) == METHOD_TYPE)
2806 {
2807 /* The first parameter must be a POINTER_TYPE pointing to the
2808 `this' parameter. */
2809 tree this_type = class_of_this_parm (type);
2810 write_CV_qualifiers_for_type (this_type);
2811 }
2812
2813 write_exception_spec (TYPE_RAISES_EXCEPTIONS (type)((tree_class_check (((tree_check2 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2813, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2813, __FUNCTION__))->type_non_common.lang_1));
2814
2815 if (tx_safe_fn_type_p (type))
2816 write_string ("Dx")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("Dx")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("Dx"), __len); __o->next_free += __len
; (void) 0; });
2817
2818 write_char ('F')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('F')))); });
2819 /* We don't track whether or not a type is `extern "C"'. Note that
2820 you can have an `extern "C"' function that does not have
2821 `extern "C"' type, and vice versa:
2822
2823 extern "C" typedef void function_t();
2824 function_t f; // f has C++ linkage, but its type is
2825 // `extern "C"'
2826
2827 typedef void function_t();
2828 extern "C" function_t f; // Vice versa.
2829
2830 See [dcl.link]. */
2831 write_bare_function_type (type, /*include_return_type_p=*/1,
2832 /*decl=*/NULLnullptr);
2833 if (FUNCTION_REF_QUALIFIED (type)((tree_not_check2 (((tree_check2 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2833, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2833, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4))
2834 {
2835 if (FUNCTION_RVALUE_QUALIFIED (type)((tree_not_check2 (((tree_check2 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2835, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2835, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5))
2836 write_char ('O')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('O')))); });
2837 else
2838 write_char ('R')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('R')))); });
2839 }
2840 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
2841}
2842
2843/* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or
2844 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value
2845 is mangled before the parameter types. If non-NULL, DECL is
2846 FUNCTION_DECL for the function whose type is being emitted. */
2847
2848static void
2849write_bare_function_type (const tree type, const int include_return_type_p,
2850 const tree decl)
2851{
2852 MANGLE_TRACE_TREE ("bare-function-type", type);
2853
2854 /* Mangle the return type, if requested. */
2855 if (include_return_type_p)
2856 write_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2856, __FUNCTION__))->typed.type));
2857
2858 /* Now mangle the types of the arguments. */
2859 ++G.parm_depth;
2860 write_method_parms (TYPE_ARG_TYPES (type)((tree_check2 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2860, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values),
2861 TREE_CODE (type)((enum tree_code) (type)->base.code) == METHOD_TYPE,
2862 decl);
2863 --G.parm_depth;
2864}
2865
2866/* Write the mangled representation of a method parameter list of
2867 types given in PARM_TYPES. If METHOD_P is nonzero, the function is
2868 considered a non-static method, and the this parameter is omitted.
2869 If non-NULL, DECL is the FUNCTION_DECL for the function whose
2870 parameters are being emitted. */
2871
2872static void
2873write_method_parms (tree parm_types, const int method_p, const tree decl)
2874{
2875 tree first_parm_type;
2876 tree parm_decl = decl ? DECL_ARGUMENTS (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2876, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
) : NULL_TREE(tree) nullptr;
2877
2878 /* Assume this parameter type list is variable-length. If it ends
2879 with a void type, then it's not. */
2880 int varargs_p = 1;
2881
2882 /* If this is a member function, skip the first arg, which is the
2883 this pointer.
2884 "Member functions do not encode the type of their implicit this
2885 parameter."
2886
2887 Similarly, there's no need to mangle artificial parameters, like
2888 the VTT parameters for constructors and destructors. */
2889 if (method_p)
2890 {
2891 parm_types = TREE_CHAIN (parm_types)((contains_struct_check ((parm_types), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2891, __FUNCTION__))->common.chain);
2892 parm_decl = parm_decl ? DECL_CHAIN (parm_decl)(((contains_struct_check (((contains_struct_check ((parm_decl
), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2892, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2892, __FUNCTION__))->common.chain)) : NULL_TREE(tree) nullptr;
2893
2894 while (parm_decl && DECL_ARTIFICIAL (parm_decl)((contains_struct_check ((parm_decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2894, __FUNCTION__))->decl_common.artificial_flag))
2895 {
2896 parm_types = TREE_CHAIN (parm_types)((contains_struct_check ((parm_types), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2896, __FUNCTION__))->common.chain);
2897 parm_decl = DECL_CHAIN (parm_decl)(((contains_struct_check (((contains_struct_check ((parm_decl
), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2897, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2897, __FUNCTION__))->common.chain));
2898 }
2899
2900 if (decl && ctor_omit_inherited_parms (decl))
2901 /* Bring back parameters omitted from an inherited ctor. */
2902 parm_types = FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (decl))skip_artificial_parms_for (((((contains_struct_check ((decl),
(TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2902, __FUNCTION__))->decl_common.abstract_origin) ? ((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2902, __FUNCTION__))->decl_common.abstract_origin) : (decl
))), ((tree_check2 ((((contains_struct_check (((((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2902, __FUNCTION__))->decl_common.abstract_origin) ? ((contains_struct_check
((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2902, __FUNCTION__))->decl_common.abstract_origin) : (decl
))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2902, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2902, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values));
2903 }
2904
2905 for (first_parm_type = parm_types;
2906 parm_types;
2907 parm_types = TREE_CHAIN (parm_types)((contains_struct_check ((parm_types), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2907, __FUNCTION__))->common.chain))
2908 {
2909 tree parm = TREE_VALUE (parm_types)((tree_check ((parm_types), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2909, __FUNCTION__, (TREE_LIST)))->list.value);
2910 if (parm == void_type_nodeglobal_trees[TI_VOID_TYPE])
2911 {
2912 /* "Empty parameter lists, whether declared as () or
2913 conventionally as (void), are encoded with a void parameter
2914 (v)." */
2915 if (parm_types == first_parm_type)
2916 write_type (parm);
2917 /* If the parm list is terminated with a void type, it's
2918 fixed-length. */
2919 varargs_p = 0;
2920 /* A void type better be the last one. */
2921 gcc_assert (TREE_CHAIN (parm_types) == NULL)((void)(!(((contains_struct_check ((parm_types), (TS_COMMON),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2921, __FUNCTION__))->common.chain) == nullptr) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2921, __FUNCTION__), 0 : 0));
2922 }
2923 else
2924 write_type (parm);
2925 }
2926
2927 if (varargs_p)
2928 /* <builtin-type> ::= z # ellipsis */
2929 write_char ('z')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('z')))); });
2930}
2931
2932/* <class-enum-type> ::= <name> */
2933
2934static void
2935write_class_enum_type (const tree type)
2936{
2937 write_name (TYPE_NAME (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2937, __FUNCTION__))->type_common.name), /*ignore_local_scope=*/0);
2938}
2939
2940/* Non-terminal <template-args>. ARGS is a TREE_VEC of template
2941 arguments.
2942
2943 <template-args> ::= I <template-arg>* E */
2944
2945static void
2946write_template_args (tree args)
2947{
2948 int i;
2949 int length = 0;
2950
2951 MANGLE_TRACE_TREE ("template-args", args);
2952
2953 write_char ('I')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('I')))); });
2954
2955 if (args)
2956 length = TREE_VEC_LENGTH (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2956, __FUNCTION__, (TREE_VEC)))->base.u.length);
2957
2958 if (args && length && TREE_CODE (TREE_VEC_ELT (args, 0))((enum tree_code) ((*((const_cast<tree *> (tree_vec_elt_check
((args), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2958, __FUNCTION__))))))->base.code) == TREE_VEC)
2959 {
2960 /* We have nested template args. We want the innermost template
2961 argument list. */
2962 args = TREE_VEC_ELT (args, length - 1)(*((const_cast<tree *> (tree_vec_elt_check ((args), (length
- 1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2962, __FUNCTION__)))));
2963 length = TREE_VEC_LENGTH (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2963, __FUNCTION__, (TREE_VEC)))->base.u.length);
2964 }
2965 for (i = 0; i < length; ++i)
2966 write_template_arg (TREE_VEC_ELT (args, i)(*((const_cast<tree *> (tree_vec_elt_check ((args), (i)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2966, __FUNCTION__))))));
2967
2968 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
2969}
2970
2971/* Write out the
2972 <unqualified-name>
2973 <unqualified-name> <template-args>
2974 part of SCOPE_REF or COMPONENT_REF mangling. */
2975
2976static void
2977write_member_name (tree member)
2978{
2979 if (identifier_p (member))
2980 {
2981 if (IDENTIFIER_ANY_OP_P (member)(((tree_not_check2 (((tree_check ((member), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2981, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2981, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)))
2982 {
2983 if (abi_version_at_least (11)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)))
2984 write_string ("on")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("on")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("on"), __len); __o->next_free += __len
; (void) 0; });
2985 if (abi_warn_or_compat_version_crosses (11)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)) != (warn_abi_version == 0 || warn_abi_version >=
(11))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (11)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (11))
)))
2986 G.need_abi_warning = 1;
2987 }
2988 write_unqualified_id (member);
2989 }
2990 else if (DECL_P (member)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (member)->base.code))] == tcc_declaration))
2991 {
2992 gcc_assert (!DECL_OVERLOADED_OPERATOR_P (member))((void)(!(!(((tree_not_check2 (((tree_check ((((contains_struct_check
((member), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2992, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2992, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2992, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2992, __FUNCTION__), 0 : 0));
2993 write_unqualified_name (member);
2994 }
2995 else if (TREE_CODE (member)((enum tree_code) (member)->base.code) == TEMPLATE_ID_EXPR)
2996 {
2997 tree name = TREE_OPERAND (member, 0)(*((const_cast<tree*> (tree_operand_check ((member), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 2997, __FUNCTION__)))));
2998 name = OVL_FIRST (name)ovl_first (name);
2999 write_member_name (name);
3000 write_template_args (TREE_OPERAND (member, 1)(*((const_cast<tree*> (tree_operand_check ((member), (1
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3000, __FUNCTION__))))));
3001 }
3002 else
3003 write_expression (member);
3004}
3005
3006/* EXPR is a base COMPONENT_REF; write the minimized base conversion path for
3007 converting to BASE, or just the conversion of EXPR if BASE is null.
3008
3009 "Given a fully explicit base path P := C_n -> ... -> C_0, the minimized base
3010 path Min(P) is defined as follows: let C_i be the last element for which the
3011 conversion to C_0 is unambiguous; if that element is C_n, the minimized path
3012 is C_n -> C_0; otherwise, the minimized path is Min(C_n -> ... -> C_i) ->
3013 C_0."
3014
3015 We mangle the conversion to C_i if it's different from C_n. */
3016
3017static bool
3018write_base_ref (tree expr, tree base = NULL_TREE(tree) nullptr)
3019{
3020 if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) != COMPONENT_REF)
3021 return false;
3022
3023 tree field = TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3023, __FUNCTION__)))));
3024
3025 if (TREE_CODE (field)((enum tree_code) (field)->base.code) != FIELD_DECL || !DECL_FIELD_IS_BASE (field)((contains_struct_check (((tree_check ((field), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3025, __FUNCTION__, (FIELD_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3025, __FUNCTION__))->decl_common.lang_flag_6))
3026 return false;
3027
3028 tree object = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3028, __FUNCTION__)))));
3029
3030 tree binfo = NULL_TREE(tree) nullptr;
3031 if (base)
3032 {
3033 tree cur = TREE_TYPE (object)((contains_struct_check ((object), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3033, __FUNCTION__))->typed.type);
3034 binfo = lookup_base (cur, base, ba_unique, NULLnullptr, tf_none);
3035 }
3036 else
3037 /* We're at the end of the base conversion chain, so it can't be
3038 ambiguous. */
3039 base = TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3039, __FUNCTION__))->typed.type);
3040
3041 if (binfo == error_mark_nodeglobal_trees[TI_ERROR_MARK])
3042 {
3043 /* cur->base is ambiguous, so make the conversion to
3044 last explicit, expressed as a cast (last&)object. */
3045 tree last = TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3045, __FUNCTION__))->typed.type);
3046 write_string (OVL_OP_INFO (false, CAST_EXPR)->mangled_name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ((&ovl_op_info[(false) != 0][ovl_op_mapping
[(CAST_EXPR)]])->mangled_name)); if (__extension__ ({ struct
obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
__o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); memcpy (__o->next_free, ((&ovl_op_info[(false) != 0
][ovl_op_mapping[(CAST_EXPR)]])->mangled_name), __len); __o
->next_free += __len; (void) 0; });
3047 write_type (build_reference_type (last));
3048 write_expression (object);
3049 }
3050 else if (write_base_ref (object, base))
3051 /* cur->base is unambiguous, but we had another base conversion
3052 underneath and wrote it out. */;
3053 else
3054 /* No more base conversions, just write out the object. */
3055 write_expression (object);
3056
3057 return true;
3058}
3059
3060/* The number of elements spanned by a RANGE_EXPR. */
3061
3062unsigned HOST_WIDE_INTlong
3063range_expr_nelts (tree expr)
3064{
3065 tree lo = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3065, __FUNCTION__)))));
3066 tree hi = TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3066, __FUNCTION__)))));
3067 return tree_to_uhwi (hi) - tree_to_uhwi (lo) + 1;
3068}
3069
3070/* <expression> ::= <unary operator-name> <expression>
3071 ::= <binary operator-name> <expression> <expression>
3072 ::= <expr-primary>
3073
3074 <expr-primary> ::= <template-param>
3075 ::= L <type> <value number> E # literal
3076 ::= L <mangled-name> E # external name
3077 ::= st <type> # sizeof
3078 ::= sr <type> <unqualified-name> # dependent name
3079 ::= sr <type> <unqualified-name> <template-args> */
3080
3081static void
3082write_expression (tree expr)
3083{
3084 enum tree_code code = TREE_CODE (expr)((enum tree_code) (expr)->base.code);
3085
3086 if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == TARGET_EXPR)
3087 {
3088 expr = TARGET_EXPR_INITIAL (expr)(*(tree_operand_check_code ((expr), (TARGET_EXPR), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3088, __FUNCTION__)));
3089 code = TREE_CODE (expr)((enum tree_code) (expr)->base.code);
3090 }
3091
3092 /* Skip NOP_EXPR and CONVERT_EXPR. They can occur when (say) a pointer
3093 argument is converted (via qualification conversions) to another type. */
3094 while (CONVERT_EXPR_CODE_P (code)((code) == NOP_EXPR || (code) == CONVERT_EXPR)
3095 || code == IMPLICIT_CONV_EXPR
3096 || location_wrapper_p (expr)
3097 /* Parentheses aren't mangled. */
3098 || code == PAREN_EXPR
3099 || code == NON_LVALUE_EXPR
3100 || (code == VIEW_CONVERT_EXPR
3101 && TREE_CODE (TREE_OPERAND (expr, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3101, __FUNCTION__))))))->base.code) == TEMPLATE_PARM_INDEX))
3102 {
3103 expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3103, __FUNCTION__)))));
3104 code = TREE_CODE (expr)((enum tree_code) (expr)->base.code);
3105 }
3106
3107 if (code == BASELINK
3108 && (!type_unknown_p (expr)
3109 || !BASELINK_QUALIFIED_P (expr)((tree_not_check2 (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3109, __FUNCTION__, (BASELINK)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3109, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))
3110 {
3111 expr = BASELINK_FUNCTIONS (expr)(((struct tree_baselink*) (tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3111, __FUNCTION__, (BASELINK))))->functions);
3112 code = TREE_CODE (expr)((enum tree_code) (expr)->base.code);
3113 }
3114
3115 /* Handle pointers-to-members by making them look like expression
3116 nodes. */
3117 if (code == PTRMEM_CST)
3118 {
3119 expr = build_nt (ADDR_EXPR,
3120 build_qualified_name (/*type=*/NULL_TREE(tree) nullptr,
3121 PTRMEM_CST_CLASS (expr)((((enum tree_code) (((contains_struct_check (((tree_check ((
expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__))->typed.type))->base.code) == OFFSET_TYPE
) ? ((tree_check ((((contains_struct_check (((tree_check ((expr
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__, (OFFSET_TYPE)))->type_non_common.maxval
) : ((tree_check2 ((((contains_struct_check (((cp_build_qualified_type
(((contains_struct_check ((((tree_check3 ((((contains_struct_check
(((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__))->typed.type), cp_type_quals (((contains_struct_check
(((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__))->typed.type))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3121, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.maxval)),
3122 PTRMEM_CST_MEMBER (expr)(((ptrmem_cst_t)(tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3122, __FUNCTION__, (PTRMEM_CST))))->member),
3123 /*template_p=*/false));
3124 code = TREE_CODE (expr)((enum tree_code) (expr)->base.code);
3125 }
3126
3127 /* Handle template parameters. */
3128 if (code == TEMPLATE_TYPE_PARM
3129 || code == TEMPLATE_TEMPLATE_PARM
3130 || code == BOUND_TEMPLATE_TEMPLATE_PARM
3131 || code == TEMPLATE_PARM_INDEX)
3132 write_template_param (expr);
3133 /* Handle literals. */
3134 else if (TREE_CODE_CLASS (code)tree_code_type_tmpl <0>::tree_code_type[(int) (code)] == tcc_constant
3135 || code == CONST_DECL)
3136 write_template_arg_literal (expr);
3137 else if (code == EXCESS_PRECISION_EXPR
3138 && TREE_CODE (TREE_OPERAND (expr, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3138, __FUNCTION__))))))->base.code) == REAL_CST)
3139 write_template_arg_literal (fold_convert (TREE_TYPE (expr),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3139, __FUNCTION__))->typed.type), (*((const_cast<tree
*> (tree_operand_check ((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3140, __FUNCTION__))))))
3140 TREE_OPERAND (expr, 0))fold_convert_loc (((location_t) 0), ((contains_struct_check (
(expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3139, __FUNCTION__))->typed.type), (*((const_cast<tree
*> (tree_operand_check ((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3140, __FUNCTION__)))))));
3141 else if (code == PARM_DECL && DECL_ARTIFICIAL (expr)((contains_struct_check ((expr), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3141, __FUNCTION__))->decl_common.artificial_flag))
3142 {
3143 gcc_assert (id_equal (DECL_NAME (expr), "this"))((void)(!(id_equal (((contains_struct_check ((expr), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3143, __FUNCTION__))->decl_minimal.name), "this")) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3143, __FUNCTION__), 0 : 0));
3144 write_string ("fpT")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("fpT")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("fpT"), __len); __o->next_free += __len
; (void) 0; });
3145 }
3146 else if (code == PARM_DECL)
3147 {
3148 /* A function parameter used in a late-specified return type. */
3149 int index = DECL_PARM_INDEX (expr)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
((expr), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3149, __FUNCTION__))->decl_common.lang_specific); if (((
enum tree_code) (expr)->base.code) != PARM_DECL || lt->
u.base.selector != lds_parm) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3149, __FUNCTION__); &lt->u.parm; })->index);
3150 int level = DECL_PARM_LEVEL (expr)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
((expr), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3150, __FUNCTION__))->decl_common.lang_specific); if (((
enum tree_code) (expr)->base.code) != PARM_DECL || lt->
u.base.selector != lds_parm) lang_check_failed ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3150, __FUNCTION__); &lt->u.parm; })->level);
3151 int delta = G.parm_depth - level + 1;
3152 gcc_assert (index >= 1)((void)(!(index >= 1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3152, __FUNCTION__), 0 : 0));
3153 write_char ('f')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('f')))); });
3154 if (delta != 0)
3155 {
3156 if (abi_version_at_least (5)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (5)))
3157 {
3158 /* Let L be the number of function prototype scopes from the
3159 innermost one (in which the parameter reference occurs) up
3160 to (and including) the one containing the declaration of
3161 the referenced parameter. If the parameter declaration
3162 clause of the innermost function prototype scope has been
3163 completely seen, it is not counted (in that case -- which
3164 is perhaps the most common -- L can be zero). */
3165 write_char ('L')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('L')))); });
3166 write_unsigned_number (delta - 1)write_number ((delta - 1), 1, 10);
3167 }
3168 if (abi_warn_or_compat_version_crosses (5)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (5)) != (warn_abi_version == 0 || warn_abi_version >=
(5))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (5)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (5)))
))
3169 G.need_abi_warning = true;
3170 }
3171 write_char ('p')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('p')))); });
3172 write_compact_number (index - 1);
3173 }
3174 else if (DECL_P (expr)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (expr)->base.code))] == tcc_declaration))
3175 {
3176 write_char ('L')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('L')))); });
3177 write_mangled_name (expr, false);
3178 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3179 }
3180 else if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == SIZEOF_EXPR)
3181 {
3182 tree op = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3182, __FUNCTION__)))));
3183
3184 if (PACK_EXPANSION_P (op)(((enum tree_code) (op)->base.code) == TYPE_PACK_EXPANSION
|| ((enum tree_code) (op)->base.code) == EXPR_PACK_EXPANSION
))
3185 {
3186 if (abi_warn_or_compat_version_crosses (11)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)) != (warn_abi_version == 0 || warn_abi_version >=
(11))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (11)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (11))
)))
3187 G.need_abi_warning = true;
3188 if (abi_version_at_least (11)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (11)))
3189 {
3190 /* sZ rather than szDp. */
3191 write_string ("sZ")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("sZ")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("sZ"), __len); __o->next_free += __len
; (void) 0; });
3192 write_expression (PACK_EXPANSION_PATTERN (op)(((enum tree_code) ((tree_check2 ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3192, __FUNCTION__, (TYPE_PACK_EXPANSION), (EXPR_PACK_EXPANSION
))))->base.code) == TYPE_PACK_EXPANSION ? ((contains_struct_check
((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3192, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((op), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3192, __FUNCTION__)))))));
3193 return;
3194 }
3195 }
3196
3197 if (SIZEOF_EXPR_TYPE_P (expr)((tree_not_check2 (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3197, __FUNCTION__, (SIZEOF_EXPR)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3197, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
3198 {
3199 write_string ("st")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("st")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("st"), __len); __o->next_free += __len
; (void) 0; });
3200 write_type (TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3200, __FUNCTION__))->typed.type));
3201 }
3202 else if (ARGUMENT_PACK_P (op)(((enum tree_code) (op)->base.code) == TYPE_ARGUMENT_PACK ||
((enum tree_code) (op)->base.code) == NONTYPE_ARGUMENT_PACK
))
3203 {
3204 tree args = ARGUMENT_PACK_ARGS (op)(((enum tree_code) ((tree_check2 ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3204, __FUNCTION__, (TYPE_ARGUMENT_PACK), (NONTYPE_ARGUMENT_PACK
))))->base.code) == TYPE_ARGUMENT_PACK ? ((contains_struct_check
((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3204, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((op), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3204, __FUNCTION__))))));
3205 int length = TREE_VEC_LENGTH (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3205, __FUNCTION__, (TREE_VEC)))->base.u.length);
3206 if (abi_warn_or_compat_version_crosses (10)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (10)) != (warn_abi_version == 0 || warn_abi_version >=
(10))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (10)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (10))
)))
3207 G.need_abi_warning = true;
3208 if (abi_version_at_least (10)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (10)))
3209 {
3210 /* sP <template-arg>* E # sizeof...(T), size of a captured
3211 template parameter pack from an alias template */
3212 write_string ("sP")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("sP")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("sP"), __len); __o->next_free += __len
; (void) 0; });
3213 for (int i = 0; i < length; ++i)
3214 write_template_arg (TREE_VEC_ELT (args, i)(*((const_cast<tree *> (tree_vec_elt_check ((args), (i)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3214, __FUNCTION__))))));
3215 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3216 }
3217 else
3218 {
3219 /* In GCC 5 we represented this sizeof wrong, with the effect
3220 that we mangled it as the last element of the pack. */
3221 tree arg = TREE_VEC_ELT (args, length-1)(*((const_cast<tree *> (tree_vec_elt_check ((args), (length
-1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3221, __FUNCTION__)))));
3222 if (TYPE_P (op)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (op)->base.code))] == tcc_type))
3223 {
3224 write_string ("st")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("st")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("st"), __len); __o->next_free += __len
; (void) 0; });
3225 write_type (arg);
3226 }
3227 else
3228 {
3229 write_string ("sz")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("sz")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("sz"), __len); __o->next_free += __len
; (void) 0; });
3230 write_expression (arg);
3231 }
3232 }
3233 }
3234 else if (TYPE_P (TREE_OPERAND (expr, 0))(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) ((*((const_cast<tree*> (tree_operand_check ((expr), (
0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3234, __FUNCTION__))))))->base.code))] == tcc_type))
3235 {
3236 write_string ("st")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("st")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("st"), __len); __o->next_free += __len
; (void) 0; });
3237 write_type (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3237, __FUNCTION__))))));
3238 }
3239 else
3240 goto normal_expr;
3241 }
3242 else if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == ALIGNOF_EXPR)
3243 {
3244 if (!ALIGNOF_EXPR_STD_P (expr)((tree_not_check2 (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3244, __FUNCTION__, (ALIGNOF_EXPR)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3244, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
3245 {
3246 if (abi_warn_or_compat_version_crosses (16)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (16)) != (warn_abi_version == 0 || warn_abi_version >=
(16))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (16)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (16))
)))
3247 G.need_abi_warning = true;
3248 if (abi_version_at_least (16)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (16)))
3249 {
3250 /* We used to mangle __alignof__ like alignof. */
3251 write_string ("u11__alignof__")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("u11__alignof__")); if (__extension__ ({ struct
obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit -
__o1->next_free); }) < __len) _obstack_newchunk (__o, __len
); memcpy (__o->next_free, ("u11__alignof__"), __len); __o
->next_free += __len; (void) 0; });
3252 write_template_arg (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3252, __FUNCTION__))))));
3253 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3254 return;
3255 }
3256 }
3257 if (TYPE_P (TREE_OPERAND (expr, 0))(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) ((*((const_cast<tree*> (tree_operand_check ((expr), (
0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3257, __FUNCTION__))))))->base.code))] == tcc_type))
3258 {
3259 write_string ("at")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("at")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("at"), __len); __o->next_free += __len
; (void) 0; });
3260 write_type (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3260, __FUNCTION__))))));
3261 }
3262 else
3263 goto normal_expr;
3264 }
3265 else if (code == SCOPE_REF
3266 || code == BASELINK)
3267 {
3268 tree scope, member;
3269 if (code == SCOPE_REF)
3270 {
3271 scope = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3271, __FUNCTION__)))));
3272 member = TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3272, __FUNCTION__)))));
3273 if (BASELINK_P (member)(((enum tree_code) (member)->base.code) == BASELINK))
3274 member = BASELINK_FUNCTIONS (member)(((struct tree_baselink*) (tree_check ((member), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3274, __FUNCTION__, (BASELINK))))->functions);
3275 }
3276 else
3277 {
3278 scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr))((contains_struct_check (((tree_check (((((struct tree_baselink
*) (tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3278, __FUNCTION__, (BASELINK))))->access_binfo)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3278, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3278, __FUNCTION__))->typed.type);
3279 member = BASELINK_FUNCTIONS (expr)(((struct tree_baselink*) (tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3279, __FUNCTION__, (BASELINK))))->functions);
3280 }
3281
3282 /* If the MEMBER is a real declaration, then the qualifying
3283 scope was not dependent. Ideally, we would not have a
3284 SCOPE_REF in those cases, but sometimes we do. If the second
3285 argument is a DECL, then the name must not have been
3286 dependent. */
3287 if (DECL_P (member)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (member)->base.code))] == tcc_declaration))
3288 write_expression (member);
3289 else
3290 {
3291 gcc_assert (code != BASELINK || BASELINK_QUALIFIED_P (expr))((void)(!(code != BASELINK || ((tree_not_check2 (((tree_check
((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3291, __FUNCTION__, (BASELINK)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3291, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3291, __FUNCTION__), 0 : 0));
3292 write_string ("sr")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("sr")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("sr"), __len); __o->next_free += __len
; (void) 0; });
3293 write_type (scope);
3294 write_member_name (member);
3295 }
3296 }
3297 else if (INDIRECT_REF_P (expr)(((enum tree_code) (expr)->base.code) == INDIRECT_REF)
3298 && TREE_TYPE (TREE_OPERAND (expr, 0))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3298, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3298, __FUNCTION__))->typed.type)
3299 && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0)))(((enum tree_code) (((contains_struct_check (((*((const_cast<
tree*> (tree_operand_check ((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3299, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3299, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
3300 {
3301 write_expression (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3301, __FUNCTION__))))));
3302 }
3303 else if (identifier_p (expr))
3304 {
3305 /* An operator name appearing as a dependent name needs to be
3306 specially marked to disambiguate between a use of the operator
3307 name and a use of the operator in an expression. */
3308 if (IDENTIFIER_ANY_OP_P (expr)(((tree_not_check2 (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3308, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3308, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)))
3309 write_string ("on")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("on")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("on"), __len); __o->next_free += __len
; (void) 0; });
3310 write_unqualified_id (expr);
3311 }
3312 else if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == TEMPLATE_ID_EXPR)
3313 {
3314 tree fn = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3314, __FUNCTION__)))));
3315 fn = OVL_NAME (fn)((contains_struct_check ((ovl_first (fn)), (TS_DECL_MINIMAL),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3315, __FUNCTION__))->decl_minimal.name);
3316 if (IDENTIFIER_ANY_OP_P (fn)(((tree_not_check2 (((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3316, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3316, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)))
3317 write_string ("on")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("on")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("on"), __len); __o->next_free += __len
; (void) 0; });
3318 write_unqualified_id (fn);
3319 write_template_args (TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3319, __FUNCTION__))))));
3320 }
3321 else if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == MODOP_EXPR)
3322 {
3323 enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3323, __FUNCTION__))))))->base.code);
3324 const char *name = OVL_OP_INFO (true, subop)(&ovl_op_info[(true) != 0][ovl_op_mapping[(subop)]])->mangled_name;
3325
3326 write_string (name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (name)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (name), __len); __o->next_free += __len
; (void) 0; });
3327 write_expression (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3327, __FUNCTION__))))));
3328 write_expression (TREE_OPERAND (expr, 2)(*((const_cast<tree*> (tree_operand_check ((expr), (2),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3328, __FUNCTION__))))));
3329 }
3330 else if (code == NEW_EXPR || code == VEC_NEW_EXPR)
3331 {
3332 /* ::= [gs] nw <expression>* _ <type> E
3333 ::= [gs] nw <expression>* _ <type> <initializer>
3334 ::= [gs] na <expression>* _ <type> E
3335 ::= [gs] na <expression>* _ <type> <initializer>
3336 <initializer> ::= pi <expression>* E */
3337 tree placement = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3337, __FUNCTION__)))));
3338 tree type = TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3338, __FUNCTION__)))));
3339 tree nelts = TREE_OPERAND (expr, 2)(*((const_cast<tree*> (tree_operand_check ((expr), (2),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3339, __FUNCTION__)))));
3340 tree init = TREE_OPERAND (expr, 3)(*((const_cast<tree*> (tree_operand_check ((expr), (3),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3340, __FUNCTION__)))));
3341 tree t;
3342
3343 gcc_assert (code == NEW_EXPR)((void)(!(code == NEW_EXPR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3343, __FUNCTION__), 0 : 0));
3344 if (TREE_OPERAND (expr, 2)(*((const_cast<tree*> (tree_operand_check ((expr), (2),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3344, __FUNCTION__))))))
3345 code = VEC_NEW_EXPR;
3346
3347 if (NEW_EXPR_USE_GLOBAL (expr)((tree_not_check2 (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3347, __FUNCTION__, (NEW_EXPR)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3347, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
3348 write_string ("gs")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("gs")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("gs"), __len); __o->next_free += __len
; (void) 0; });
3349
3350 write_string (OVL_OP_INFO (false, code)->mangled_name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ((&ovl_op_info[(false) != 0][ovl_op_mapping
[(code)]])->mangled_name)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ((&ovl_op_info[(false) != 0][ovl_op_mapping
[(code)]])->mangled_name), __len); __o->next_free += __len
; (void) 0; });
3351
3352 for (t = placement; t; t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3352, __FUNCTION__))->common.chain))
3353 write_expression (TREE_VALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3353, __FUNCTION__, (TREE_LIST)))->list.value));
3354
3355 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
3356
3357 if (nelts)
3358 {
3359 tree domain;
3360 ++processing_template_declscope_chain->x_processing_template_decl;
3361 domain = compute_array_index_type (NULL_TREE(tree) nullptr, nelts,
3362 tf_warning_or_error);
3363 type = build_cplus_array_type (type, domain);
3364 --processing_template_declscope_chain->x_processing_template_decl;
3365 }
3366 write_type (type);
3367
3368 if (init && TREE_CODE (init)((enum tree_code) (init)->base.code) == TREE_LIST
3369 && DIRECT_LIST_INIT_P (TREE_VALUE (init))((((enum tree_code) (((tree_check ((init), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3369, __FUNCTION__, (TREE_LIST)))->list.value))->base
.code) == CONSTRUCTOR && ((contains_struct_check ((((
tree_check ((init), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3369, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3369, __FUNCTION__))->typed.type) == cp_global_trees[CPTI_INIT_LIST_TYPE
]) && (((tree_not_check2 (((tree_check ((((tree_check
((init), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3369, __FUNCTION__, (TREE_LIST)))->list.value)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3369, __FUNCTION__, (CONSTRUCTOR)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3369, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))))
3370 write_expression (TREE_VALUE (init)((tree_check ((init), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3370, __FUNCTION__, (TREE_LIST)))->list.value));
3371 else
3372 {
3373 if (init)
3374 write_string ("pi")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("pi")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("pi"), __len); __o->next_free += __len
; (void) 0; });
3375 if (init && init != void_nodeglobal_trees[TI_VOID])
3376 for (t = init; t; t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3376, __FUNCTION__))->common.chain))
3377 write_expression (TREE_VALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3377, __FUNCTION__, (TREE_LIST)))->list.value));
3378 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3379 }
3380 }
3381 else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR)
3382 {
3383 gcc_assert (code == DELETE_EXPR)((void)(!(code == DELETE_EXPR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3383, __FUNCTION__), 0 : 0));
3384 if (DELETE_EXPR_USE_VEC (expr)((tree_not_check2 (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3384, __FUNCTION__, (DELETE_EXPR)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3384, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1))
3385 code = VEC_DELETE_EXPR;
3386
3387 if (DELETE_EXPR_USE_GLOBAL (expr)((tree_not_check2 (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3387, __FUNCTION__, (DELETE_EXPR)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3387, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
3388 write_string ("gs")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("gs")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("gs"), __len); __o->next_free += __len
; (void) 0; });
3389
3390 write_string (OVL_OP_INFO (false, code)->mangled_name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ((&ovl_op_info[(false) != 0][ovl_op_mapping
[(code)]])->mangled_name)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ((&ovl_op_info[(false) != 0][ovl_op_mapping
[(code)]])->mangled_name), __len); __o->next_free += __len
; (void) 0; });
3391
3392 write_expression (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3392, __FUNCTION__))))));
3393 }
3394 else if (code == THROW_EXPR)
3395 {
3396 tree op = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3396, __FUNCTION__)))));
3397 if (op)
3398 {
3399 write_string ("tw")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("tw")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("tw"), __len); __o->next_free += __len
; (void) 0; });
3400 write_expression (op);
3401 }
3402 else
3403 write_string ("tr")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("tr")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("tr"), __len); __o->next_free += __len
; (void) 0; });
3404 }
3405 else if (code == CONSTRUCTOR)
3406 {
3407 bool braced_init = BRACE_ENCLOSED_INITIALIZER_P (expr)(((enum tree_code) (expr)->base.code) == CONSTRUCTOR &&
((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3407, __FUNCTION__))->typed.type) == cp_global_trees[CPTI_INIT_LIST_TYPE
]);
3408 tree etype = TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3408, __FUNCTION__))->typed.type);
3409
3410 if (braced_init)
3411 write_string ("il")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("il")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("il"), __len); __o->next_free += __len
; (void) 0; });
3412 else
3413 {
3414 write_string ("tl")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("tl")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("tl"), __len); __o->next_free += __len
; (void) 0; });
3415 write_type (etype);
3416 }
3417
3418 /* If this is an undigested initializer, mangle it as written.
3419 COMPOUND_LITERAL_P doesn't actually distinguish between digested and
3420 undigested braced casts, but it should work to use it to distinguish
3421 between braced casts in a template signature (undigested) and template
3422 parm object values (digested), and all CONSTRUCTORS that get here
3423 should be one of those two cases. */
3424 bool undigested = braced_init || COMPOUND_LITERAL_P (expr)(((enum tree_code) (expr)->base.code) == CONSTRUCTOR &&
(((tree_not_check2 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3424, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)));
3425 if (undigested || !zero_init_expr_p (expr))
3426 {
3427 /* Convert braced initializer lists to STRING_CSTs so that
3428 A<"Foo"> mangles the same as A<{'F', 'o', 'o', 0}> while
3429 still using the latter mangling for strings that
3430 originated as braced initializer lists. */
3431 expr = braced_lists_to_strings (etype, expr);
3432
3433 if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == CONSTRUCTOR)
3434 {
3435 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (expr)((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3435, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts);
3436 unsigned last_nonzero = UINT_MAX(2147483647 *2U +1U);
3437 constructor_elt *ce;
3438
3439 if (!undigested)
3440 for (HOST_WIDE_INTlong i = 0; vec_safe_iterate (elts, i, &ce); ++i)
3441 if ((TREE_CODE (etype)((enum tree_code) (etype)->base.code) == UNION_TYPE
3442 && ce->index != first_field (etype))
3443 || !zero_init_expr_p (ce->value))
3444 last_nonzero = i;
3445
3446 if (undigested || last_nonzero != UINT_MAX(2147483647 *2U +1U))
3447 for (HOST_WIDE_INTlong i = 0; vec_safe_iterate (elts, i, &ce); ++i)
3448 {
3449 if (i > last_nonzero)
3450 break;
3451 if (!undigested && TREE_CODE (etype)((enum tree_code) (etype)->base.code) == UNION_TYPE)
3452 {
3453 /* Express the active member as a designator. */
3454 write_string ("di")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("di")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("di"), __len); __o->next_free += __len
; (void) 0; });
3455 write_unqualified_name (ce->index);
3456 }
3457 unsigned reps = 1;
3458 if (ce->index && TREE_CODE (ce->index)((enum tree_code) (ce->index)->base.code) == RANGE_EXPR)
3459 reps = range_expr_nelts (ce->index);
3460 for (unsigned j = 0; j < reps; ++j)
3461 write_expression (ce->value);
3462 }
3463 }
3464 else
3465 {
3466 gcc_assert (TREE_CODE (expr) == STRING_CST)((void)(!(((enum tree_code) (expr)->base.code) == STRING_CST
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3466, __FUNCTION__), 0 : 0));
3467 write_expression (expr);
3468 }
3469 }
3470 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3471 }
3472 else if (code == LAMBDA_EXPR)
3473 {
3474 /* [temp.over.link] Two lambda-expressions are never considered
3475 equivalent.
3476
3477 So just use the closure type mangling. */
3478 write_string ("tl")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("tl")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("tl"), __len); __o->next_free += __len
; (void) 0; });
3479 write_type (LAMBDA_EXPR_CLOSURE (expr)(((contains_struct_check (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3479, __FUNCTION__, (LAMBDA_EXPR)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3479, __FUNCTION__))->typed.type)));
3480 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3481 }
3482 else if (dependent_name (expr))
3483 {
3484 tree name = dependent_name (expr);
3485 if (IDENTIFIER_ANY_OP_P (name)(((tree_not_check2 (((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3485, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3485, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)))
3486 {
3487 if (abi_version_at_least (16)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (16)))
3488 write_string ("on")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("on")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("on"), __len); __o->next_free += __len
; (void) 0; });
3489 if (abi_warn_or_compat_version_crosses (16)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (16)) != (warn_abi_version == 0 || warn_abi_version >=
(16))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (16)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (16))
)))
3490 G.need_abi_warning = 1;
3491 }
3492 write_unqualified_id (name);
3493 }
3494 else
3495 {
3496 normal_expr:
3497 int i, len;
3498 const char *name;
3499
3500 /* When we bind a variable or function to a non-type template
3501 argument with reference type, we create an ADDR_EXPR to show
3502 the fact that the entity's address has been taken. But, we
3503 don't actually want to output a mangling code for the `&'. */
3504 if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == ADDR_EXPR
3505 && TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3505, __FUNCTION__))->typed.type)
3506 && TYPE_REF_P (TREE_TYPE (expr))(((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3506, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
3507 {
3508 expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3508, __FUNCTION__)))));
3509 if (DECL_P (expr)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (expr)->base.code))] == tcc_declaration))
3510 {
3511 write_expression (expr);
3512 return;
3513 }
3514
3515 code = TREE_CODE (expr)((enum tree_code) (expr)->base.code);
3516 }
3517
3518 if (code == COMPONENT_REF)
3519 {
3520 tree ob = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3520, __FUNCTION__)))));
3521
3522 if (TREE_CODE (ob)((enum tree_code) (ob)->base.code) == ARROW_EXPR)
3523 {
3524 write_string (OVL_OP_INFO (false, code)->mangled_name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ((&ovl_op_info[(false) != 0][ovl_op_mapping
[(code)]])->mangled_name)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ((&ovl_op_info[(false) != 0][ovl_op_mapping
[(code)]])->mangled_name), __len); __o->next_free += __len
; (void) 0; });
3525 ob = TREE_OPERAND (ob, 0)(*((const_cast<tree*> (tree_operand_check ((ob), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3525, __FUNCTION__)))));
3526 write_expression (ob);
3527 }
3528 else if (write_base_ref (expr))
3529 return;
3530 else if (!is_dummy_object (ob))
3531 {
3532 write_string ("dt")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("dt")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("dt"), __len); __o->next_free += __len
; (void) 0; });
3533 write_expression (ob);
3534 }
3535 /* else, for a non-static data member with no associated object (in
3536 unevaluated context), use the unresolved-name mangling. */
3537
3538 write_member_name (TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3538, __FUNCTION__))))));
3539 return;
3540 }
3541
3542 /* If it wasn't any of those, recursively expand the expression. */
3543 name = OVL_OP_INFO (false, code)(&ovl_op_info[(false) != 0][ovl_op_mapping[(code)]])->mangled_name;
3544
3545 /* We used to mangle const_cast and static_cast like a C cast. */
3546 if (code == CONST_CAST_EXPR
3547 || code == STATIC_CAST_EXPR)
3548 {
3549 if (abi_warn_or_compat_version_crosses (6)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (6)) != (warn_abi_version == 0 || warn_abi_version >=
(6))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (6)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (6)))
))
3550 G.need_abi_warning = 1;
3551 if (!abi_version_at_least (6)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (6)))
3552 name = OVL_OP_INFO (false, CAST_EXPR)(&ovl_op_info[(false) != 0][ovl_op_mapping[(CAST_EXPR)]])->mangled_name;
3553 }
3554
3555 if (name == NULLnullptr)
3556 {
3557 switch (code)
3558 {
3559 case TRAIT_EXPR:
3560 error ("use of built-in trait %qE in function signature; "
3561 "use library traits instead", expr);
3562 break;
3563
3564 default:
3565 sorry ("mangling %C", code);
3566 break;
3567 }
3568 return;
3569 }
3570 else
3571 write_string (name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (name)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (name), __len); __o->next_free += __len
; (void) 0; });
3572
3573 switch (code)
3574 {
3575 case CALL_EXPR:
3576 {
3577 tree fn = CALL_EXPR_FN (expr)(*((const_cast<tree*> (tree_operand_check (((tree_check
((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3577, __FUNCTION__, (CALL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3577, __FUNCTION__)))));
3578
3579 if (TREE_CODE (fn)((enum tree_code) (fn)->base.code) == ADDR_EXPR)
3580 fn = TREE_OPERAND (fn, 0)(*((const_cast<tree*> (tree_operand_check ((fn), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3580, __FUNCTION__)))));
3581
3582 /* Mangle a dependent name as the name, not whatever happens to
3583 be the first function in the overload set. */
3584 if (OVL_P (fn)(((enum tree_code) (fn)->base.code) == FUNCTION_DECL || ((
enum tree_code) (fn)->base.code) == OVERLOAD)
3585 && type_dependent_expression_p_push (expr))
3586 fn = OVL_NAME (fn)((contains_struct_check ((ovl_first (fn)), (TS_DECL_MINIMAL),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3586, __FUNCTION__))->decl_minimal.name);
3587
3588 write_expression (fn);
3589 }
3590
3591 for (i = 0; i < call_expr_nargs (expr)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
((expr), (tcc_vl_exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3591, __FUNCTION__))->exp.operands[0]), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3591, __FUNCTION__)))) - 3); ++i)
3592 write_expression (CALL_EXPR_ARG (expr, i)(*((const_cast<tree*> (tree_operand_check (((tree_check
((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3592, __FUNCTION__, (CALL_EXPR)))), ((i) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3592, __FUNCTION__))))));
3593 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3594 break;
3595
3596 case CAST_EXPR:
3597 write_type (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3597, __FUNCTION__))->typed.type));
3598 if (list_length (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3598, __FUNCTION__)))))) == 1)
3599 write_expression (TREE_VALUE (TREE_OPERAND (expr, 0))((tree_check (((*((const_cast<tree*> (tree_operand_check
((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3599, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3599, __FUNCTION__, (TREE_LIST)))->list.value));
3600 else
3601 {
3602 tree args = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3602, __FUNCTION__)))));
3603 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
3604 for (; args; args = TREE_CHAIN (args)((contains_struct_check ((args), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3604, __FUNCTION__))->common.chain))
3605 write_expression (TREE_VALUE (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3605, __FUNCTION__, (TREE_LIST)))->list.value));
3606 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3607 }
3608 break;
3609
3610 case DYNAMIC_CAST_EXPR:
3611 case REINTERPRET_CAST_EXPR:
3612 case STATIC_CAST_EXPR:
3613 case CONST_CAST_EXPR:
3614 write_type (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3614, __FUNCTION__))->typed.type));
3615 write_expression (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3615, __FUNCTION__))))));
3616 break;
3617
3618 case PREINCREMENT_EXPR:
3619 case PREDECREMENT_EXPR:
3620 if (abi_version_at_least (6)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (6)))
3621 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
3622 if (abi_warn_or_compat_version_crosses (6)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (6)) != (warn_abi_version == 0 || warn_abi_version >=
(6))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (6)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (6)))
))
3623 G.need_abi_warning = 1;
3624 /* Fall through. */
3625
3626 default:
3627 /* In the middle-end, some expressions have more operands than
3628 they do in templates (and mangling). */
3629 len = cp_tree_operand_length (expr);
3630
3631 for (i = 0; i < len; ++i)
3632 {
3633 tree operand = TREE_OPERAND (expr, i)(*((const_cast<tree*> (tree_operand_check ((expr), (i),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3633, __FUNCTION__)))));
3634 /* As a GNU extension, the middle operand of a
3635 conditional may be omitted. Since expression
3636 manglings are supposed to represent the input token
3637 stream, there's no good way to mangle such an
3638 expression without extending the C++ ABI. */
3639 if (code == COND_EXPR && i == 1 && !operand)
3640 {
3641 error ("omitted middle operand to %<?:%> operand "
3642 "cannot be mangled");
3643 continue;
3644 }
3645 else if (FOLD_EXPR_P (expr)(((enum tree_code) (expr)->base.code) == UNARY_LEFT_FOLD_EXPR
|| ((enum tree_code) (expr)->base.code) == UNARY_RIGHT_FOLD_EXPR
|| ((enum tree_code) (expr)->base.code) == BINARY_LEFT_FOLD_EXPR
|| ((enum tree_code) (expr)->base.code) == BINARY_RIGHT_FOLD_EXPR
))
3646 {
3647 /* The first 'operand' of a fold-expression is the operator
3648 that it folds over. */
3649 if (i == 0)
3650 {
3651 int fcode = TREE_INT_CST_LOW (operand)((unsigned long) (*tree_int_cst_elt_check ((operand), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3651, __FUNCTION__)));
3652 write_string (OVL_OP_INFO (false, fcode)->mangled_name)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ((&ovl_op_info[(false) != 0][ovl_op_mapping
[(fcode)]])->mangled_name)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ((&ovl_op_info[(false) != 0][ovl_op_mapping
[(fcode)]])->mangled_name), __len); __o->next_free += __len
; (void) 0; });
3653 continue;
3654 }
3655 else if (code == BINARY_LEFT_FOLD_EXPR)
3656 {
3657 /* The order of operands of the binary left and right
3658 folds is the same, but we want to mangle them in
3659 lexical order, i.e. non-pack first. */
3660 if (i == 1)
3661 operand = FOLD_EXPR_INIT (expr)(*((const_cast<tree*> (tree_operand_check (((tree_check2
((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3661, __FUNCTION__, (BINARY_LEFT_FOLD_EXPR), (BINARY_RIGHT_FOLD_EXPR
)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3661, __FUNCTION__)))));
3662 else
3663 operand = FOLD_EXPR_PACK (expr)(*((const_cast<tree*> (tree_operand_check (((tree_check4
((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3663, __FUNCTION__, (UNARY_LEFT_FOLD_EXPR), (UNARY_RIGHT_FOLD_EXPR
), (BINARY_LEFT_FOLD_EXPR), (BINARY_RIGHT_FOLD_EXPR)))), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3663, __FUNCTION__)))));
3664 }
3665 if (PACK_EXPANSION_P (operand)(((enum tree_code) (operand)->base.code) == TYPE_PACK_EXPANSION
|| ((enum tree_code) (operand)->base.code) == EXPR_PACK_EXPANSION
))
3666 operand = PACK_EXPANSION_PATTERN (operand)(((enum tree_code) ((tree_check2 ((operand), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3666, __FUNCTION__, (TYPE_PACK_EXPANSION), (EXPR_PACK_EXPANSION
))))->base.code) == TYPE_PACK_EXPANSION ? ((contains_struct_check
((operand), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3666, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((operand), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3666, __FUNCTION__))))));
3667 }
3668 write_expression (operand);
3669 }
3670 }
3671 }
3672}
3673
3674/* Literal subcase of non-terminal <template-arg>.
3675
3676 "Literal arguments, e.g. "A<42L>", are encoded with their type
3677 and value. Negative integer values are preceded with "n"; for
3678 example, "A<-42L>" becomes "1AILln42EE". The bool value false is
3679 encoded as 0, true as 1." */
3680
3681static void
3682write_template_arg_literal (const tree value)
3683{
3684 if (TREE_CODE (value)((enum tree_code) (value)->base.code) == STRING_CST)
3685 /* Temporarily mangle strings as braced initializer lists. */
3686 write_string ("tl")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("tl")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("tl"), __len); __o->next_free += __len
; (void) 0; });
3687 else
3688 write_char ('L')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('L')))); });
3689
3690 tree valtype = TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3690, __FUNCTION__))->typed.type);
3691 write_type (valtype);
3692
3693 /* Write a null member pointer value as (type)0, regardless of its
3694 real representation. */
3695 if (null_member_pointer_value_p (value))
3696 write_integer_cst (integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);
3697 else
3698 switch (TREE_CODE (value)((enum tree_code) (value)->base.code))
3699 {
3700 case CONST_DECL:
3701 write_integer_cst (DECL_INITIAL (value)((contains_struct_check ((value), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3701, __FUNCTION__))->decl_common.initial));
3702 break;
3703
3704 case INTEGER_CST:
3705 gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node)((void)(!(!comptypes ((((contains_struct_check ((value), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3705, __FUNCTION__))->typed.type)), (global_trees[TI_BOOLEAN_TYPE
]), 0) || integer_zerop (value) || integer_onep (value)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3706, __FUNCTION__), 0 : 0))
3706 || integer_zerop (value) || integer_onep (value))((void)(!(!comptypes ((((contains_struct_check ((value), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3705, __FUNCTION__))->typed.type)), (global_trees[TI_BOOLEAN_TYPE
]), 0) || integer_zerop (value) || integer_onep (value)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3706, __FUNCTION__), 0 : 0));
3707 if (!(abi_version_at_least (14)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (14))
3708 && NULLPTR_TYPE_P (TREE_TYPE (value))(((enum tree_code) (((contains_struct_check ((value), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3708, __FUNCTION__))->typed.type))->base.code) == NULLPTR_TYPE
)))
3709 write_integer_cst (value);
3710 break;
3711
3712 case REAL_CST:
3713 write_real_cst (value);
3714 break;
3715
3716 case COMPLEX_CST:
3717 if (TREE_CODE (TREE_REALPART (value))((enum tree_code) (((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3717, __FUNCTION__, (COMPLEX_CST)))->complex.real))->
base.code) == INTEGER_CST
3718 && TREE_CODE (TREE_IMAGPART (value))((enum tree_code) (((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3718, __FUNCTION__, (COMPLEX_CST)))->complex.imag))->
base.code) == INTEGER_CST)
3719 {
3720 write_integer_cst (TREE_REALPART (value)((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3720, __FUNCTION__, (COMPLEX_CST)))->complex.real));
3721 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
3722 write_integer_cst (TREE_IMAGPART (value)((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3722, __FUNCTION__, (COMPLEX_CST)))->complex.imag));
3723 }
3724 else if (TREE_CODE (TREE_REALPART (value))((enum tree_code) (((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3724, __FUNCTION__, (COMPLEX_CST)))->complex.real))->
base.code) == REAL_CST
3725 && TREE_CODE (TREE_IMAGPART (value))((enum tree_code) (((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3725, __FUNCTION__, (COMPLEX_CST)))->complex.imag))->
base.code) == REAL_CST)
3726 {
3727 write_real_cst (TREE_REALPART (value)((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3727, __FUNCTION__, (COMPLEX_CST)))->complex.real));
3728 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
3729 write_real_cst (TREE_IMAGPART (value)((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3729, __FUNCTION__, (COMPLEX_CST)))->complex.imag));
3730 }
3731 else
3732 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3732, __FUNCTION__));
3733 break;
3734
3735 case STRING_CST:
3736 {
3737 /* Mangle strings the same as braced initializer lists. */
3738 unsigned n = TREE_STRING_LENGTH (value)((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3738, __FUNCTION__, (STRING_CST)))->string.length);
3739 const char *str = TREE_STRING_POINTER (value)((const char *)((tree_check ((value), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3739, __FUNCTION__, (STRING_CST)))->string.str));
3740
3741 /* Count the number of trailing nuls and subtract them from
3742 STRSIZE because they don't need to be mangled. */
3743 for (const char *p = str + n - 1; ; --p)
3744 {
3745 if (*p || p == str)
3746 {
3747 n -= str + n - !!*p - p;
3748 break;
3749 }
3750 }
3751 tree eltype = TREE_TYPE (valtype)((contains_struct_check ((valtype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3751, __FUNCTION__))->typed.type);
3752 for (const char *p = str; n--; ++p)
3753 {
3754 write_char ('L')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('L')))); });
3755 write_type (eltype);
3756 write_unsigned_number (*(const unsigned char*)p)write_number ((*(const unsigned char*)p), 1, 10);
3757 write_string ("E")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("E")); if (__extension__ ({ struct obstack const
*__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->next_free
); }) < __len) _obstack_newchunk (__o, __len); memcpy (__o
->next_free, ("E"), __len); __o->next_free += __len; (void
) 0; });
3758 }
3759 break;
3760 }
3761
3762 default:
3763 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3763, __FUNCTION__));
3764 }
3765
3766 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3767}
3768
3769/* Non-terminal <template-arg>.
3770
3771 <template-arg> ::= <type> # type
3772 ::= L <type> </value/ number> E # literal
3773 ::= LZ <name> E # external name
3774 ::= X <expression> E # expression */
3775
3776static void
3777write_template_arg (tree node)
3778{
3779 enum tree_code code = TREE_CODE (node)((enum tree_code) (node)->base.code);
3780
3781 MANGLE_TRACE_TREE ("template-arg", node);
3782
3783 /* A template template parameter's argument list contains TREE_LIST
3784 nodes of which the value field is the actual argument. */
3785 if (code == TREE_LIST)
3786 {
3787 node = TREE_VALUE (node)((tree_check ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3787, __FUNCTION__, (TREE_LIST)))->list.value);
3788 /* If it's a decl, deal with its type instead. */
3789 if (DECL_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_declaration))
3790 {
3791 node = TREE_TYPE (node)((contains_struct_check ((node), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3791, __FUNCTION__))->typed.type);
3792 code = TREE_CODE (node)((enum tree_code) (node)->base.code);
3793 }
3794 }
3795
3796 if (TREE_CODE (node)((enum tree_code) (node)->base.code) == VAR_DECL && DECL_NTTP_OBJECT_P (node)((tree_not_check2 (((tree_check ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3796, __FUNCTION__, (VAR_DECL)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3796, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5))
3797 /* We want to mangle the argument, not the var we stored it in. */
3798 node = tparm_object_argument (node);
3799
3800 /* Strip a conversion added by convert_nontype_argument. */
3801 if (TREE_CODE (node)((enum tree_code) (node)->base.code) == IMPLICIT_CONV_EXPR)
3802 node = TREE_OPERAND (node, 0)(*((const_cast<tree*> (tree_operand_check ((node), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3802, __FUNCTION__)))));
3803 if (REFERENCE_REF_P (node)((((enum tree_code) (node)->base.code) == INDIRECT_REF) &&
((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((node), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3803, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3803, __FUNCTION__))->typed.type) && (((enum tree_code
) (((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((node)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3803, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3803, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)))
3804 node = TREE_OPERAND (node, 0)(*((const_cast<tree*> (tree_operand_check ((node), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3804, __FUNCTION__)))));
3805 if (TREE_CODE (node)((enum tree_code) (node)->base.code) == NOP_EXPR
3806 && TYPE_REF_P (TREE_TYPE (node))(((enum tree_code) (((contains_struct_check ((node), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3806, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
3807 {
3808 /* Template parameters can be of reference type. To maintain
3809 internal consistency, such arguments use a conversion from
3810 address of object to reference type. */
3811 gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR)((void)(!(((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((node), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3811, __FUNCTION__))))))->base.code) == ADDR_EXPR) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3811, __FUNCTION__), 0 : 0));
3812 node = TREE_OPERAND (TREE_OPERAND (node, 0), 0)(*((const_cast<tree*> (tree_operand_check (((*((const_cast
<tree*> (tree_operand_check ((node), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3812, __FUNCTION__)))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3812, __FUNCTION__)))));
3813 }
3814
3815 if (TREE_CODE (node)((enum tree_code) (node)->base.code) == BASELINK
3816 && !type_unknown_p (node))
3817 {
3818 if (abi_version_at_least (6)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (6)))
3819 node = BASELINK_FUNCTIONS (node)(((struct tree_baselink*) (tree_check ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3819, __FUNCTION__, (BASELINK))))->functions);
3820 if (abi_warn_or_compat_version_crosses (6)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (6)) != (warn_abi_version == 0 || warn_abi_version >=
(6))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (6)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (6)))
))
3821 /* We wrongly wrapped a class-scope function in X/E. */
3822 G.need_abi_warning = 1;
3823 }
3824
3825 if (ARGUMENT_PACK_P (node)(((enum tree_code) (node)->base.code) == TYPE_ARGUMENT_PACK
|| ((enum tree_code) (node)->base.code) == NONTYPE_ARGUMENT_PACK
))
3826 {
3827 /* Expand the template argument pack. */
3828 tree args = ARGUMENT_PACK_ARGS (node)(((enum tree_code) ((tree_check2 ((node), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3828, __FUNCTION__, (TYPE_ARGUMENT_PACK), (NONTYPE_ARGUMENT_PACK
))))->base.code) == TYPE_ARGUMENT_PACK ? ((contains_struct_check
((node), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3828, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((node), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3828, __FUNCTION__))))));
3829 int i, length = TREE_VEC_LENGTH (args)((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3829, __FUNCTION__, (TREE_VEC)))->base.u.length);
3830 if (abi_version_at_least (6)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (6)))
3831 write_char ('J')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('J')))); });
3832 else
3833 write_char ('I')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('I')))); });
3834 if (abi_warn_or_compat_version_crosses (6)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (6)) != (warn_abi_version == 0 || warn_abi_version >=
(6))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (6)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (6)))
))
3835 G.need_abi_warning = 1;
3836 for (i = 0; i < length; ++i)
3837 write_template_arg (TREE_VEC_ELT (args, i)(*((const_cast<tree *> (tree_vec_elt_check ((args), (i)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3837, __FUNCTION__))))));
3838 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3839 }
3840 else if (TYPE_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_type))
3841 write_type (node);
3842 else if (code == TEMPLATE_DECL)
3843 /* A template appearing as a template arg is a template template arg. */
3844 write_template_template_arg (node);
3845 else if ((TREE_CODE_CLASS (code)tree_code_type_tmpl <0>::tree_code_type[(int) (code)] == tcc_constant && code != PTRMEM_CST)
3846 || code == CONST_DECL
3847 || null_member_pointer_value_p (node))
3848 write_template_arg_literal (node);
3849 else if (code == EXCESS_PRECISION_EXPR
3850 && TREE_CODE (TREE_OPERAND (node, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((node), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3850, __FUNCTION__))))))->base.code) == REAL_CST)
3851 write_template_arg_literal (fold_convert (TREE_TYPE (node),fold_convert_loc (((location_t) 0), ((contains_struct_check (
(node), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3851, __FUNCTION__))->typed.type), (*((const_cast<tree
*> (tree_operand_check ((node), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3852, __FUNCTION__))))))
3852 TREE_OPERAND (node, 0))fold_convert_loc (((location_t) 0), ((contains_struct_check (
(node), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3851, __FUNCTION__))->typed.type), (*((const_cast<tree
*> (tree_operand_check ((node), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3852, __FUNCTION__)))))));
3853 else if (DECL_P (node)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (node)->base.code))] == tcc_declaration))
3854 {
3855 write_char ('L')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('L')))); });
3856 /* Until ABI version 3, the underscore before the mangled name
3857 was incorrectly omitted. */
3858 if (!abi_version_at_least (3)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (3)))
3859 write_char ('Z')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('Z')))); });
3860 else
3861 write_string ("_Z")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("_Z")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("_Z"), __len); __o->next_free += __len
; (void) 0; });
3862 if (abi_warn_or_compat_version_crosses (3)(((global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (3)) != (warn_abi_version == 0 || warn_abi_version >=
(3))) || ((global_options.x_flag_abi_version == 0 || global_options
.x_flag_abi_version >= (3)) != (global_options.x_flag_abi_compat_version
== 0 || global_options.x_flag_abi_compat_version >= (3)))
))
3863 G.need_abi_warning = 1;
3864 write_encoding (node);
3865 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3866 }
3867 else
3868 {
3869 /* Template arguments may be expressions. */
3870 write_char ('X')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('X')))); });
3871 write_expression (node);
3872 write_char ('E')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('E')))); });
3873 }
3874}
3875
3876/* <template-template-arg>
3877 ::= <name>
3878 ::= <substitution> */
3879
3880static void
3881write_template_template_arg (const tree decl)
3882{
3883 MANGLE_TRACE_TREE ("template-template-arg", decl);
3884
3885 if (find_substitution (decl))
3886 return;
3887 write_name (decl, /*ignore_local_scope=*/0);
3888 add_substitution (decl);
3889}
3890
3891
3892/* Non-terminal <array-type>. TYPE is an ARRAY_TYPE.
3893
3894 <array-type> ::= A [</dimension/ number>] _ </element/ type>
3895 ::= A <expression> _ </element/ type>
3896
3897 "Array types encode the dimension (number of elements) and the
3898 element type. For variable length arrays, the dimension (but not
3899 the '_' separator) is omitted."
3900 Note that for flexible array members, like for other arrays of
3901 unspecified size, the dimension is also omitted. */
3902
3903static void
3904write_array_type (const tree type)
3905{
3906 write_char ('A')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('A')))); });
3907 if (TYPE_DOMAIN (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3907, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
))
3908 {
3909 tree index_type;
3910
3911 index_type = TYPE_DOMAIN (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3911, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
);
3912 /* The INDEX_TYPE gives the upper and lower bounds of the array.
3913 It's null for flexible array members which have no upper bound
3914 (this is a change from GCC 5 and prior where such members were
3915 incorrectly mangled as zero-length arrays). */
3916 if (tree max = TYPE_MAX_VALUE (index_type)((tree_check5 ((index_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3916, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
))
3917 {
3918 if (TREE_CODE (max)((enum tree_code) (max)->base.code) == INTEGER_CST)
3919 {
3920 /* The ABI specifies that we should mangle the number of
3921 elements in the array, not the largest allowed index. */
3922 offset_int wmax = wi::to_offset (max) + 1;
3923 /* Truncate the result - this will mangle [0, SIZE_INT_MAX]
3924 number of elements as zero. */
3925 wmax = wi::zext (wmax, TYPE_PRECISION (TREE_TYPE (max))((tree_class_check ((((contains_struct_check ((max), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3925, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3925, __FUNCTION__))->type_common.precision));
3926 gcc_assert (wi::fits_uhwi_p (wmax))((void)(!(wi::fits_uhwi_p (wmax)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3926, __FUNCTION__), 0 : 0));
3927 write_unsigned_number (wmax.to_uhwi ())write_number ((wmax.to_uhwi ()), 1, 10);
3928 }
3929 else
3930 {
3931 max = TREE_OPERAND (max, 0)(*((const_cast<tree*> (tree_operand_check ((max), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3931, __FUNCTION__)))));
3932 write_expression (max);
3933 }
3934 }
3935 }
3936 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
3937 write_type (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3937, __FUNCTION__))->typed.type));
3938}
3939
3940/* Non-terminal <pointer-to-member-type> for pointer-to-member
3941 variables. TYPE is a pointer-to-member POINTER_TYPE.
3942
3943 <pointer-to-member-type> ::= M </class/ type> </member/ type> */
3944
3945static void
3946write_pointer_to_member_type (const tree type)
3947{
3948 write_char ('M')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('M')))); });
3949 write_type (TYPE_PTRMEM_CLASS_TYPE (type)((((enum tree_code) (type)->base.code) == OFFSET_TYPE) ? (
(tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3949, __FUNCTION__, (OFFSET_TYPE)))->type_non_common.maxval
) : ((tree_check2 ((((contains_struct_check (((cp_build_qualified_type
(((contains_struct_check ((((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3949, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3949, __FUNCTION__))->typed.type), cp_type_quals (type))
)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3949, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3949, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.maxval)));
3950 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type)((((enum tree_code) (type)->base.code) == OFFSET_TYPE) ? (
(contains_struct_check ((type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3950, __FUNCTION__))->typed.type) : ((contains_struct_check
(((cp_build_qualified_type (((contains_struct_check ((((tree_check3
((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3950, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3950, __FUNCTION__))->typed.type), cp_type_quals (type))
)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3950, __FUNCTION__))->typed.type)));
3951}
3952
3953/* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM,
3954 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a
3955 TEMPLATE_PARM_INDEX.
3956
3957 <template-param> ::= T </parameter/ number> _ */
3958
3959static void
3960write_template_param (const tree parm)
3961{
3962 int parm_index;
3963
3964 MANGLE_TRACE_TREE ("template-parm", parm);
3965
3966 switch (TREE_CODE (parm)((enum tree_code) (parm)->base.code))
3967 {
3968 case TEMPLATE_TYPE_PARM:
3969 case TEMPLATE_TEMPLATE_PARM:
3970 case BOUND_TEMPLATE_TEMPLATE_PARM:
3971 parm_index = TEMPLATE_TYPE_IDX (parm)((((template_parm_index*)(tree_check (((((tree_class_check ((
(tree_check3 (((parm)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3971, __FUNCTION__, (TEMPLATE_TYPE_PARM), (TEMPLATE_TEMPLATE_PARM
), (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3971, __FUNCTION__))->type_non_common.values))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3971, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->index));
3972 break;
3973
3974 case TEMPLATE_PARM_INDEX:
3975 parm_index = TEMPLATE_PARM_IDX (parm)(((template_parm_index*)(tree_check ((parm), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3975, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->index);
3976 break;
3977
3978 default:
3979 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 3979, __FUNCTION__));
3980 }
3981
3982 write_char ('T')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('T')))); });
3983 /* NUMBER as it appears in the mangling is (-1)-indexed, with the
3984 earliest template param denoted by `_'. */
3985 write_compact_number (parm_index);
3986}
3987
3988/* <template-template-param>
3989 ::= <template-param>
3990 ::= <substitution> */
3991
3992static void
3993write_template_template_param (const tree parm)
3994{
3995 tree templ = NULL_TREE(tree) nullptr;
3996
3997 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
3998 template template parameter. The substitution candidate here is
3999 only the template. */
4000 if (TREE_CODE (parm)((enum tree_code) (parm)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM)
4001 {
4002 templ
4003 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm))((struct tree_template_info*)(tree_check (((((tree_class_check
(((tree_check ((parm), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4003, __FUNCTION__, (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4003, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4003, __FUNCTION__, (TEMPLATE_INFO))))->tmpl;
4004 if (find_substitution (templ))
4005 return;
4006 }
4007
4008 /* <template-param> encodes only the template parameter position,
4009 not its template arguments, which is fine here. */
4010 write_template_param (parm);
4011 if (templ)
4012 add_substitution (templ);
4013}
4014
4015/* Non-terminal <substitution>.
4016
4017 <substitution> ::= S <seq-id> _
4018 ::= S_ */
4019
4020static void
4021write_substitution (const int seq_id)
4022{
4023 MANGLE_TRACE ("substitution", "");
4024
4025 write_char ('S')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('S')))); });
4026 if (seq_id > 0)
4027 write_number (seq_id - 1, /*unsigned=*/1, 36);
4028 write_char ('_')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('_')))); });
4029}
4030
4031/* Start mangling ENTITY. */
4032
4033static inline void
4034start_mangling (const tree entity)
4035{
4036 G.entity = entity;
4037 G.need_abi_warning = false;
4038 G.need_cxx17_warning = false;
4039 G.mod = false;
4040 obstack_free (&name_obstack, name_base)__extension__ ({ struct obstack *__o = (&name_obstack); void
*__obj = (void *) (name_base); if (__obj > (void *) __o->
chunk && __obj < (void *) __o->chunk_limit) __o
->next_free = __o->object_base = (char *) __obj; else _obstack_free
(__o, __obj); });
4041 mangle_obstack = &name_obstack;
4042 name_base = obstack_alloc (&name_obstack, 0)__extension__ ({ struct obstack *__h = (&name_obstack); __extension__
({ struct obstack *__o = (__h); size_t __len = ((0)); if (__extension__
({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit
- __o1->next_free); }) < __len) _obstack_newchunk (__o
, __len); ((void) ((__o)->next_free += (__len))); }); __extension__
({ struct obstack *__o1 = (__h); void *__value = (void *) __o1
->object_base; if (__o1->next_free == __value) __o1->
maybe_empty_object = 1; __o1->next_free = (sizeof (ptrdiff_t
) < sizeof (void *) ? ((__o1->object_base) + (((__o1->
next_free) - (__o1->object_base) + (__o1->alignment_mask
)) & ~(__o1->alignment_mask))) : (char *) (((ptrdiff_t
) (__o1->next_free) + (__o1->alignment_mask)) & ~(__o1
->alignment_mask))); if ((size_t) (__o1->next_free - (char
*) __o1->chunk) > (size_t) (__o1->chunk_limit - (char
*) __o1->chunk)) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; __value; }); });
4043}
4044
4045/* Done with mangling. Release the data. */
4046
4047static void
4048finish_mangling_internal (void)
4049{
4050 /* Clear all the substitutions. */
4051 vec_safe_truncate (G.substitutions, 0);
4052
4053 if (G.mod)
4054 mangle_module_fini ();
4055
4056 /* Null-terminate the string. */
4057 write_char ('\0')__extension__ ({ struct obstack *__o = (mangle_obstack); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
(__o1->chunk_limit - __o1->next_free); }) < 1) _obstack_newchunk
(__o, 1); ((void) (*((__o)->next_free)++ = (('\0')))); });
4058}
4059
4060
4061/* Like finish_mangling_internal, but return the mangled string. */
4062
4063static inline const char *
4064finish_mangling (void)
4065{
4066 finish_mangling_internal ();
4067 return (const char *) obstack_finish (mangle_obstack)__extension__ ({ struct obstack *__o1 = (mangle_obstack); void
*__value = (void *) __o1->object_base; if (__o1->next_free
== __value) __o1->maybe_empty_object = 1; __o1->next_free
= (sizeof (ptrdiff_t) < sizeof (void *) ? ((__o1->object_base
) + (((__o1->next_free) - (__o1->object_base) + (__o1->
alignment_mask)) & ~(__o1->alignment_mask))) : (char *
) (((ptrdiff_t) (__o1->next_free) + (__o1->alignment_mask
)) & ~(__o1->alignment_mask))); if ((size_t) (__o1->
next_free - (char *) __o1->chunk) > (size_t) (__o1->
chunk_limit - (char *) __o1->chunk)) __o1->next_free = __o1
->chunk_limit; __o1->object_base = __o1->next_free; __value
; });
4068}
4069
4070/* Like finish_mangling_internal, but return an identifier. */
4071
4072static tree
4073finish_mangling_get_identifier (void)
4074{
4075 finish_mangling_internal ();
4076 /* Don't obstack_finish here, and the next start_mangling will
4077 remove the identifier. */
4078 return get_identifier ((const char *) obstack_base (mangle_obstack))(__builtin_constant_p ((const char *) ((void *) (mangle_obstack
)->object_base)) ? get_identifier_with_length (((const char
*) ((void *) (mangle_obstack)->object_base)), strlen ((const
char *) ((void *) (mangle_obstack)->object_base))) : get_identifier
((const char *) ((void *) (mangle_obstack)->object_base))
);
4079}
4080
4081/* Initialize data structures for mangling. */
4082
4083void
4084init_mangle (void)
4085{
4086 gcc_obstack_init (&name_obstack)_obstack_begin (((&name_obstack)), (memory_block_pool::block_size
), (0), (mempool_obstack_chunk_alloc), (mempool_obstack_chunk_free
));
4087 name_base = obstack_alloc (&name_obstack, 0)__extension__ ({ struct obstack *__h = (&name_obstack); __extension__
({ struct obstack *__o = (__h); size_t __len = ((0)); if (__extension__
({ struct obstack const *__o1 = (__o); (size_t) (__o1->chunk_limit
- __o1->next_free); }) < __len) _obstack_newchunk (__o
, __len); ((void) ((__o)->next_free += (__len))); }); __extension__
({ struct obstack *__o1 = (__h); void *__value = (void *) __o1
->object_base; if (__o1->next_free == __value) __o1->
maybe_empty_object = 1; __o1->next_free = (sizeof (ptrdiff_t
) < sizeof (void *) ? ((__o1->object_base) + (((__o1->
next_free) - (__o1->object_base) + (__o1->alignment_mask
)) & ~(__o1->alignment_mask))) : (char *) (((ptrdiff_t
) (__o1->next_free) + (__o1->alignment_mask)) & ~(__o1
->alignment_mask))); if ((size_t) (__o1->next_free - (char
*) __o1->chunk) > (size_t) (__o1->chunk_limit - (char
*) __o1->chunk)) __o1->next_free = __o1->chunk_limit
; __o1->object_base = __o1->next_free; __value; }); });
4088 vec_alloc (G.substitutions, 0);
4089
4090 /* Cache these identifiers for quick comparison when checking for
4091 standard substitutions. */
4092 subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator")(__builtin_constant_p ("allocator") ? get_identifier_with_length
(("allocator"), strlen ("allocator")) : get_identifier ("allocator"
));
4093 subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string")(__builtin_constant_p ("basic_string") ? get_identifier_with_length
(("basic_string"), strlen ("basic_string")) : get_identifier
("basic_string"));
4094 subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits")(__builtin_constant_p ("char_traits") ? get_identifier_with_length
(("char_traits"), strlen ("char_traits")) : get_identifier (
"char_traits"));
4095 subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream")(__builtin_constant_p ("basic_istream") ? get_identifier_with_length
(("basic_istream"), strlen ("basic_istream")) : get_identifier
("basic_istream"));
4096 subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream")(__builtin_constant_p ("basic_ostream") ? get_identifier_with_length
(("basic_ostream"), strlen ("basic_ostream")) : get_identifier
("basic_ostream"));
4097 subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream")(__builtin_constant_p ("basic_iostream") ? get_identifier_with_length
(("basic_iostream"), strlen ("basic_iostream")) : get_identifier
("basic_iostream"));
4098}
4099
4100/* Generate a mangling for MODULE's global initializer fn. */
4101
4102tree
4103mangle_module_global_init (int module)
4104{
4105 start_mangling (NULL_TREE(tree) nullptr);
4106
4107 write_string ("_ZGI")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("_ZGI")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("_ZGI"), __len); __o->next_free += __len
; (void) 0; });
4108 write_module (module, true);
4109
4110 return finish_mangling_get_identifier ();
4111}
4112
4113/* Generate the mangled name of DECL. */
4114
4115static tree
4116mangle_decl_string (const tree decl)
4117{
4118 tree result;
4119 tree saved_fn = NULL_TREE(tree) nullptr;
4120 bool template_p = false;
4121
4122 /* We shouldn't be trying to mangle an uninstantiated template. */
4123 gcc_assert (!type_dependent_expression_p (decl))((void)(!(!type_dependent_expression_p (decl)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4123, __FUNCTION__), 0 : 0));
4124
4125 if (DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4125, __FUNCTION__))->decl_common.lang_specific) && DECL_USE_TEMPLATE (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4125, __FUNCTION__))->decl_common.lang_specific)->u.base
.use_template))
4126 {
4127 struct tinst_level *tl = current_instantiation ();
4128 if ((!tl || tl->maybe_get_node () != decl)
4129 && push_tinst_level (decl))
4130 {
4131 template_p = true;
4132 saved_fn = current_function_decl;
4133 current_function_decl = NULL_TREE(tree) nullptr;
4134 }
4135 }
4136 iloc_sentinel ils (DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4136, __FUNCTION__))->decl_minimal.locus));
4137
4138 start_mangling (decl);
4139
4140 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL)
4141 write_type (TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4141, __FUNCTION__))->typed.type));
4142 else
4143 write_mangled_name (decl, true);
4144
4145 result = finish_mangling_get_identifier ();
4146 if (DEBUG_MANGLE0)
4147 fprintf (stderrstderr, "mangle_decl_string = '%s'\n\n",
4148 IDENTIFIER_POINTER (result)((const char *) (tree_check ((result), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4148, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
4149
4150 if (template_p)
4151 {
4152 pop_tinst_level ();
4153 current_function_decl = saved_fn;
4154 }
4155
4156 return result;
4157}
4158
4159/* Return an identifier for the external mangled name of DECL. */
4160
4161static tree
4162get_mangled_id (tree decl)
4163{
4164 tree id = mangle_decl_string (decl);
4165 return targetm.mangle_decl_assembler_name (decl, id);
4166}
4167
4168/* Create an identifier for the external mangled name of DECL. */
4169
4170void
4171mangle_decl (const tree decl)
4172{
4173 tree id;
4174 bool dep;
4175
4176 /* Don't bother mangling uninstantiated templates. */
4177 ++processing_template_declscope_chain->x_processing_template_decl;
4178 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL)
4179 dep = dependent_type_p (TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4179, __FUNCTION__))->typed.type));
4180 else
4181 dep = (DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4181, __FUNCTION__))->decl_common.lang_specific) && DECL_TEMPLATE_INFO (decl)(((contains_struct_check ((template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4181, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4181, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)
4182 && any_dependent_template_arguments_p (DECL_TI_ARGS (decl)((struct tree_template_info*)(tree_check (((((contains_struct_check
((template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4182, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4182, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4182, __FUNCTION__, (TEMPLATE_INFO))))->args));
4183 --processing_template_declscope_chain->x_processing_template_decl;
4184 if (dep)
4185 return;
4186
4187 /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging.
4188 It is not needed to assign names to anonymous namespace, but we use the
4189 "<anon>" marker to be able to tell if type is C++ ODR type or type
4190 produced by other language. */
4191 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL
4192 && TYPE_STUB_DECL (TREE_TYPE (decl))(((contains_struct_check (((tree_class_check ((((contains_struct_check
((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4192, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4192, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4192, __FUNCTION__))->common.chain))
4193 && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl)))(((((contains_struct_check (((tree_class_check ((((contains_struct_check
((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4193, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4193, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4193, __FUNCTION__))->common.chain)))->base.public_flag
))
4194 id = get_identifier ("<anon>")(__builtin_constant_p ("<anon>") ? get_identifier_with_length
(("<anon>"), strlen ("<anon>")) : get_identifier
("<anon>"));
4195 else
4196 {
4197 gcc_assert (TREE_CODE (decl) != TYPE_DECL((void)(!(((enum tree_code) (decl)->base.code) != TYPE_DECL
|| !no_linkage_check (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4198, __FUNCTION__))->typed.type), true)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4198, __FUNCTION__), 0 : 0))
4198 || !no_linkage_check (TREE_TYPE (decl), true))((void)(!(((enum tree_code) (decl)->base.code) != TYPE_DECL
|| !no_linkage_check (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4198, __FUNCTION__))->typed.type), true)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4198, __FUNCTION__), 0 : 0));
4199 if (abi_version_at_least (10)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (10)))
4200 if (tree fn = decl_function_context (decl))
4201 maybe_check_abi_tags (fn, decl);
4202 id = get_mangled_id (decl);
4203 }
4204 SET_DECL_ASSEMBLER_NAME (decl, id)overwrite_decl_assembler_name (decl, id);
4205
4206 if (G.need_cxx17_warning
4207 && (TREE_PUBLIC (decl)((decl)->base.public_flag) || DECL_REALLY_EXTERN (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4207, __FUNCTION__))->decl_common.decl_flag_1) &&
(!((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4207, __FUNCTION__))->decl_common.lang_specific) || !(((
contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4207, __FUNCTION__))->decl_common.lang_specific)->u.base
.not_really_extern)))))
4208 warning_at (DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4208, __FUNCTION__))->decl_minimal.locus), OPT_Wnoexcept_type,
4209 "mangled name for %qD will change in C++17 because the "
4210 "exception specification is part of a function type",
4211 decl);
4212
4213 if (id != DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4213, __FUNCTION__))->decl_minimal.name)
4214 /* Don't do this for a fake symbol we aren't going to emit anyway. */
4215 && TREE_CODE (decl)((enum tree_code) (decl)->base.code) != TYPE_DECL
4216 && !DECL_MAYBE_IN_CHARGE_CDTOR_P (decl)((((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4216, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_CTOR_IDENTIFIER]) || (((contains_struct_check ((decl), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4216, __FUNCTION__))->decl_minimal.name) == cp_global_trees
[CPTI_DTOR_IDENTIFIER])))
4217 {
4218 int save_ver = flag_abi_versionglobal_options.x_flag_abi_version;
4219 tree id2 = NULL_TREE(tree) nullptr;
4220
4221 if (!DECL_REALLY_EXTERN (decl)(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4221, __FUNCTION__))->decl_common.decl_flag_1) &&
(!((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4221, __FUNCTION__))->decl_common.lang_specific) || !(((
contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4221, __FUNCTION__))->decl_common.lang_specific)->u.base
.not_really_extern))))
4222 {
4223 record_mangling (decl, G.need_abi_warning);
4224
4225 if (!G.need_abi_warning)
4226 return;
4227
4228 flag_abi_versionglobal_options.x_flag_abi_version = flag_abi_compat_versionglobal_options.x_flag_abi_compat_version;
4229 id2 = mangle_decl_string (decl);
4230 id2 = targetm.mangle_decl_assembler_name (decl, id2);
4231 flag_abi_versionglobal_options.x_flag_abi_version = save_ver;
4232
4233 if (id2 != id)
4234 note_mangling_alias (decl, id2);
4235 }
4236
4237 if (warn_abiglobal_options.x_warn_abi)
4238 {
4239 const char fabi_version[] = "-fabi-version";
4240
4241 if (flag_abi_compat_versionglobal_options.x_flag_abi_compat_version != warn_abi_version
4242 || id2 == NULL_TREE(tree) nullptr)
4243 {
4244 flag_abi_versionglobal_options.x_flag_abi_version = warn_abi_version;
4245 id2 = mangle_decl_string (decl);
4246 id2 = targetm.mangle_decl_assembler_name (decl, id2);
4247 }
4248 flag_abi_versionglobal_options.x_flag_abi_version = save_ver;
4249
4250 if (id2 == id)
4251 /* OK. */;
4252 else if (warn_abi_version != 0
4253 && abi_version_at_least (warn_abi_version)(global_options.x_flag_abi_version == 0 || global_options.x_flag_abi_version
>= (warn_abi_version)))
4254 warning_at (DECL_SOURCE_LOCATION (G.entity)((contains_struct_check ((G.entity), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4254, __FUNCTION__))->decl_minimal.locus), OPT_Wabi,
4255 "the mangled name of %qD changed between "
4256 "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
4257 G.entity, fabi_version, warn_abi_version, id2,
4258 fabi_version, save_ver, id);
4259 else
4260 warning_at (DECL_SOURCE_LOCATION (G.entity)((contains_struct_check ((G.entity), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4260, __FUNCTION__))->decl_minimal.locus), OPT_Wabi,
4261 "the mangled name of %qD changes between "
4262 "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)",
4263 G.entity, fabi_version, save_ver, id,
4264 fabi_version, warn_abi_version, id2);
4265 }
4266
4267 flag_abi_versionglobal_options.x_flag_abi_version = save_ver;
4268 }
4269}
4270
4271/* Generate the mangled representation of TYPE. */
4272
4273const char *
4274mangle_type_string (const tree type)
4275{
4276 const char *result;
4277
4278 start_mangling (type);
4279 write_type (type);
4280 result = finish_mangling ();
4281 if (DEBUG_MANGLE0)
4282 fprintf (stderrstderr, "mangle_type_string = '%s'\n\n", result);
4283 return result;
4284}
4285
4286/* Create an identifier for the mangled name of a special component
4287 for belonging to TYPE. CODE is the ABI-specified code for this
4288 component. */
4289
4290static tree
4291mangle_special_for_type (const tree type, const char *code)
4292{
4293 tree result;
4294
4295 /* We don't have an actual decl here for the special component, so
4296 we can't just process the <encoded-name>. Instead, fake it. */
4297 start_mangling (type);
4298
4299 /* Start the mangling. */
4300 write_string ("_Z")__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen ("_Z")); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, ("_Z"), __len); __o->next_free += __len
; (void) 0; });
4301 write_string (code)__extension__ ({ struct obstack *__o = (mangle_obstack); size_t
__len = (strlen (code)); if (__extension__ ({ struct obstack
const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
(__o->next_free, (code), __len); __o->next_free += __len
; (void) 0; });
4302
4303 /* Add the type. */
4304 write_type (type);
4305 result = finish_mangling_get_identifier ();
4306
4307 if (DEBUG_MANGLE0)
4308 fprintf (stderrstderr, "mangle_special_for_type = %s\n\n",
4309 IDENTIFIER_POINTER (result)((const char *) (tree_check ((result), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/mangle.cc"
, 4309, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
4310
4311 return result;
4312}
4313
4314/* Create an identifier for the mangled representation of the typeinfo
4315 structure for TYPE. */
4316
4317tree
4318mangle_typeinfo_for_type (const tree type)
4319{
4320 return mangle_special_for_type (type, "TI");
4321}
4322
4323/* Create an identifier for the mangled name of the NTBS containing
4324 the mangled name of TYPE. */
4325
4326tree
4327mangle_typeinfo_string_for_type (const tree type)
4328{
4329 return mangle_special_for_type (type, "TS");
4330}
4331
4332/* Create an identifier for the mangled name of the vtable for TYPE. */