Bug Summary

File:build/gcc/cp/error.cc
Warning:line 1338, column 4
Value stored to 'flags' 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 error.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-WWs05q.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc
1/* Call-backs for C++ error reporting.
2 This code is non-reentrant.
3 Copyright (C) 1993-2023 Free Software Foundation, Inc.
4 This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 3, or (at your option)
9any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#include "config.h"
21/* For use with name_hint. */
22#define INCLUDE_MEMORY
23#include "system.h"
24#include "coretypes.h"
25#include "cp-tree.h"
26#include "stringpool.h"
27#include "tree-diagnostic.h"
28#include "diagnostic-color.h"
29#include "langhooks-def.h"
30#include "intl.h"
31#include "cxx-pretty-print.h"
32#include "tree-pretty-print.h"
33#include "gimple-pretty-print.h"
34#include "c-family/c-objc.h"
35#include "ubsan.h"
36#include "internal-fn.h"
37#include "gcc-rich-location.h"
38#include "cp-name-hint.h"
39#include "attribs.h"
40
41#define pp_separate_with_comma(PP)pp_cxx_separate_with (PP, ',') pp_cxx_separate_with (PP, ',')
42#define pp_separate_with_semicolon(PP)pp_cxx_separate_with (PP, ';') pp_cxx_separate_with (PP, ';')
43
44/* cxx_pp is a C++ front-end-specific pretty printer: this is where we
45 dump C++ ASTs as strings. It is mostly used only by the various
46 tree -> string functions that are occasionally called from the
47 debugger or by the front-end for things like
48 __PRETTY_FUNCTION__. */
49static cxx_pretty_printer actual_pretty_printer;
50static cxx_pretty_printer * const cxx_pp = &actual_pretty_printer;
51
52/* Translate if being used for diagnostics, but not for dump files or
53 __PRETTY_FUNCTION. */
54#define M_(msgid)((cxx_pp)->translate_identifiers ? gettext (msgid) : (msgid
)) (pp_translate_identifiers (cxx_pp)(cxx_pp)->translate_identifiers ? _(msgid)gettext (msgid) : (msgid))
55
56# define NEXT_CODE(T)(((enum tree_code) (((contains_struct_check ((T), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 56, __FUNCTION__))->typed.type))->base.code)) (TREE_CODE (TREE_TYPE (T))((enum tree_code) (((contains_struct_check ((T), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 56, __FUNCTION__))->typed.type))->base.code))
57
58static const char *args_to_string (tree, int);
59static const char *code_to_string (enum tree_code);
60static const char *cv_to_string (tree, int);
61static const char *decl_to_string (tree, int, bool);
62static const char *fndecl_to_string (tree, int);
63static const char *op_to_string (bool, enum tree_code);
64static const char *parm_to_string (int);
65static const char *type_to_string (tree, int, bool, bool *, bool);
66
67static void dump_alias_template_specialization (cxx_pretty_printer *, tree, int);
68static void dump_type (cxx_pretty_printer *, tree, int);
69static void dump_typename (cxx_pretty_printer *, tree, int);
70static void dump_simple_decl (cxx_pretty_printer *, tree, tree, int);
71static void dump_decl (cxx_pretty_printer *, tree, int);
72static void dump_template_decl (cxx_pretty_printer *, tree, int);
73static void dump_function_decl (cxx_pretty_printer *, tree, int);
74static void dump_expr (cxx_pretty_printer *, tree, int);
75static void dump_unary_op (cxx_pretty_printer *, const char *, tree, int);
76static void dump_binary_op (cxx_pretty_printer *, const char *, tree, int);
77static void dump_aggr_type (cxx_pretty_printer *, tree, int);
78static void dump_type_prefix (cxx_pretty_printer *, tree, int);
79static void dump_type_suffix (cxx_pretty_printer *, tree, int);
80static void dump_function_name (cxx_pretty_printer *, tree, int);
81static void dump_call_expr_args (cxx_pretty_printer *, tree, int, bool);
82static void dump_aggr_init_expr_args (cxx_pretty_printer *, tree, int, bool);
83static void dump_expr_list (cxx_pretty_printer *, tree, int);
84static void dump_global_iord (cxx_pretty_printer *, tree);
85static void dump_parameters (cxx_pretty_printer *, tree, int);
86static void dump_ref_qualifier (cxx_pretty_printer *, tree, int);
87static void dump_exception_spec (cxx_pretty_printer *, tree, int);
88static void dump_template_argument (cxx_pretty_printer *, tree, int);
89static void dump_template_argument_list (cxx_pretty_printer *, tree, int);
90static void dump_template_parameter (cxx_pretty_printer *, tree, int);
91static void dump_template_bindings (cxx_pretty_printer *, tree, tree,
92 vec<tree, va_gc> *);
93static void dump_scope (cxx_pretty_printer *, tree, int);
94static void dump_template_parms (cxx_pretty_printer *, tree, int, int);
95static int get_non_default_template_args_count (tree, int);
96static const char *function_category (tree);
97static void maybe_print_constexpr_context (diagnostic_context *);
98static void maybe_print_instantiation_context (diagnostic_context *);
99static void print_instantiation_full_context (diagnostic_context *);
100static void print_instantiation_partial_context (diagnostic_context *,
101 struct tinst_level *,
102 location_t);
103static void maybe_print_constraint_context (diagnostic_context *);
104static void cp_diagnostic_starter (diagnostic_context *, diagnostic_info *);
105static void cp_print_error_function (diagnostic_context *, diagnostic_info *);
106
107static bool cp_printer (pretty_printer *, text_info *, const char *,
108 int, bool, bool, bool, bool *, const char **);
109
110/* Struct for handling %H or %I, which require delaying printing the
111 type until a postprocessing stage. */
112
113class deferred_printed_type
114{
115public:
116 deferred_printed_type ()
117 : m_tree (NULL_TREE(tree) __null), m_buffer_ptr (NULL__null), m_verbose (false), m_quote (false)
118 {}
119
120 deferred_printed_type (tree type, const char **buffer_ptr, bool verbose,
121 bool quote)
122 : m_tree (type), m_buffer_ptr (buffer_ptr), m_verbose (verbose),
123 m_quote (quote)
124 {
125 gcc_assert (type)((void)(!(type) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 125, __FUNCTION__), 0 : 0));
126 gcc_assert (buffer_ptr)((void)(!(buffer_ptr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 126, __FUNCTION__), 0 : 0));
127 }
128
129 /* The tree is not GTY-marked: they are only non-NULL within a
130 call to pp_format. */
131 tree m_tree;
132 const char **m_buffer_ptr;
133 bool m_verbose;
134 bool m_quote;
135};
136
137/* Subclass of format_postprocessor for the C++ frontend.
138 This handles the %H and %I formatting codes, printing them
139 in a postprocessing phase (since they affect each other). */
140
141class cxx_format_postprocessor : public format_postprocessor
142{
143 public:
144 cxx_format_postprocessor ()
145 : m_type_a (), m_type_b ()
146 {}
147
148 format_postprocessor *clone() const final override
149 {
150 return new cxx_format_postprocessor ();
151 }
152
153 void handle (pretty_printer *pp) final override;
154
155 deferred_printed_type m_type_a;
156 deferred_printed_type m_type_b;
157};
158
159/* CONTEXT->printer is a basic pretty printer that was constructed
160 presumably by diagnostic_initialize(), called early in the
161 compiler's initialization process (in general_init) Before the FE
162 is initialized. This (C++) FE-specific diagnostic initializer is
163 thus replacing the basic pretty printer with one that has C++-aware
164 capacities. */
165
166void
167cxx_initialize_diagnostics (diagnostic_context *context)
168{
169 pretty_printer *base = context->printer;
170 cxx_pretty_printer *pp = XNEW (cxx_pretty_printer)((cxx_pretty_printer *) xmalloc (sizeof (cxx_pretty_printer))
);
171 context->printer = new (pp) cxx_pretty_printer ();
172
173 /* It is safe to free this object because it was previously XNEW()'d. */
174 base->~pretty_printer ();
175 XDELETE (base)free ((void*) (base));
176
177 c_common_diagnostics_set_defaults (context);
178 diagnostic_starter (context)(context)->begin_diagnostic = cp_diagnostic_starter;
179 /* diagnostic_finalizer is already c_diagnostic_finalizer. */
180 diagnostic_format_decoder (context)((context)->printer->format_decoder) = cp_printer;
181 pp->m_format_postprocessor = new cxx_format_postprocessor ();
182}
183
184/* Dump an '@module' name suffix for DECL, if any. */
185
186static void
187dump_module_suffix (cxx_pretty_printer *pp, tree decl)
188{
189 if (!modules_p ())
190 return;
191
192 if (!DECL_CONTEXT (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 192, __FUNCTION__))->decl_minimal.context))
193 return;
194
195 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) != CONST_DECL
196 || !UNSCOPED_ENUM_P (DECL_CONTEXT (decl))(((enum tree_code) (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 196, __FUNCTION__))->decl_minimal.context))->base.code
) == ENUMERAL_TYPE && !((tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 196, __FUNCTION__))->decl_minimal.context)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 196, __FUNCTION__, (ENUMERAL_TYPE)))->base.static_flag)))
197 {
198 if (!DECL_NAMESPACE_SCOPE_P (decl)(!(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 198, __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/error.cc"
, 198, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 198, __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/error.cc"
, 198, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]))->base.code) == NAMESPACE_DECL))
199 return;
200
201 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == NAMESPACE_DECL
202 && !DECL_NAMESPACE_ALIAS (decl)((contains_struct_check (((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 202, __FUNCTION__, (NAMESPACE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 202, __FUNCTION__))->decl_common.abstract_origin)
203 && (TREE_PUBLIC (decl)((decl)->base.public_flag) || !TREE_PUBLIC (CP_DECL_CONTEXT (decl))(((!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 203, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 203, __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/error.cc"
, 203, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]))->base.public_flag)))
204 return;
205 }
206
207 if (unsigned m = get_originating_module (decl))
208 if (const char *n = module_name (m, false))
209 {
210 pp_character (pp, '@');
211 pp->padding = pp_none;
212 pp_string (pp, n);
213 }
214}
215
216/* The scope of the declaration we're currently printing, to avoid redundantly
217 dumping the same scope on parameter types. */
218static tree current_dump_scope;
219
220/* Dump a scope, if deemed necessary. */
221
222static void
223dump_scope (cxx_pretty_printer *pp, tree scope, int flags)
224{
225 int f = flags & (TFF_SCOPE(1) | TFF_CHASE_TYPEDEF(1 << 1));
226
227 if (scope == NULL_TREE(tree) __null || scope == current_dump_scope)
228 return;
229
230 /* Enum values within an unscoped enum will be CONST_DECL with an
231 ENUMERAL_TYPE as their "scope". Use CP_TYPE_CONTEXT of the
232 ENUMERAL_TYPE, so as to print any enclosing namespace. */
233 if (UNSCOPED_ENUM_P (scope)(((enum tree_code) (scope)->base.code) == ENUMERAL_TYPE &&
!((tree_check ((scope), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 233, __FUNCTION__, (ENUMERAL_TYPE)))->base.static_flag)))
234 scope = CP_TYPE_CONTEXT (scope)(!(! (((tree_class_check ((scope), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 234, __FUNCTION__))->type_common.context)) || ((enum tree_code
) (((tree_class_check ((scope), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 234, __FUNCTION__))->type_common.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((tree_class_check ((scope), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 234, __FUNCTION__))->type_common.context) : cp_global_trees
[CPTI_GLOBAL]);
235
236 if (TREE_CODE (scope)((enum tree_code) (scope)->base.code) == NAMESPACE_DECL)
237 {
238 if (scope != global_namespacecp_global_trees[CPTI_GLOBAL])
239 {
240 dump_decl (pp, scope, f);
241 pp_cxx_colon_colon (pp);
242 }
243 }
244 else if (AGGREGATE_TYPE_P (scope)(((enum tree_code) (scope)->base.code) == ARRAY_TYPE || ((
(enum tree_code) (scope)->base.code) == RECORD_TYPE || ((enum
tree_code) (scope)->base.code) == UNION_TYPE || ((enum tree_code
) (scope)->base.code) == QUAL_UNION_TYPE))
245 || SCOPED_ENUM_P (scope)(((enum tree_code) (scope)->base.code) == ENUMERAL_TYPE &&
((tree_check ((scope), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 245, __FUNCTION__, (ENUMERAL_TYPE)))->base.static_flag)))
246 {
247 dump_type (pp, scope, f);
248 pp_cxx_colon_colon (pp);
249 }
250 else if ((flags & TFF_SCOPE(1)) && TREE_CODE (scope)((enum tree_code) (scope)->base.code) == FUNCTION_DECL)
251 {
252 dump_function_decl (pp, scope, f | TFF_NO_TEMPLATE_BINDINGS(1 << 13));
253 pp_cxx_colon_colon (pp);
254 }
255}
256
257/* Dump the template ARGument under control of FLAGS. */
258
259static void
260dump_template_argument (cxx_pretty_printer *pp, tree arg, int flags)
261{
262 if (ARGUMENT_PACK_P (arg)(((enum tree_code) (arg)->base.code) == TYPE_ARGUMENT_PACK
|| ((enum tree_code) (arg)->base.code) == NONTYPE_ARGUMENT_PACK
))
263 dump_template_argument_list (pp, ARGUMENT_PACK_ARGS (arg)(((enum tree_code) ((tree_check2 ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 263, __FUNCTION__, (TYPE_ARGUMENT_PACK), (NONTYPE_ARGUMENT_PACK
))))->base.code) == TYPE_ARGUMENT_PACK ? ((contains_struct_check
((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 263, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 263, __FUNCTION__)))))),
264 /* No default args in argument packs. */
265 flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS(1 << 12));
266 else if (TYPE_P (arg)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (arg)->base.code))] == tcc_type) || TREE_CODE (arg)((enum tree_code) (arg)->base.code) == TEMPLATE_DECL)
267 dump_type (pp, arg, flags & ~TFF_CLASS_KEY_OR_ENUM(1 << 3));
268 else
269 {
270 if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == TREE_LIST)
271 arg = TREE_VALUE (arg)((tree_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 271, __FUNCTION__, (TREE_LIST)))->list.value);
272
273 /* Strip implicit conversions. */
274 while (CONVERT_EXPR_P (arg)((((enum tree_code) (arg)->base.code)) == NOP_EXPR || (((enum
tree_code) (arg)->base.code)) == CONVERT_EXPR))
275 arg = TREE_OPERAND (arg, 0)(*((const_cast<tree*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 275, __FUNCTION__)))));
276
277 dump_expr (pp, arg, (flags | TFF_EXPR_IN_PARENS(1 << 9)) & ~TFF_CLASS_KEY_OR_ENUM(1 << 3));
278 }
279}
280
281/* Count the number of template arguments ARGS whose value does not
282 match the (optional) default template parameter in PARAMS */
283
284static int
285get_non_default_template_args_count (tree args, int flags)
286{
287 int n = TREE_VEC_LENGTH (INNERMOST_TEMPLATE_ARGS (args))((tree_check (((get_innermost_template_args ((args), 1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 287, __FUNCTION__, (TREE_VEC)))->base.u.length);
288
289 if (/* We use this flag when generating debug information. We don't
290 want to expand templates at this point, for this may generate
291 new decls, which gets decl counts out of sync, which may in
292 turn cause codegen differences between compilations with and
293 without -g. */
294 (flags & TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS(1 << 12)) != 0
295 || !flag_pretty_templatesglobal_options.x_flag_pretty_templates)
296 return n;
297
298 return GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (INNERMOST_TEMPLATE_ARGS (args))int_cst_value (((contains_struct_check (((tree_check (((get_innermost_template_args
((args), 1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 298, __FUNCTION__, (TREE_VEC)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 298, __FUNCTION__))->common.chain));
299}
300
301/* Dump a template-argument-list ARGS (always a TREE_VEC) under control
302 of FLAGS. */
303
304static void
305dump_template_argument_list (cxx_pretty_printer *pp, tree args, int flags)
306{
307 int n = get_non_default_template_args_count (args, flags);
308 int need_comma = 0;
309 int i;
310
311 for (i = 0; i < n; ++i)
312 {
313 tree arg = TREE_VEC_ELT (args, i)(*((const_cast<tree *> (tree_vec_elt_check ((args), (i)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 313, __FUNCTION__)))));
314
315 /* Only print a comma if we know there is an argument coming. In
316 the case of an empty template argument pack, no actual
317 argument will be printed. */
318 if (need_comma
319 && (!ARGUMENT_PACK_P (arg)(((enum tree_code) (arg)->base.code) == TYPE_ARGUMENT_PACK
|| ((enum tree_code) (arg)->base.code) == NONTYPE_ARGUMENT_PACK
)
320 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg))((tree_check (((((enum tree_code) ((tree_check2 ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 320, __FUNCTION__, (TYPE_ARGUMENT_PACK), (NONTYPE_ARGUMENT_PACK
))))->base.code) == TYPE_ARGUMENT_PACK ? ((contains_struct_check
((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 320, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 320, __FUNCTION__))))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 320, __FUNCTION__, (TREE_VEC)))->base.u.length) > 0))
321 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
322
323 dump_template_argument (pp, arg, flags);
324 need_comma = 1;
325 }
326}
327
328/* Dump a template parameter PARM (a TREE_LIST) under control of FLAGS. */
329
330static void
331dump_template_parameter (cxx_pretty_printer *pp, tree parm, int flags)
332{
333 tree p;
334 tree a;
335
336 if (parm == error_mark_nodeglobal_trees[TI_ERROR_MARK])
337 return;
338
339 p = TREE_VALUE (parm)((tree_check ((parm), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 339, __FUNCTION__, (TREE_LIST)))->list.value);
340 a = TREE_PURPOSE (parm)((tree_check ((parm), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 340, __FUNCTION__, (TREE_LIST)))->list.purpose);
341
342 if (TREE_CODE (p)((enum tree_code) (p)->base.code) == TYPE_DECL)
343 {
344 if (flags & TFF_DECL_SPECIFIERS(1 << 2))
345 {
346 pp_cxx_ws_string (pp, "class")pp_c_ws_string (pp, "class");
347 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (p))((((tree_not_check2 (((tree_check (((((tree_class_check (((tree_check3
(((((contains_struct_check ((p), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 347, __FUNCTION__))->typed.type))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 347, __FUNCTION__, (TEMPLATE_TYPE_PARM), (TEMPLATE_TEMPLATE_PARM
), (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 347, __FUNCTION__))->type_non_common.values))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 347, __FUNCTION__, (TEMPLATE_PARM_INDEX)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 347, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))))
348 pp_cxx_ws_string (pp, "...")pp_c_ws_string (pp, "...");
349 if (DECL_NAME (p)((contains_struct_check ((p), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 349, __FUNCTION__))->decl_minimal.name))
350 pp_cxx_tree_identifier (pp, DECL_NAME (p))pp_c_identifier (pp, ((const char *) (tree_check ((((contains_struct_check
((p), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 350, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 350, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
351 }
352 else if (DECL_NAME (p)((contains_struct_check ((p), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 352, __FUNCTION__))->decl_minimal.name))
353 pp_cxx_tree_identifier (pp, DECL_NAME (p))pp_c_identifier (pp, ((const char *) (tree_check ((((contains_struct_check
((p), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 353, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 353, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
354 else
355 pp_cxx_canonical_template_parameter (pp, TREE_TYPE (p)((contains_struct_check ((p), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 355, __FUNCTION__))->typed.type));
356 }
357 else
358 dump_decl (pp, p, flags | TFF_DECL_SPECIFIERS(1 << 2));
359
360 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS(1 << 5)) && a != NULL_TREE(tree) __null)
361 {
362 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
363 pp_equal (pp)pp_character (pp, '=');
364 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
365 if (TREE_CODE (p)((enum tree_code) (p)->base.code) == TYPE_DECL || TREE_CODE (p)((enum tree_code) (p)->base.code) == TEMPLATE_DECL)
366 dump_type (pp, a, flags & ~TFF_CHASE_TYPEDEF(1 << 1));
367 else
368 dump_expr (pp, a, flags | TFF_EXPR_IN_PARENS(1 << 9));
369 }
370}
371
372/* Dump, under control of FLAGS, a template-parameter-list binding.
373 PARMS is a TREE_LIST of TREE_VEC of TREE_LIST and ARGS is a
374 TREE_VEC. */
375
376static void
377dump_template_bindings (cxx_pretty_printer *pp, tree parms, tree args,
378 vec<tree, va_gc> *typenames)
379{
380 /* Print "[with" and ']', conditional on whether anything is printed at all.
381 This is tied to whether a semicolon is needed to separate multiple template
382 parameters. */
383 struct prepost_semicolon
384 {
385 cxx_pretty_printer *pp;
386 bool need_semicolon;
387
388 void operator() ()
389 {
390 if (need_semicolon)
391 pp_separate_with_semicolon (pp)pp_cxx_separate_with (pp, ';');
392 else
393 {
394 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
395 pp_string (pp, colorize_start (pp_show_color (pp)(pp)->show_color, "targs"));
396 pp_cxx_left_bracket (pp)pp_c_left_bracket (pp);
397 pp->translate_string ("with");
398 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
399 need_semicolon = true;
400 }
401 }
402
403 ~prepost_semicolon ()
404 {
405 if (need_semicolon)
406 {
407 pp_cxx_right_bracket (pp)pp_c_right_bracket (pp);
408 pp_string (pp, colorize_stop (pp_show_color (pp)(pp)->show_color));
409 }
410 }
411 } semicolon_or_introducer = {pp, false};
412
413 int i;
414 tree t;
415
416 while (parms)
417 {
418 tree p = TREE_VALUE (parms)((tree_check ((parms), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 418, __FUNCTION__, (TREE_LIST)))->list.value);
419 int lvl = TMPL_PARMS_DEPTH (parms)((long) ((unsigned long) (*tree_int_cst_elt_check ((((tree_check
((parms), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 419, __FUNCTION__, (TREE_LIST)))->list.purpose)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 419, __FUNCTION__))));
420 int arg_idx = 0;
421 int i;
422 tree lvl_args = NULL_TREE(tree) __null;
423
424 /* Don't crash if we had an invalid argument list. */
425 if (TMPL_ARGS_DEPTH (args)((args) == (tree) __null ? 0 : (args && ((tree_check (
(args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 425, __FUNCTION__, (TREE_VEC)))->base.u.length) &&
(*((const_cast<tree *> (tree_vec_elt_check ((args), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 425, __FUNCTION__))))) && ((enum tree_code) ((*((const_cast
<tree *> (tree_vec_elt_check ((args), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 425, __FUNCTION__))))))->base.code) == TREE_VEC) ? ((tree_check
((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 425, __FUNCTION__, (TREE_VEC)))->base.u.length) : 1) >= lvl)
426 lvl_args = TMPL_ARGS_LEVEL (args, lvl)((args && ((tree_check ((args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 426, __FUNCTION__, (TREE_VEC)))->base.u.length) &&
(*((const_cast<tree *> (tree_vec_elt_check ((args), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 426, __FUNCTION__))))) && ((enum tree_code) ((*((const_cast
<tree *> (tree_vec_elt_check ((args), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 426, __FUNCTION__))))))->base.code) == TREE_VEC) ? (*((const_cast
<tree *> (tree_vec_elt_check ((args), ((lvl) - 1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 426, __FUNCTION__))))) : (((void)(!((lvl) == 1) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 426, __FUNCTION__), 0 : 0)), (args)));
427
428 for (i = 0; i < TREE_VEC_LENGTH (p)((tree_check ((p), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 428, __FUNCTION__, (TREE_VEC)))->base.u.length); ++i)
429 {
430 tree arg = NULL_TREE(tree) __null;
431
432 /* Don't crash if we had an invalid argument list. */
433 if (lvl_args && NUM_TMPL_ARGS (lvl_args)(((tree_check ((lvl_args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 433, __FUNCTION__, (TREE_VEC)))->base.u.length)) > arg_idx)
434 arg = TREE_VEC_ELT (lvl_args, arg_idx)(*((const_cast<tree *> (tree_vec_elt_check ((lvl_args),
(arg_idx), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 434, __FUNCTION__)))));
435
436 tree parm_i = TREE_VEC_ELT (p, i)(*((const_cast<tree *> (tree_vec_elt_check ((p), (i), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 436, __FUNCTION__)))));
437 /* If the template argument repeats the template parameter (T = T),
438 skip the parameter.*/
439 if (arg && TREE_CODE (arg)((enum tree_code) (arg)->base.code) == TEMPLATE_TYPE_PARM
440 && TREE_CODE (parm_i)((enum tree_code) (parm_i)->base.code) == TREE_LIST
441 && TREE_CODE (TREE_VALUE (parm_i))((enum tree_code) (((tree_check ((parm_i), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 441, __FUNCTION__, (TREE_LIST)))->list.value))->base.
code) == TYPE_DECL
442 && TREE_CODE (TREE_TYPE (TREE_VALUE (parm_i)))((enum tree_code) (((contains_struct_check ((((tree_check ((parm_i
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 442, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 442, __FUNCTION__))->typed.type))->base.code)
443 == TEMPLATE_TYPE_PARM
444 && DECL_NAME (TREE_VALUE (parm_i))((contains_struct_check ((((tree_check ((parm_i), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 444, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 444, __FUNCTION__))->decl_minimal.name)
445 == DECL_NAME (TREE_CHAIN (arg))((contains_struct_check ((((contains_struct_check ((arg), (TS_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 445, __FUNCTION__))->common.chain)), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 445, __FUNCTION__))->decl_minimal.name))
446 continue;
447
448 semicolon_or_introducer ();
449 dump_template_parameter (pp, parm_i, TFF_PLAIN_IDENTIFIER(0));
450 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
451 pp_equal (pp)pp_character (pp, '=');
452 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
453 if (arg)
454 {
455 if (ARGUMENT_PACK_P (arg)(((enum tree_code) (arg)->base.code) == TYPE_ARGUMENT_PACK
|| ((enum tree_code) (arg)->base.code) == NONTYPE_ARGUMENT_PACK
))
456 pp_cxx_left_brace (pp)pp_c_left_brace (pp);
457 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER(0));
458 if (ARGUMENT_PACK_P (arg)(((enum tree_code) (arg)->base.code) == TYPE_ARGUMENT_PACK
|| ((enum tree_code) (arg)->base.code) == NONTYPE_ARGUMENT_PACK
))
459 pp_cxx_right_brace (pp)pp_c_right_brace (pp);
460 }
461 else
462 pp_string (pp, M_("<missing>")((cxx_pp)->translate_identifiers ? gettext ("<missing>"
) : ("<missing>")));
463
464 ++arg_idx;
465 }
466
467 parms = TREE_CHAIN (parms)((contains_struct_check ((parms), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 467, __FUNCTION__))->common.chain);
468 }
469
470 /* Don't bother with typenames for a partial instantiation. */
471 if (vec_safe_is_empty (typenames) || uses_template_parms (args))
472 return;
473
474 /* Don't try to print typenames when we're processing a clone. */
475 if (current_function_decl
476 && !DECL_LANG_SPECIFIC (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 476, __FUNCTION__))->decl_common.lang_specific))
477 return;
478
479 /* Don't try to do this once cgraph starts throwing away front-end
480 information. */
481 if (at_eof >= 2)
482 return;
483
484 FOR_EACH_VEC_SAFE_ELT (typenames, i, t)for (i = 0; vec_safe_iterate ((typenames), (i), &(t)); ++
(i))
485 {
486 semicolon_or_introducer ();
487 dump_type (pp, t, TFF_PLAIN_IDENTIFIER(0));
488 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
489 pp_equal (pp)pp_character (pp, '=');
490 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
491 push_deferring_access_checks (dk_no_check);
492 t = tsubst (t, args, tf_none, NULL_TREE(tree) __null);
493 pop_deferring_access_checks ();
494 /* Strip typedefs. We can't just use TFF_CHASE_TYPEDEF because
495 pp_simple_type_specifier doesn't know about it. */
496 t = strip_typedefs (t, NULL__null, STF_USER_VISIBLE);
497 dump_type (pp, t, TFF_PLAIN_IDENTIFIER(0));
498 }
499}
500
501/* Dump a human-readable equivalent of the alias template
502 specialization of T. */
503
504static void
505dump_alias_template_specialization (cxx_pretty_printer *pp, tree t, int flags)
506{
507 gcc_assert (alias_template_specialization_p (t, nt_opaque))((void)(!(alias_template_specialization_p (t, nt_opaque)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 507, __FUNCTION__), 0 : 0));
508
509 tree decl = TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 509, __FUNCTION__))->type_common.name);
510 if (!(flags & TFF_UNQUALIFIED_NAME(1 << 11)))
511 dump_scope (pp, CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 511, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 511, __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/error.cc"
, 511, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]), flags);
512 pp_cxx_tree_identifier (pp, DECL_NAME (decl))pp_c_identifier (pp, ((const char *) (tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 512, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 512, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
513 dump_template_parms (pp, DECL_TEMPLATE_INFO (decl)(((contains_struct_check ((template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 513, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 513, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info),
514 /*primary=*/false,
515 flags & ~TFF_TEMPLATE_HEADER(1 << 7));
516}
517
518/* Dump a human-readable equivalent of TYPE. FLAGS controls the
519 format. */
520
521static void
522dump_type (cxx_pretty_printer *pp, tree t, int flags)
523{
524 if (t == NULL_TREE(tree) __null)
525 return;
526
527 /* Don't print e.g. "struct mytypedef". */
528 if (TYPE_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_type) && typedef_variant_p (t))
529 {
530 tree decl = TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 530, __FUNCTION__))->type_common.name);
531 if ((flags & TFF_CHASE_TYPEDEF(1 << 1))
532 || DECL_SELF_REFERENCE_P (decl)(((enum tree_code) (decl)->base.code) == TYPE_DECL &&
((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 532, __FUNCTION__))->decl_common.lang_flag_4))
533 || (!flag_pretty_templatesglobal_options.x_flag_pretty_templates
534 && DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 534, __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/error.cc"
, 534, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 534, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info)))
535 {
536 unsigned int stf_flags = (!(pp->flags & pp_c_flag_gnu_v3)
537 ? STF_USER_VISIBLE : 0);
538 t = strip_typedefs (t, NULL__null, stf_flags);
539 }
540 else if (alias_template_specialization_p (t, nt_opaque))
541 {
542 dump_alias_template_specialization (pp, t, flags);
543 return;
544 }
545 else if (same_type_p (t, TREE_TYPE (decl))comptypes ((t), (((contains_struct_check ((decl), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 545, __FUNCTION__))->typed.type)), 0))
546 t = decl;
547 else
548 {
549 pp_cxx_cv_qualifier_seq (pp, t)pp_c_type_qualifier_list (pp, t);
550 if (! (flags & TFF_UNQUALIFIED_NAME(1 << 11)))
551 dump_scope (pp, CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 551, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 551, __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/error.cc"
, 551, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]), flags);
552 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t))pp_c_identifier (pp, ((const char *) (tree_check (((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 552, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 552, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 552, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 552, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 552, __FUNCTION__))->type_common.name))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 552, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
553 return;
554 }
555 }
556
557 if (TYPE_PTRMEMFUNC_P (t)(((enum tree_code) (t)->base.code) == RECORD_TYPE &&
(((tree_class_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 557, __FUNCTION__, (RECORD_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 557, __FUNCTION__))->type_common.lang_flag_2))))
558 goto offset_type;
559
560 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
561 {
562 case LANG_TYPE:
563 if (t == init_list_type_nodecp_global_trees[CPTI_INIT_LIST_TYPE])
564 pp_string (pp, M_("<brace-enclosed initializer list>")((cxx_pp)->translate_identifiers ? gettext ("<brace-enclosed initializer list>"
) : ("<brace-enclosed initializer list>")));
565 else if (t == unknown_type_nodecp_global_trees[CPTI_UNKNOWN_TYPE])
566 pp_string (pp, M_("<unresolved overloaded function type>")((cxx_pp)->translate_identifiers ? gettext ("<unresolved overloaded function type>"
) : ("<unresolved overloaded function type>")));
567 else
568 {
569 pp_cxx_cv_qualifier_seq (pp, t)pp_c_type_qualifier_list (pp, t);
570 if (tree id = TYPE_IDENTIFIER (t)(((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 570, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 570, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 570, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 570, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 570, __FUNCTION__))->type_common.name)))
571 pp_cxx_tree_identifier (pp, id)pp_c_identifier (pp, ((const char *) (tree_check ((id), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 571, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
572 }
573 break;
574
575 case TREE_LIST:
576 /* A list of function parms. */
577 dump_parameters (pp, t, flags);
578 break;
579
580 case IDENTIFIER_NODE:
581 pp_cxx_tree_identifier (pp, t)pp_c_identifier (pp, ((const char *) (tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 581, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
582 break;
583
584 case TREE_BINFO:
585 dump_type (pp, BINFO_TYPE (t)((contains_struct_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 585, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 585, __FUNCTION__))->typed.type), flags);
586 break;
587
588 case RECORD_TYPE:
589 case UNION_TYPE:
590 case ENUMERAL_TYPE:
591 dump_aggr_type (pp, t, flags);
592 break;
593
594 case TYPE_DECL:
595 if (flags & TFF_CHASE_TYPEDEF(1 << 1))
596 {
597 dump_type (pp, DECL_ORIGINAL_TYPE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 597, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
)
598 ? DECL_ORIGINAL_TYPE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 598, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
) : TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 598, __FUNCTION__))->typed.type), flags);
599 break;
600 }
601 /* Fall through. */
602
603 case TEMPLATE_DECL:
604 case NAMESPACE_DECL:
605 dump_decl (pp, t, flags & ~TFF_DECL_SPECIFIERS(1 << 2));
606 break;
607
608 case INTEGER_TYPE:
609 case REAL_TYPE:
610 case VOID_TYPE:
611 case OPAQUE_TYPE:
612 case BOOLEAN_TYPE:
613 case COMPLEX_TYPE:
614 case VECTOR_TYPE:
615 case FIXED_POINT_TYPE:
616 pp_type_specifier_seq (pp, t)(pp)->type_specifier_seq (pp, t);
617 break;
618
619 case TEMPLATE_TEMPLATE_PARM:
620 /* For parameters inside template signature. */
621 if (TYPE_IDENTIFIER (t)(((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 621, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 621, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 621, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 621, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 621, __FUNCTION__))->type_common.name)))
622 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t))pp_c_identifier (pp, ((const char *) (tree_check (((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 622, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 622, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 622, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 622, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 622, __FUNCTION__))->type_common.name))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 622, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
623 else
624 pp_cxx_canonical_template_parameter (pp, t);
625 break;
626
627 case BOUND_TEMPLATE_TEMPLATE_PARM:
628 {
629 tree args = TYPE_TI_ARGS (t)(((struct tree_template_info*)(tree_check (((((enum tree_code
) (t)->base.code) == ENUMERAL_TYPE || ((enum tree_code) (t
)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM || (((enum tree_code
) (t)->base.code) == RECORD_TYPE || ((enum tree_code) (t)->
base.code) == UNION_TYPE || ((enum tree_code) (t)->base.code
) == QUAL_UNION_TYPE) ? ((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 629, __FUNCTION__))->type_non_common.lang_1) : (tree) __null
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 629, __FUNCTION__, (TEMPLATE_INFO))))->args);
630 pp_cxx_cv_qualifier_seq (pp, t)pp_c_type_qualifier_list (pp, t);
631 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t))pp_c_identifier (pp, ((const char *) (tree_check (((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 631, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 631, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 631, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 631, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 631, __FUNCTION__))->type_common.name))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 631, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
632 pp_cxx_begin_template_argument_list (pp);
633 dump_template_argument_list (pp, args, flags);
634 pp_cxx_end_template_argument_list (pp);
635 }
636 break;
637
638 case TEMPLATE_TYPE_PARM:
639 pp_cxx_cv_qualifier_seq (pp, t)pp_c_type_qualifier_list (pp, t);
640 if (template_placeholder_p (t))
641 {
642 t = TREE_TYPE (CLASS_PLACEHOLDER_TEMPLATE (t))((contains_struct_check (((((contains_struct_check ((((tree_class_check
(((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 642, __FUNCTION__, (TEMPLATE_TYPE_PARM)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 642, __FUNCTION__))->type_common.name)), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 642, __FUNCTION__))->decl_common.initial))), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 642, __FUNCTION__))->typed.type);
643 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t))pp_c_identifier (pp, ((const char *) (tree_check (((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 643, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 643, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 643, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 643, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 643, __FUNCTION__))->type_common.name))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 643, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
644 pp_string (pp, "<...auto...>");
645 }
646 else if (TYPE_IDENTIFIER (t)(((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 646, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 646, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 646, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 646, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 646, __FUNCTION__))->type_common.name)))
647 pp_cxx_tree_identifier (pp, TYPE_IDENTIFIER (t))pp_c_identifier (pp, ((const char *) (tree_check (((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 647, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 647, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 647, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 647, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 647, __FUNCTION__))->type_common.name))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 647, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
648 else
649 pp_cxx_canonical_template_parameter
650 (pp, TEMPLATE_TYPE_PARM_INDEX (t)(((tree_class_check (((tree_check3 (((t)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 650, __FUNCTION__, (TEMPLATE_TYPE_PARM), (TEMPLATE_TEMPLATE_PARM
), (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 650, __FUNCTION__))->type_non_common.values)));
651 /* If this is a constrained placeholder, add the requirements. */
652 if (tree c = PLACEHOLDER_TYPE_CONSTRAINTS (t)(((contains_struct_check ((((tree_class_check ((t), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 652, __FUNCTION__))->type_common.name)), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 652, __FUNCTION__))->decl_common.size_unit) ? ((tree_check
((((contains_struct_check ((((tree_class_check ((t), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 652, __FUNCTION__))->type_common.name)), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 652, __FUNCTION__))->decl_common.size_unit)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 652, __FUNCTION__, (TREE_LIST)))->list.value) : (tree) __null
))
653 pp_cxx_constrained_type_spec (pp, c);
654 break;
655
656 /* This is not always necessary for pointers and such, but doing this
657 reduces code size. */
658 case ARRAY_TYPE:
659 case POINTER_TYPE:
660 case REFERENCE_TYPE:
661 case OFFSET_TYPE:
662 offset_type:
663 case FUNCTION_TYPE:
664 case METHOD_TYPE:
665 {
666 dump_type_prefix (pp, t, flags);
667 dump_type_suffix (pp, t, flags);
668 break;
669 }
670 case TYPENAME_TYPE:
671 if (! (flags & TFF_CHASE_TYPEDEF(1 << 1))
672 && DECL_ORIGINAL_TYPE (TYPE_NAME (t))((tree_check ((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 672, __FUNCTION__))->type_common.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 672, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
))
673 {
674 dump_decl (pp, TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 674, __FUNCTION__))->type_common.name), TFF_PLAIN_IDENTIFIER(0));
675 break;
676 }
677 pp_cxx_cv_qualifier_seq (pp, t)pp_c_type_qualifier_list (pp, t);
678 pp_cxx_ws_string (pp,pp_c_ws_string (pp, (((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 679, __FUNCTION__, (TYPENAME_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 679, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)) ? "enum" : (((tree_not_check2 (((tree_check ((
t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 680, __FUNCTION__, (TYPENAME_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 680, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)) ? "class" : "typename")
679 TYPENAME_IS_ENUM_P (t) ? "enum"pp_c_ws_string (pp, (((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 679, __FUNCTION__, (TYPENAME_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 679, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)) ? "enum" : (((tree_not_check2 (((tree_check ((
t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 680, __FUNCTION__, (TYPENAME_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 680, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)) ? "class" : "typename")
680 : TYPENAME_IS_CLASS_P (t) ? "class"pp_c_ws_string (pp, (((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 679, __FUNCTION__, (TYPENAME_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 679, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)) ? "enum" : (((tree_not_check2 (((tree_check ((
t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 680, __FUNCTION__, (TYPENAME_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 680, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)) ? "class" : "typename")
681 : "typename")pp_c_ws_string (pp, (((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 679, __FUNCTION__, (TYPENAME_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 679, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)) ? "enum" : (((tree_not_check2 (((tree_check ((
t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 680, __FUNCTION__, (TYPENAME_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 680, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)) ? "class" : "typename");
682 dump_typename (pp, t, flags);
683 break;
684
685 case UNBOUND_CLASS_TEMPLATE:
686 if (! (flags & TFF_UNQUALIFIED_NAME(1 << 11)))
687 {
688 dump_type (pp, TYPE_CONTEXT (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 688, __FUNCTION__))->type_common.context), flags);
689 pp_cxx_colon_colon (pp);
690 }
691 pp_cxx_ws_string (pp, "template")pp_c_ws_string (pp, "template");
692 dump_type (pp, TYPE_IDENTIFIER (t)(((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 692, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 692, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 692, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 692, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 692, __FUNCTION__))->type_common.name)), flags);
693 break;
694
695 case TYPEOF_TYPE:
696 pp_cxx_ws_string (pp, "__typeof__")pp_c_ws_string (pp, "__typeof__");
697 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
698 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
699 dump_expr (pp, TYPEOF_TYPE_EXPR (t)(((tree_class_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 699, __FUNCTION__, (TYPEOF_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 699, __FUNCTION__))->type_non_common.values)), flags & ~TFF_EXPR_IN_PARENS(1 << 9));
700 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
701 break;
702
703 case TRAIT_TYPE:
704 pp_cxx_trait (pp, t);
705 break;
706
707 case TYPE_PACK_EXPANSION:
708 dump_type (pp, PACK_EXPANSION_PATTERN (t)(((enum tree_code) ((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 708, __FUNCTION__, (TYPE_PACK_EXPANSION), (EXPR_PACK_EXPANSION
))))->base.code) == TYPE_PACK_EXPANSION ? ((contains_struct_check
((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 708, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 708, __FUNCTION__)))))), flags);
709 pp_cxx_ws_string (pp, "...")pp_c_ws_string (pp, "...");
710 break;
711
712 case TYPE_ARGUMENT_PACK:
713 dump_template_argument (pp, t, flags);
714 break;
715
716 case DECLTYPE_TYPE:
717 pp_cxx_ws_string (pp, "decltype")pp_c_ws_string (pp, "decltype");
718 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
719 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
720 dump_expr (pp, DECLTYPE_TYPE_EXPR (t)(((tree_class_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 720, __FUNCTION__, (DECLTYPE_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 720, __FUNCTION__))->type_non_common.values)), flags & ~TFF_EXPR_IN_PARENS(1 << 9));
721 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
722 break;
723
724 case NULLPTR_TYPE:
725 pp_string (pp, "std::nullptr_t");
726 break;
727
728 default:
729 pp_unsupported_tree (pp, t)pp_verbatim (pp, "%qs not supported by %s", get_tree_code_name
(((enum tree_code) (t)->base.code)), __FUNCTION__);
730 /* Fall through. */
731
732 case ERROR_MARK:
733 pp_string (pp, M_("<type error>")((cxx_pp)->translate_identifiers ? gettext ("<type error>"
) : ("<type error>")));
734 break;
735 }
736}
737
738/* Dump a TYPENAME_TYPE. We need to notice when the context is itself
739 a TYPENAME_TYPE. */
740
741static void
742dump_typename (cxx_pretty_printer *pp, tree t, int flags)
743{
744 tree ctx = TYPE_CONTEXT (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 744, __FUNCTION__))->type_common.context);
745
746 if (TREE_CODE (ctx)((enum tree_code) (ctx)->base.code) == TYPENAME_TYPE)
747 dump_typename (pp, ctx, flags);
748 else
749 dump_type (pp, ctx, flags & ~TFF_CLASS_KEY_OR_ENUM(1 << 3));
750 pp_cxx_colon_colon (pp);
751 dump_decl (pp, TYPENAME_TYPE_FULLNAME (t)(((tree_class_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 751, __FUNCTION__, (TYPENAME_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 751, __FUNCTION__))->type_non_common.values)), flags);
752}
753
754/* Return the name of the supplied aggregate, or enumeral type. */
755
756const char *
757class_key_or_enum_as_string (tree t)
758{
759 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == ENUMERAL_TYPE)
760 {
761 if (SCOPED_ENUM_P (t)(((enum tree_code) (t)->base.code) == ENUMERAL_TYPE &&
((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 761, __FUNCTION__, (ENUMERAL_TYPE)))->base.static_flag)))
762 return "enum class";
763 else
764 return "enum";
765 }
766 else if (TREE_CODE (t)((enum tree_code) (t)->base.code) == UNION_TYPE)
767 return "union";
768 else if (TYPE_LANG_SPECIFIC (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 768, __FUNCTION__))->type_with_lang_specific.lang_specific
) && CLASSTYPE_DECLARED_CLASS (t)((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 768, __FUNCTION__))->type_with_lang_specific.lang_specific
))->declared_class))
769 return "class";
770 else
771 return "struct";
772}
773
774/* Disable warnings about missing quoting in GCC diagnostics for
775 the pp_verbatim call. Their format strings deliberately don't
776 follow GCC diagnostic conventions. */
777#if __GNUC__4 >= 10
778#pragma GCC diagnostic push
779#pragma GCC diagnostic ignored "-Wformat-diag"
780#endif
781
782/* Print out a class declaration T under the control of FLAGS,
783 in the form `class foo'. */
784
785static void
786dump_aggr_type (cxx_pretty_printer *pp, tree t, int flags)
787{
788 const char *variety = class_key_or_enum_as_string (t);
789 int typdef = 0;
790 int tmplate = 0;
791
792 pp_cxx_cv_qualifier_seq (pp, t)pp_c_type_qualifier_list (pp, t);
793
794 if (flags & TFF_CLASS_KEY_OR_ENUM(1 << 3))
795 pp_cxx_ws_string (pp, variety)pp_c_ws_string (pp, variety);
796
797 tree decl = TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 797, __FUNCTION__))->type_common.name);
798
799 if (decl)
800 {
801 typdef = (!DECL_ARTIFICIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 801, __FUNCTION__))->decl_common.artificial_flag)
802 /* An alias specialization is not considered to be a
803 typedef. */
804 && !alias_template_specialization_p (t, nt_opaque));
805
806 if ((typdef
807 && ((flags & TFF_CHASE_TYPEDEF(1 << 1))
808 || (!flag_pretty_templatesglobal_options.x_flag_pretty_templates && DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 808, __FUNCTION__))->decl_common.lang_specific)
809 && DECL_TEMPLATE_INFO (decl)(((contains_struct_check ((template_info_decl_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 809, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 809, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info))))
810 || DECL_SELF_REFERENCE_P (decl)(((enum tree_code) (decl)->base.code) == TYPE_DECL &&
((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 810, __FUNCTION__))->decl_common.lang_flag_4)))
811 {
812 t = TYPE_MAIN_VARIANT (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 812, __FUNCTION__))->type_common.main_variant);
813 decl = TYPE_NAME (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 813, __FUNCTION__))->type_common.name);
814 typdef = 0;
815 }
816
817 tmplate = !typdef && TREE_CODE (t)((enum tree_code) (t)->base.code) != ENUMERAL_TYPE
818 && TYPE_LANG_SPECIFIC (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 818, __FUNCTION__))->type_with_lang_specific.lang_specific
) && CLASSTYPE_TEMPLATE_INFO (t)(((tree_class_check (((tree_check3 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 818, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 818, __FUNCTION__))->type_non_common.lang_1))
819 && (TREE_CODE (CLASSTYPE_TI_TEMPLATE (t))((enum tree_code) (((struct tree_template_info*)(tree_check (
((((tree_class_check (((tree_check3 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 819, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 819, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 819, __FUNCTION__, (TEMPLATE_INFO))))->tmpl)->base.code
) != TEMPLATE_DECL
820 || PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t))(((((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
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 820, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 820, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 820, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 820, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 820, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 820, __FUNCTION__))->typed.type))) == (((struct tree_template_info
*)(tree_check (((((tree_class_check (((tree_check3 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 820, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 820, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 820, __FUNCTION__, (TEMPLATE_INFO))))->tmpl)));
821
822 if (! (flags & TFF_UNQUALIFIED_NAME(1 << 11)))
823 dump_scope (pp, CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 823, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 823, __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/error.cc"
, 823, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]), flags | TFF_SCOPE(1));
824 flags &= ~TFF_UNQUALIFIED_NAME(1 << 11);
825 if (tmplate)
826 {
827 /* Because the template names are mangled, we have to locate
828 the most general template, and use that name. */
829 tree tpl = TYPE_TI_TEMPLATE (t)(((struct tree_template_info*)(tree_check (((((enum tree_code
) (t)->base.code) == ENUMERAL_TYPE || ((enum tree_code) (t
)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM || (((enum tree_code
) (t)->base.code) == RECORD_TYPE || ((enum tree_code) (t)->
base.code) == UNION_TYPE || ((enum tree_code) (t)->base.code
) == QUAL_UNION_TYPE) ? ((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 829, __FUNCTION__))->type_non_common.lang_1) : (tree) __null
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 829, __FUNCTION__, (TEMPLATE_INFO))))->tmpl);
830
831 while (DECL_TEMPLATE_INFO (tpl)(((contains_struct_check ((template_info_decl_check ((tpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 831, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 831, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info))
832 tpl = DECL_TI_TEMPLATE (tpl)((struct tree_template_info*)(tree_check (((((contains_struct_check
((template_info_decl_check ((tpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 832, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 832, __FUNCTION__))->decl_common.lang_specific) ->u.min
.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 832, __FUNCTION__, (TEMPLATE_INFO))))->tmpl;
833 decl = tpl;
834 }
835 }
836
837 if (LAMBDA_TYPE_P (t)(((enum tree_code) (t)->base.code) == RECORD_TYPE &&
((((tree_class_check ((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((t), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.name) && (tree_code_type_tmpl
<0>::tree_code_type[(int) (((enum tree_code) (((tree_class_check
((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.name))->base.code))]
== tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 837, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
)))
838 {
839 /* A lambda's "type" is essentially its signature. */
840 pp_string (pp, M_("<lambda")((cxx_pp)->translate_identifiers ? gettext ("<lambda") :
("<lambda")));
841 if (lambda_function (t))
842 dump_parameters (pp,
843 FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t))skip_artificial_parms_for ((lambda_function (t)), ((tree_check2
((((contains_struct_check ((lambda_function (t)), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 843, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 843, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)),
844 flags);
845 pp_greater (pp)pp_character (pp, '>');
846 }
847 else if (!decl || IDENTIFIER_ANON_P (DECL_NAME (decl))((tree_check ((((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 847, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 847, __FUNCTION__, (IDENTIFIER_NODE)))->base.private_flag
))
848 {
849 if (flags & TFF_CLASS_KEY_OR_ENUM(1 << 3))
850 pp_string (pp, M_("<unnamed>")((cxx_pp)->translate_identifiers ? gettext ("<unnamed>"
) : ("<unnamed>")));
851 else
852 pp_printf (pp, M_("<unnamed %s>")((cxx_pp)->translate_identifiers ? gettext ("<unnamed %s>"
) : ("<unnamed %s>")), variety);
853 }
854 else
855 pp_cxx_tree_identifier (pp, DECL_NAME (decl))pp_c_identifier (pp, ((const char *) (tree_check ((((contains_struct_check
((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 855, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 855, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
856
857 dump_module_suffix (pp, decl);
858
859 if (tmplate)
860 dump_template_parms (pp, TYPE_TEMPLATE_INFO (t)(((enum tree_code) (t)->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (t)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| (((enum tree_code) (t)->base.code) == RECORD_TYPE || (
(enum tree_code) (t)->base.code) == UNION_TYPE || ((enum tree_code
) (t)->base.code) == QUAL_UNION_TYPE) ? ((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 860, __FUNCTION__))->type_non_common.lang_1) : (tree) __null
),
861 !CLASSTYPE_USE_TEMPLATE (t)((((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 861, __FUNCTION__))->type_with_lang_specific.lang_specific
))->use_template),
862 flags & ~TFF_TEMPLATE_HEADER(1 << 7));
863}
864
865#if __GNUC__4 >= 10
866#pragma GCC diagnostic pop
867#endif
868
869/* Dump into the obstack the initial part of the output for a given type.
870 This is necessary when dealing with things like functions returning
871 functions. Examples:
872
873 return type of `int (* fee ())()': pointer -> function -> int. Both
874 pointer (and reference and offset) and function (and member) types must
875 deal with prefix and suffix.
876
877 Arrays must also do this for DECL nodes, like int a[], and for things like
878 int *[]&. */
879
880static void
881dump_type_prefix (cxx_pretty_printer *pp, tree t, int flags)
882{
883 if (TYPE_PTRMEMFUNC_P (t)(((enum tree_code) (t)->base.code) == RECORD_TYPE &&
(((tree_class_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 883, __FUNCTION__, (RECORD_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 883, __FUNCTION__))->type_common.lang_flag_2))))
884 {
885 t = TYPE_PTRMEMFUNC_FN_TYPE (t)(cp_build_qualified_type (((contains_struct_check ((((tree_check3
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 885, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 885, __FUNCTION__))->typed.type), cp_type_quals (t)));
886 goto offset_type;
887 }
888
889 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
890 {
891 case POINTER_TYPE:
892 case REFERENCE_TYPE:
893 {
894 tree sub = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 894, __FUNCTION__))->typed.type);
895
896 dump_type_prefix (pp, sub, flags);
897 if (TREE_CODE (sub)((enum tree_code) (sub)->base.code) == ARRAY_TYPE
898 || TREE_CODE (sub)((enum tree_code) (sub)->base.code) == FUNCTION_TYPE)
899 {
900 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
901 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
902 /* If we're dealing with the GNU form of attributes, print this:
903 void (__attribute__((noreturn)) *f) ();
904 If it is the standard [[]] attribute, we'll print the attribute
905 in dump_type_suffix. */
906 if (!cxx11_attribute_p (TYPE_ATTRIBUTES (sub)((tree_class_check ((sub), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 906, __FUNCTION__))->type_common.attributes)))
907 pp_c_attributes_display (pp, TYPE_ATTRIBUTES (sub)((tree_class_check ((sub), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 907, __FUNCTION__))->type_common.attributes));
908 }
909 if (TYPE_PTR_P (t)(((enum tree_code) (t)->base.code) == POINTER_TYPE))
910 pp_star (pp)pp_character (pp, '*');
911 else if (TYPE_REF_P (t)(((enum tree_code) (t)->base.code) == REFERENCE_TYPE))
912 {
913 if (TYPE_REF_IS_RVALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 913, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
))
914 pp_ampersand_ampersand (pp)pp_string (pp, "&&");
915 else
916 pp_ampersand (pp)pp_character (pp, '&');
917 }
918 pp->padding = pp_before;
919 pp_cxx_cv_qualifier_seq (pp, t)pp_c_type_qualifier_list (pp, t);
920 }
921 break;
922
923 case OFFSET_TYPE:
924 offset_type:
925 dump_type_prefix (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 925, __FUNCTION__))->typed.type), flags);
926 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == OFFSET_TYPE) /* pmfs deal with this in d_t_p */
927 {
928 pp_maybe_space (pp);
929 if (TREE_CODE (TREE_TYPE (t))((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 929, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE)
930 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
931 dump_type (pp, TYPE_OFFSET_BASETYPE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 931, __FUNCTION__, (OFFSET_TYPE)))->type_non_common.maxval
), flags);
932 pp_cxx_colon_colon (pp);
933 }
934 pp_cxx_star (pp)pp_c_star (pp);
935 pp_cxx_cv_qualifier_seq (pp, t)pp_c_type_qualifier_list (pp, t);
936 pp->padding = pp_before;
937 break;
938
939 /* This can be reached without a pointer when dealing with
940 templates, e.g. std::is_function. */
941 case FUNCTION_TYPE:
942 dump_type_prefix (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 942, __FUNCTION__))->typed.type), flags);
943 break;
944
945 case METHOD_TYPE:
946 dump_type_prefix (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 946, __FUNCTION__))->typed.type), flags);
947 pp_maybe_space (pp);
948 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
949 dump_aggr_type (pp, TYPE_METHOD_BASETYPE (t)((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 949, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.maxval), flags);
950 pp_cxx_colon_colon (pp);
951 break;
952
953 case ARRAY_TYPE:
954 dump_type_prefix (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 954, __FUNCTION__))->typed.type), flags);
955 break;
956
957 case ENUMERAL_TYPE:
958 case IDENTIFIER_NODE:
959 case INTEGER_TYPE:
960 case BOOLEAN_TYPE:
961 case REAL_TYPE:
962 case RECORD_TYPE:
963 case TEMPLATE_TYPE_PARM:
964 case TEMPLATE_TEMPLATE_PARM:
965 case BOUND_TEMPLATE_TEMPLATE_PARM:
966 case TREE_LIST:
967 case TYPE_DECL:
968 case TREE_VEC:
969 case UNION_TYPE:
970 case LANG_TYPE:
971 case VOID_TYPE:
972 case OPAQUE_TYPE:
973 case TYPENAME_TYPE:
974 case COMPLEX_TYPE:
975 case VECTOR_TYPE:
976 case TYPEOF_TYPE:
977 case TRAIT_TYPE:
978 case DECLTYPE_TYPE:
979 case TYPE_PACK_EXPANSION:
980 case FIXED_POINT_TYPE:
981 case NULLPTR_TYPE:
982 dump_type (pp, t, flags);
983 pp->padding = pp_before;
984 break;
985
986 default:
987 pp_unsupported_tree (pp, t)pp_verbatim (pp, "%qs not supported by %s", get_tree_code_name
(((enum tree_code) (t)->base.code)), __FUNCTION__);
988 /* fall through. */
989 case ERROR_MARK:
990 pp_string (pp, M_("<typeprefixerror>")((cxx_pp)->translate_identifiers ? gettext ("<typeprefixerror>"
) : ("<typeprefixerror>")));
991 break;
992 }
993}
994
995/* Dump the suffix of type T, under control of FLAGS. This is the part
996 which appears after the identifier (or function parms). */
997
998static void
999dump_type_suffix (cxx_pretty_printer *pp, tree t, int flags)
1000{
1001 if (TYPE_PTRMEMFUNC_P (t)(((enum tree_code) (t)->base.code) == RECORD_TYPE &&
(((tree_class_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1001, __FUNCTION__, (RECORD_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1001, __FUNCTION__))->type_common.lang_flag_2))))
1002 t = TYPE_PTRMEMFUNC_FN_TYPE (t)(cp_build_qualified_type (((contains_struct_check ((((tree_check3
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1002, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1002, __FUNCTION__))->typed.type), cp_type_quals (t)));
1003
1004 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1005 {
1006 case POINTER_TYPE:
1007 case REFERENCE_TYPE:
1008 case OFFSET_TYPE:
1009 if (TREE_CODE (TREE_TYPE (t))((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1009, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
1010 || TREE_CODE (TREE_TYPE (t))((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1010, __FUNCTION__))->typed.type))->base.code) == FUNCTION_TYPE)
1011 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
1012 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == POINTER_TYPE)
1013 flags |= TFF_POINTER(1 << 14);
1014 dump_type_suffix (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1014, __FUNCTION__))->typed.type), flags);
1015 break;
1016
1017 case FUNCTION_TYPE:
1018 case METHOD_TYPE:
1019 {
1020 tree arg;
1021 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == METHOD_TYPE)
1022 /* Can only be reached through a pointer. */
1023 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
1024 arg = TYPE_ARG_TYPES (t)((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1024, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values);
1025 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == METHOD_TYPE)
1026 arg = TREE_CHAIN (arg)((contains_struct_check ((arg), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1026, __FUNCTION__))->common.chain);
1027
1028 /* Function pointers don't have default args. Not in standard C++,
1029 anyway; they may in g++, but we'll just pretend otherwise. */
1030 dump_parameters (pp, arg, flags & ~TFF_FUNCTION_DEFAULT_ARGUMENTS(1 << 5));
1031
1032 pp->padding = pp_before;
1033 pp_cxx_cv_qualifiers (pp, type_memfn_quals (t),pp_c_cv_qualifiers (pp, type_memfn_quals (t), ((enum tree_code
) (t)->base.code) == FUNCTION_TYPE && (flags &
(1 << 14)))
1034 TREE_CODE (t) == FUNCTION_TYPEpp_c_cv_qualifiers (pp, type_memfn_quals (t), ((enum tree_code
) (t)->base.code) == FUNCTION_TYPE && (flags &
(1 << 14)))
1035 && (flags & TFF_POINTER))pp_c_cv_qualifiers (pp, type_memfn_quals (t), ((enum tree_code
) (t)->base.code) == FUNCTION_TYPE && (flags &
(1 << 14)));
1036 dump_ref_qualifier (pp, t, flags);
1037 if (tx_safe_fn_type_p (t))
1038 pp_cxx_ws_string (pp, "transaction_safe")pp_c_ws_string (pp, "transaction_safe");
1039 dump_exception_spec (pp, TYPE_RAISES_EXCEPTIONS (t)((tree_class_check (((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1039, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1039, __FUNCTION__))->type_non_common.lang_1), flags);
1040 /* If this is the standard [[]] attribute, print
1041 void (*)() [[noreturn]]; */
1042 if (cxx11_attribute_p (TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1042, __FUNCTION__))->type_common.attributes)))
1043 {
1044 pp_space (pp)pp_character (pp, ' ');
1045 pp_c_attributes_display (pp, TYPE_ATTRIBUTES (t)((tree_class_check ((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1045, __FUNCTION__))->type_common.attributes));
1046 pp->padding = pp_before;
1047 }
1048 dump_type_suffix (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1048, __FUNCTION__))->typed.type), flags);
1049 break;
1050 }
1051
1052 case ARRAY_TYPE:
1053 pp_maybe_space (pp);
1054 pp_cxx_left_bracket (pp)pp_c_left_bracket (pp);
1055 if (tree dtype = TYPE_DOMAIN (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1055, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
))
1056 {
1057 tree max = TYPE_MAX_VALUE (dtype)((tree_check5 ((dtype), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1057, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
);
1058 /* Zero-length arrays have a null upper bound in C and SIZE_MAX
1059 in C++. Handle both since the type might be constructed by
1060 the middle end and end up here as a result of a warning (see
1061 PR c++/97201). */
1062 if (!max || integer_all_onesp (max))
1063 pp_character (pp, '0');
1064 else if (tree_fits_shwi_p (max))
1065 pp_wide_integer (pp, tree_to_shwi (max) + 1);
1066 else
1067 {
1068 STRIP_NOPS (max)(max) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((max)))));
1069 if (TREE_CODE (max)((enum tree_code) (max)->base.code) == SAVE_EXPR)
1070 max = TREE_OPERAND (max, 0)(*((const_cast<tree*> (tree_operand_check ((max), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1070, __FUNCTION__)))));
1071 if (TREE_CODE (max)((enum tree_code) (max)->base.code) == MINUS_EXPR
1072 || TREE_CODE (max)((enum tree_code) (max)->base.code) == PLUS_EXPR)
1073 {
1074 max = TREE_OPERAND (max, 0)(*((const_cast<tree*> (tree_operand_check ((max), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1074, __FUNCTION__)))));
1075 while (CONVERT_EXPR_P (max)((((enum tree_code) (max)->base.code)) == NOP_EXPR || (((enum
tree_code) (max)->base.code)) == CONVERT_EXPR))
1076 max = TREE_OPERAND (max, 0)(*((const_cast<tree*> (tree_operand_check ((max), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1076, __FUNCTION__)))));
1077 }
1078 else
1079 max = fold_build2_loc (input_location,
1080 PLUS_EXPR, dtype, max,
1081 build_int_cst (dtype, 1));
1082 dump_expr (pp, max, flags & ~TFF_EXPR_IN_PARENS(1 << 9));
1083 }
1084 }
1085 pp_cxx_right_bracket (pp)pp_c_right_bracket (pp);
1086 dump_type_suffix (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1086, __FUNCTION__))->typed.type), flags);
1087 break;
1088
1089 case ENUMERAL_TYPE:
1090 case IDENTIFIER_NODE:
1091 case INTEGER_TYPE:
1092 case BOOLEAN_TYPE:
1093 case REAL_TYPE:
1094 case RECORD_TYPE:
1095 case TEMPLATE_TYPE_PARM:
1096 case TEMPLATE_TEMPLATE_PARM:
1097 case BOUND_TEMPLATE_TEMPLATE_PARM:
1098 case TREE_LIST:
1099 case TYPE_DECL:
1100 case TREE_VEC:
1101 case UNION_TYPE:
1102 case LANG_TYPE:
1103 case VOID_TYPE:
1104 case OPAQUE_TYPE:
1105 case TYPENAME_TYPE:
1106 case COMPLEX_TYPE:
1107 case VECTOR_TYPE:
1108 case TYPEOF_TYPE:
1109 case TRAIT_TYPE:
1110 case DECLTYPE_TYPE:
1111 case TYPE_PACK_EXPANSION:
1112 case FIXED_POINT_TYPE:
1113 case NULLPTR_TYPE:
1114 break;
1115
1116 default:
1117 pp_unsupported_tree (pp, t)pp_verbatim (pp, "%qs not supported by %s", get_tree_code_name
(((enum tree_code) (t)->base.code)), __FUNCTION__);
1118 case ERROR_MARK:
1119 /* Don't mark it here, we should have already done in
1120 dump_type_prefix. */
1121 break;
1122 }
1123}
1124
1125static void
1126dump_global_iord (cxx_pretty_printer *pp, tree t)
1127{
1128 const char *p = NULL__null;
1129
1130 if (DECL_GLOBAL_CTOR_P (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/error.cc"
, 1130, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1130, __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/error.cc"
, 1130, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1130, __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/error.cc"
, 1130, __FUNCTION__); &lt->u.fn; })->global_ctor_p
))
1131 p = M_("(static initializers for %s)")((cxx_pp)->translate_identifiers ? gettext ("(static initializers for %s)"
) : ("(static initializers for %s)"));
1132 else if (DECL_GLOBAL_DTOR_P (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/error.cc"
, 1132, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1132, __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/error.cc"
, 1132, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1132, __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/error.cc"
, 1132, __FUNCTION__); &lt->u.fn; })->global_dtor_p
))
1133 p = M_("(static destructors for %s)")((cxx_pp)->translate_identifiers ? gettext ("(static destructors for %s)"
) : ("(static destructors for %s)"));
1134 else
1135 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1135, __FUNCTION__));
1136
1137 pp_printf (pp, p, DECL_SOURCE_FILE (t)((expand_location (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1137, __FUNCTION__))->decl_minimal.locus))).file));
1138}
1139
1140static void
1141dump_simple_decl (cxx_pretty_printer *pp, tree t, tree type, int flags)
1142{
1143 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == VAR_DECL && DECL_NTTP_OBJECT_P (t)((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1143, __FUNCTION__, (VAR_DECL)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1143, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5))
1144 return dump_expr (pp, DECL_INITIAL (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1144, __FUNCTION__))->decl_common.initial), flags);
1145
1146 if (flags & TFF_DECL_SPECIFIERS(1 << 2))
1147 {
1148 if (concept_definition_p (t))
1149 pp_cxx_ws_string (pp, "concept")pp_c_ws_string (pp, "concept");
1150 else if (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL) && DECL_DECLARED_CONSTEXPR_P (t)((contains_struct_check (((tree_check2 (((((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/error.cc"
, 1150, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1150, __FUNCTION__, (VAR_DECL), (FUNCTION_DECL)))), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1150, __FUNCTION__))->decl_common.lang_flag_8))
1151 pp_cxx_ws_string (pp, "constexpr")pp_c_ws_string (pp, "constexpr");
1152
1153 if (!standard_concept_p (t))
1154 dump_type_prefix (pp, type, flags & ~TFF_UNQUALIFIED_NAME(1 << 11));
1155 pp_maybe_space (pp);
1156 }
1157 if (! (flags & TFF_UNQUALIFIED_NAME(1 << 11))
1158 && TREE_CODE (t)((enum tree_code) (t)->base.code) != PARM_DECL
1159 && (!DECL_INITIAL (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1159, __FUNCTION__))->decl_common.initial)
1160 || TREE_CODE (DECL_INITIAL (t))((enum tree_code) (((contains_struct_check ((t), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1160, __FUNCTION__))->decl_common.initial))->base.code
) != TEMPLATE_PARM_INDEX))
1161 dump_scope (pp, CP_DECL_CONTEXT (t)(!(! (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1161, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1161, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1161, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]), flags);
1162 flags &= ~TFF_UNQUALIFIED_NAME(1 << 11);
1163 if ((flags & TFF_DECL_SPECIFIERS(1 << 2))
1164 && DECL_TEMPLATE_PARM_P (t)(((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1164, __FUNCTION__))->decl_common.lang_flag_0) &&
(((enum tree_code) (t)->base.code) == CONST_DECL || ((enum
tree_code) (t)->base.code) == PARM_DECL || ((enum tree_code
) (t)->base.code) == TYPE_DECL || ((enum tree_code) (t)->
base.code) == TEMPLATE_DECL))
1165 && TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (t))(((tree_not_check2 (((tree_check ((((contains_struct_check ((
t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1165, __FUNCTION__))->decl_common.initial)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1165, __FUNCTION__, (TEMPLATE_PARM_INDEX)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1165, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))
1166 pp_string (pp, "...");
1167 if (DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1167, __FUNCTION__))->decl_minimal.name))
1168 {
1169 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == FIELD_DECL && DECL_NORMAL_CAPTURE_P (t)((contains_struct_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1169, __FUNCTION__, (FIELD_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1169, __FUNCTION__))->decl_common.lang_flag_7))
1170 {
1171 pp_less (pp)pp_character (pp, '<');
1172 pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t))((const char *) (tree_check ((((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1172, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1172, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
) + 2);
1173 pp_string (pp, " capture>");
1174 }
1175 else
1176 dump_decl (pp, DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1176, __FUNCTION__))->decl_minimal.name), flags);
1177 }
1178 else if (DECL_DECOMPOSITION_P (t)((((enum tree_code) (t)->base.code) == VAR_DECL) &&
((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1178, __FUNCTION__))->decl_common.lang_specific) ? ((contains_struct_check
((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1178, __FUNCTION__))->decl_common.lang_specific)->u.base
.selector == lds_decomp : false))
1179 pp_string (pp, M_("<structured bindings>")((cxx_pp)->translate_identifiers ? gettext ("<structured bindings>"
) : ("<structured bindings>")));
1180 else
1181 pp_string (pp, M_("<anonymous>")((cxx_pp)->translate_identifiers ? gettext ("<anonymous>"
) : ("<anonymous>")));
1182
1183 dump_module_suffix (pp, t);
1184
1185 if (flags & TFF_DECL_SPECIFIERS(1 << 2))
1186 dump_type_suffix (pp, type, flags);
1187}
1188
1189class colorize_guard
1190{
1191 bool colorize;
1192 cxx_pretty_printer *pp;
1193public:
1194 colorize_guard (bool _colorize, cxx_pretty_printer *pp, const char *name)
1195 : colorize (_colorize && pp_show_color (pp)(pp)->show_color), pp (pp)
1196 {
1197 pp_string (pp, colorize_start (colorize, name));
1198 }
1199 ~colorize_guard ()
1200 {
1201 pp_string (pp, colorize_stop (colorize));
1202 }
1203};
1204
1205/* Print an IDENTIFIER_NODE that is the name of a declaration. */
1206
1207static void
1208dump_decl_name (cxx_pretty_printer *pp, tree t, int flags)
1209{
1210 /* These special cases are duplicated here so that other functions
1211 can feed identifiers to error and get them demangled properly. */
1212 if (IDENTIFIER_CONV_OP_P (t)((((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1212, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1212, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1212, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1212, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1212, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1212, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))))
1213 {
1214 pp_cxx_ws_string (pp, "operator")pp_c_ws_string (pp, "operator");
1215 /* Not exactly IDENTIFIER_TYPE_VALUE. */
1216 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1216, __FUNCTION__))->typed.type), flags);
1217 return;
1218 }
1219 if (dguide_name_p (t))
1220 {
1221 dump_decl (pp, CLASSTYPE_TI_TEMPLATE (TREE_TYPE (t))((struct tree_template_info*)(tree_check (((((tree_class_check
(((tree_check3 ((((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1221, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1221, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1221, __FUNCTION__))->type_non_common.lang_1))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1221, __FUNCTION__, (TEMPLATE_INFO))))->tmpl,
1222 TFF_UNQUALIFIED_NAME(1 << 11));
1223 return;
1224 }
1225
1226 const char *str = IDENTIFIER_POINTER (t)((const char *) (tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1226, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
1227 if (startswith (str, "_ZGR"))
1228 {
1229 pp_cxx_ws_string (pp, "<temporary>")pp_c_ws_string (pp, "<temporary>");
1230 return;
1231 }
1232
1233 pp_cxx_tree_identifier (pp, t)pp_c_identifier (pp, ((const char *) (tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1233, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
1234}
1235
1236/* Dump a human readable string for the decl T under control of FLAGS. */
1237
1238static void
1239dump_decl (cxx_pretty_printer *pp, tree t, int flags)
1240{
1241 if (t == NULL_TREE(tree) __null)
1242 return;
1243
1244 /* If doing Objective-C++, give Objective-C a chance to demangle
1245 Objective-C method names. */
1246 if (c_dialect_objc ()((c_language & clk_objc) != 0))
1247 {
1248 const char *demangled = objc_maybe_printable_name (t, flags);
1249 if (demangled)
1250 {
1251 pp_string (pp, demangled);
1252 return;
1253 }
1254 }
1255
1256 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1257 {
1258 case TYPE_DECL:
1259 /* Don't say 'typedef class A' */
1260 if (DECL_ARTIFICIAL (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1260, __FUNCTION__))->decl_common.artificial_flag) && !DECL_SELF_REFERENCE_P (t)(((enum tree_code) (t)->base.code) == TYPE_DECL &&
((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1260, __FUNCTION__))->decl_common.lang_flag_4)))
1261 {
1262 if ((flags & TFF_DECL_SPECIFIERS(1 << 2))
1263 && TREE_CODE (TREE_TYPE (t))((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1263, __FUNCTION__))->typed.type))->base.code) == TEMPLATE_TYPE_PARM)
1264 {
1265 /* Say `class T' not just `T'. */
1266 pp_cxx_ws_string (pp, "class")pp_c_ws_string (pp, "class");
1267
1268 /* Emit the `...' for a parameter pack. */
1269 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t))((((tree_not_check2 (((tree_check (((((tree_class_check (((tree_check3
(((((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1269, __FUNCTION__))->typed.type))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1269, __FUNCTION__, (TEMPLATE_TYPE_PARM), (TEMPLATE_TEMPLATE_PARM
), (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1269, __FUNCTION__))->type_non_common.values))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1269, __FUNCTION__, (TEMPLATE_PARM_INDEX)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1269, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))))
1270 pp_cxx_ws_string (pp, "...")pp_c_ws_string (pp, "...");
1271 }
1272
1273 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1273, __FUNCTION__))->typed.type), flags);
1274 break;
1275 }
1276 if (TYPE_DECL_ALIAS_P (t)((contains_struct_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1276, __FUNCTION__, (TYPE_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1276, __FUNCTION__))->decl_common.lang_flag_6)
1277 && (flags & TFF_DECL_SPECIFIERS(1 << 2)
1278 || flags & TFF_CLASS_KEY_OR_ENUM(1 << 3)))
1279 {
1280 pp_cxx_ws_string (pp, "using")pp_c_ws_string (pp, "using");
1281 if (! (flags & TFF_UNQUALIFIED_NAME(1 << 11)))
1282 dump_scope (pp, CP_DECL_CONTEXT (t)(!(! (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1282, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1282, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1282, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]), flags);
1283 dump_decl (pp, DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1283, __FUNCTION__))->decl_minimal.name), flags);
1284 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
1285 pp_cxx_ws_string (pp, "=")pp_c_ws_string (pp, "=");
1286 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
1287 dump_type (pp, (DECL_ORIGINAL_TYPE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1287, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
)
1288 ? DECL_ORIGINAL_TYPE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1288, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
) : TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1288, __FUNCTION__))->typed.type)),
1289 flags);
1290 break;
1291 }
1292 if ((flags & TFF_DECL_SPECIFIERS(1 << 2))
1293 && !DECL_SELF_REFERENCE_P (t)(((enum tree_code) (t)->base.code) == TYPE_DECL &&
((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1293, __FUNCTION__))->decl_common.lang_flag_4)))
1294 pp_cxx_ws_string (pp, "typedef")pp_c_ws_string (pp, "typedef");
1295 dump_simple_decl (pp, t, DECL_ORIGINAL_TYPE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1295, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
)
1296 ? DECL_ORIGINAL_TYPE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1296, __FUNCTION__, (TYPE_DECL)))->decl_non_common.result
) : TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1296, __FUNCTION__))->typed.type),
1297 flags);
1298 break;
1299
1300 case VAR_DECL:
1301 if (DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1301, __FUNCTION__))->decl_minimal.name) && VTABLE_NAME_P (DECL_NAME (t))(((const char *) (tree_check ((((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1301, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1301, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)[1] == 'v' && ((const char *) (tree_check ((((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1301, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1301, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)[2] == 't' && ((const char *) (tree_check ((((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1301, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1301, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)[3] == '.'))
1302 {
1303 pp_string (pp, M_("vtable for ")((cxx_pp)->translate_identifiers ? gettext ("vtable for ")
: ("vtable for ")));
1304 gcc_assert (TYPE_P (DECL_CONTEXT (t)))((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1304, __FUNCTION__))->decl_minimal.context))->base.code
))] == tcc_type)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1304, __FUNCTION__), 0 : 0));
1305 dump_type (pp, DECL_CONTEXT (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1305, __FUNCTION__))->decl_minimal.context), flags);
1306 break;
1307 }
1308 /* Fall through. */
1309 case FIELD_DECL:
1310 case PARM_DECL:
1311 dump_simple_decl (pp, t, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1311, __FUNCTION__))->typed.type), flags);
1312
1313 /* Handle variable template specializations. */
1314 if (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL)
1315 && DECL_LANG_SPECIFIC (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1315, __FUNCTION__))->decl_common.lang_specific)
1316 && DECL_TEMPLATE_INFO (t)(((contains_struct_check ((template_info_decl_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1316, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1316, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)
1317 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))(((((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 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1317, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1317, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1317, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1317, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1317, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1317, __FUNCTION__))->typed.type))) == (((struct tree_template_info
*)(tree_check (((((contains_struct_check ((template_info_decl_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1317, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1317, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1317, __FUNCTION__, (TEMPLATE_INFO))))->tmpl)))
1318 {
1319 pp_cxx_begin_template_argument_list (pp);
1320 tree args = INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t))(get_innermost_template_args ((((struct tree_template_info*)(
tree_check (((((contains_struct_check ((template_info_decl_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1320, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1320, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1320, __FUNCTION__, (TEMPLATE_INFO))))->args), 1));
1321 dump_template_argument_list (pp, args, flags);
1322 pp_cxx_end_template_argument_list (pp);
1323 }
1324 break;
1325
1326 case RESULT_DECL:
1327 pp_string (pp, M_("<return value> ")((cxx_pp)->translate_identifiers ? gettext ("<return value> "
) : ("<return value> ")));
1328 dump_simple_decl (pp, t, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1328, __FUNCTION__))->typed.type), flags);
1329 break;
1330
1331 case NAMESPACE_DECL:
1332 if (flags & TFF_DECL_SPECIFIERS(1 << 2))
1333 pp->declaration (t);
1334 else
1335 {
1336 if (! (flags & TFF_UNQUALIFIED_NAME(1 << 11)))
1337 dump_scope (pp, CP_DECL_CONTEXT (t)(!(! (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1337, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1337, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1337, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]), flags);
1338 flags &= ~TFF_UNQUALIFIED_NAME(1 << 11);
Value stored to 'flags' is never read
1339 if (DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1339, __FUNCTION__))->decl_minimal.name) == NULL_TREE(tree) __null)
1340 {
1341 if (!(pp->flags & pp_c_flag_gnu_v3))
1342 pp_cxx_ws_string (pp, M_("{anonymous}"))pp_c_ws_string (pp, ((cxx_pp)->translate_identifiers ? gettext
("{anonymous}") : ("{anonymous}")));
1343 else
1344 pp_cxx_ws_string (pp, M_("(anonymous namespace)"))pp_c_ws_string (pp, ((cxx_pp)->translate_identifiers ? gettext
("(anonymous namespace)") : ("(anonymous namespace)")));
1345 }
1346 else
1347 pp_cxx_tree_identifier (pp, DECL_NAME (t))pp_c_identifier (pp, ((const char *) (tree_check ((((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1347, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1347, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
1348 }
1349 break;
1350
1351 case SCOPE_REF:
1352 dump_type (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1352, __FUNCTION__))))), flags);
1353 pp_cxx_colon_colon (pp);
1354 dump_decl (pp, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1354, __FUNCTION__))))), TFF_UNQUALIFIED_NAME(1 << 11));
1355 break;
1356
1357 case ARRAY_REF:
1358 dump_decl (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1358, __FUNCTION__))))), flags);
1359 pp_cxx_left_bracket (pp)pp_c_left_bracket (pp);
1360 dump_decl (pp, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1360, __FUNCTION__))))), flags);
1361 pp_cxx_right_bracket (pp)pp_c_right_bracket (pp);
1362 break;
1363
1364 /* So that we can do dump_decl on an aggr type. */
1365 case RECORD_TYPE:
1366 case UNION_TYPE:
1367 case ENUMERAL_TYPE:
1368 dump_type (pp, t, flags);
1369 break;
1370
1371 case BIT_NOT_EXPR:
1372 /* This is a pseudo destructor call which has not been folded into
1373 a PSEUDO_DTOR_EXPR yet. */
1374 pp_cxx_complement (pp)pp_c_complement (pp);
1375 dump_type (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1375, __FUNCTION__))))), flags);
1376 break;
1377
1378 case TYPE_EXPR:
1379 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1379, __FUNCTION__));
1380 break;
1381
1382 case IDENTIFIER_NODE:
1383 dump_decl_name (pp, t, flags);
1384 break;
1385
1386 case OVERLOAD:
1387 if (!OVL_SINGLE_P (t)(((enum tree_code) (t)->base.code) != OVERLOAD || !(((struct
tree_overload*)(tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1387, __FUNCTION__, (OVERLOAD))))->common.chain)))
1388 {
1389 tree ctx = ovl_scope (t);
1390 if (ctx != global_namespacecp_global_trees[CPTI_GLOBAL])
1391 {
1392 if (TYPE_P (ctx)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (ctx)->base.code))] == tcc_type))
1393 dump_type (pp, ctx, flags);
1394 else
1395 dump_decl (pp, ctx, flags);
1396 pp_cxx_colon_colon (pp);
1397 }
1398 dump_decl (pp, OVL_NAME (t)((contains_struct_check ((ovl_first (t)), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1398, __FUNCTION__))->decl_minimal.name), flags);
1399 break;
1400 }
1401
1402 /* If there's only one function, just treat it like an ordinary
1403 FUNCTION_DECL. */
1404 t = OVL_FIRST (t)ovl_first (t);
1405 /* Fall through. */
1406
1407 case FUNCTION_DECL:
1408 if (! DECL_LANG_SPECIFIC (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1408, __FUNCTION__))->decl_common.lang_specific))
1409 {
1410 if (DECL_ABSTRACT_ORIGIN (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1410, __FUNCTION__))->decl_common.abstract_origin)
1411 && DECL_ABSTRACT_ORIGIN (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1411, __FUNCTION__))->decl_common.abstract_origin) != t)
1412 dump_decl (pp, DECL_ABSTRACT_ORIGIN (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1412, __FUNCTION__))->decl_common.abstract_origin), flags);
1413 else
1414 dump_function_name (pp, t, flags);
1415 }
1416 else if (DECL_GLOBAL_CTOR_P (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/error.cc"
, 1416, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1416, __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/error.cc"
, 1416, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1416, __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/error.cc"
, 1416, __FUNCTION__); &lt->u.fn; })->global_ctor_p
) || DECL_GLOBAL_DTOR_P (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/error.cc"
, 1416, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1416, __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/error.cc"
, 1416, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1416, __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/error.cc"
, 1416, __FUNCTION__); &lt->u.fn; })->global_dtor_p
))
1417 dump_global_iord (pp, t);
1418 else
1419 dump_function_decl (pp, t, flags);
1420 break;
1421
1422 case TEMPLATE_DECL:
1423 dump_template_decl (pp, t, flags);
1424 break;
1425
1426 case CONCEPT_DECL:
1427 dump_simple_decl (pp, t, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1427, __FUNCTION__))->typed.type), flags);
1428 break;
1429
1430 case WILDCARD_DECL:
1431 pp_string (pp, "<wildcard>");
1432 break;
1433
1434 case TEMPLATE_ID_EXPR:
1435 {
1436 tree name = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1436, __FUNCTION__)))));
1437 tree args = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1437, __FUNCTION__)))));
1438
1439 if (!identifier_p (name))
1440 name = OVL_NAME (name)((contains_struct_check ((ovl_first (name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1440, __FUNCTION__))->decl_minimal.name);
1441 dump_decl (pp, name, flags);
1442 pp_cxx_begin_template_argument_list (pp);
1443 if (args == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1444 pp_string (pp, M_("<template arguments error>")((cxx_pp)->translate_identifiers ? gettext ("<template arguments error>"
) : ("<template arguments error>")));
1445 else if (args)
1446 dump_template_argument_list
1447 (pp, args, flags|TFF_NO_OMIT_DEFAULT_TEMPLATE_ARGUMENTS(1 << 12));
1448 pp_cxx_end_template_argument_list (pp);
1449 }
1450 break;
1451
1452 case LABEL_DECL:
1453 if (DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1453, __FUNCTION__))->decl_minimal.name))
1454 pp_cxx_tree_identifier (pp, DECL_NAME (t))pp_c_identifier (pp, ((const char *) (tree_check ((((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1454, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1454, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
1455 else
1456 dump_generic_node (pp, t, 0, TDF_SLIM, false);
1457 break;
1458
1459 case CONST_DECL:
1460 if ((TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1460, __FUNCTION__))->typed.type) != NULL_TREE(tree) __null && NEXT_CODE (t)(((enum tree_code) (((contains_struct_check ((t), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1460, __FUNCTION__))->typed.type))->base.code)) == ENUMERAL_TYPE)
1461 || (DECL_INITIAL (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1461, __FUNCTION__))->decl_common.initial) &&
1462 TREE_CODE (DECL_INITIAL (t))((enum tree_code) (((contains_struct_check ((t), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1462, __FUNCTION__))->decl_common.initial))->base.code
) == TEMPLATE_PARM_INDEX))
1463 dump_simple_decl (pp, t, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1463, __FUNCTION__))->typed.type), flags);
1464 else if (DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1464, __FUNCTION__))->decl_minimal.name))
1465 dump_decl (pp, DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1465, __FUNCTION__))->decl_minimal.name), flags);
1466 else if (DECL_INITIAL (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1466, __FUNCTION__))->decl_common.initial))
1467 dump_expr (pp, DECL_INITIAL (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1467, __FUNCTION__))->decl_common.initial), flags | TFF_EXPR_IN_PARENS(1 << 9));
1468 else
1469 pp_string (pp, M_("<enumerator>")((cxx_pp)->translate_identifiers ? gettext ("<enumerator>"
) : ("<enumerator>")));
1470 break;
1471
1472 case USING_DECL:
1473 {
1474 if (flags & TFF_DECL_SPECIFIERS(1 << 2))
1475 pp_cxx_ws_string (pp, "using")pp_c_ws_string (pp, "using");
1476 bool variadic = false;
1477 if (!(flags & TFF_UNQUALIFIED_NAME(1 << 11)))
1478 {
1479 tree scope = USING_DECL_SCOPE (t)((contains_struct_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1479, __FUNCTION__, (USING_DECL)))), (TS_DECL_NON_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1479, __FUNCTION__))->decl_non_common.result);
1480 tree name = DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1480, __FUNCTION__))->decl_minimal.name);
1481 if (PACK_EXPANSION_P (scope)(((enum tree_code) (scope)->base.code) == TYPE_PACK_EXPANSION
|| ((enum tree_code) (scope)->base.code) == EXPR_PACK_EXPANSION
))
1482 {
1483 scope = PACK_EXPANSION_PATTERN (scope)(((enum tree_code) ((tree_check2 ((scope), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1483, __FUNCTION__, (TYPE_PACK_EXPANSION), (EXPR_PACK_EXPANSION
))))->base.code) == TYPE_PACK_EXPANSION ? ((contains_struct_check
((scope), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1483, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((scope), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1483, __FUNCTION__))))));
1484 variadic = true;
1485 }
1486 if (identifier_p (name)
1487 && IDENTIFIER_CONV_OP_P (name)((((tree_not_check2 (((tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1487, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1487, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((name),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1487, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1487, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((name)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1487, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1487, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))
1488 && PACK_EXPANSION_P (TREE_TYPE (name))(((enum tree_code) (((contains_struct_check ((name), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1488, __FUNCTION__))->typed.type))->base.code) == TYPE_PACK_EXPANSION
|| ((enum tree_code) (((contains_struct_check ((name), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1488, __FUNCTION__))->typed.type))->base.code) == EXPR_PACK_EXPANSION
))
1489 {
1490 name = make_conv_op_name (PACK_EXPANSION_PATTERN(((enum tree_code) ((tree_check2 ((((contains_struct_check ((
name), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__, (TYPE_PACK_EXPANSION), (EXPR_PACK_EXPANSION
))))->base.code) == TYPE_PACK_EXPANSION ? ((contains_struct_check
((((contains_struct_check ((name), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((((contains_struct_check ((name), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__))->typed.type)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__))))))
1491 (TREE_TYPE (name))(((enum tree_code) ((tree_check2 ((((contains_struct_check ((
name), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__, (TYPE_PACK_EXPANSION), (EXPR_PACK_EXPANSION
))))->base.code) == TYPE_PACK_EXPANSION ? ((contains_struct_check
((((contains_struct_check ((name), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((((contains_struct_check ((name), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__))->typed.type)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1491, __FUNCTION__)))))));
1492 variadic = true;
1493 }
1494 dump_type (pp, scope, flags);
1495 pp_cxx_colon_colon (pp);
1496 }
1497 dump_decl (pp, DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1497, __FUNCTION__))->decl_minimal.name), flags);
1498 if (variadic)
1499 pp_cxx_ws_string (pp, "...")pp_c_ws_string (pp, "...");
1500 }
1501 break;
1502
1503 case STATIC_ASSERT:
1504 pp->declaration (t);
1505 break;
1506
1507 case BASELINK:
1508 dump_decl (pp, BASELINK_FUNCTIONS (t)(((struct tree_baselink*) (tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1508, __FUNCTION__, (BASELINK))))->functions), flags);
1509 break;
1510
1511 case NON_DEPENDENT_EXPR:
1512 dump_expr (pp, t, flags);
1513 break;
1514
1515 case TEMPLATE_TYPE_PARM:
1516 if (flags & TFF_DECL_SPECIFIERS(1 << 2))
1517 pp->declaration (t);
1518 else
1519 pp->type_id (t);
1520 break;
1521
1522 case UNBOUND_CLASS_TEMPLATE:
1523 case TYPE_PACK_EXPANSION:
1524 case TREE_BINFO:
1525 dump_type (pp, t, flags);
1526 break;
1527
1528 default:
1529 pp_unsupported_tree (pp, t)pp_verbatim (pp, "%qs not supported by %s", get_tree_code_name
(((enum tree_code) (t)->base.code)), __FUNCTION__);
1530 /* Fall through. */
1531
1532 case ERROR_MARK:
1533 pp_string (pp, M_("<declaration error>")((cxx_pp)->translate_identifiers ? gettext ("<declaration error>"
) : ("<declaration error>")));
1534 break;
1535 }
1536}
1537
1538/* Dump a template declaration T under control of FLAGS. This means the
1539 'template <...> leaders plus the 'class X' or 'void fn(...)' part. */
1540
1541static void
1542dump_template_decl (cxx_pretty_printer *pp, tree t, int flags)
1543{
1544 tree orig_parms = DECL_TEMPLATE_PARMS (t)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1544, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments;
1545 tree parms;
1546 int i;
1547
1548 if (flags & TFF_TEMPLATE_HEADER(1 << 7))
1549 {
1550 for (parms = orig_parms = nreverse (orig_parms);
1551 parms;
1552 parms = TREE_CHAIN (parms)((contains_struct_check ((parms), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1552, __FUNCTION__))->common.chain))
1553 {
1554 tree inner_parms = INNERMOST_TEMPLATE_PARMS (parms)((tree_check ((parms), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1554, __FUNCTION__, (TREE_LIST)))->list.value);
1555 int len = TREE_VEC_LENGTH (inner_parms)((tree_check ((inner_parms), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1555, __FUNCTION__, (TREE_VEC)))->base.u.length);
1556
1557 if (len == 0)
1558 {
1559 /* Skip over the dummy template levels of a template template
1560 parm. */
1561 gcc_assert (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TEMPLATE_PARM)((void)(!(((enum tree_code) (((contains_struct_check ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1561, __FUNCTION__))->typed.type))->base.code) == TEMPLATE_TEMPLATE_PARM
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1561, __FUNCTION__), 0 : 0));
1562 continue;
1563 }
1564
1565 pp_cxx_ws_string (pp, "template")pp_c_ws_string (pp, "template");
1566 pp_cxx_begin_template_argument_list (pp);
1567
1568 /* If we've shown the template prefix, we'd better show the
1569 parameters' and decl's type too. */
1570 flags |= TFF_DECL_SPECIFIERS(1 << 2);
1571
1572 for (i = 0; i < len; i++)
1573 {
1574 if (i)
1575 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
1576 dump_template_parameter (pp, TREE_VEC_ELT (inner_parms, i)(*((const_cast<tree *> (tree_vec_elt_check ((inner_parms
), (i), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1576, __FUNCTION__))))),
1577 flags);
1578 }
1579 pp_cxx_end_template_argument_list (pp);
1580 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
1581 }
1582 nreverse(orig_parms);
1583
1584 if (DECL_TEMPLATE_TEMPLATE_PARM_P (t)(((enum tree_code) (t)->base.code) == TEMPLATE_DECL &&
(((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1584, __FUNCTION__))->decl_common.lang_flag_0) &&
(((enum tree_code) (t)->base.code) == CONST_DECL || ((enum
tree_code) (t)->base.code) == PARM_DECL || ((enum tree_code
) (t)->base.code) == TYPE_DECL || ((enum tree_code) (t)->
base.code) == TEMPLATE_DECL))))
1585 {
1586 /* Say `template<arg> class TT' not just `template<arg> TT'. */
1587 pp_cxx_ws_string (pp, "class")pp_c_ws_string (pp, "class");
1588
1589 /* If this is a parameter pack, print the ellipsis. */
1590 if (TEMPLATE_TYPE_PARAMETER_PACK (TREE_TYPE (t))((((tree_not_check2 (((tree_check (((((tree_class_check (((tree_check3
(((((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1590, __FUNCTION__))->typed.type))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1590, __FUNCTION__, (TEMPLATE_TYPE_PARM), (TEMPLATE_TEMPLATE_PARM
), (BOUND_TEMPLATE_TEMPLATE_PARM)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1590, __FUNCTION__))->type_non_common.values))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1590, __FUNCTION__, (TEMPLATE_PARM_INDEX)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1590, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))))
1591 pp_cxx_ws_string (pp, "...")pp_c_ws_string (pp, "...");
1592 }
1593
1594 /* Only print the requirements if we're also printing
1595 the template header. */
1596 if (flag_conceptsglobal_options.x_flag_concepts)
1597 if (tree ci = get_constraints (t))
1598 if (check_constraint_info (ci))
1599 if (tree reqs = CI_TEMPLATE_REQS (ci)check_constraint_info (check_nonnull (ci))->template_reqs)
1600 {
1601 pp_cxx_requires_clause (pp, reqs);
1602 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
1603 }
1604 }
1605
1606
1607 if (DECL_CLASS_TEMPLATE_P (t)((((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/error.cc"
, 1607, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1607, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == TYPE_DECL) && (((enum tree_code) (((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1607, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == TYPE_DECL && ((contains_struct_check ((
((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1607, __FUNCTION__, (TEMPLATE_DECL))))))))->result), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1607, __FUNCTION__))->decl_common.lang_flag_2))))
1608 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1608, __FUNCTION__))->typed.type),
1609 ((flags & ~TFF_CLASS_KEY_OR_ENUM(1 << 3)) | TFF_TEMPLATE_NAME(1 << 8)
1610 | (flags & TFF_DECL_SPECIFIERS(1 << 2) ? TFF_CLASS_KEY_OR_ENUM(1 << 3) : 0)));
1611 else if (DECL_TEMPLATE_RESULT (t)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1611, __FUNCTION__, (TEMPLATE_DECL))))))))->result
1612 && (VAR_P (DECL_TEMPLATE_RESULT (t))(((enum tree_code) (((struct tree_template_decl *)(const_cast
<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1612, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == VAR_DECL)
1613 /* Alias template. */
1614 || DECL_TYPE_TEMPLATE_P (t)(((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/error.cc"
, 1614, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1614, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == TYPE_DECL)
1615 /* Concept definition. &*/
1616 || TREE_CODE (DECL_TEMPLATE_RESULT (t))((enum tree_code) (((struct tree_template_decl *)(const_cast<
union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1616, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == CONCEPT_DECL))
1617 dump_decl (pp, DECL_TEMPLATE_RESULT (t)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1617, __FUNCTION__, (TEMPLATE_DECL))))))))->result, flags | TFF_TEMPLATE_NAME(1 << 8));
1618 else
1619 {
1620 gcc_assert (TREE_TYPE (t))((void)(!(((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1620, __FUNCTION__))->typed.type)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1620, __FUNCTION__), 0 : 0));
1621 switch (NEXT_CODE (t)(((enum tree_code) (((contains_struct_check ((t), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1621, __FUNCTION__))->typed.type))->base.code)))
1622 {
1623 case METHOD_TYPE:
1624 case FUNCTION_TYPE:
1625 dump_function_decl (pp, t, flags | TFF_TEMPLATE_NAME(1 << 8));
1626 break;
1627 default:
1628 /* This case can occur with some invalid code. */
1629 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1629, __FUNCTION__))->typed.type),
1630 (flags & ~TFF_CLASS_KEY_OR_ENUM(1 << 3)) | TFF_TEMPLATE_NAME(1 << 8)
1631 | (flags & TFF_DECL_SPECIFIERS(1 << 2)
1632 ? TFF_CLASS_KEY_OR_ENUM(1 << 3) : 0));
1633 }
1634 }
1635}
1636
1637/* find_typenames looks through the type of the function template T
1638 and returns a vec containing any typedefs, decltypes or TYPENAME_TYPEs
1639 it finds. */
1640
1641struct find_typenames_t
1642{
1643 hash_set<tree> *p_set;
1644 vec<tree, va_gc> *typenames;
1645};
1646
1647static tree
1648find_typenames_r (tree *tp, int *walk_subtrees, void *data)
1649{
1650 struct find_typenames_t *d = (struct find_typenames_t *)data;
1651 tree mv = NULL_TREE(tree) __null;
1652
1653 if (TYPE_P (*tp)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (*tp)->base.code))] == tcc_type) && is_typedef_decl (TYPE_NAME (*tp)((tree_class_check ((*tp), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1653, __FUNCTION__))->type_common.name)))
1654 /* Add the type of the typedef without any additional cv-quals. */
1655 mv = TREE_TYPE (TYPE_NAME (*tp))((contains_struct_check ((((tree_class_check ((*tp), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1655, __FUNCTION__))->type_common.name)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1655, __FUNCTION__))->typed.type);
1656 else if (TREE_CODE (*tp)((enum tree_code) (*tp)->base.code) == TYPENAME_TYPE
1657 || TREE_CODE (*tp)((enum tree_code) (*tp)->base.code) == DECLTYPE_TYPE)
1658 /* Add the typename without any cv-qualifiers. */
1659 mv = TYPE_MAIN_VARIANT (*tp)((tree_class_check ((*tp), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1659, __FUNCTION__))->type_common.main_variant);
1660
1661 if (PACK_EXPANSION_P (*tp)(((enum tree_code) (*tp)->base.code) == TYPE_PACK_EXPANSION
|| ((enum tree_code) (*tp)->base.code) == EXPR_PACK_EXPANSION
))
1662 {
1663 /* Don't mess with parameter packs since we don't remember
1664 the pack expansion context for a particular typename. */
1665 *walk_subtrees = false;
1666 return NULL_TREE(tree) __null;
1667 }
1668
1669 if (mv && (mv == *tp || !d->p_set->add (mv)))
1670 vec_safe_push (d->typenames, mv);
1671
1672 return NULL_TREE(tree) __null;
1673}
1674
1675static vec<tree, va_gc> *
1676find_typenames (tree t)
1677{
1678 struct find_typenames_t ft;
1679 ft.p_set = new hash_set<tree>;
1680 ft.typenames = NULL__null;
1681 cp_walk_tree (&TREE_TYPE (DECL_TEMPLATE_RESULT (t)),walk_tree_1 (&((contains_struct_check ((((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1681, __FUNCTION__, (TEMPLATE_DECL))))))))->result), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1681, __FUNCTION__))->typed.type), find_typenames_r, &
ft, ft.p_set, cp_walk_subtrees)
1682 find_typenames_r, &ft, ft.p_set)walk_tree_1 (&((contains_struct_check ((((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1681, __FUNCTION__, (TEMPLATE_DECL))))))))->result), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1681, __FUNCTION__))->typed.type), find_typenames_r, &
ft, ft.p_set, cp_walk_subtrees);
1683 delete ft.p_set;
1684 return ft.typenames;
1685}
1686
1687/* Output the "[with ...]" clause for a template instantiation T iff
1688 TEMPLATE_PARMS, TEMPLATE_ARGS and FLAGS are suitable. T may be NULL if
1689 formatting a deduction/substitution diagnostic rather than an
1690 instantiation. */
1691
1692static void
1693dump_substitution (cxx_pretty_printer *pp,
1694 tree t, tree template_parms, tree template_args,
1695 int flags)
1696{
1697 if (template_parms != NULL_TREE(tree) __null && template_args != NULL_TREE(tree) __null
1698 && !(flags & TFF_NO_TEMPLATE_BINDINGS(1 << 13)))
1699 {
1700 vec<tree, va_gc> *typenames = t ? find_typenames (t) : NULL__null;
1701 dump_template_bindings (pp, template_parms, template_args, typenames);
1702 }
1703}
1704
1705/* Dump the lambda function FN including its 'mutable' qualifier and any
1706 template bindings. */
1707
1708static void
1709dump_lambda_function (cxx_pretty_printer *pp,
1710 tree fn, tree template_parms, tree template_args,
1711 int flags)
1712{
1713 /* A lambda's signature is essentially its "type". */
1714 dump_type (pp, DECL_CONTEXT (fn)((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1714, __FUNCTION__))->decl_minimal.context), flags);
1715 if (TREE_CODE (TREE_TYPE (fn))((enum tree_code) (((contains_struct_check ((fn), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1715, __FUNCTION__))->typed.type))->base.code) == FUNCTION_TYPE)
1716 {
1717 pp->padding = pp_before;
1718 pp_c_ws_string (pp, "static");
1719 }
1720 else if (!(TYPE_QUALS (class_of_this_parm (TREE_TYPE (fn)))((int) ((((tree_class_check ((class_of_this_parm (((contains_struct_check
((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->typed.type))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((class_of_this_parm (((contains_struct_check
((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->typed.type))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((class_of_this_parm (((contains_struct_check
((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->typed.type))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((class_of_this_parm (((contains_struct_check
((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->typed.type))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((class_of_this_parm (((contains_struct_check
((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->typed.type))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1720, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8))))
1721 & TYPE_QUAL_CONST))
1722 {
1723 pp->padding = pp_before;
1724 pp_c_ws_string (pp, "mutable");
1725 }
1726 dump_substitution (pp, fn, template_parms, template_args, flags);
1727}
1728
1729/* Pretty print a function decl. There are several ways we want to print a
1730 function declaration. The TFF_ bits in FLAGS tells us how to behave.
1731 As error can only apply the '#' flag once to give 0 and 1 for V, there
1732 is %D which doesn't print the throw specs, and %F which does. */
1733
1734static void
1735dump_function_decl (cxx_pretty_printer *pp, tree t, int flags)
1736{
1737 tree fntype;
1738 tree parmtypes;
1739 tree cname = NULL_TREE(tree) __null;
1740 tree template_args = NULL_TREE(tree) __null;
1741 tree template_parms = NULL_TREE(tree) __null;
1742 int show_return = flags & TFF_RETURN_TYPE(1 << 4) || flags & TFF_DECL_SPECIFIERS(1 << 2);
1743 int do_outer_scope = ! (flags & TFF_UNQUALIFIED_NAME(1 << 11));
1744 tree exceptions;
1745 bool constexpr_p;
1746 tree ret = NULL_TREE(tree) __null;
1747
1748 int dump_function_name_flags = flags & ~TFF_UNQUALIFIED_NAME(1 << 11);
1749 flags = dump_function_name_flags & ~TFF_TEMPLATE_NAME(1 << 8);
1750 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == TEMPLATE_DECL)
1751 t = DECL_TEMPLATE_RESULT (t)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1751, __FUNCTION__, (TEMPLATE_DECL))))))))->result;
1752
1753 /* Save the exceptions, in case t is a specialization and we are
1754 emitting an error about incompatible specifications. */
1755 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t))((tree_class_check (((tree_check2 ((((contains_struct_check (
(t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1755, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1755, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1755, __FUNCTION__))->type_non_common.lang_1);
1756
1757 /* Likewise for the constexpr specifier, in case t is a specialization. */
1758 constexpr_p = (DECL_DECLARED_CONSTEXPR_P (t)((contains_struct_check (((tree_check2 (((((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/error.cc"
, 1758, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1758, __FUNCTION__, (VAR_DECL), (FUNCTION_DECL)))), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1758, __FUNCTION__))->decl_common.lang_flag_8)
1759 && !decl_implicit_constexpr_p (t));
1760
1761 /* Pretty print template instantiations only. */
1762 if (DECL_USE_TEMPLATE (t)(((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1762, __FUNCTION__))->decl_common.lang_specific)->u.base
.use_template) && DECL_TEMPLATE_INFO (t)(((contains_struct_check ((template_info_decl_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1762, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1762, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)
1763 && !(flags & TFF_NO_TEMPLATE_BINDINGS(1 << 13))
1764 && flag_pretty_templatesglobal_options.x_flag_pretty_templates)
1765 {
1766 tree tmpl;
1767
1768 template_args = DECL_TI_ARGS (t)((struct tree_template_info*)(tree_check (((((contains_struct_check
((template_info_decl_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1768, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1768, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1768, __FUNCTION__, (TEMPLATE_INFO))))->args;
1769 tmpl = most_general_template (t);
1770 if (tmpl && TREE_CODE (tmpl)((enum tree_code) (tmpl)->base.code) == TEMPLATE_DECL)
1771 {
1772 template_parms = DECL_TEMPLATE_PARMS (tmpl)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1772, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments;
1773 t = tmpl;
1774 }
1775 }
1776
1777 if (DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.name) && LAMBDA_FUNCTION_P (t)((((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/error.cc"
, 1777, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) && (((tree_not_check2 (
((tree_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) && ((__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/error.cc"
, 1777, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __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/error.cc"
, 1777, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __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/error.cc"
, 1777, __FUNCTION__); &lt->u.fn; })->ovl_op_code) ==
OVL_OP_CALL_EXPR) && (((enum tree_code) ((!(! (((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]))->base.code) == RECORD_TYPE && ((((
tree_class_check ((((tree_class_check (((!(! (((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __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 ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check (((!(! (((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check (((!(! (((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check (((!(! (((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __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 ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check (((!(! (((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check (((!(! (((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1777, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
))))
1778 return dump_lambda_function (pp, t, template_parms, template_args, flags);
1779
1780 fntype = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1780, __FUNCTION__))->typed.type);
1781 parmtypes = FUNCTION_FIRST_USER_PARMTYPE (t)skip_artificial_parms_for ((t), ((tree_check2 ((((contains_struct_check
((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1781, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1781, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values));
1782
1783 if (DECL_CLASS_SCOPE_P (t)(((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1783, __FUNCTION__))->decl_minimal.context) && (
tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1783, __FUNCTION__))->decl_minimal.context))->base.code
))] == tcc_type)))
1784 cname = DECL_CONTEXT (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1784, __FUNCTION__))->decl_minimal.context);
1785 /* This is for partially instantiated template methods. */
1786 else if (TREE_CODE (fntype)((enum tree_code) (fntype)->base.code) == METHOD_TYPE)
1787 cname = TREE_TYPE (TREE_VALUE (parmtypes))((contains_struct_check ((((tree_check ((parmtypes), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1787, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1787, __FUNCTION__))->typed.type);
1788
1789 if (flags & TFF_DECL_SPECIFIERS(1 << 2))
1790 {
1791 if (DECL_STATIC_FUNCTION_P (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/error.cc"
, 1791, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1791, __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/error.cc"
, 1791, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1791, __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/error.cc"
, 1791, __FUNCTION__); &lt->u.fn; })->static_function
))
1792 pp_cxx_ws_string (pp, "static")pp_c_ws_string (pp, "static");
1793 else if (DECL_VIRTUAL_P (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1793, __FUNCTION__))->decl_common.virtual_flag))
1794 pp_cxx_ws_string (pp, "virtual")pp_c_ws_string (pp, "virtual");
1795
1796 if (constexpr_p)
1797 {
1798 if (DECL_DECLARED_CONCEPT_P (t)(((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1798, __FUNCTION__))->decl_common.lang_specific)->u.base
.concept_p))
1799 pp_cxx_ws_string (pp, "concept")pp_c_ws_string (pp, "concept");
1800 else if (DECL_IMMEDIATE_FUNCTION_P (t)(((contains_struct_check (((tree_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/error.cc"
, 1800, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1800, __FUNCTION__, (FUNCTION_DECL)))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1800, __FUNCTION__))->decl_common.lang_specific) ? __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/error.cc"
, 1800, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1800, __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/error.cc"
, 1800, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1800, __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/error.cc"
, 1800, __FUNCTION__); &lt->u.fn; })->immediate_fn_p
: false))
1801 pp_cxx_ws_string (pp, "consteval")pp_c_ws_string (pp, "consteval");
1802 else
1803 pp_cxx_ws_string (pp, "constexpr")pp_c_ws_string (pp, "constexpr");
1804 }
1805 }
1806
1807 /* Print the return type? */
1808 if (show_return)
1809 show_return = (!DECL_CONV_FN_P (t)((((tree_not_check2 (((tree_check ((((contains_struct_check (
(t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1809, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1809, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1809, __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/error.cc"
, 1809, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1809, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1809, __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/error.cc"
, 1809, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1809, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1809, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))) && !DECL_CONSTRUCTOR_P (t)((tree_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/error.cc"
, 1809, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1809, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)
1810 && !DECL_DESTRUCTOR_P (t)((tree_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/error.cc"
, 1810, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1810, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_destructor
) && !deduction_guide_p (t));
1811 if (show_return)
1812 {
1813 ret = fndecl_declared_return_type (t);
1814 dump_type_prefix (pp, ret, flags);
1815 }
1816
1817 /* Print the function name. */
1818 if (!do_outer_scope)
1819 /* Nothing. */;
1820 else if (cname)
1821 {
1822 dump_type (pp, cname, flags);
1823 pp_cxx_colon_colon (pp);
1824 }
1825 else
1826 dump_scope (pp, CP_DECL_CONTEXT (t)(!(! (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1826, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1826, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1826, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]), flags);
1827
1828 /* Name lookup for the rest of the function declarator is implicitly in the
1829 scope of the function, so avoid printing redundant scope qualifiers. */
1830 auto cds = make_temp_override (current_dump_scope, CP_DECL_CONTEXT (t)(!(! (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1830, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1830, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((t), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1830, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]));
1831
1832 dump_function_name (pp, t, dump_function_name_flags);
1833
1834 if (!(flags & TFF_NO_FUNCTION_ARGUMENTS(1 << 10)))
1835 {
1836 dump_parameters (pp, parmtypes, flags);
1837
1838 if (TREE_CODE (fntype)((enum tree_code) (fntype)->base.code) == METHOD_TYPE)
1839 {
1840 pp->padding = pp_before;
1841 pp_cxx_cv_qualifier_seq (pp, class_of_this_parm (fntype))pp_c_type_qualifier_list (pp, class_of_this_parm (fntype));
1842 dump_ref_qualifier (pp, fntype, flags);
1843 }
1844
1845 if (tx_safe_fn_type_p (fntype))
1846 {
1847 pp->padding = pp_before;
1848 pp_cxx_ws_string (pp, "transaction_safe")pp_c_ws_string (pp, "transaction_safe");
1849 }
1850
1851 if (flags & TFF_EXCEPTION_SPECIFICATION(1 << 6))
1852 {
1853 pp->padding = pp_before;
1854 dump_exception_spec (pp, exceptions, flags);
1855 }
1856
1857 if (show_return)
1858 dump_type_suffix (pp, ret, flags);
1859 else if (deduction_guide_p (t))
1860 {
1861 pp_cxx_ws_string (pp, "->")pp_c_ws_string (pp, "->");
1862 dump_type (pp, TREE_TYPE (TREE_TYPE (t))((contains_struct_check ((((contains_struct_check ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1862, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1862, __FUNCTION__))->typed.type), flags);
1863 }
1864
1865 if (flag_conceptsglobal_options.x_flag_concepts)
1866 if (tree ci = get_constraints (t))
1867 if (tree reqs = CI_DECLARATOR_REQS (ci)check_constraint_info (check_nonnull (ci))->declarator_reqs)
1868 pp_cxx_requires_clause (pp, reqs);
1869
1870 dump_substitution (pp, t, template_parms, template_args, flags);
1871
1872 if (tree base = DECL_INHERITED_CTOR_BASE (t)(((((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/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) && ((tree_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/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1872, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
) ? __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/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1872, __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/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1872, __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/error.cc"
, 1872, __FUNCTION__); &lt->u.fn; })->context : (tree
) __null) ? ((contains_struct_check ((global_options.x_flag_new_inheriting_ctors
? strip_inheriting_ctors (t) : ((((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/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) && ((tree_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/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1872, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
) ? __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/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1872, __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/error.cc"
, 1872, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1872, __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/error.cc"
, 1872, __FUNCTION__); &lt->u.fn; })->context : (tree
) __null)), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1872, __FUNCTION__))->decl_minimal.context) : (tree) __null
))
1873 {
1874 pp_cxx_ws_string (pp, "[inherited from")pp_c_ws_string (pp, "[inherited from");
1875 dump_type (pp, base, TFF_PLAIN_IDENTIFIER(0));
1876 pp_character (pp, ']');
1877 }
1878 }
1879 else if (template_args)
1880 {
1881 bool need_comma = false;
1882 int i;
1883 pp_cxx_begin_template_argument_list (pp);
1884 template_args = INNERMOST_TEMPLATE_ARGS (template_args)(get_innermost_template_args ((template_args), 1));
1885 for (i = 0; i < TREE_VEC_LENGTH (template_args)((tree_check ((template_args), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1885, __FUNCTION__, (TREE_VEC)))->base.u.length); ++i)
1886 {
1887 tree arg = TREE_VEC_ELT (template_args, i)(*((const_cast<tree *> (tree_vec_elt_check ((template_args
), (i), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1887, __FUNCTION__)))));
1888 if (need_comma)
1889 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
1890 if (ARGUMENT_PACK_P (arg)(((enum tree_code) (arg)->base.code) == TYPE_ARGUMENT_PACK
|| ((enum tree_code) (arg)->base.code) == NONTYPE_ARGUMENT_PACK
))
1891 pp_cxx_left_brace (pp)pp_c_left_brace (pp);
1892 dump_template_argument (pp, arg, TFF_PLAIN_IDENTIFIER(0));
1893 if (ARGUMENT_PACK_P (arg)(((enum tree_code) (arg)->base.code) == TYPE_ARGUMENT_PACK
|| ((enum tree_code) (arg)->base.code) == NONTYPE_ARGUMENT_PACK
))
1894 pp_cxx_right_brace (pp)pp_c_right_brace (pp);
1895 need_comma = true;
1896 }
1897 pp_cxx_end_template_argument_list (pp);
1898 }
1899}
1900
1901/* Print a parameter list. If this is for a member function, the
1902 member object ptr (and any other hidden args) should have
1903 already been removed. */
1904
1905static void
1906dump_parameters (cxx_pretty_printer *pp, tree parmtypes, int flags)
1907{
1908 int first = 1;
1909 flags &= ~TFF_SCOPE(1);
1910 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
1911
1912 for (first = 1; parmtypes != void_list_nodeglobal_trees[TI_VOID_LIST_NODE];
1913 parmtypes = TREE_CHAIN (parmtypes)((contains_struct_check ((parmtypes), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1913, __FUNCTION__))->common.chain))
1914 {
1915 if (!first)
1916 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
1917 first = 0;
1918 if (!parmtypes)
1919 {
1920 pp_cxx_ws_string (pp, "...")pp_c_ws_string (pp, "...");
1921 break;
1922 }
1923
1924 dump_type (pp, TREE_VALUE (parmtypes)((tree_check ((parmtypes), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1924, __FUNCTION__, (TREE_LIST)))->list.value), flags);
1925
1926 if ((flags & TFF_FUNCTION_DEFAULT_ARGUMENTS(1 << 5)) && TREE_PURPOSE (parmtypes)((tree_check ((parmtypes), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1926, __FUNCTION__, (TREE_LIST)))->list.purpose))
1927 {
1928 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
1929 pp_equal (pp)pp_character (pp, '=');
1930 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
1931 dump_expr (pp, TREE_PURPOSE (parmtypes)((tree_check ((parmtypes), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1931, __FUNCTION__, (TREE_LIST)))->list.purpose), flags | TFF_EXPR_IN_PARENS(1 << 9));
1932 }
1933 }
1934
1935 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
1936}
1937
1938/* Print ref-qualifier of a FUNCTION_TYPE or METHOD_TYPE. FLAGS are ignored. */
1939
1940static void
1941dump_ref_qualifier (cxx_pretty_printer *pp, tree t, int flags ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1942{
1943 if (FUNCTION_REF_QUALIFIED (t)((tree_not_check2 (((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1943, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1943, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4))
1944 {
1945 pp->padding = pp_before;
1946 if (FUNCTION_RVALUE_QUALIFIED (t)((tree_not_check2 (((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1946, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1946, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5))
1947 pp_cxx_ws_string (pp, "&&")pp_c_ws_string (pp, "&&");
1948 else
1949 pp_cxx_ws_string (pp, "&")pp_c_ws_string (pp, "&");
1950 }
1951}
1952
1953/* Print an exception specification. T is the exception specification. */
1954
1955static void
1956dump_exception_spec (cxx_pretty_printer *pp, tree t, int flags)
1957{
1958 if (t && TREE_PURPOSE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1958, __FUNCTION__, (TREE_LIST)))->list.purpose))
1959 {
1960 pp_cxx_ws_string (pp, "noexcept")pp_c_ws_string (pp, "noexcept");
1961 if (!integer_onep (TREE_PURPOSE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1961, __FUNCTION__, (TREE_LIST)))->list.purpose)))
1962 {
1963 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
1964 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
1965 if (DEFERRED_NOEXCEPT_SPEC_P (t)((t) && (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1965, __FUNCTION__, (TREE_LIST)))->list.purpose)) &&
(((enum tree_code) (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1965, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code) == DEFERRED_NOEXCEPT)))
1966 pp_cxx_ws_string (pp, "<uninstantiated>")pp_c_ws_string (pp, "<uninstantiated>");
1967 else
1968 dump_expr (pp, TREE_PURPOSE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1968, __FUNCTION__, (TREE_LIST)))->list.purpose), flags);
1969 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
1970 }
1971 }
1972 else if (t)
1973 {
1974 pp_cxx_ws_string (pp, "throw")pp_c_ws_string (pp, "throw");
1975 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
1976 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
1977 if (TREE_VALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1977, __FUNCTION__, (TREE_LIST)))->list.value) != NULL_TREE(tree) __null)
1978 while (1)
1979 {
1980 dump_type (pp, TREE_VALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1980, __FUNCTION__, (TREE_LIST)))->list.value), flags);
1981 t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 1981, __FUNCTION__))->common.chain);
1982 if (!t)
1983 break;
1984 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
1985 }
1986 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
1987 }
1988}
1989
1990/* Handle the function name for a FUNCTION_DECL node, grokking operators
1991 and destructors properly. */
1992
1993static void
1994dump_function_name (cxx_pretty_printer *pp, tree t, int flags)
1995{
1996 /* Only colorize when we're printing something before the name; in
1997 particular, not when printing a CALL_EXPR. */
1998 bool colorize = flags & (TFF_DECL_SPECIFIERS(1 << 2) | TFF_RETURN_TYPE(1 << 4)
1999 | TFF_TEMPLATE_HEADER(1 << 7));
2000
2001 colorize_guard g (colorize, pp, "fnname");
2002
2003 tree name = DECL_NAME (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2003, __FUNCTION__))->decl_minimal.name);
2004
2005 /* We can get here with a decl that was synthesized by language-
2006 independent machinery (e.g. coverage.cc) in which case it won't
2007 have a lang_specific structure attached and DECL_CONSTRUCTOR_P
2008 will crash. In this case it is safe just to print out the
2009 literal name. */
2010 if (!DECL_LANG_SPECIFIC (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2010, __FUNCTION__))->decl_common.lang_specific))
2011 {
2012 pp_cxx_tree_identifier (pp, name)pp_c_identifier (pp, ((const char *) (tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2012, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
2013 return;
2014 }
2015
2016 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == TEMPLATE_DECL)
2017 t = DECL_TEMPLATE_RESULT (t)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2017, __FUNCTION__, (TEMPLATE_DECL))))))))->result;
2018
2019 /* Don't let the user see __comp_ctor et al. */
2020 if (DECL_CONSTRUCTOR_P (t)((tree_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/error.cc"
, 2020, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2020, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)
2021 || DECL_DESTRUCTOR_P (t)((tree_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/error.cc"
, 2021, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2021, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_destructor
))
2022 {
2023 if (LAMBDA_TYPE_P (DECL_CONTEXT (t))(((enum tree_code) (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.context))->base.code
) == RECORD_TYPE && ((((tree_class_check ((((tree_class_check
((((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __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 ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __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 ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2023, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
)))
2024 name = get_identifier ("<lambda>")(__builtin_constant_p ("<lambda>") ? get_identifier_with_length
(("<lambda>"), strlen ("<lambda>")) : get_identifier
("<lambda>"));
2025 else if (TYPE_UNNAMED_P (DECL_CONTEXT (t))((((((tree_class_check ((((tree_class_check ((((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __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 ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((((contains_struct_check
((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __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 ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__, (IDENTIFIER_NODE)))->base.private_flag
)) && !((tree_check ((((((tree_class_check ((((tree_class_check
((((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __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 ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->decl_minimal.context)), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2025, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
)))
2026 name = get_identifier ("<constructor>")(__builtin_constant_p ("<constructor>") ? get_identifier_with_length
(("<constructor>"), strlen ("<constructor>")) : get_identifier
("<constructor>"));
2027 else
2028 name = constructor_name (DECL_CONTEXT (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2028, __FUNCTION__))->decl_minimal.context));
2029 }
2030
2031 if (DECL_DESTRUCTOR_P (t)((tree_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/error.cc"
, 2031, __FUNCTION__, (TEMPLATE_DECL))))))))->result : t))
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2031, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_destructor
))
2032 {
2033 pp_cxx_complement (pp)pp_c_complement (pp);
2034 dump_decl (pp, name, TFF_PLAIN_IDENTIFIER(0));
2035 }
2036 else if (DECL_CONV_FN_P (t)((((tree_not_check2 (((tree_check ((((contains_struct_check (
(t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2036, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2036, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2036, __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/error.cc"
, 2036, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2036, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2036, __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/error.cc"
, 2036, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2036, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2036, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))))
2037 {
2038 /* This cannot use the hack that the operator's return
2039 type is stashed off of its name because it may be
2040 used for error reporting. In the case of conflicting
2041 declarations, both will have the same name, yet
2042 the types will be different, hence the TREE_TYPE field
2043 of the first name will be clobbered by the second. */
2044 pp_cxx_ws_string (pp, "operator")pp_c_ws_string (pp, "operator");
2045 dump_type (pp, TREE_TYPE (TREE_TYPE (t))((contains_struct_check ((((contains_struct_check ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2045, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2045, __FUNCTION__))->typed.type), flags);
2046 }
2047 else
2048 dump_decl (pp, name, flags);
2049
2050 dump_module_suffix (pp, t);
2051
2052 if (DECL_TEMPLATE_INFO (t)(((contains_struct_check ((template_info_decl_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2052, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2052, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)
2053 && !(flags & TFF_TEMPLATE_NAME(1 << 8))
2054 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)(((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2054, __FUNCTION__))->decl_common.lang_specific) &&
(((contains_struct_check ((template_info_decl_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2054, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2054, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info) && !(((contains_struct_check ((t),
(TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2054, __FUNCTION__))->decl_common.lang_specific)->u.base
.use_template))
2055 && (TREE_CODE (DECL_TI_TEMPLATE (t))((enum tree_code) (((struct tree_template_info*)(tree_check (
((((contains_struct_check ((template_info_decl_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2055, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2055, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2055, __FUNCTION__, (TEMPLATE_INFO))))->tmpl)->base.code
) != TEMPLATE_DECL
2056 || PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))(((((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 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2056, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2056, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2056, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2056, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2056, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2056, __FUNCTION__))->typed.type))) == (((struct tree_template_info
*)(tree_check (((((contains_struct_check ((template_info_decl_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2056, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2056, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2056, __FUNCTION__, (TEMPLATE_INFO))))->tmpl))))
2057 dump_template_parms (pp, DECL_TEMPLATE_INFO (t)(((contains_struct_check ((template_info_decl_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2057, __FUNCTION__)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2057, __FUNCTION__))->decl_common.lang_specific) ->u.
min.template_info), !DECL_USE_TEMPLATE (t)(((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2057, __FUNCTION__))->decl_common.lang_specific)->u.base
.use_template),
2058 flags);
2059}
2060
2061/* Dump the template parameters from the template info INFO under control of
2062 FLAGS. PRIMARY indicates whether this is a primary template decl, or
2063 specialization (partial or complete). For partial specializations we show
2064 the specialized parameter values. For a primary template we show no
2065 decoration. */
2066
2067static void
2068dump_template_parms (cxx_pretty_printer *pp, tree info,
2069 int primary, int flags)
2070{
2071 tree args = info ? TI_ARGS (info)((struct tree_template_info*)(tree_check ((info), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2071, __FUNCTION__, (TEMPLATE_INFO))))->args : NULL_TREE(tree) __null;
2072
2073 if (primary && flags & TFF_TEMPLATE_NAME(1 << 8))
2074 return;
2075 flags &= ~(TFF_CLASS_KEY_OR_ENUM(1 << 3) | TFF_TEMPLATE_NAME(1 << 8));
2076 pp_cxx_begin_template_argument_list (pp);
2077
2078 /* Be careful only to print things when we have them, so as not
2079 to crash producing error messages. */
2080 if (args && !primary)
2081 {
2082 int len, ix;
2083 len = get_non_default_template_args_count (args, flags);
2084
2085 args = INNERMOST_TEMPLATE_ARGS (args)(get_innermost_template_args ((args), 1));
2086 for (ix = 0; ix != len; ix++)
2087 {
2088 tree arg = TREE_VEC_ELT (args, ix)(*((const_cast<tree *> (tree_vec_elt_check ((args), (ix
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2088, __FUNCTION__)))));
2089
2090 /* Only print a comma if we know there is an argument coming. In
2091 the case of an empty template argument pack, no actual
2092 argument will be printed. */
2093 if (ix
2094 && (!ARGUMENT_PACK_P (arg)(((enum tree_code) (arg)->base.code) == TYPE_ARGUMENT_PACK
|| ((enum tree_code) (arg)->base.code) == NONTYPE_ARGUMENT_PACK
)
2095 || TREE_VEC_LENGTH (ARGUMENT_PACK_ARGS (arg))((tree_check (((((enum tree_code) ((tree_check2 ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2095, __FUNCTION__, (TYPE_ARGUMENT_PACK), (NONTYPE_ARGUMENT_PACK
))))->base.code) == TYPE_ARGUMENT_PACK ? ((contains_struct_check
((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2095, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2095, __FUNCTION__))))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2095, __FUNCTION__, (TREE_VEC)))->base.u.length) > 0))
2096 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
2097
2098 if (!arg)
2099 pp_string (pp, M_("<template parameter error>")((cxx_pp)->translate_identifiers ? gettext ("<template parameter error>"
) : ("<template parameter error>")));
2100 else
2101 dump_template_argument (pp, arg, flags);
2102 }
2103 }
2104 else if (primary)
2105 {
2106 tree tpl = TI_TEMPLATE (info)((struct tree_template_info*)(tree_check ((info), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2106, __FUNCTION__, (TEMPLATE_INFO))))->tmpl;
2107 tree parms = DECL_TEMPLATE_PARMS (tpl)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((tpl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2107, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments;
2108 int len, ix;
2109
2110 parms = TREE_CODE (parms)((enum tree_code) (parms)->base.code) == TREE_LIST ? TREE_VALUE (parms)((tree_check ((parms), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2110, __FUNCTION__, (TREE_LIST)))->list.value) : NULL_TREE(tree) __null;
2111 len = parms ? TREE_VEC_LENGTH (parms)((tree_check ((parms), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2111, __FUNCTION__, (TREE_VEC)))->base.u.length) : 0;
2112
2113 for (ix = 0; ix != len; ix++)
2114 {
2115 tree parm;
2116
2117 if (TREE_VEC_ELT (parms, ix)(*((const_cast<tree *> (tree_vec_elt_check ((parms), (ix
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2117, __FUNCTION__))))) == error_mark_nodeglobal_trees[TI_ERROR_MARK])
2118 {
2119 pp_string (pp, M_("<template parameter error>")((cxx_pp)->translate_identifiers ? gettext ("<template parameter error>"
) : ("<template parameter error>")));
2120 continue;
2121 }
2122
2123 parm = TREE_VALUE (TREE_VEC_ELT (parms, ix))((tree_check (((*((const_cast<tree *> (tree_vec_elt_check
((parms), (ix), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2123, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2123, __FUNCTION__, (TREE_LIST)))->list.value);
2124
2125 if (ix)
2126 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
2127
2128 dump_decl (pp, parm, flags & ~TFF_DECL_SPECIFIERS(1 << 2));
2129 }
2130 }
2131 pp_cxx_end_template_argument_list (pp);
2132}
2133
2134/* Print out the arguments of CALL_EXPR T as a parenthesized list using
2135 flags FLAGS. Skip over the first argument if SKIPFIRST is true. */
2136
2137static void
2138dump_call_expr_args (cxx_pretty_printer *pp, tree t, int flags, bool skipfirst)
2139{
2140 tree arg;
2141 call_expr_arg_iterator iter;
2142
2143 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2144 FOR_EACH_CALL_EXPR_ARG (arg, iter, t)for ((arg) = first_call_expr_arg ((t), &(iter)); (arg); (
arg) = next_call_expr_arg (&(iter)))
2145 {
2146 if (skipfirst)
2147 skipfirst = false;
2148 else
2149 {
2150 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS(1 << 9));
2151 if (more_call_expr_args_p (&iter))
2152 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
2153 }
2154 }
2155 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2156}
2157
2158/* Print out the arguments of AGGR_INIT_EXPR T as a parenthesized list
2159 using flags FLAGS. Skip over the first argument if SKIPFIRST is
2160 true. */
2161
2162static void
2163dump_aggr_init_expr_args (cxx_pretty_printer *pp, tree t, int flags,
2164 bool skipfirst)
2165{
2166 tree arg;
2167 aggr_init_expr_arg_iterator iter;
2168
2169 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2170 FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t)for ((arg) = first_aggr_init_expr_arg ((t), &(iter)); (arg
); (arg) = next_aggr_init_expr_arg (&(iter)))
2171 {
2172 if (skipfirst)
2173 skipfirst = false;
2174 else
2175 {
2176 dump_expr (pp, arg, flags | TFF_EXPR_IN_PARENS(1 << 9));
2177 if (more_aggr_init_expr_args_p (&iter))
2178 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
2179 }
2180 }
2181 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2182}
2183
2184/* Print out a list of initializers (subr of dump_expr). */
2185
2186static void
2187dump_expr_list (cxx_pretty_printer *pp, tree l, int flags)
2188{
2189 while (l)
2190 {
2191 dump_expr (pp, TREE_VALUE (l)((tree_check ((l), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2191, __FUNCTION__, (TREE_LIST)))->list.value), flags | TFF_EXPR_IN_PARENS(1 << 9));
2192 l = TREE_CHAIN (l)((contains_struct_check ((l), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2192, __FUNCTION__))->common.chain);
2193 if (l)
2194 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
2195 }
2196}
2197
2198/* Print out a vector of initializers (subr of dump_expr). */
2199
2200static void
2201dump_expr_init_vec (cxx_pretty_printer *pp, vec<constructor_elt, va_gc> *v,
2202 int flags)
2203{
2204 unsigned HOST_WIDE_INTlong idx;
2205 tree value;
2206
2207 FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)for (idx = 0; (idx >= vec_safe_length (v)) ? false : ((value
= (*(v))[idx].value), true); (idx)++)
2208 {
2209 dump_expr (pp, value, flags | TFF_EXPR_IN_PARENS(1 << 9));
2210 if (idx != v->length () - 1)
2211 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
2212 }
2213}
2214
2215
2216/* We've gotten an indirect REFERENCE (an OBJ_TYPE_REF) to a virtual
2217 function. Resolve it to a close relative -- in the sense of static
2218 type -- variant being overridden. That is close to what was written in
2219 the source code. Subroutine of dump_expr. */
2220
2221static tree
2222resolve_virtual_fun_from_obj_type_ref (tree ref)
2223{
2224 tree obj_type = TREE_TYPE (OBJ_TYPE_REF_TOKEN (ref))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((tree_check ((ref), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2224, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2224, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2224, __FUNCTION__))->typed.type);
2225 HOST_WIDE_INTlong index = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref)(*((const_cast<tree*> (tree_operand_check (((tree_check
((ref), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2225, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2225, __FUNCTION__))))));
2226 tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)))((tree_check ((((tree_check3 ((((contains_struct_check ((obj_type
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2226, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2226, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2226, __FUNCTION__, (TREE_BINFO)))->binfo.virtuals);
2227 while (index)
2228 {
2229 fun = TREE_CHAIN (fun)((contains_struct_check ((fun), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2229, __FUNCTION__))->common.chain);
2230 index -= (TARGET_VTABLE_USES_DESCRIPTORS0
2231 ? TARGET_VTABLE_USES_DESCRIPTORS0 : 1);
2232 }
2233
2234 return BV_FN (fun)(((tree_check ((fun), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2234, __FUNCTION__, (TREE_LIST)))->list.value));
2235}
2236
2237/* Print out an expression E under control of FLAGS. */
2238
2239static void
2240dump_expr (cxx_pretty_printer *pp, tree t, int flags)
2241{
2242 tree op;
2243
2244 if (t == 0)
2245 return;
2246
2247 if (STATEMENT_CLASS_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_statement))
2248 {
2249 pp_cxx_ws_string (pp, M_("<statement>"))pp_c_ws_string (pp, ((cxx_pp)->translate_identifiers ? gettext
("<statement>") : ("<statement>")));
2250 return;
2251 }
2252
2253 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
2254 {
2255 case VAR_DECL:
2256 case PARM_DECL:
2257 case FIELD_DECL:
2258 case CONST_DECL:
2259 case FUNCTION_DECL:
2260 case TEMPLATE_DECL:
2261 case NAMESPACE_DECL:
2262 case LABEL_DECL:
2263 case WILDCARD_DECL:
2264 case OVERLOAD:
2265 case TYPE_DECL:
2266 case USING_DECL:
2267 case IDENTIFIER_NODE:
2268 dump_decl (pp, t, ((flags & ~(TFF_DECL_SPECIFIERS(1 << 2)|TFF_RETURN_TYPE(1 << 4)
2269 |TFF_TEMPLATE_HEADER(1 << 7)))
2270 | TFF_NO_TEMPLATE_BINDINGS(1 << 13)
2271 | TFF_NO_FUNCTION_ARGUMENTS(1 << 10)));
2272 break;
2273
2274 case SSA_NAME:
2275 if (SSA_NAME_VAR (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2275, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
__null || ((enum tree_code) ((t)->ssa_name.var)->base.
code) == IDENTIFIER_NODE ? (tree) __null : (t)->ssa_name.var
)
2276 && !DECL_ARTIFICIAL (SSA_NAME_VAR (t))((contains_struct_check ((((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2276, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
__null || ((enum tree_code) ((t)->ssa_name.var)->base.
code) == IDENTIFIER_NODE ? (tree) __null : (t)->ssa_name.var
)), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2276, __FUNCTION__))->decl_common.artificial_flag))
2277 dump_expr (pp, SSA_NAME_VAR (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2277, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
__null || ((enum tree_code) ((t)->ssa_name.var)->base.
code) == IDENTIFIER_NODE ? (tree) __null : (t)->ssa_name.var
), flags);
2278 else
2279 pp_cxx_ws_string (pp, M_("<unknown>"))pp_c_ws_string (pp, ((cxx_pp)->translate_identifiers ? gettext
("<unknown>") : ("<unknown>")));
2280 break;
2281
2282 case VOID_CST:
2283 case INTEGER_CST:
2284 case REAL_CST:
2285 case STRING_CST:
2286 case COMPLEX_CST:
2287 pp->constant (t);
2288 break;
2289
2290 case USERDEF_LITERAL:
2291 pp_cxx_userdef_literal (pp, t);
2292 break;
2293
2294 case THROW_EXPR:
2295 /* While waiting for caret diagnostics, avoid printing
2296 __cxa_allocate_exception, __cxa_throw, and the like. */
2297 pp_cxx_ws_string (pp, M_("<throw-expression>"))pp_c_ws_string (pp, ((cxx_pp)->translate_identifiers ? gettext
("<throw-expression>") : ("<throw-expression>"))
);
2298 break;
2299
2300 case PTRMEM_CST:
2301 pp_ampersand (pp)pp_character (pp, '&');
2302 dump_type (pp, PTRMEM_CST_CLASS (t)((((enum tree_code) (((contains_struct_check (((tree_check ((
t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__))->typed.type))->base.code) == OFFSET_TYPE
) ? ((tree_check ((((contains_struct_check (((tree_check ((t)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __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 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__))->typed.type), cp_type_quals (((contains_struct_check
(((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__, (PTRMEM_CST)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__))->typed.type))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2302, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.maxval)), flags);
2303 pp_cxx_colon_colon (pp);
2304 pp_cxx_tree_identifier (pp, DECL_NAME (PTRMEM_CST_MEMBER (t)))pp_c_identifier (pp, ((const char *) (tree_check ((((contains_struct_check
(((((ptrmem_cst_t)(tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2304, __FUNCTION__, (PTRMEM_CST))))->member)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2304, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2304, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
2305 break;
2306
2307 case COMPOUND_EXPR:
2308 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2309 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2309, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2310 pp_separate_with_comma (pp)pp_cxx_separate_with (pp, ',');
2311 dump_expr (pp, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2311, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2312 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2313 break;
2314
2315 case COND_EXPR:
2316 case VEC_COND_EXPR:
2317 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2318 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2318, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2319 pp_string (pp, " ? ");
2320 dump_expr (pp, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2320, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2321 pp_string (pp, " : ");
2322 dump_expr (pp, TREE_OPERAND (t, 2)(*((const_cast<tree*> (tree_operand_check ((t), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2322, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2323 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2324 break;
2325
2326 case SAVE_EXPR:
2327 if (TREE_HAS_CONSTRUCTOR (t)(((tree_not_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2327, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)))
2328 {
2329 pp_cxx_ws_string (pp, "new")pp_c_ws_string (pp, "new");
2330 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
2331 dump_type (pp, TREE_TYPE (TREE_TYPE (t))((contains_struct_check ((((contains_struct_check ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2331, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2331, __FUNCTION__))->typed.type), flags);
2332 }
2333 else
2334 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2334, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2335 break;
2336
2337 case AGGR_INIT_EXPR:
2338 {
2339 tree fn = NULL_TREE(tree) __null;
2340
2341 if (TREE_CODE (AGGR_INIT_EXPR_FN (t))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
(((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2341, __FUNCTION__, (AGGR_INIT_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2341, __FUNCTION__))))))->base.code) == ADDR_EXPR)
2342 fn = TREE_OPERAND (AGGR_INIT_EXPR_FN (t), 0)(*((const_cast<tree*> (tree_operand_check (((*((const_cast
<tree*> (tree_operand_check (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2342, __FUNCTION__, (AGGR_INIT_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2342, __FUNCTION__)))))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2342, __FUNCTION__)))));
2343
2344 if (fn && TREE_CODE (fn)((enum tree_code) (fn)->base.code) == FUNCTION_DECL)
2345 {
2346 if (DECL_CONSTRUCTOR_P (fn)((tree_check (((((enum tree_code) (fn)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2346, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2346, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
))
2347 dump_type (pp, DECL_CONTEXT (fn)((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2347, __FUNCTION__))->decl_minimal.context), flags);
2348 else
2349 dump_decl (pp, fn, 0);
2350 }
2351 else
2352 dump_expr (pp, AGGR_INIT_EXPR_FN (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2352, __FUNCTION__, (AGGR_INIT_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2352, __FUNCTION__))))), 0);
2353 }
2354 dump_aggr_init_expr_args (pp, t, flags, true);
2355 break;
2356
2357 case CALL_EXPR:
2358 {
2359 tree fn = CALL_EXPR_FN (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2359, __FUNCTION__, (CALL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2359, __FUNCTION__)))));
2360 bool skipfirst = false;
2361
2362 /* Deal with internal functions. */
2363 if (fn == NULL_TREE(tree) __null)
2364 {
2365 pp_string (pp, internal_fn_name (CALL_EXPR_IFN (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2365, __FUNCTION__, (CALL_EXPR)))->base.u.ifn)));
2366 dump_call_expr_args (pp, t, flags, skipfirst);
2367 break;
2368 }
2369
2370 if (TREE_CODE (fn)((enum tree_code) (fn)->base.code) == ADDR_EXPR)
2371 fn = TREE_OPERAND (fn, 0)(*((const_cast<tree*> (tree_operand_check ((fn), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2371, __FUNCTION__)))));
2372
2373 /* Nobody is interested in seeing the guts of vcalls. */
2374 if (TREE_CODE (fn)((enum tree_code) (fn)->base.code) == OBJ_TYPE_REF)
2375 fn = resolve_virtual_fun_from_obj_type_ref (fn);
2376
2377 if (TREE_TYPE (fn)((contains_struct_check ((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2377, __FUNCTION__))->typed.type) != NULL_TREE(tree) __null
2378 && NEXT_CODE (fn)(((enum tree_code) (((contains_struct_check ((fn), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2378, __FUNCTION__))->typed.type))->base.code)) == METHOD_TYPE
2379 && call_expr_nargs (t)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
((t), (tcc_vl_exp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2379, __FUNCTION__))->exp.operands[0]), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2379, __FUNCTION__)))) - 3))
2380 {
2381 tree ob = CALL_EXPR_ARG (t, 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2381, __FUNCTION__, (CALL_EXPR)))), ((0) + 3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2381, __FUNCTION__)))));
2382 if (TREE_CODE (ob)((enum tree_code) (ob)->base.code) == ADDR_EXPR)
2383 {
2384 dump_expr (pp, TREE_OPERAND (ob, 0)(*((const_cast<tree*> (tree_operand_check ((ob), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2384, __FUNCTION__))))),
2385 flags | TFF_EXPR_IN_PARENS(1 << 9));
2386 pp_cxx_dot (pp)pp_c_dot (pp);
2387 }
2388 else if (!is_this_parameter (ob))
2389 {
2390 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS(1 << 9));
2391 pp_cxx_arrow (pp)pp_c_arrow (pp);
2392 }
2393 skipfirst = true;
2394 }
2395 if (flag_sanitizeglobal_options.x_flag_sanitize & SANITIZE_UNDEFINED
2396 && is_ubsan_builtin_p (fn))
2397 {
2398 pp_string (cxx_pp, M_("<ubsan routine call>")((cxx_pp)->translate_identifiers ? gettext ("<ubsan routine call>"
) : ("<ubsan routine call>")));
2399 break;
2400 }
2401 dump_expr (pp, fn, flags | TFF_EXPR_IN_PARENS(1 << 9));
2402 dump_call_expr_args (pp, t, flags, skipfirst);
2403 }
2404 break;
2405
2406 case TARGET_EXPR:
2407 /* Note that this only works for G++ target exprs. If somebody
2408 builds a general TARGET_EXPR, there's no way to represent that
2409 it initializes anything other that the parameter slot for the
2410 default argument. Note we may have cleared out the first
2411 operand in expand_expr, so don't go killing ourselves. */
2412 if (TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2412, __FUNCTION__))))))
2413 dump_expr (pp, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2413, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2414 break;
2415
2416 case POINTER_PLUS_EXPR:
2417 dump_binary_op (pp, "+", t, flags);
2418 break;
2419
2420 case POINTER_DIFF_EXPR:
2421 dump_binary_op (pp, "-", t, flags);
2422 break;
2423
2424 case INIT_EXPR:
2425 case MODIFY_EXPR:
2426 dump_binary_op (pp, OVL_OP_INFO (true, NOP_EXPR)(&ovl_op_info[(true) != 0][ovl_op_mapping[(NOP_EXPR)]])->name, t, flags);
2427 break;
2428
2429 case PLUS_EXPR:
2430 case MINUS_EXPR:
2431 case MULT_EXPR:
2432 case TRUNC_DIV_EXPR:
2433 case TRUNC_MOD_EXPR:
2434 case MIN_EXPR:
2435 case MAX_EXPR:
2436 case LSHIFT_EXPR:
2437 case RSHIFT_EXPR:
2438 case BIT_IOR_EXPR:
2439 case BIT_XOR_EXPR:
2440 case BIT_AND_EXPR:
2441 case TRUTH_ANDIF_EXPR:
2442 case TRUTH_ORIF_EXPR:
2443 case LT_EXPR:
2444 case LE_EXPR:
2445 case GT_EXPR:
2446 case GE_EXPR:
2447 case EQ_EXPR:
2448 case NE_EXPR:
2449 case SPACESHIP_EXPR:
2450 case EXACT_DIV_EXPR:
2451 dump_binary_op (pp, OVL_OP_INFO (false, TREE_CODE (t))(&ovl_op_info[(false) != 0][ovl_op_mapping[(((enum tree_code
) (t)->base.code))]])->name, t, flags);
2452 break;
2453
2454 case CEIL_DIV_EXPR:
2455 case FLOOR_DIV_EXPR:
2456 case ROUND_DIV_EXPR:
2457 case RDIV_EXPR:
2458 dump_binary_op (pp, "/", t, flags);
2459 break;
2460
2461 case CEIL_MOD_EXPR:
2462 case FLOOR_MOD_EXPR:
2463 case ROUND_MOD_EXPR:
2464 dump_binary_op (pp, "%", t, flags);
2465 break;
2466
2467 case COMPONENT_REF:
2468 {
2469 tree ob = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2469, __FUNCTION__)))));
2470 if (INDIRECT_REF_P (ob)(((enum tree_code) (ob)->base.code) == INDIRECT_REF))
2471 {
2472 ob = TREE_OPERAND (ob, 0)(*((const_cast<tree*> (tree_operand_check ((ob), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2472, __FUNCTION__)))));
2473 if (!is_this_parameter (ob)
2474 && !is_dummy_object (ob))
2475 {
2476 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS(1 << 9));
2477 if (TYPE_REF_P (TREE_TYPE (ob))(((enum tree_code) (((contains_struct_check ((ob), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2477, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
2478 pp_cxx_dot (pp)pp_c_dot (pp);
2479 else
2480 pp_cxx_arrow (pp)pp_c_arrow (pp);
2481 }
2482 }
2483 else
2484 {
2485 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS(1 << 9));
2486 if (TREE_CODE (ob)((enum tree_code) (ob)->base.code) != ARROW_EXPR)
2487 pp_cxx_dot (pp)pp_c_dot (pp);
2488 }
2489 dump_expr (pp, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2489, __FUNCTION__))))), flags & ~TFF_EXPR_IN_PARENS(1 << 9));
2490 }
2491 break;
2492
2493 case ARRAY_REF:
2494 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2494, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2495 pp_cxx_left_bracket (pp)pp_c_left_bracket (pp);
2496 dump_expr (pp, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2496, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2497 pp_cxx_right_bracket (pp)pp_c_right_bracket (pp);
2498 break;
2499
2500 case UNARY_PLUS_EXPR:
2501 dump_unary_op (pp, "+", t, flags);
2502 break;
2503
2504 case ADDR_EXPR:
2505 if (TREE_CODE (TREE_OPERAND (t, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2505, __FUNCTION__))))))->base.code) == FUNCTION_DECL
2506 || TREE_CODE (TREE_OPERAND (t, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2506, __FUNCTION__))))))->base.code) == STRING_CST
2507 /* An ADDR_EXPR can have reference type. In that case, we
2508 shouldn't print the `&' doing so indicates to the user
2509 that the expression has pointer type. */
2510 || (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2510, __FUNCTION__))->typed.type)
2511 && TYPE_REF_P (TREE_TYPE (t))(((enum tree_code) (((contains_struct_check ((t), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2511, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)))
2512 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2512, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2513 else if (TREE_CODE (TREE_OPERAND (t, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2513, __FUNCTION__))))))->base.code) == LABEL_DECL)
2514 dump_unary_op (pp, "&&", t, flags);
2515 else
2516 dump_unary_op (pp, "&", t, flags);
2517 break;
2518
2519 case INDIRECT_REF:
2520 if (TREE_HAS_CONSTRUCTOR (t)(((tree_not_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2520, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)))
2521 {
2522 t = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2522, __FUNCTION__)))));
2523 gcc_assert (TREE_CODE (t) == CALL_EXPR)((void)(!(((enum tree_code) (t)->base.code) == CALL_EXPR) ?
fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2523, __FUNCTION__), 0 : 0));
2524 dump_expr (pp, CALL_EXPR_FN (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2524, __FUNCTION__, (CALL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2524, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2525 dump_call_expr_args (pp, t, flags, true);
2526 }
2527 else
2528 {
2529 if (TREE_OPERAND (t,0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2529, __FUNCTION__))))) != NULL_TREE(tree) __null
2530 && TREE_TYPE (TREE_OPERAND (t, 0))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2530, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2530, __FUNCTION__))->typed.type)
2531 && NEXT_CODE (TREE_OPERAND (t, 0))(((enum tree_code) (((contains_struct_check (((*((const_cast<
tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2531, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2531, __FUNCTION__))->typed.type))->base.code)) == REFERENCE_TYPE)
2532 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2532, __FUNCTION__))))), flags);
2533 else
2534 dump_unary_op (pp, "*", t, flags);
2535 }
2536 break;
2537
2538 case MEM_REF:
2539 /* Delegate to the base "C" pretty printer. */
2540 pp->c_pretty_printer::unary_expression (t);
2541 break;
2542
2543 case TARGET_MEM_REF:
2544 /* TARGET_MEM_REF can't appear directly from source, but can appear
2545 during late GIMPLE optimizations and through late diagnostic we might
2546 need to support it. Print it as dereferencing of a pointer after
2547 cast to the TARGET_MEM_REF type, with pointer arithmetics on some
2548 pointer to single byte types, so
2549 *(type *)((char *) ptr + step * index + index2) if all the operands
2550 are present and the casts are needed. */
2551 pp_cxx_star (pp)pp_c_star (pp);
2552 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2553 if (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (TMR_BASE (t))))((tree_class_check ((((contains_struct_check ((((contains_struct_check
((((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2553, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2553, __FUNCTION__))))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2553, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2553, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2553, __FUNCTION__))->type_common.size_unit) == NULL_TREE(tree) __null
2554 || !integer_onep (TYPE_SIZE_UNIT((tree_class_check ((((contains_struct_check ((((contains_struct_check
((((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__))))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__))->type_common.size_unit)
2555 (TREE_TYPE (TREE_TYPE (TMR_BASE (t))))((tree_class_check ((((contains_struct_check ((((contains_struct_check
((((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__))))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2555, __FUNCTION__))->type_common.size_unit)))
2556 {
2557 if (TYPE_SIZE_UNIT (TREE_TYPE (t))((tree_class_check ((((contains_struct_check ((t), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2557, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2557, __FUNCTION__))->type_common.size_unit)
2558 && integer_onep (TYPE_SIZE_UNIT (TREE_TYPE (t))((tree_class_check ((((contains_struct_check ((t), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2558, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2558, __FUNCTION__))->type_common.size_unit)))
2559 {
2560 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2561 dump_type (pp, build_pointer_type (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2561, __FUNCTION__))->typed.type)), flags);
2562 }
2563 else
2564 {
2565 dump_type (pp, build_pointer_type (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2565, __FUNCTION__))->typed.type)), flags);
2566 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2567 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2568 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2569 dump_type (pp, build_pointer_type (char_type_nodeinteger_types[itk_char]), flags);
2570 }
2571 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2572 }
2573 else if (!same_type_p (TREE_TYPE (t),comptypes ((((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2573, __FUNCTION__))->typed.type)), (((contains_struct_check
((((contains_struct_check ((((*((const_cast<tree*> (tree_operand_check
(((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2574, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2574, __FUNCTION__))))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2574, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2574, __FUNCTION__))->typed.type)), 0)
2574 TREE_TYPE (TREE_TYPE (TMR_BASE (t))))comptypes ((((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2573, __FUNCTION__))->typed.type)), (((contains_struct_check
((((contains_struct_check ((((*((const_cast<tree*> (tree_operand_check
(((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2574, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2574, __FUNCTION__))))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2574, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2574, __FUNCTION__))->typed.type)), 0))
2575 {
2576 dump_type (pp, build_pointer_type (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2576, __FUNCTION__))->typed.type)), flags);
2577 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2578 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2579 }
2580 dump_expr (pp, TMR_BASE (t)((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2580, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2580, __FUNCTION__)))))), flags);
2581 if (TMR_STEP (t)((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2581, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2581, __FUNCTION__)))))) && TMR_INDEX (t)((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2581, __FUNCTION__, (TARGET_MEM_REF)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2581, __FUNCTION__)))))))
2582 {
2583 pp_cxx_ws_string (pp, "+")pp_c_ws_string (pp, "+");
2584 dump_expr (pp, TMR_INDEX (t)((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2584, __FUNCTION__, (TARGET_MEM_REF)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2584, __FUNCTION__)))))), flags);
2585 pp_cxx_ws_string (pp, "*")pp_c_ws_string (pp, "*");
2586 dump_expr (pp, TMR_STEP (t)((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2586, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2586, __FUNCTION__)))))), flags);
2587 }
2588 if (TMR_INDEX2 (t)((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2588, __FUNCTION__, (TARGET_MEM_REF)))), (4), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2588, __FUNCTION__)))))))
2589 {
2590 pp_cxx_ws_string (pp, "+")pp_c_ws_string (pp, "+");
2591 dump_expr (pp, TMR_INDEX2 (t)((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2591, __FUNCTION__, (TARGET_MEM_REF)))), (4), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2591, __FUNCTION__)))))), flags);
2592 }
2593 if (!integer_zerop (TMR_OFFSET (t)((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2593, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2593, __FUNCTION__))))))))
2594 {
2595 pp_cxx_ws_string (pp, "+")pp_c_ws_string (pp, "+");
2596 dump_expr (pp, fold_convert (ssizetype, TMR_OFFSET (t))fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_ssizetype
], ((*((const_cast<tree*> (tree_operand_check (((tree_check
((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2596, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2596, __FUNCTION__))))))), flags);
2597 }
2598 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2599 break;
2600
2601 case NEGATE_EXPR:
2602 case BIT_NOT_EXPR:
2603 case TRUTH_NOT_EXPR:
2604 case PREDECREMENT_EXPR:
2605 case PREINCREMENT_EXPR:
2606 dump_unary_op (pp, OVL_OP_INFO (false, TREE_CODE (t))(&ovl_op_info[(false) != 0][ovl_op_mapping[(((enum tree_code
) (t)->base.code))]])->name, t, flags);
2607 break;
2608
2609 case POSTDECREMENT_EXPR:
2610 case POSTINCREMENT_EXPR:
2611 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2612 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2612, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2613 pp_cxx_ws_string (pp, OVL_OP_INFO (false, TREE_CODE (t))->name)pp_c_ws_string (pp, (&ovl_op_info[(false) != 0][ovl_op_mapping
[(((enum tree_code) (t)->base.code))]])->name);
2614 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2615 break;
2616
2617 case NON_LVALUE_EXPR:
2618 /* FIXME: This is a KLUDGE workaround for a parsing problem. There
2619 should be another level of INDIRECT_REF so that I don't have to do
2620 this. */
2621 if (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2621, __FUNCTION__))->typed.type) != NULL_TREE(tree) __null && NEXT_CODE (t)(((enum tree_code) (((contains_struct_check ((t), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2621, __FUNCTION__))->typed.type))->base.code)) == POINTER_TYPE)
2622 {
2623 tree next = TREE_TYPE (TREE_TYPE (t))((contains_struct_check ((((contains_struct_check ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2623, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2623, __FUNCTION__))->typed.type);
2624
2625 while (TYPE_PTR_P (next)(((enum tree_code) (next)->base.code) == POINTER_TYPE))
2626 next = TREE_TYPE (next)((contains_struct_check ((next), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2626, __FUNCTION__))->typed.type);
2627
2628 if (TREE_CODE (next)((enum tree_code) (next)->base.code) == FUNCTION_TYPE)
2629 {
2630 if (flags & TFF_EXPR_IN_PARENS(1 << 9))
2631 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2632 pp_cxx_star (pp)pp_c_star (pp);
2633 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2633, __FUNCTION__))))), flags & ~TFF_EXPR_IN_PARENS(1 << 9));
2634 if (flags & TFF_EXPR_IN_PARENS(1 << 9))
2635 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2636 break;
2637 }
2638 /* Else fall through. */
2639 }
2640 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2640, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2641 break;
2642
2643 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
2644 case IMPLICIT_CONV_EXPR:
2645 case VIEW_CONVERT_EXPR:
2646 {
2647 tree op = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2647, __FUNCTION__)))));
2648
2649 if (location_wrapper_p (t))
2650 {
2651 dump_expr (pp, op, flags);
2652 break;
2653 }
2654
2655 tree ttype = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2655, __FUNCTION__))->typed.type);
2656 tree optype = TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2656, __FUNCTION__))->typed.type);
2657
2658 if (TREE_CODE (ttype)((enum tree_code) (ttype)->base.code) != TREE_CODE (optype)((enum tree_code) (optype)->base.code)
2659 && INDIRECT_TYPE_P (ttype)((((enum tree_code) (ttype)->base.code) == POINTER_TYPE) ||
(((enum tree_code) (ttype)->base.code) == REFERENCE_TYPE)
)
2660 && INDIRECT_TYPE_P (optype)((((enum tree_code) (optype)->base.code) == POINTER_TYPE) ||
(((enum tree_code) (optype)->base.code) == REFERENCE_TYPE
))
2661 && same_type_p (TREE_TYPE (optype),comptypes ((((contains_struct_check ((optype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2661, __FUNCTION__))->typed.type)), (((contains_struct_check
((ttype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2662, __FUNCTION__))->typed.type)), 0)
2662 TREE_TYPE (ttype))comptypes ((((contains_struct_check ((optype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2661, __FUNCTION__))->typed.type)), (((contains_struct_check
((ttype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2662, __FUNCTION__))->typed.type)), 0))
2663 {
2664 if (TYPE_REF_P (ttype)(((enum tree_code) (ttype)->base.code) == REFERENCE_TYPE))
2665 {
2666 STRIP_NOPS (op)(op) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((op)))));
2667 if (TREE_CODE (op)((enum tree_code) (op)->base.code) == ADDR_EXPR)
2668 dump_expr (pp, TREE_OPERAND (op, 0)(*((const_cast<tree*> (tree_operand_check ((op), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2668, __FUNCTION__))))), flags);
2669 else
2670 dump_unary_op (pp, "*", t, flags);
2671 }
2672 else
2673 dump_unary_op (pp, "&", t, flags);
2674 }
2675 else if (!same_type_p (TREE_TYPE (op), TREE_TYPE (t))comptypes ((((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2675, __FUNCTION__))->typed.type)), (((contains_struct_check
((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2675, __FUNCTION__))->typed.type)), 0))
2676 {
2677 /* It is a cast, but we cannot tell whether it is a
2678 reinterpret or static cast. Use the C style notation. */
2679 if (flags & TFF_EXPR_IN_PARENS(1 << 9))
2680 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2681 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2682 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2682, __FUNCTION__))->typed.type), flags);
2683 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2684 dump_expr (pp, op, flags | TFF_EXPR_IN_PARENS(1 << 9));
2685 if (flags & TFF_EXPR_IN_PARENS(1 << 9))
2686 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2687 }
2688 else
2689 dump_expr (pp, op, flags);
2690 break;
2691 }
2692
2693 case CONSTRUCTOR:
2694 if (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2694, __FUNCTION__))->typed.type) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))(((enum tree_code) (((contains_struct_check ((t), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2694, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
&& (((tree_class_check (((tree_check ((((contains_struct_check
((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2694, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2694, __FUNCTION__, (RECORD_TYPE)))), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2694, __FUNCTION__))->type_common.lang_flag_2))))
2695 {
2696 tree idx = build_ptrmemfunc_access_expr (t, pfn_identifiercp_global_trees[CPTI_PFN_IDENTIFIER]);
2697
2698 if (integer_zerop (idx))
2699 {
2700 /* A NULL pointer-to-member constant. */
2701 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2702 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2703 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2703, __FUNCTION__))->typed.type), flags);
2704 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2705 pp_character (pp, '0');
2706 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2707 break;
2708 }
2709 else if (tree_fits_shwi_p (idx))
2710 {
2711 tree virtuals;
2712 unsigned HOST_WIDE_INTlong n;
2713
2714 t = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)))((contains_struct_check (((cp_build_qualified_type (((contains_struct_check
((((tree_check3 ((((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2714, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2714, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2714, __FUNCTION__))->typed.type), cp_type_quals (((contains_struct_check
((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2714, __FUNCTION__))->typed.type))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2714, __FUNCTION__))->typed.type);
2715 t = TYPE_METHOD_BASETYPE (t)((tree_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2715, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.maxval);
2716 virtuals = BINFO_VIRTUALS (TYPE_BINFO (TYPE_MAIN_VARIANT (t)))((tree_check ((((tree_check3 ((((tree_class_check ((t), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2716, __FUNCTION__))->type_common.main_variant)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2716, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2716, __FUNCTION__, (TREE_BINFO)))->binfo.virtuals);
2717
2718 n = tree_to_shwi (idx);
2719
2720 /* Map vtable index back one, to allow for the null pointer to
2721 member. */
2722 --n;
2723
2724 while (n > 0 && virtuals)
2725 {
2726 --n;
2727 virtuals = TREE_CHAIN (virtuals)((contains_struct_check ((virtuals), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2727, __FUNCTION__))->common.chain);
2728 }
2729 if (virtuals)
2730 {
2731 dump_expr (pp, BV_FN (virtuals)(((tree_check ((virtuals), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2731, __FUNCTION__, (TREE_LIST)))->list.value)),
2732 flags | TFF_EXPR_IN_PARENS(1 << 9));
2733 break;
2734 }
2735 }
2736 }
2737 if (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type) && LAMBDA_TYPE_P (TREE_TYPE (t))(((enum tree_code) (((contains_struct_check ((t), (TS_TYPED),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
&& ((((tree_class_check ((((tree_class_check ((((contains_struct_check
((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __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 ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check ((((contains_struct_check
((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __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 ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check ((((contains_struct_check ((t), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2737, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
)))
2738 pp_string (pp, "<lambda closure object>");
2739 if (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2739, __FUNCTION__))->typed.type) && EMPTY_CONSTRUCTOR_P (t)(((enum tree_code) (t)->base.code) == CONSTRUCTOR &&
vec_safe_is_empty(((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2739, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)) &&
!(((tree_not_check2 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2739, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4))))
2740 {
2741 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2741, __FUNCTION__))->typed.type), 0);
2742 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2743 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2744 }
2745 else
2746 {
2747 if (!BRACE_ENCLOSED_INITIALIZER_P (t)(((enum tree_code) (t)->base.code) == CONSTRUCTOR &&
((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2747, __FUNCTION__))->typed.type) == cp_global_trees[CPTI_INIT_LIST_TYPE
]))
2748 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2748, __FUNCTION__))->typed.type), 0);
2749 pp_cxx_left_brace (pp)pp_c_left_brace (pp);
2750 dump_expr_init_vec (pp, CONSTRUCTOR_ELTS (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2750, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts), flags);
2751 pp_cxx_right_brace (pp)pp_c_right_brace (pp);
2752 }
2753
2754 break;
2755
2756 case OFFSET_REF:
2757 {
2758 tree ob = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2758, __FUNCTION__)))));
2759 if (is_dummy_object (ob))
2760 {
2761 t = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2761, __FUNCTION__)))));
2762 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == FUNCTION_DECL)
2763 /* A::f */
2764 dump_expr (pp, t, flags | TFF_EXPR_IN_PARENS(1 << 9));
2765 else if (BASELINK_P (t)(((enum tree_code) (t)->base.code) == BASELINK))
2766 dump_expr (pp, OVL_FIRST (BASELINK_FUNCTIONS (t))ovl_first ((((struct tree_baselink*) (tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2766, __FUNCTION__, (BASELINK))))->functions)),
2767 flags | TFF_EXPR_IN_PARENS(1 << 9));
2768 else
2769 dump_decl (pp, t, flags);
2770 }
2771 else
2772 {
2773 if (INDIRECT_REF_P (ob)(((enum tree_code) (ob)->base.code) == INDIRECT_REF))
2774 {
2775 dump_expr (pp, TREE_OPERAND (ob, 0)(*((const_cast<tree*> (tree_operand_check ((ob), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2775, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2776 pp_cxx_arrow (pp)pp_c_arrow (pp);
2777 pp_cxx_star (pp)pp_c_star (pp);
2778 }
2779 else
2780 {
2781 dump_expr (pp, ob, flags | TFF_EXPR_IN_PARENS(1 << 9));
2782 pp_cxx_dot (pp)pp_c_dot (pp);
2783 pp_cxx_star (pp)pp_c_star (pp);
2784 }
2785 dump_expr (pp, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2785, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
2786 }
2787 break;
2788 }
2789
2790 case TEMPLATE_PARM_INDEX:
2791 dump_decl (pp, TEMPLATE_PARM_DECL (t)(((template_parm_index*)(tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2791, __FUNCTION__, (TEMPLATE_PARM_INDEX))))->decl), flags & ~TFF_DECL_SPECIFIERS(1 << 2));
2792 break;
2793
2794 case CAST_EXPR:
2795 if (TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2795, __FUNCTION__))))) == NULL_TREE(tree) __null
2796 || TREE_CHAIN (TREE_OPERAND (t, 0))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2796, __FUNCTION__)))))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2796, __FUNCTION__))->common.chain))
2797 {
2798 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2798, __FUNCTION__))->typed.type), flags);
2799 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2800 dump_expr_list (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2800, __FUNCTION__))))), flags);
2801 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2802 }
2803 else
2804 {
2805 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2806 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2806, __FUNCTION__))->typed.type), flags);
2807 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2808 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2809 dump_expr_list (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2809, __FUNCTION__))))), flags);
2810 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2811 }
2812 break;
2813
2814 case STATIC_CAST_EXPR:
2815 pp_cxx_ws_string (pp, "static_cast")pp_c_ws_string (pp, "static_cast");
2816 goto cast;
2817 case REINTERPRET_CAST_EXPR:
2818 pp_cxx_ws_string (pp, "reinterpret_cast")pp_c_ws_string (pp, "reinterpret_cast");
2819 goto cast;
2820 case CONST_CAST_EXPR:
2821 pp_cxx_ws_string (pp, "const_cast")pp_c_ws_string (pp, "const_cast");
2822 goto cast;
2823 case DYNAMIC_CAST_EXPR:
2824 pp_cxx_ws_string (pp, "dynamic_cast")pp_c_ws_string (pp, "dynamic_cast");
2825 cast:
2826 pp_cxx_begin_template_argument_list (pp);
2827 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2827, __FUNCTION__))->typed.type), flags);
2828 pp_cxx_end_template_argument_list (pp);
2829 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2830 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2830, __FUNCTION__))))), flags);
2831 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2832 break;
2833
2834 case ARROW_EXPR:
2835 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2835, __FUNCTION__))))), flags);
2836 pp_cxx_arrow (pp)pp_c_arrow (pp);
2837 break;
2838
2839 case SIZEOF_EXPR:
2840 case ALIGNOF_EXPR:
2841 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == SIZEOF_EXPR)
2842 pp_cxx_ws_string (pp, "sizeof")pp_c_ws_string (pp, "sizeof");
2843 else
2844 {
2845 gcc_assert (TREE_CODE (t) == ALIGNOF_EXPR)((void)(!(((enum tree_code) (t)->base.code) == ALIGNOF_EXPR
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2845, __FUNCTION__), 0 : 0));
2846 pp_cxx_ws_string (pp, "__alignof__")pp_c_ws_string (pp, "__alignof__");
2847 }
2848 op = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2848, __FUNCTION__)))));
2849 if (PACK_EXPANSION_P (op)(((enum tree_code) (op)->base.code) == TYPE_PACK_EXPANSION
|| ((enum tree_code) (op)->base.code) == EXPR_PACK_EXPANSION
))
2850 {
2851 pp_string (pp, "...");
2852 op = PACK_EXPANSION_PATTERN (op)(((enum tree_code) ((tree_check2 ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2852, __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/error.cc"
, 2852, __FUNCTION__))->typed.type) : (*((const_cast<tree
*> (tree_operand_check ((op), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2852, __FUNCTION__))))));
2853 }
2854 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
2855 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2856 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == SIZEOF_EXPR && SIZEOF_EXPR_TYPE_P (t)((tree_not_check2 (((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2856, __FUNCTION__, (SIZEOF_EXPR)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2856, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
2857 dump_type (pp, TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2857, __FUNCTION__))->typed.type), flags);
2858 else if (TYPE_P (TREE_OPERAND (t, 0))(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) ((*((const_cast<tree*> (tree_operand_check ((t), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2858, __FUNCTION__))))))->base.code))] == tcc_type))
2859 dump_type (pp, op, flags);
2860 else
2861 dump_expr (pp, op, flags);
2862 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2863 break;
2864
2865 case AT_ENCODE_EXPR:
2866 pp_cxx_ws_string (pp, "@encode")pp_c_ws_string (pp, "@encode");
2867 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
2868 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2869 dump_type (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2869, __FUNCTION__))))), flags);
2870 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2871 break;
2872
2873 case NOEXCEPT_EXPR:
2874 pp_cxx_ws_string (pp, "noexcept")pp_c_ws_string (pp, "noexcept");
2875 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
2876 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2877 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2877, __FUNCTION__))))), flags);
2878 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2879 break;
2880
2881 case REALPART_EXPR:
2882 case IMAGPART_EXPR:
2883 pp_cxx_ws_string (pp, OVL_OP_INFO (false, TREE_CODE (t))->name)pp_c_ws_string (pp, (&ovl_op_info[(false) != 0][ovl_op_mapping
[(((enum tree_code) (t)->base.code))]])->name);
2884 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
2885 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2885, __FUNCTION__))))), flags);
2886 break;
2887
2888 case DEFERRED_PARSE:
2889 pp_string (pp, M_("<unparsed>")((cxx_pp)->translate_identifiers ? gettext ("<unparsed>"
) : ("<unparsed>")));
2890 break;
2891
2892 case TRY_CATCH_EXPR:
2893 case CLEANUP_POINT_EXPR:
2894 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2894, __FUNCTION__))))), flags);
2895 break;
2896
2897 case PSEUDO_DTOR_EXPR:
2898 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2898, __FUNCTION__))))), flags);
2899 pp_cxx_dot (pp)pp_c_dot (pp);
2900 if (TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2900, __FUNCTION__))))))
2901 {
2902 dump_type (pp, TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2902, __FUNCTION__))))), flags);
2903 pp_cxx_colon_colon (pp);
2904 }
2905 pp_cxx_complement (pp)pp_c_complement (pp);
2906 dump_type (pp, TREE_OPERAND (t, 2)(*((const_cast<tree*> (tree_operand_check ((t), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2906, __FUNCTION__))))), flags);
2907 break;
2908
2909 case TEMPLATE_ID_EXPR:
2910 dump_decl (pp, t, flags);
2911 break;
2912
2913 case BIND_EXPR:
2914 case STMT_EXPR:
2915 case EXPR_STMT:
2916 case STATEMENT_LIST:
2917 /* We don't yet have a way of dumping statements in a
2918 human-readable format. */
2919 pp_string (pp, "({...})");
2920 break;
2921
2922 case LOOP_EXPR:
2923 pp_string (pp, "while (1) { ");
2924 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2924, __FUNCTION__))))), flags & ~TFF_EXPR_IN_PARENS(1 << 9));
2925 pp_cxx_right_brace (pp)pp_c_right_brace (pp);
2926 break;
2927
2928 case EXIT_EXPR:
2929 pp_string (pp, "if (");
2930 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2930, __FUNCTION__))))), flags & ~TFF_EXPR_IN_PARENS(1 << 9));
2931 pp_string (pp, ") break; ");
2932 break;
2933
2934 case BASELINK:
2935 dump_expr (pp, BASELINK_FUNCTIONS (t)(((struct tree_baselink*) (tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2935, __FUNCTION__, (BASELINK))))->functions), flags & ~TFF_EXPR_IN_PARENS(1 << 9));
2936 break;
2937
2938 case EMPTY_CLASS_EXPR:
2939 dump_type (pp, TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2939, __FUNCTION__))->typed.type), flags);
2940 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
2941 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
2942 break;
2943
2944 case NON_DEPENDENT_EXPR:
2945 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2945, __FUNCTION__))))), flags);
2946 break;
2947
2948 case ARGUMENT_PACK_SELECT:
2949 dump_template_argument (pp, ARGUMENT_PACK_SELECT_FROM_PACK (t)(((struct tree_argument_pack_select *)(tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 2949, __FUNCTION__, (ARGUMENT_PACK_SELECT))))->argument_pack
), flags);
2950 break;
2951
2952 case RECORD_TYPE:
2953 case UNION_TYPE:
2954 case ENUMERAL_TYPE:
2955 case REAL_TYPE:
2956 case VOID_TYPE:
2957 case OPAQUE_TYPE:
2958 case BOOLEAN_TYPE:
2959 case INTEGER_TYPE:
2960 case COMPLEX_TYPE:
2961 case VECTOR_TYPE:
2962 case DECLTYPE_TYPE:
2963 pp_type_specifier_seq (pp, t)(pp)->type_specifier_seq (pp, t);
2964 break;
2965
2966 case TYPENAME_TYPE:
2967 /* We get here when we want to print a dependent type as an
2968 id-expression, without any disambiguator decoration. */
2969 pp->id_expression (t);
2970 break;
2971
2972 case TEMPLATE_TYPE_PARM:
2973 case TEMPLATE_TEMPLATE_PARM:
2974 case BOUND_TEMPLATE_TEMPLATE_PARM:
2975 dump_type (pp, t, flags);
2976 break;
2977
2978 case TRAIT_EXPR:
2979 pp_cxx_trait (pp, t);
2980 break;
2981
2982 case VA_ARG_EXPR:
2983 pp_cxx_va_arg_expression (pp, t);
2984 break;
2985
2986 case OFFSETOF_EXPR:
2987 pp_cxx_offsetof_expression (pp, t);
2988 break;
2989
2990 case ADDRESSOF_EXPR:
2991 pp_cxx_addressof_expression (pp, t);
2992 break;
2993
2994 case SCOPE_REF:
2995 dump_decl (pp, t, flags);
2996 break;
2997
2998 case EXPR_PACK_EXPANSION:
2999 case UNARY_LEFT_FOLD_EXPR:
3000 case UNARY_RIGHT_FOLD_EXPR:
3001 case BINARY_LEFT_FOLD_EXPR:
3002 case BINARY_RIGHT_FOLD_EXPR:
3003 case TYPEID_EXPR:
3004 case MEMBER_REF:
3005 case DOTSTAR_EXPR:
3006 case NEW_EXPR:
3007 case VEC_NEW_EXPR:
3008 case DELETE_EXPR:
3009 case VEC_DELETE_EXPR:
3010 case MODOP_EXPR:
3011 case ABS_EXPR:
3012 case ABSU_EXPR:
3013 case CONJ_EXPR:
3014 case VECTOR_CST:
3015 case FIXED_CST:
3016 case UNORDERED_EXPR:
3017 case ORDERED_EXPR:
3018 case UNLT_EXPR:
3019 case UNLE_EXPR:
3020 case UNGT_EXPR:
3021 case UNGE_EXPR:
3022 case UNEQ_EXPR:
3023 case LTGT_EXPR:
3024 case COMPLEX_EXPR:
3025 case BIT_FIELD_REF:
3026 case FIX_TRUNC_EXPR:
3027 case FLOAT_EXPR:
3028 pp->expression (t);
3029 break;
3030
3031 case TRUTH_AND_EXPR:
3032 case TRUTH_OR_EXPR:
3033 case TRUTH_XOR_EXPR:
3034 if (flags & TFF_EXPR_IN_PARENS(1 << 9))
3035 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
3036 pp->expression (t);
3037 if (flags & TFF_EXPR_IN_PARENS(1 << 9))
3038 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
3039 break;
3040
3041 case OBJ_TYPE_REF:
3042 dump_expr (pp, resolve_virtual_fun_from_obj_type_ref (t), flags);
3043 break;
3044
3045 case LAMBDA_EXPR:
3046 pp_string (pp, M_("<lambda>")((cxx_pp)->translate_identifiers ? gettext ("<lambda>"
) : ("<lambda>")));
3047 break;
3048
3049 case PAREN_EXPR:
3050 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
3051 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3051, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
3052 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
3053 break;
3054
3055 case REQUIRES_EXPR:
3056 pp_cxx_requires_expr (cxx_pp, t);
3057 break;
3058
3059 case SIMPLE_REQ:
3060 pp_cxx_simple_requirement (cxx_pp, t);
3061 break;
3062
3063 case TYPE_REQ:
3064 pp_cxx_type_requirement (cxx_pp, t);
3065 break;
3066
3067 case COMPOUND_REQ:
3068 pp_cxx_compound_requirement (cxx_pp, t);
3069 break;
3070
3071 case NESTED_REQ:
3072 pp_cxx_nested_requirement (cxx_pp, t);
3073 break;
3074
3075 case ATOMIC_CONSTR:
3076 case CHECK_CONSTR:
3077 case CONJ_CONSTR:
3078 case DISJ_CONSTR:
3079 {
3080 pp_cxx_constraint (cxx_pp, t);
3081 break;
3082 }
3083
3084 case PLACEHOLDER_EXPR:
3085 pp_string (pp, M_("*this")((cxx_pp)->translate_identifiers ? gettext ("*this") : ("*this"
)));
3086 break;
3087
3088 case TREE_LIST:
3089 dump_expr_list (pp, t, flags);
3090 break;
3091
3092 /* This list is incomplete, but should suffice for now.
3093 It is very important that `sorry' does not call
3094 `report_error_function'. That could cause an infinite loop. */
3095 default:
3096 pp_unsupported_tree (pp, t)pp_verbatim (pp, "%qs not supported by %s", get_tree_code_name
(((enum tree_code) (t)->base.code)), __FUNCTION__);
3097 /* Fall through. */
3098 case ERROR_MARK:
3099 pp_string (pp, M_("<expression error>")((cxx_pp)->translate_identifiers ? gettext ("<expression error>"
) : ("<expression error>")));
3100 break;
3101 }
3102}
3103
3104static void
3105dump_binary_op (cxx_pretty_printer *pp, const char *opstring, tree t,
3106 int flags)
3107{
3108 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
3109 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3109, __FUNCTION__))))), flags | TFF_EXPR_IN_PARENS(1 << 9));
3110 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
3111 if (opstring)
3112 pp_cxx_ws_string (pp, opstring)pp_c_ws_string (pp, opstring);
3113 else
3114 pp_string (pp, M_("<unknown operator>")((cxx_pp)->translate_identifiers ? gettext ("<unknown operator>"
) : ("<unknown operator>")));
3115 pp_cxx_whitespace (pp)pp_c_whitespace (pp);
3116 tree op1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3116, __FUNCTION__)))));
3117 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == POINTER_PLUS_EXPR
3118 && TREE_CODE (op1)((enum tree_code) (op1)->base.code) == INTEGER_CST
3119 && tree_int_cst_sign_bit (op1))
3120 /* A pointer minus an integer is represented internally as plus a very
3121 large number, don't expose that to users. */
3122 op1 = convert (ssizetypesizetype_tab[(int) stk_ssizetype], op1);
3123 dump_expr (pp, op1, flags | TFF_EXPR_IN_PARENS(1 << 9));
3124 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
3125}
3126
3127static void
3128dump_unary_op (cxx_pretty_printer *pp, const char *opstring, tree t, int flags)
3129{
3130 if (flags & TFF_EXPR_IN_PARENS(1 << 9))
3131 pp_cxx_left_paren (pp)pp_c_left_paren (pp);
3132 pp_cxx_ws_string (pp, opstring)pp_c_ws_string (pp, opstring);
3133 dump_expr (pp, TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3133, __FUNCTION__))))), flags & ~TFF_EXPR_IN_PARENS(1 << 9));
3134 if (flags & TFF_EXPR_IN_PARENS(1 << 9))
3135 pp_cxx_right_paren (pp)pp_c_right_paren (pp);
3136}
3137
3138static void
3139reinit_cxx_pp (void)
3140{
3141 pp_clear_output_area (cxx_pp);
3142 cxx_pp->padding = pp_none;
3143 pp_indentation (cxx_pp)(cxx_pp)->indent_skip = 0;
3144 pp_needs_newline (cxx_pp)(cxx_pp)->need_newline = false;
3145 pp_show_color (cxx_pp)(cxx_pp)->show_color = false;
3146 cxx_pp->enclosing_scope = current_function_decl;
3147}
3148
3149/* Same as pp_formatted_text, except the return string is a separate
3150 copy and has a GGC storage duration, e.g. an indefinite lifetime. */
3151
3152inline const char *
3153pp_ggc_formatted_text (pretty_printer *pp)
3154{
3155 return ggc_strdup (pp_formatted_text (pp))ggc_alloc_string ((pp_formatted_text (pp)), -1 );
3156}
3157
3158/* Exported interface to stringifying types, exprs and decls under TFF_*
3159 control. */
3160
3161const char *
3162type_as_string (tree typ, int flags)
3163{
3164 reinit_cxx_pp ();
3165 pp_translate_identifiers (cxx_pp)(cxx_pp)->translate_identifiers = false;
3166 dump_type (cxx_pp, typ, flags);
3167 return pp_ggc_formatted_text (cxx_pp);
3168}
3169
3170const char *
3171type_as_string_translate (tree typ, int flags)
3172{
3173 reinit_cxx_pp ();
3174 dump_type (cxx_pp, typ, flags);
3175 return pp_ggc_formatted_text (cxx_pp);
3176}
3177
3178const char *
3179expr_as_string (tree decl, int flags)
3180{
3181 reinit_cxx_pp ();
3182 pp_translate_identifiers (cxx_pp)(cxx_pp)->translate_identifiers = false;
3183 dump_expr (cxx_pp, decl, flags);
3184 return pp_ggc_formatted_text (cxx_pp);
3185}
3186
3187/* Wrap decl_as_string with options appropriate for dwarf. */
3188
3189const char *
3190decl_as_dwarf_string (tree decl, int flags)
3191{
3192 const char *name;
3193 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
3194 here will be adequate to get the desired behavior. */
3195 cxx_pp->flags |= pp_c_flag_gnu_v3;
3196 name = decl_as_string (decl, flags);
3197 /* Subsequent calls to the pretty printer shouldn't use this style. */
3198 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
3199 return name;
3200}
3201
3202const char *
3203decl_as_string (tree decl, int flags)
3204{
3205 reinit_cxx_pp ();
3206 pp_translate_identifiers (cxx_pp)(cxx_pp)->translate_identifiers = false;
3207 dump_decl (cxx_pp, decl, flags);
3208 return pp_ggc_formatted_text (cxx_pp);
3209}
3210
3211const char *
3212decl_as_string_translate (tree decl, int flags)
3213{
3214 reinit_cxx_pp ();
3215 dump_decl (cxx_pp, decl, flags);
3216 return pp_ggc_formatted_text (cxx_pp);
3217}
3218
3219/* Wrap lang_decl_name with options appropriate for dwarf. */
3220
3221const char *
3222lang_decl_dwarf_name (tree decl, int v, bool translate)
3223{
3224 const char *name;
3225 /* Curiously, reinit_cxx_pp doesn't reset the flags field, so setting the flag
3226 here will be adequate to get the desired behavior. */
3227 cxx_pp->flags |= pp_c_flag_gnu_v3;
3228 name = lang_decl_name (decl, v, translate);
3229 /* Subsequent calls to the pretty printer shouldn't use this style. */
3230 cxx_pp->flags &= ~pp_c_flag_gnu_v3;
3231 return name;
3232}
3233
3234/* Generate the three forms of printable names for cxx_printable_name. */
3235
3236const char *
3237lang_decl_name (tree decl, int v, bool translate)
3238{
3239 if (v >= 2)
3240 return (translate
3241 ? decl_as_string_translate (decl, TFF_DECL_SPECIFIERS(1 << 2))
3242 : decl_as_string (decl, TFF_DECL_SPECIFIERS(1 << 2)));
3243
3244 reinit_cxx_pp ();
3245 pp_translate_identifiers (cxx_pp)(cxx_pp)->translate_identifiers = translate;
3246 if (v == 1
3247 && (DECL_CLASS_SCOPE_P (decl)(((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3247, __FUNCTION__))->decl_minimal.context) && (
tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3247, __FUNCTION__))->decl_minimal.context))->base.code
))] == tcc_type))
3248 || (DECL_NAMESPACE_SCOPE_P (decl)(!(((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3248, __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/error.cc"
, 3248, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3248, __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/error.cc"
, 3248, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]))->base.code) == NAMESPACE_DECL)
3249 && CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3249, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3249, __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/error.cc"
, 3249, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]) != global_namespacecp_global_trees[CPTI_GLOBAL])))
3250 {
3251 dump_type (cxx_pp, CP_DECL_CONTEXT (decl)(!(! (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3251, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3251, __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/error.cc"
, 3251, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]), TFF_PLAIN_IDENTIFIER(0));
3252 pp_cxx_colon_colon (cxx_pp);
3253 }
3254
3255 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FUNCTION_DECL)
3256 dump_function_name (cxx_pp, decl, TFF_PLAIN_IDENTIFIER(0));
3257 else if ((DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3257, __FUNCTION__))->decl_minimal.name) == NULL_TREE(tree) __null)
3258 && TREE_CODE (decl)((enum tree_code) (decl)->base.code) == NAMESPACE_DECL)
3259 dump_decl (cxx_pp, decl, TFF_PLAIN_IDENTIFIER(0) | TFF_UNQUALIFIED_NAME(1 << 11));
3260 else
3261 dump_decl (cxx_pp, DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3261, __FUNCTION__))->decl_minimal.name), TFF_PLAIN_IDENTIFIER(0));
3262
3263 return pp_ggc_formatted_text (cxx_pp);
3264}
3265
3266/* Return the location of a tree passed to %+ formats. */
3267
3268location_t
3269location_of (tree t)
3270{
3271 if (TYPE_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_type))
3272 {
3273 t = TYPE_MAIN_DECL (t)((((contains_struct_check (((tree_class_check ((((tree_class_check
((t), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3273, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3273, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3273, __FUNCTION__))->common.chain)));
3274 if (t == NULL_TREE(tree) __null)
3275 return input_location;
3276 }
3277 else if (TREE_CODE (t)((enum tree_code) (t)->base.code) == OVERLOAD)
3278 t = OVL_FIRST (t)ovl_first (t);
3279
3280 if (DECL_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_declaration))
3281 return DECL_SOURCE_LOCATION (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3281, __FUNCTION__))->decl_minimal.locus);
3282 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == DEFERRED_PARSE)
3283 return defparse_location (t);
3284 return cp_expr_loc_or_input_loc (t);
3285}
3286
3287/* Now the interfaces from error et al to dump_type et al. Each takes an
3288 on/off VERBOSE flag and supply the appropriate TFF_ flags to a dump_
3289 function. */
3290
3291static const char *
3292decl_to_string (tree decl, int verbose, bool show_color)
3293{
3294 int flags = 0;
3295
3296 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == RECORD_TYPE
3297 || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == UNION_TYPE || TREE_CODE (decl)((enum tree_code) (decl)->base.code) == ENUMERAL_TYPE)
3298 flags = TFF_CLASS_KEY_OR_ENUM(1 << 3);
3299 if (verbose)
3300 flags |= TFF_DECL_SPECIFIERS(1 << 2);
3301 else if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FUNCTION_DECL)
3302 flags |= TFF_DECL_SPECIFIERS(1 << 2) | TFF_RETURN_TYPE(1 << 4);
3303 flags |= TFF_TEMPLATE_HEADER(1 << 7);
3304
3305 reinit_cxx_pp ();
3306 pp_show_color (cxx_pp)(cxx_pp)->show_color = show_color;
3307 dump_decl (cxx_pp, decl, flags);
3308 return pp_ggc_formatted_text (cxx_pp);
3309}
3310
3311const char *
3312expr_to_string (tree decl)
3313{
3314 reinit_cxx_pp ();
3315 dump_expr (cxx_pp, decl, 0);
3316 return pp_ggc_formatted_text (cxx_pp);
3317}
3318
3319static const char *
3320fndecl_to_string (tree fndecl, int verbose)
3321{
3322 int flags;
3323
3324 flags = TFF_EXCEPTION_SPECIFICATION(1 << 6) | TFF_DECL_SPECIFIERS(1 << 2)
3325 | TFF_TEMPLATE_HEADER(1 << 7);
3326 if (verbose)
3327 flags |= TFF_FUNCTION_DEFAULT_ARGUMENTS(1 << 5);
3328 reinit_cxx_pp ();
3329 dump_decl (cxx_pp, fndecl, flags);
3330 return pp_ggc_formatted_text (cxx_pp);
3331}
3332
3333
3334static const char *
3335code_to_string (enum tree_code c)
3336{
3337 return get_tree_code_name (c);
3338}
3339
3340const char *
3341language_to_string (enum languages c)
3342{
3343 switch (c)
3344 {
3345 case lang_c:
3346 return "C";
3347
3348 case lang_cplusplus:
3349 return "C++";
3350
3351 default:
3352 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3352, __FUNCTION__));
3353 }
3354 return NULL__null;
3355}
3356
3357/* Return the proper printed version of a parameter to a C++ function. */
3358
3359static const char *
3360parm_to_string (int p)
3361{
3362 reinit_cxx_pp ();
3363 if (p < 0)
3364 pp_string (cxx_pp, "'this'");
3365 else
3366 pp_decimal_int (cxx_pp, p + 1)do { sprintf ((cxx_pp)->buffer->digit_buffer, "%d", p +
1); pp_string (cxx_pp, (cxx_pp)->buffer->digit_buffer)
; } while (0);
3367 return pp_ggc_formatted_text (cxx_pp);
3368}
3369
3370static const char *
3371op_to_string (bool assop, enum tree_code p)
3372{
3373 tree id = ovl_op_identifier (assop, p);
3374 return id ? IDENTIFIER_POINTER (id)((const char *) (tree_check ((id), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3374, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
) : M_("<unknown>")((cxx_pp)->translate_identifiers ? gettext ("<unknown>"
) : ("<unknown>"));
3375}
3376
3377/* Return a GC-allocated representation of type TYP, with verbosity VERBOSE.
3378
3379 If QUOTE is non-NULL and if *QUOTE is true, then quotes are added to the
3380 string in appropriate places, and *QUOTE is written to with false
3381 to suppress pp_format's trailing close quote so that e.g.
3382 foo_typedef {aka underlying_foo} {enum}
3383 can be printed by "%qT" as:
3384 `foo_typedef' {aka `underlying_foo'} {enum}
3385 rather than:
3386 `foo_typedef {aka underlying_foo} {enum}'
3387 When adding such quotes, if POSTPROCESSED is true (for handling %H and %I)
3388 then a leading open quote will be added, whereas if POSTPROCESSED is false
3389 (for handling %T) then any leading quote has already been added by
3390 pp_format, or is not needed due to QUOTE being NULL (for template arguments
3391 within %H and %I).
3392
3393 SHOW_COLOR is used to determine the colorization of any quotes that
3394 are added. */
3395
3396static const char *
3397type_to_string (tree typ, int verbose, bool postprocessed, bool *quote,
3398 bool show_color)
3399{
3400 int flags = 0;
3401 if (verbose)
3402 flags |= TFF_CLASS_KEY_OR_ENUM(1 << 3);
3403 flags |= TFF_TEMPLATE_HEADER(1 << 7);
3404
3405 reinit_cxx_pp ();
3406 pp_show_color (cxx_pp)(cxx_pp)->show_color = show_color;
3407
3408 if (postprocessed && quote && *quote)
3409 pp_begin_quote (cxx_pp, show_color);
3410
3411 struct obstack *ob = pp_buffer (cxx_pp)(cxx_pp)->buffer->obstack;
3412 int type_start, type_len;
3413 type_start = obstack_object_size (ob)__extension__ ({ struct obstack const *__o = (ob); (size_t) (
__o->next_free - __o->object_base); });
3414
3415 dump_type (cxx_pp, typ, flags);
3416
3417 /* Remember the end of the initial dump. */
3418 type_len = obstack_object_size (ob)__extension__ ({ struct obstack const *__o = (ob); (size_t) (
__o->next_free - __o->object_base); }) - type_start;
3419
3420 /* If we're printing a type that involves typedefs, also print the
3421 stripped version. But sometimes the stripped version looks
3422 exactly the same, so we don't want it after all. To avoid printing
3423 it in that case, we play ugly obstack games. */
3424 if (typ && TYPE_P (typ)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (typ)->base.code))] == tcc_type) && typ != TYPE_CANONICAL (typ)((tree_class_check ((typ), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3424, __FUNCTION__))->type_common.canonical)
3425 && !uses_template_parms (typ))
3426 {
3427 int aka_start, aka_len; char *p;
3428 tree aka = strip_typedefs (typ, NULL__null, STF_USER_VISIBLE);
3429 if (quote && *quote)
3430 pp_end_quote (cxx_pp, show_color);
3431 pp_string (cxx_pp, " {aka");
3432 pp_cxx_whitespace (cxx_pp)pp_c_whitespace (cxx_pp);
3433 if (quote && *quote)
3434 pp_begin_quote (cxx_pp, show_color);
3435 /* And remember the start of the aka dump. */
3436 aka_start = obstack_object_size (ob)__extension__ ({ struct obstack const *__o = (ob); (size_t) (
__o->next_free - __o->object_base); });
3437 dump_type (cxx_pp, aka, flags);
3438 aka_len = obstack_object_size (ob)__extension__ ({ struct obstack const *__o = (ob); (size_t) (
__o->next_free - __o->object_base); }) - aka_start;
3439 if (quote && *quote)
3440 pp_end_quote (cxx_pp, show_color);
3441 pp_right_brace (cxx_pp)pp_character (cxx_pp, '}');
3442 p = (char*)obstack_base (ob)((void *) (ob)->object_base);
3443 /* If they are identical, cut off the aka by unwinding the obstack. */
3444 if (type_len == aka_len
3445 && memcmp (p + type_start, p+aka_start, type_len) == 0)
3446 {
3447 /* We can't add a '\0' here, since we may be adding a closing quote
3448 below, and it would be hidden by the '\0'.
3449 Instead, manually unwind the current object within the obstack
3450 so that the insertion point is at the end of the type, before
3451 the "' {aka". */
3452 int delta = type_start + type_len - obstack_object_size (ob)__extension__ ({ struct obstack const *__o = (ob); (size_t) (
__o->next_free - __o->object_base); });
3453 gcc_assert (delta <= 0)((void)(!(delta <= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3453, __FUNCTION__), 0 : 0));
3454 obstack_blank_fast (ob, delta)((void) ((ob)->next_free += (delta)));
3455 }
3456 else
3457 if (quote)
3458 /* No further closing quotes are needed. */
3459 *quote = false;
3460 }
3461
3462 if (quote && *quote)
3463 {
3464 pp_end_quote (cxx_pp, show_color);
3465 *quote = false;
3466 }
3467 return pp_ggc_formatted_text (cxx_pp);
3468}
3469
3470static const char *
3471args_to_string (tree p, int verbose)
3472{
3473 int flags = 0;
3474 if (verbose)
3475 flags |= TFF_CLASS_KEY_OR_ENUM(1 << 3);
3476
3477 if (p == NULL_TREE(tree) __null)
3478 return "";
3479
3480 if (TYPE_P (TREE_VALUE (p))(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (((tree_check ((p), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3480, __FUNCTION__, (TREE_LIST)))->list.value))->base
.code))] == tcc_type))
3481 return type_as_string_translate (p, flags);
3482
3483 reinit_cxx_pp ();
3484 for (; p; p = TREE_CHAIN (p)((contains_struct_check ((p), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3484, __FUNCTION__))->common.chain))
3485 {
3486 if (null_node_p (TREE_VALUE (p)((tree_check ((p), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3486, __FUNCTION__, (TREE_LIST)))->list.value)))
3487 pp_cxx_ws_string (cxx_pp, "NULL")pp_c_ws_string (cxx_pp, "NULL");
3488 else
3489 dump_type (cxx_pp, error_type (TREE_VALUE (p)((tree_check ((p), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3489, __FUNCTION__, (TREE_LIST)))->list.value)), flags);
3490 if (TREE_CHAIN (p)((contains_struct_check ((p), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3490, __FUNCTION__))->common.chain))
3491 pp_separate_with_comma (cxx_pp)pp_cxx_separate_with (cxx_pp, ',');
3492 }
3493 return pp_ggc_formatted_text (cxx_pp);
3494}
3495
3496/* Pretty-print a deduction substitution (from deduction_tsubst_fntype). P
3497 is a TREE_LIST with purpose the TEMPLATE_DECL, value the template
3498 arguments. */
3499
3500static const char *
3501subst_to_string (tree p, bool show_color)
3502{
3503 tree decl = TREE_PURPOSE (p)((tree_check ((p), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3503, __FUNCTION__, (TREE_LIST)))->list.purpose);
3504 tree targs = TREE_VALUE (p)((tree_check ((p), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3504, __FUNCTION__, (TREE_LIST)))->list.value);
3505 tree tparms = DECL_TEMPLATE_PARMS (decl)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3505, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments;
3506 int flags = (TFF_DECL_SPECIFIERS(1 << 2)|TFF_TEMPLATE_HEADER(1 << 7)
3507 |TFF_NO_TEMPLATE_BINDINGS(1 << 13));
3508
3509 if (p == NULL_TREE(tree) __null)
3510 return "";
3511
3512 reinit_cxx_pp ();
3513 pp_show_color (cxx_pp)(cxx_pp)->show_color = show_color;
3514 dump_template_decl (cxx_pp, TREE_PURPOSE (p)((tree_check ((p), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3514, __FUNCTION__, (TREE_LIST)))->list.purpose), flags);
3515 dump_substitution (cxx_pp, NULL__null, tparms, targs, /*flags=*/0);
3516 return pp_ggc_formatted_text (cxx_pp);
3517}
3518
3519static const char *
3520cv_to_string (tree p, int v)
3521{
3522 reinit_cxx_pp ();
3523 cxx_pp->padding = v ? pp_before : pp_none;
3524 pp_cxx_cv_qualifier_seq (cxx_pp, p)pp_c_type_qualifier_list (cxx_pp, p);
3525 return pp_ggc_formatted_text (cxx_pp);
3526}
3527
3528static const char *
3529eh_spec_to_string (tree p, int /*v*/)
3530{
3531 int flags = 0;
3532 reinit_cxx_pp ();
3533 dump_exception_spec (cxx_pp, p, flags);
3534 return pp_ggc_formatted_text (cxx_pp);
3535}
3536
3537/* Langhook for print_error_function. */
3538void
3539cxx_print_error_function (diagnostic_context *context, const char *file,
3540 diagnostic_info *diagnostic)
3541{
3542 char *prefix;
3543 if (file)
3544 prefix = xstrdup (file);
3545 else
3546 prefix = NULL__null;
3547 lhd_print_error_function (context, file, diagnostic);
3548 pp_set_prefix (context->printer, prefix);
3549 maybe_print_instantiation_context (context);
3550}
3551
3552static void
3553cp_diagnostic_starter (diagnostic_context *context,
3554 diagnostic_info *diagnostic)
3555{
3556 diagnostic_report_current_module (context, diagnostic_location (diagnostic));
3557 cp_print_error_function (context, diagnostic);
3558 maybe_print_instantiation_context (context);
3559 maybe_print_constexpr_context (context);
3560 maybe_print_constraint_context (context);
3561 pp_set_prefix (context->printer, diagnostic_build_prefix (context,
3562 diagnostic));
3563}
3564
3565/* Print current function onto BUFFER, in the process of reporting
3566 a diagnostic message. Called from cp_diagnostic_starter. */
3567static void
3568cp_print_error_function (diagnostic_context *context,
3569 diagnostic_info *diagnostic)
3570{
3571 /* If we are in an instantiation context, current_function_decl is likely
3572 to be wrong, so just rely on print_instantiation_full_context. */
3573 if (current_instantiation ())
3574 return;
3575 /* The above is true for constraint satisfaction also. */
3576 if (current_failed_constraint)
3577 return;
3578 if (diagnostic_last_function_changed (context, diagnostic)(((tree) (context)->x_data) != (((tree) (diagnostic)->x_data
) ? ((tree) (diagnostic)->x_data) : current_function_decl)
))
3579 {
3580 char *old_prefix = pp_take_prefix (context->printer);
3581 const char *file = LOCATION_FILE (diagnostic_location (diagnostic))((expand_location (diagnostic_location (diagnostic))).file);
3582 tree abstract_origin = diagnostic_abstract_origin (diagnostic)((tree) (diagnostic)->x_data);
3583 char *new_prefix = (file && abstract_origin == NULL__null)
3584 ? file_name_as_prefix (context, file) : NULL__null;
3585
3586 pp_set_prefix (context->printer, new_prefix);
3587
3588 if (current_function_decl == NULL__null)
3589 pp_string (context->printer, _("At global scope:")gettext ("At global scope:"));
3590 else
3591 {
3592 tree fndecl, ao;
3593
3594 if (abstract_origin)
3595 {
3596 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin)((tree_check ((abstract_origin), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3596, __FUNCTION__, (BLOCK)))->block.abstract_origin);
3597 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL)((void)(!(((enum tree_code) (ao)->base.code) == FUNCTION_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3597, __FUNCTION__), 0 : 0));
3598 fndecl = ao;
3599 }
3600 else
3601 fndecl = current_function_decl;
3602
3603 pp_printf (context->printer, function_category (fndecl),
3604 fndecl);
3605
3606 while (abstract_origin)
3607 {
3608 location_t *locus;
3609 tree block = abstract_origin;
3610
3611 locus = &BLOCK_SOURCE_LOCATION (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3611, __FUNCTION__, (BLOCK)))->block.locus);
3612 fndecl = NULL__null;
3613 block = BLOCK_SUPERCONTEXT (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3613, __FUNCTION__, (BLOCK)))->block.supercontext);
3614 while (block && TREE_CODE (block)((enum tree_code) (block)->base.code) == BLOCK
3615 && BLOCK_ABSTRACT_ORIGIN (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3615, __FUNCTION__, (BLOCK)))->block.abstract_origin))
3616 {
3617 ao = BLOCK_ABSTRACT_ORIGIN (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3617, __FUNCTION__, (BLOCK)))->block.abstract_origin);
3618 if (TREE_CODE (ao)((enum tree_code) (ao)->base.code) == FUNCTION_DECL)
3619 {
3620 fndecl = ao;
3621 break;
3622 }
3623 else if (TREE_CODE (ao)((enum tree_code) (ao)->base.code) != BLOCK)
3624 break;
3625
3626 block = BLOCK_SUPERCONTEXT (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3626, __FUNCTION__, (BLOCK)))->block.supercontext);
3627 }
3628 if (fndecl)
3629 abstract_origin = block;
3630 else
3631 {
3632 while (block && TREE_CODE (block)((enum tree_code) (block)->base.code) == BLOCK)
3633 block = BLOCK_SUPERCONTEXT (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3633, __FUNCTION__, (BLOCK)))->block.supercontext);
3634
3635 if (block && TREE_CODE (block)((enum tree_code) (block)->base.code) == FUNCTION_DECL)
3636 fndecl = block;
3637 abstract_origin = NULL__null;
3638 }
3639 if (fndecl)
3640 {
3641 expanded_location s = expand_location (*locus);
3642 pp_character (context->printer, ',');
3643 pp_newline (context->printer);
3644 if (s.file != NULL__null)
3645 {
3646 if (context->show_column && s.column != 0)
3647 pp_printf (context->printer,
3648 _(" inlined from %qD at %r%s:%d:%d%R")gettext (" inlined from %qD at %r%s:%d:%d%R"),
3649 fndecl,
3650 "locus", s.file, s.line, s.column);
3651 else
3652 pp_printf (context->printer,
3653 _(" inlined from %qD at %r%s:%d%R")gettext (" inlined from %qD at %r%s:%d%R"),
3654 fndecl,
3655 "locus", s.file, s.line);
3656
3657 }
3658 else
3659 pp_printf (context->printer, _(" inlined from %qD")gettext (" inlined from %qD"),
3660 fndecl);
3661 }
3662 }
3663 pp_character (context->printer, ':');
3664 }
3665 pp_newline (context->printer);
3666
3667 diagnostic_set_last_function (context, diagnostic)(context)->x_data = (((diagnostic) && ((tree) (diagnostic
)->x_data)) ? ((tree) (diagnostic)->x_data) : current_function_decl
);
3668 pp_destroy_prefix (context->printer);
3669 context->printer->prefix = old_prefix;
3670 }
3671}
3672
3673/* Returns a description of FUNCTION using standard terminology. The
3674 result is a format string of the form "In CATEGORY %qD". */
3675
3676static const char *
3677function_category (tree fn)
3678{
3679 /* We can get called from the middle-end for diagnostics of function
3680 clones. Make sure we have language specific information before
3681 dereferencing it. */
3682 if (DECL_LANG_SPECIFIC (STRIP_TEMPLATE (fn))((contains_struct_check (((((enum tree_code) (fn)->base.code
) == TEMPLATE_DECL ? ((struct tree_template_decl *)(const_cast
<union tree_node *> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3682, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3682, __FUNCTION__))->decl_common.lang_specific)
3683 && DECL_FUNCTION_MEMBER_P (fn)((((enum tree_code) (((contains_struct_check ((fn), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3683, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
) || (__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (fn)->base.code) == TEMPLATE_DECL ? (
(struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3683, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3683, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (fn)->base.code) == FUNCTION_DECL || (((
enum tree_code) (fn)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3683, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fn),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3683, __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/error.cc"
, 3683, __FUNCTION__); &lt->u.fn; })->static_function
)))
3684 {
3685 if (DECL_STATIC_FUNCTION_P (fn)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (fn)->base.code) == TEMPLATE_DECL ? (
(struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3685, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3685, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (fn)->base.code) == FUNCTION_DECL || (((
enum tree_code) (fn)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3685, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fn),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3685, __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/error.cc"
, 3685, __FUNCTION__); &lt->u.fn; })->static_function
))
3686 return _("In static member function %qD")gettext ("In static member function %qD");
3687 else if (DECL_COPY_CONSTRUCTOR_P (fn)(((tree_check (((((enum tree_code) (fn)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3687, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3687, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
) && copy_fn_p (fn) > 0))
3688 return _("In copy constructor %qD")gettext ("In copy constructor %qD");
3689 else if (DECL_CONSTRUCTOR_P (fn)((tree_check (((((enum tree_code) (fn)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3689, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3689, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
))
3690 return _("In constructor %qD")gettext ("In constructor %qD");
3691 else if (DECL_DESTRUCTOR_P (fn)((tree_check (((((enum tree_code) (fn)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3691, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3691, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_destructor
))
3692 return _("In destructor %qD")gettext ("In destructor %qD");
3693 else if (LAMBDA_FUNCTION_P (fn)((((enum tree_code) (fn)->base.code) == FUNCTION_DECL || (
((enum tree_code) (fn)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fn),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) && (((tree_not_check2 (
((tree_check ((((contains_struct_check ((fn), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__, (IDENTIFIER_NODE)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) && ((__extension__ ({ struct lang_decl
*lt = ((contains_struct_check (((((enum tree_code) (fn)->
base.code) == TEMPLATE_DECL ? ((struct tree_template_decl *)(
const_cast<union tree_node *> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fn)
), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (fn)->base.code) == FUNCTION_DECL || (((
enum tree_code) (fn)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fn),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __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/error.cc"
, 3693, __FUNCTION__); &lt->u.fn; })->ovl_op_code) ==
OVL_OP_CALL_EXPR) && (((enum tree_code) ((!(! (((contains_struct_check
((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL]))->base.code) == RECORD_TYPE && ((((
tree_class_check ((((tree_class_check (((!(! (((contains_struct_check
((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __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 ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check (((!(! (((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check (((!(! (((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.name))) && ((tree_check
((((((tree_class_check ((((tree_class_check (((!(! (((contains_struct_check
((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __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 ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.name))->base.code))
] == tcc_declaration) ? ((contains_struct_check ((((tree_class_check
((((tree_class_check (((!(! (((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.name)), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.name) : ((tree_class_check
((((tree_class_check (((!(! (((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context)) || ((enum tree_code
) (((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context))->base.code
) == TRANSLATION_UNIT_DECL) ? ((contains_struct_check ((fn), (
TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->decl_minimal.context) : cp_global_trees
[CPTI_GLOBAL])), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__))->type_common.name)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3693, __FUNCTION__, (IDENTIFIER_NODE)))->base.protected_flag
))))
3694 return _("In lambda function")gettext ("In lambda function");
3695 else
3696 return _("In member function %qD")gettext ("In member function %qD");
3697 }
3698 else
3699 return _("In function %qD")gettext ("In function %qD");
3700}
3701
3702/* Disable warnings about missing quoting in GCC diagnostics for
3703 the pp_verbatim calls. Their format strings deliberately don't
3704 follow GCC diagnostic conventions. */
3705#if __GNUC__4 >= 10
3706#pragma GCC diagnostic push
3707#pragma GCC diagnostic ignored "-Wformat-diag"
3708#endif
3709
3710/* Report the full context of a current template instantiation,
3711 onto BUFFER. */
3712static void
3713print_instantiation_full_context (diagnostic_context *context)
3714{
3715 struct tinst_level *p = current_instantiation ();
3716 location_t location = input_location;
3717
3718 if (p)
3719 {
3720 pp_verbatim (context->printer,
3721 p->list_p ()
3722 ? _("%s: In substitution of %qS:\n")gettext ("%s: In substitution of %qS:\n")
3723 : _("%s: In instantiation of %q#D:\n")gettext ("%s: In instantiation of %q#D:\n"),
3724 LOCATION_FILE (location)((expand_location (location)).file),
3725 p->get_node ());
3726
3727 location = p->locus;
3728 p = p->next;
3729 }
3730
3731 print_instantiation_partial_context (context, p, location);
3732}
3733
3734/* Helper function of print_instantiation_partial_context() that
3735 prints a single line of instantiation context. */
3736
3737static void
3738print_instantiation_partial_context_line (diagnostic_context *context,
3739 struct tinst_level *t,
3740 location_t loc, bool recursive_p)
3741{
3742 if (loc == UNKNOWN_LOCATION((location_t) 0))
3743 return;
3744
3745 expanded_location xloc = expand_location (loc);
3746
3747 if (context->show_column)
3748 pp_verbatim (context->printer, _("%r%s:%d:%d:%R ")gettext ("%r%s:%d:%d:%R "),
3749 "locus", xloc.file, xloc.line, xloc.column);
3750 else
3751 pp_verbatim (context->printer, _("%r%s:%d:%R ")gettext ("%r%s:%d:%R "),
3752 "locus", xloc.file, xloc.line);
3753
3754 if (t != NULL__null)
3755 {
3756 if (t->list_p ())
3757 pp_verbatim (context->printer,
3758 recursive_p
3759 ? _("recursively required by substitution of %qS\n")gettext ("recursively required by substitution of %qS\n")
3760 : _("required by substitution of %qS\n")gettext ("required by substitution of %qS\n"),
3761 t->get_node ());
3762 else
3763 pp_verbatim (context->printer,
3764 recursive_p
3765 ? _("recursively required from %q#D\n")gettext ("recursively required from %q#D\n")
3766 : _("required from %q#D\n")gettext ("required from %q#D\n"),
3767 t->get_node ());
3768 }
3769 else
3770 {
3771 pp_verbatim (context->printer,
3772 recursive_p
3773 ? _("recursively required from here\n")gettext ("recursively required from here\n")
3774 : _("required from here\n")gettext ("required from here\n"));
3775 }
3776}
3777
3778/* Same as print_instantiation_full_context but less verbose. */
3779
3780static void
3781print_instantiation_partial_context (diagnostic_context *context,
3782 struct tinst_level *t0, location_t loc)
3783{
3784 struct tinst_level *t;
3785 int n_total = 0;
3786 int n;
3787 location_t prev_loc = loc;
3788
3789 for (t = t0; t != NULL__null; t = t->next)
3790 if (prev_loc != t->locus)
3791 {
3792 prev_loc = t->locus;
3793 n_total++;
3794 }
3795
3796 t = t0;
3797
3798 if (template_backtrace_limitglobal_options.x_template_backtrace_limit
3799 && n_total > template_backtrace_limitglobal_options.x_template_backtrace_limit)
3800 {
3801 int skip = n_total - template_backtrace_limitglobal_options.x_template_backtrace_limit;
3802 int head = template_backtrace_limitglobal_options.x_template_backtrace_limit / 2;
3803
3804 /* Avoid skipping just 1. If so, skip 2. */
3805 if (skip == 1)
3806 {
3807 skip = 2;
3808 head = (template_backtrace_limitglobal_options.x_template_backtrace_limit - 1) / 2;
3809 }
3810
3811 for (n = 0; n < head; n++)
3812 {
3813 gcc_assert (t != NULL)((void)(!(t != __null) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3813, __FUNCTION__), 0 : 0));
3814 if (loc != t->locus)
3815 print_instantiation_partial_context_line (context, t, loc,
3816 /*recursive_p=*/false);
3817 loc = t->locus;
3818 t = t->next;
3819 }
3820 if (t != NULL__null && skip > 0)
3821 {
3822 expanded_location xloc;
3823 xloc = expand_location (loc);
3824 if (context->show_column)
3825 pp_verbatim (context->printer,
3826 _("%r%s:%d:%d:%R [ skipping %d instantiation "gettext ("%r%s:%d:%d:%R [ skipping %d instantiation " "contexts, use -ftemplate-backtrace-limit=0 to "
"disable ]\n")
3827 "contexts, use -ftemplate-backtrace-limit=0 to "gettext ("%r%s:%d:%d:%R [ skipping %d instantiation " "contexts, use -ftemplate-backtrace-limit=0 to "
"disable ]\n")
3828 "disable ]\n")gettext ("%r%s:%d:%d:%R [ skipping %d instantiation " "contexts, use -ftemplate-backtrace-limit=0 to "
"disable ]\n"),
3829 "locus", xloc.file, xloc.line, xloc.column, skip);
3830 else
3831 pp_verbatim (context->printer,
3832 _("%r%s:%d:%R [ skipping %d instantiation "gettext ("%r%s:%d:%R [ skipping %d instantiation " "contexts, use -ftemplate-backtrace-limit=0 to "
"disable ]\n")
3833 "contexts, use -ftemplate-backtrace-limit=0 to "gettext ("%r%s:%d:%R [ skipping %d instantiation " "contexts, use -ftemplate-backtrace-limit=0 to "
"disable ]\n")
3834 "disable ]\n")gettext ("%r%s:%d:%R [ skipping %d instantiation " "contexts, use -ftemplate-backtrace-limit=0 to "
"disable ]\n"),
3835 "locus", xloc.file, xloc.line, skip);
3836
3837 do {
3838 loc = t->locus;
3839 t = t->next;
3840 } while (t != NULL__null && --skip > 0);
3841 }
3842 }
3843
3844 while (t != NULL__null)
3845 {
3846 while (t->next != NULL__null && t->locus == t->next->locus)
3847 {
3848 loc = t->locus;
3849 t = t->next;
3850 }
3851 print_instantiation_partial_context_line (context, t, loc,
3852 t->locus == loc);
3853 loc = t->locus;
3854 t = t->next;
3855 }
3856 print_instantiation_partial_context_line (context, NULL__null, loc,
3857 /*recursive_p=*/false);
3858}
3859
3860/* Called from cp_thing to print the template context for an error. */
3861static void
3862maybe_print_instantiation_context (diagnostic_context *context)
3863{
3864 if (!problematic_instantiation_changed () || current_instantiation () == 0)
3865 return;
3866
3867 record_last_problematic_instantiation ();
3868 print_instantiation_full_context (context);
3869}
3870
3871/* Report what constexpr call(s) we're trying to expand, if any. */
3872
3873void
3874maybe_print_constexpr_context (diagnostic_context *context)
3875{
3876 vec<tree> call_stack = cx_error_context ();
3877 unsigned ix;
3878 tree t;
3879
3880 FOR_EACH_VEC_ELT (call_stack, ix, t)for (ix = 0; (call_stack).iterate ((ix), &(t)); ++(ix))
3881 {
3882 expanded_location xloc = expand_location (EXPR_LOCATION (t)((((t)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((t))->base.code))]) >= tcc_reference
&& (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((t))->base.code))]) <= tcc_expression
)) ? (t)->exp.locus : ((location_t) 0)));
3883 const char *s = expr_as_string (t, 0);
3884 if (context->show_column)
3885 pp_verbatim (context->printer,
3886 _("%r%s:%d:%d:%R in %<constexpr%> expansion of %qs")gettext ("%r%s:%d:%d:%R in %<constexpr%> expansion of %qs"
),
3887 "locus", xloc.file, xloc.line, xloc.column, s);
3888 else
3889 pp_verbatim (context->printer,
3890 _("%r%s:%d:%R in %<constexpr%> expansion of %qs")gettext ("%r%s:%d:%R in %<constexpr%> expansion of %qs"
),
3891 "locus", xloc.file, xloc.line, s);
3892 pp_newline (context->printer);
3893 }
3894}
3895
3896
3897static void
3898print_location (diagnostic_context *context, location_t loc)
3899{
3900 expanded_location xloc = expand_location (loc);
3901 if (context->show_column)
3902 pp_verbatim (context->printer, _("%r%s:%d:%d:%R ")gettext ("%r%s:%d:%d:%R "),
3903 "locus", xloc.file, xloc.line, xloc.column);
3904 else
3905 pp_verbatim (context->printer, _("%r%s:%d:%R ")gettext ("%r%s:%d:%R "),
3906 "locus", xloc.file, xloc.line);
3907}
3908
3909static void
3910print_constrained_decl_info (diagnostic_context *context, tree decl)
3911{
3912 print_location (context, DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3912, __FUNCTION__))->decl_minimal.locus));
3913 pp_verbatim (context->printer, "required by the constraints of %q#D\n", decl);
3914}
3915
3916static void
3917print_concept_check_info (diagnostic_context *context, tree expr, tree map, tree args)
3918{
3919 gcc_assert (concept_check_p (expr))((void)(!(concept_check_p (expr)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3919, __FUNCTION__), 0 : 0));
3920
3921 tree id = unpack_concept_check (expr);
3922 tree tmpl = TREE_OPERAND (id, 0)(*((const_cast<tree*> (tree_operand_check ((id), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3922, __FUNCTION__)))));
3923 if (OVL_P (tmpl)(((enum tree_code) (tmpl)->base.code) == FUNCTION_DECL || (
(enum tree_code) (tmpl)->base.code) == OVERLOAD))
3924 tmpl = OVL_FIRST (tmpl)ovl_first (tmpl);
3925
3926 print_location (context, DECL_SOURCE_LOCATION (tmpl)((contains_struct_check ((tmpl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3926, __FUNCTION__))->decl_minimal.locus));
3927
3928 cxx_pretty_printer *pp = (cxx_pretty_printer *)context->printer;
3929 pp_verbatim (pp, "required for the satisfaction of %qE", expr);
3930 if (map && map != error_mark_nodeglobal_trees[TI_ERROR_MARK])
3931 {
3932 tree subst_map = tsubst_parameter_mapping (map, args, tf_none, NULL_TREE(tree) __null);
3933 pp_cxx_parameter_mapping (pp, (subst_map != error_mark_nodeglobal_trees[TI_ERROR_MARK]
3934 ? subst_map : map));
3935 }
3936 pp_newline (pp);
3937}
3938
3939/* Diagnose the entry point into the satisfaction error. Returns the next
3940 context, if any. */
3941
3942static tree
3943print_constraint_context_head (diagnostic_context *context, tree cxt, tree args)
3944{
3945 tree src = TREE_VALUE (cxt)((tree_check ((cxt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3945, __FUNCTION__, (TREE_LIST)))->list.value);
3946 if (!src)
3947 {
3948 print_location (context, input_location);
3949 pp_verbatim (context->printer, "required for constraint satisfaction\n");
3950 return NULL_TREE(tree) __null;
3951 }
3952 if (DECL_P (src)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (src)->base.code))] == tcc_declaration))
3953 {
3954 print_constrained_decl_info (context, src);
3955 return NULL_TREE(tree) __null;
3956 }
3957 else
3958 {
3959 print_concept_check_info (context, src, TREE_PURPOSE (cxt)((tree_check ((cxt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3959, __FUNCTION__, (TREE_LIST)))->list.purpose), args);
3960 return TREE_CHAIN (cxt)((contains_struct_check ((cxt), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3960, __FUNCTION__))->common.chain);
3961 }
3962}
3963
3964static void
3965print_requires_expression_info (diagnostic_context *context, tree constr, tree args)
3966{
3967
3968 tree expr = ATOMIC_CONSTR_EXPR (constr)((tree_check ((((contains_struct_check (((tree_check3 (((tree_check
((constr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3968, __FUNCTION__, (ATOMIC_CONSTR)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3968, __FUNCTION__, (ATOMIC_CONSTR), (CONJ_CONSTR), (DISJ_CONSTR
)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3968, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3968, __FUNCTION__, (TREE_LIST)))->list.purpose);
3969 tree map = ATOMIC_CONSTR_MAP (constr)(*((const_cast<tree*> (tree_operand_check (((tree_check
((constr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3969, __FUNCTION__, (ATOMIC_CONSTR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3969, __FUNCTION__)))));
3970 map = tsubst_parameter_mapping (map, args, tf_none, NULL_TREE(tree) __null);
3971 if (map == error_mark_nodeglobal_trees[TI_ERROR_MARK])
3972 return;
3973
3974 print_location (context, cp_expr_loc_or_input_loc (expr));
3975 pp_verbatim (context->printer, "in requirements ");
3976
3977 tree parms = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3977, __FUNCTION__)))));
3978 if (parms)
3979 pp_verbatim (context->printer, "with ");
3980 while (parms)
3981 {
3982 pp_verbatim (context->printer, "%q#D", parms);
3983 if (TREE_CHAIN (parms)((contains_struct_check ((parms), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3983, __FUNCTION__))->common.chain))
3984 pp_separate_with_comma ((cxx_pretty_printer *)context->printer)pp_cxx_separate_with ((cxx_pretty_printer *)context->printer
, ',');
3985 parms = TREE_CHAIN (parms)((contains_struct_check ((parms), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3985, __FUNCTION__))->common.chain);
3986 }
3987 pp_cxx_parameter_mapping ((cxx_pretty_printer *)context->printer, map);
3988
3989 pp_verbatim (context->printer, "\n");
3990}
3991
3992void
3993maybe_print_single_constraint_context (diagnostic_context *context, tree failed)
3994{
3995 if (!failed)
3996 return;
3997
3998 tree constr = TREE_VALUE (failed)((tree_check ((failed), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 3998, __FUNCTION__, (TREE_LIST)))->list.value);
3999 if (!constr || constr == error_mark_nodeglobal_trees[TI_ERROR_MARK])
4000 return;
4001 tree cxt = CONSTR_CONTEXT (constr)((tree_check ((((contains_struct_check (((tree_check3 ((constr
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4001, __FUNCTION__, (ATOMIC_CONSTR), (CONJ_CONSTR), (DISJ_CONSTR
)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4001, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4001, __FUNCTION__, (TREE_LIST)))->list.value);
4002 if (!cxt)
4003 return;
4004 tree args = TREE_PURPOSE (failed)((tree_check ((failed), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4004, __FUNCTION__, (TREE_LIST)))->list.purpose);
4005
4006 /* Print the stack of requirements. */
4007 cxt = print_constraint_context_head (context, cxt, args);
4008 while (cxt && !DECL_P (TREE_VALUE (cxt))(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (((tree_check ((cxt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4008, __FUNCTION__, (TREE_LIST)))->list.value))->base
.code))] == tcc_declaration))
4009 {
4010 tree expr = TREE_VALUE (cxt)((tree_check ((cxt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4010, __FUNCTION__, (TREE_LIST)))->list.value);
4011 tree map = TREE_PURPOSE (cxt)((tree_check ((cxt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4011, __FUNCTION__, (TREE_LIST)))->list.purpose);
4012 print_concept_check_info (context, expr, map, args);
4013 cxt = TREE_CHAIN (cxt)((contains_struct_check ((cxt), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4013, __FUNCTION__))->common.chain);
4014 }
4015
4016 /* For certain constraints, we can provide additional context. */
4017 if (TREE_CODE (constr)((enum tree_code) (constr)->base.code) == ATOMIC_CONSTR
4018 && TREE_CODE (ATOMIC_CONSTR_EXPR (constr))((enum tree_code) (((tree_check ((((contains_struct_check (((
tree_check3 (((tree_check ((constr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4018, __FUNCTION__, (ATOMIC_CONSTR)))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4018, __FUNCTION__, (ATOMIC_CONSTR), (CONJ_CONSTR), (DISJ_CONSTR
)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4018, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4018, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code) == REQUIRES_EXPR)
4019 print_requires_expression_info (context, constr, args);
4020}
4021
4022void
4023maybe_print_constraint_context (diagnostic_context *context)
4024{
4025 if (!current_failed_constraint)
4026 return;
4027
4028 tree cur = current_failed_constraint;
4029
4030 /* Recursively print nested contexts. */
4031 current_failed_constraint = TREE_CHAIN (current_failed_constraint)((contains_struct_check ((current_failed_constraint), (TS_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4031, __FUNCTION__))->common.chain);
4032 if (current_failed_constraint)
4033 maybe_print_constraint_context (context);
4034
4035 /* Print this context. */
4036 maybe_print_single_constraint_context (context, cur);
4037}
4038
4039/* Return true iff TYPE_A and TYPE_B are template types that are
4040 meaningful to compare. */
4041
4042static bool
4043comparable_template_types_p (tree type_a, tree type_b)
4044{
4045 if (!CLASS_TYPE_P (type_a)(((((enum tree_code) (type_a)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type_a)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type_a), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4045, __FUNCTION__))->type_common.lang_flag_5)))
4046 return false;
4047 if (!CLASS_TYPE_P (type_b)(((((enum tree_code) (type_b)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type_b)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type_b), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4047, __FUNCTION__))->type_common.lang_flag_5)))
4048 return false;
4049
4050 tree tinfo_a = TYPE_TEMPLATE_INFO (type_a)(((enum tree_code) (type_a)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type_a)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| (((enum tree_code) (type_a)->base.code) == RECORD_TYPE
|| ((enum tree_code) (type_a)->base.code) == UNION_TYPE ||
((enum tree_code) (type_a)->base.code) == QUAL_UNION_TYPE
) ? ((tree_class_check ((type_a), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4050, __FUNCTION__))->type_non_common.lang_1) : (tree) __null
);
4051 tree tinfo_b = TYPE_TEMPLATE_INFO (type_b)(((enum tree_code) (type_b)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type_b)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| (((enum tree_code) (type_b)->base.code) == RECORD_TYPE
|| ((enum tree_code) (type_b)->base.code) == UNION_TYPE ||
((enum tree_code) (type_b)->base.code) == QUAL_UNION_TYPE
) ? ((tree_class_check ((type_b), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4051, __FUNCTION__))->type_non_common.lang_1) : (tree) __null
);
4052 if (!tinfo_a || !tinfo_b)
4053 return false;
4054
4055 return TI_TEMPLATE (tinfo_a)((struct tree_template_info*)(tree_check ((tinfo_a), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4055, __FUNCTION__, (TEMPLATE_INFO))))->tmpl == TI_TEMPLATE (tinfo_b)((struct tree_template_info*)(tree_check ((tinfo_b), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4055, __FUNCTION__, (TEMPLATE_INFO))))->tmpl;
4056}
4057
4058/* Start a new line indented by SPC spaces on PP. */
4059
4060static void
4061newline_and_indent (pretty_printer *pp, int spc)
4062{
4063 pp_newline (pp);
4064 for (int i = 0; i < spc; i++)
4065 pp_space (pp)pp_character (pp, ' ');
4066}
4067
4068/* Generate a GC-allocated string for ARG, an expression or type. */
4069
4070static const char *
4071arg_to_string (tree arg, bool verbose)
4072{
4073 if (TYPE_P (arg)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (arg)->base.code))] == tcc_type))
4074 return type_to_string (arg, verbose, true, NULL__null, false);
4075 else
4076 return expr_to_string (arg);
4077}
4078
4079/* Subroutine to type_to_string_with_compare and
4080 print_template_tree_comparison.
4081
4082 Print a representation of ARG (an expression or type) to PP,
4083 colorizing it as "type-diff" if PP->show_color. */
4084
4085static void
4086print_nonequal_arg (pretty_printer *pp, tree arg, bool verbose)
4087{
4088 pp_printf (pp, "%r%s%R",
4089 "type-diff",
4090 (arg
4091 ? arg_to_string (arg, verbose)
4092 : G_("(no argument)")"(no argument)"));
4093}
4094
4095/* Recursively print template TYPE_A to PP, as compared to template TYPE_B.
4096
4097 The types must satisfy comparable_template_types_p.
4098
4099 If INDENT is 0, then this is equivalent to type_to_string (TYPE_A), but
4100 potentially colorizing/eliding in comparison with TYPE_B.
4101
4102 For example given types:
4103 vector<map<int,double>>
4104 and
4105 vector<map<int,float>>
4106 then the result on PP would be:
4107 vector<map<[...],double>>
4108 with type elision, and:
4109 vector<map<int,double>>
4110 without type elision.
4111
4112 In both cases the parts of TYPE that differ from PEER will be colorized
4113 if pp_show_color (pp) is true. In the above example, this would be
4114 "double".
4115
4116 If INDENT is non-zero, then the types are printed in a tree-like form
4117 which shows both types. In the above example, the result on PP would be:
4118
4119 vector<
4120 map<
4121 [...],
4122 [double != float]>>
4123
4124 and without type-elision would be:
4125
4126 vector<
4127 map<
4128 int,
4129 [double != float]>>
4130
4131 As before, the differing parts of the types are colorized if
4132 pp_show_color (pp) is true ("double" and "float" in this example).
4133
4134 Template arguments in which both types are using the default arguments
4135 are not printed; if at least one of the two types is using a non-default
4136 argument, then that argument is printed (or both arguments for the
4137 tree-like print format). */
4138
4139static void
4140print_template_differences (pretty_printer *pp, tree type_a, tree type_b,
4141 bool verbose, int indent)
4142{
4143 if (indent)
4144 newline_and_indent (pp, indent);
4145
4146 tree tinfo_a = TYPE_TEMPLATE_INFO (type_a)(((enum tree_code) (type_a)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type_a)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| (((enum tree_code) (type_a)->base.code) == RECORD_TYPE
|| ((enum tree_code) (type_a)->base.code) == UNION_TYPE ||
((enum tree_code) (type_a)->base.code) == QUAL_UNION_TYPE
) ? ((tree_class_check ((type_a), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4146, __FUNCTION__))->type_non_common.lang_1) : (tree) __null
);
4147 tree tinfo_b = TYPE_TEMPLATE_INFO (type_b)(((enum tree_code) (type_b)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (type_b)->base.code) == BOUND_TEMPLATE_TEMPLATE_PARM
|| (((enum tree_code) (type_b)->base.code) == RECORD_TYPE
|| ((enum tree_code) (type_b)->base.code) == UNION_TYPE ||
((enum tree_code) (type_b)->base.code) == QUAL_UNION_TYPE
) ? ((tree_class_check ((type_b), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4147, __FUNCTION__))->type_non_common.lang_1) : (tree) __null
);
4148
4149 pp_printf (pp, "%s<",
4150 IDENTIFIER_POINTER (DECL_NAME (TI_TEMPLATE (tinfo_a)))((const char *) (tree_check ((((contains_struct_check ((((struct
tree_template_info*)(tree_check ((tinfo_a), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4150, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4150, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4150, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
4151
4152 tree args_a = TI_ARGS (tinfo_a)((struct tree_template_info*)(tree_check ((tinfo_a), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4152, __FUNCTION__, (TEMPLATE_INFO))))->args;
4153 tree args_b = TI_ARGS (tinfo_b)((struct tree_template_info*)(tree_check ((tinfo_b), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4153, __FUNCTION__, (TEMPLATE_INFO))))->args;
4154 gcc_assert (TREE_CODE (args_a) == TREE_VEC)((void)(!(((enum tree_code) (args_a)->base.code) == TREE_VEC
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4154, __FUNCTION__), 0 : 0));
4155 gcc_assert (TREE_CODE (args_b) == TREE_VEC)((void)(!(((enum tree_code) (args_b)->base.code) == TREE_VEC
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4155, __FUNCTION__), 0 : 0));
4156 int flags = 0;
4157 int len_a = get_non_default_template_args_count (args_a, flags);
4158 args_a = INNERMOST_TEMPLATE_ARGS (args_a)(get_innermost_template_args ((args_a), 1));
4159 int len_b = get_non_default_template_args_count (args_b, flags);
4160 args_b = INNERMOST_TEMPLATE_ARGS (args_b)(get_innermost_template_args ((args_b), 1));
4161 /* Determine the maximum range of args for which non-default template args
4162 were used; beyond this, only default args (if any) were used, and so
4163 they will be equal from this point onwards.
4164 One of the two peers might have used default arguments within this
4165 range, but the other will be using non-default arguments, and so
4166 it's more readable to print both within this range, to highlight
4167 the differences. */
4168 int len_max = MAX (len_a, len_b)((len_a) > (len_b) ? (len_a) : (len_b));
4169 gcc_assert (TREE_CODE (args_a) == TREE_VEC)((void)(!(((enum tree_code) (args_a)->base.code) == TREE_VEC
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4169, __FUNCTION__), 0 : 0));
4170 gcc_assert (TREE_CODE (args_b) == TREE_VEC)((void)(!(((enum tree_code) (args_b)->base.code) == TREE_VEC
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4170, __FUNCTION__), 0 : 0));
4171 for (int idx = 0; idx < len_max; idx++)
4172 {
4173 if (idx)
4174 pp_character (pp, ',');
4175
4176 tree arg_a = TREE_VEC_ELT (args_a, idx)(*((const_cast<tree *> (tree_vec_elt_check ((args_a), (
idx), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4176, __FUNCTION__)))));
4177 tree arg_b = TREE_VEC_ELT (args_b, idx)(*((const_cast<tree *> (tree_vec_elt_check ((args_b), (
idx), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4177, __FUNCTION__)))));
4178 if (arg_a == arg_b)
4179 {
4180 if (indent)
4181 newline_and_indent (pp, indent + 2);
4182 /* Can do elision here, printing "[...]". */
4183 if (flag_elide_typeglobal_options.x_flag_elide_type)
4184 pp_string (pp, G_("[...]")"[...]");
4185 else
4186 pp_string (pp, arg_to_string (arg_a, verbose));
4187 }
4188 else
4189 {
4190 int new_indent = indent ? indent + 2 : 0;
4191 if (comparable_template_types_p (arg_a, arg_b))
4192 print_template_differences (pp, arg_a, arg_b, verbose, new_indent);
4193 else
4194 if (indent)
4195 {
4196 newline_and_indent (pp, indent + 2);
4197 pp_character (pp, '[');
4198 print_nonequal_arg (pp, arg_a, verbose);
4199 pp_string (pp, " != ");
4200 print_nonequal_arg (pp, arg_b, verbose);
4201 pp_character (pp, ']');
4202 }
4203 else
4204 print_nonequal_arg (pp, arg_a, verbose);
4205 }
4206 }
4207 pp_printf (pp, ">");
4208}
4209
4210/* As type_to_string, but for a template, potentially colorizing/eliding
4211 in comparison with PEER.
4212 For example, if TYPE is map<int,double> and PEER is map<int,int>,
4213 then the resulting string would be:
4214 map<[...],double>
4215 with type elision, and:
4216 map<int,double>
4217 without type elision.
4218
4219 In both cases the parts of TYPE that differ from PEER will be colorized
4220 if SHOW_COLOR is true. In the above example, this would be "double".
4221
4222 Template arguments in which both types are using the default arguments
4223 are not printed; if at least one of the two types is using a non-default
4224 argument, then both arguments are printed.
4225
4226 The resulting string is in a GC-allocated buffer. */
4227
4228static const char *
4229type_to_string_with_compare (tree type, tree peer, bool verbose,
4230 bool show_color)
4231{
4232 pretty_printer inner_pp;
4233 pretty_printer *pp = &inner_pp;
4234 pp_show_color (pp)(pp)->show_color = show_color;
4235
4236 print_template_differences (pp, type, peer, verbose, 0);
4237 return pp_ggc_formatted_text (pp);
4238}
4239
4240/* Recursively print a tree-like comparison of TYPE_A and TYPE_B to PP,
4241 indented by INDENT spaces.
4242
4243 For example given types:
4244
4245 vector<map<int,double>>
4246
4247 and
4248
4249 vector<map<double,float>>
4250
4251 the output with type elision would be:
4252
4253 vector<
4254 map<
4255 [...],
4256 [double != float]>>
4257
4258 and without type-elision would be:
4259
4260 vector<
4261 map<
4262 int,
4263 [double != float]>>
4264
4265 TYPE_A and TYPE_B must both be comparable template types
4266 (as per comparable_template_types_p).
4267
4268 Template arguments in which both types are using the default arguments
4269 are not printed; if at least one of the two types is using a non-default
4270 argument, then both arguments are printed. */
4271
4272static void
4273print_template_tree_comparison (pretty_printer *pp, tree type_a, tree type_b,
4274 bool verbose, int indent)
4275{
4276 print_template_differences (pp, type_a, type_b, verbose, indent);
4277}
4278
4279/* Subroutine for use in a format_postprocessor::handle
4280 implementation. Adds a chunk to the end of
4281 formatted output, so that it will be printed
4282 by pp_output_formatted_text. */
4283
4284static void
4285append_formatted_chunk (pretty_printer *pp, const char *content)
4286{
4287 output_buffer *buffer = pp_buffer (pp)(pp)->buffer;
4288 struct chunk_info *chunk_array = buffer->cur_chunk_array;
4289 const char **args = chunk_array->args;
4290
4291 unsigned int chunk_idx;
4292 for (chunk_idx = 0; args[chunk_idx]; chunk_idx++)
4293 ;
4294 args[chunk_idx++] = content;
4295 args[chunk_idx] = NULL__null;
4296}
4297
4298/* Create a copy of CONTENT, with quotes added, and,
4299 potentially, with colorization.
4300 No escaped is performed on CONTENT.
4301 The result is in a GC-allocated buffer. */
4302
4303static const char *
4304add_quotes (const char *content, bool show_color)
4305{
4306 pretty_printer tmp_pp;
4307 pp_show_color (&tmp_pp)(&tmp_pp)->show_color = show_color;
4308
4309 /* We have to use "%<%s%>" rather than "%qs" here in order to avoid
4310 quoting colorization bytes within the results and using either
4311 pp_quote or pp_begin_quote doesn't work the same. */
4312 pp_printf (&tmp_pp, "%<%s%>", content);
4313
4314 return pp_ggc_formatted_text (&tmp_pp);
4315}
4316
4317#if __GNUC__4 >= 10
4318#pragma GCC diagnostic pop
4319#endif
4320
4321/* If we had %H and %I, and hence deferred printing them,
4322 print them now, storing the result into the chunk_info
4323 for pp_format. Quote them if 'q' was provided.
4324 Also print the difference in tree form, adding it as
4325 an additional chunk. */
4326
4327void
4328cxx_format_postprocessor::handle (pretty_printer *pp)
4329{
4330 /* If we have one of %H and %I, the other should have
4331 been present. */
4332 if (m_type_a.m_tree || m_type_b.m_tree)
4333 {
4334 /* Avoid reentrancy issues by working with a copy of
4335 m_type_a and m_type_b, resetting them now. */
4336 deferred_printed_type type_a = m_type_a;
4337 deferred_printed_type type_b = m_type_b;
4338 m_type_a = deferred_printed_type ();
4339 m_type_b = deferred_printed_type ();
4340
4341 gcc_assert (type_a.m_buffer_ptr)((void)(!(type_a.m_buffer_ptr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4341, __FUNCTION__), 0 : 0));
4342 gcc_assert (type_b.m_buffer_ptr)((void)(!(type_b.m_buffer_ptr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4342, __FUNCTION__), 0 : 0));
4343
4344 bool show_color = pp_show_color (pp)(pp)->show_color;
4345
4346 const char *type_a_text;
4347 const char *type_b_text;
4348
4349 if (comparable_template_types_p (type_a.m_tree, type_b.m_tree))
4350 {
4351 type_a_text
4352 = type_to_string_with_compare (type_a.m_tree, type_b.m_tree,
4353 type_a.m_verbose, show_color);
4354 type_b_text
4355 = type_to_string_with_compare (type_b.m_tree, type_a.m_tree,
4356 type_b.m_verbose, show_color);
4357
4358 if (flag_diagnostics_show_template_treeglobal_options.x_flag_diagnostics_show_template_tree)
4359 {
4360 pretty_printer inner_pp;
4361 pp_show_color (&inner_pp)(&inner_pp)->show_color = pp_show_color (pp)(pp)->show_color;
4362 print_template_tree_comparison
4363 (&inner_pp, type_a.m_tree, type_b.m_tree, type_a.m_verbose, 2);
4364 append_formatted_chunk (pp, pp_ggc_formatted_text (&inner_pp));
4365 }
4366 }
4367 else
4368 {
4369 /* If the types were not comparable (or if only one of %H/%I was
4370 provided), they are printed normally, and no difference tree
4371 is printed. */
4372 type_a_text = type_to_string (type_a.m_tree, type_a.m_verbose,
4373 true, &type_a.m_quote, show_color);
4374 type_b_text = type_to_string (type_b.m_tree, type_b.m_verbose,
4375 true, &type_b.m_quote, show_color);
4376 }
4377
4378 if (type_a.m_quote)
4379 type_a_text = add_quotes (type_a_text, show_color);
4380 *type_a.m_buffer_ptr = type_a_text;
4381
4382 if (type_b.m_quote)
4383 type_b_text = add_quotes (type_b_text, show_color);
4384 *type_b.m_buffer_ptr = type_b_text;
4385 }
4386}
4387
4388/* Subroutine for handling %H and %I, to support i18n of messages like:
4389
4390 error_at (loc, "could not convert %qE from %qH to %qI",
4391 expr, type_a, type_b);
4392
4393 so that we can print things like:
4394
4395 could not convert 'foo' from 'map<int,double>' to 'map<int,int>'
4396
4397 and, with type-elision:
4398
4399 could not convert 'foo' from 'map<[...],double>' to 'map<[...],int>'
4400
4401 (with color-coding of the differences between the types).
4402
4403 The %H and %I format codes are peers: both must be present,
4404 and they affect each other. Hence to handle them, we must
4405 delay printing until we have both, deferring the printing to
4406 pretty_printer's m_format_postprocessor hook.
4407
4408 This is called in phase 2 of pp_format, when it is accumulating
4409 a series of formatted chunks. We stash the location of the chunk
4410 we're meant to have written to, so that we can write to it in the
4411 m_format_postprocessor hook.
4412
4413 We also need to stash whether a 'q' prefix was provided (the QUOTE
4414 param) so that we can add the quotes when writing out the delayed
4415 chunk. */
4416
4417static void
4418defer_phase_2_of_type_diff (deferred_printed_type *deferred,
4419 tree type, const char **buffer_ptr,
4420 bool verbose, bool quote)
4421{
4422 gcc_assert (deferred->m_tree == NULL_TREE)((void)(!(deferred->m_tree == (tree) __null) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4422, __FUNCTION__), 0 : 0));
4423 gcc_assert (deferred->m_buffer_ptr == NULL)((void)(!(deferred->m_buffer_ptr == __null) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4423, __FUNCTION__), 0 : 0));
4424 *deferred = deferred_printed_type (type, buffer_ptr, verbose, quote);
4425}
4426
4427
4428/* Called from output_format -- during diagnostic message processing --
4429 to handle C++ specific format specifier with the following meanings:
4430 %A function argument-list.
4431 %C tree code.
4432 %D declaration.
4433 %E expression.
4434 %F function declaration.
4435 %H type difference (from).
4436 %I type difference (to).
4437 %L language as used in extern "lang".
4438 %O binary operator.
4439 %P function parameter whose position is indicated by an integer.
4440 %Q assignment operator.
4441 %S substitution (template + args)
4442 %T type.
4443 %V cv-qualifier.
4444 %X exception-specification. */
4445static bool
4446cp_printer (pretty_printer *pp, text_info *text, const char *spec,
4447 int precision, bool wide, bool set_locus, bool verbose,
4448 bool *quoted, const char **buffer_ptr)
4449{
4450 gcc_assert (pp->m_format_postprocessor)((void)(!(pp->m_format_postprocessor) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4450, __FUNCTION__), 0 : 0));
4451 cxx_format_postprocessor *postprocessor
4452 = static_cast <cxx_format_postprocessor *> (pp->m_format_postprocessor);
4453
4454 const char *result;
4455 tree t = NULL__null;
4456#define next_tree (t = va_arg (*text->args_ptr, tree)__builtin_va_arg(*text->args_ptr, tree))
4457#define next_tcode ((enum tree_code) va_arg (*text->args_ptr, int)__builtin_va_arg(*text->args_ptr, int))
4458#define next_lang ((enum languages) va_arg (*text->args_ptr, int)__builtin_va_arg(*text->args_ptr, int))
4459#define next_int va_arg (*text->args_ptr, int)__builtin_va_arg(*text->args_ptr, int)
4460
4461 if (precision != 0 || wide)
4462 return false;
4463
4464 switch (*spec)
4465 {
4466 case 'A': result = args_to_string (next_tree, verbose); break;
4467 case 'C': result = code_to_string (next_tcode); break;
4468 case 'D':
4469 {
4470 tree temp = next_tree;
4471 if (VAR_P (temp)(((enum tree_code) (temp)->base.code) == VAR_DECL)
4472 && DECL_HAS_DEBUG_EXPR_P (temp)((tree_check ((temp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4472, __FUNCTION__, (VAR_DECL)))->decl_common.debug_expr_is_from
))
4473 {
4474 temp = DECL_DEBUG_EXPR (temp)(decl_debug_expr_lookup ((tree_check ((temp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/error.cc"
, 4474, __FUNCTION__, (VAR_DECL)))));
4475 if (!DECL_P (temp)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (temp)->base.code))] == tcc_declaration))
4476 {
4477 result = expr_to_string (temp);
4478 break;
4479 }
4480 }
4481 result = decl_to_string (temp, verbose, pp_show_color (pp)(pp)->show_color);
4482 }
4483 break;
4484 case 'E': result = expr_to_string (next_tree); break;
4485 case 'F': result = fndecl_to_string (next_tree, verbose); break;
4486 case 'H':
4487 defer_phase_2_of_type_diff (&postprocessor->m_type_a, next_tree,
4488 buffer_ptr, verbose, *quoted);
4489 return true;
4490 case 'I':
4491 defer_phase_2_of_type_diff (&postprocessor->m_type_b, next_tree,
4492 buffer_ptr, verbose, *quoted);
4493 return true;
4494 case 'L': result = language_to_string (next_lang); break;
4495 case 'O': result = op_to_string (false, next_tcode); break;
4496 case 'P': result = parm_to_string (next_int); break;
4497 case 'Q': result = op_to_string (true, next_tcode); break;
4498 case 'S': result = subst_to_string (next_tree, pp_show_color (pp)(pp)->show_color); break;
4499 case 'T':
4500 {
4501 result = type_to_string (next_tree, verbose, false, quoted,
4502 pp_show_color (pp)(pp)->show_color);
4503 }
4504 break;
4505 case 'V': result = cv_to_string (next_tree, verbose); break;
4506 case 'X': result = eh_spec_to_string (next_tree, verbose); break;
4507
4508 default:
4509 return false;
4510 }
4511
4512 pp_string (pp, result);
4513 if (set_locus && t != NULL__null)
4514 text->set_location (0, location_of (t), SHOW_RANGE_WITH_CARET);
4515 return true;
4516#undef next_tree
4517#undef next_tcode
4518#undef next_lang
4519#undef next_int
4520}
4521
4522/* Warn about the use of C++0x features when appropriate. */
4523void
4524maybe_warn_cpp0x (cpp0x_warn_str str, location_t loc/*=input_location*/)
4525{
4526 if (cxx_dialect == cxx98)
4527 switch (str)
4528 {
4529 case CPP0X_INITIALIZER_LISTS:
4530 pedwarn (loc, OPT_Wc__11_extensions,
4531 "extended initializer lists "
4532 "only available with %<-std=c++11%> or %<-std=gnu++11%>");
4533 break;
4534 case CPP0X_EXPLICIT_CONVERSION:
4535 pedwarn (loc, OPT_Wc__11_extensions,
4536 "explicit conversion operators "
4537 "only available with %<-std=c++11%> or %<-std=gnu++11%>");
4538 break;
4539 case CPP0X_VARIADIC_TEMPLATES:
4540 pedwarn (loc, OPT_Wc__11_extensions,
4541 "variadic templates "
4542 "only available with %<-std=c++11%> or %<-std=gnu++11%>");
4543 break;
4544 case CPP0X_LAMBDA_EXPR:
4545 pedwarn (loc, OPT_Wc__11_extensions,
4546 "lambda expressions "
4547 "only available with %<-std=c++11%> or %<-std=gnu++11%>");
4548 break;
4549 case CPP0X_AUTO:
4550 pedwarn (loc, OPT_Wc__11_extensions,
4551