Bug Summary

File:build/gcc/vec.h
Warning:line 814, column 10
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name search.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/13.0.0 -D IN_GCC_FRONTEND -D IN_GCC -D HAVE_CONFIG_H -I . -I cp -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/backward -internal-isystem /usr/lib64/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/home/marxin/BIG/buildbot/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 /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-11-20-133755-20252-1/report-ocQFYX.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c

1/* Breadth-first and depth-first routines for
2 searching multiple-inheritance lattice for GNU C++.
3 Copyright (C) 1987-2021 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 3, or (at your option)
11any later version.
12
13GCC is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22/* High-level class interface. */
23
24#include "config.h"
25#include "system.h"
26#include "coretypes.h"
27#include "cp-tree.h"
28#include "intl.h"
29#include "toplev.h"
30#include "spellcheck-tree.h"
31#include "stringpool.h"
32#include "attribs.h"
33
34static int is_subobject_of_p (tree, tree);
35static tree dfs_lookup_base (tree, void *);
36static tree dfs_dcast_hint_pre (tree, void *);
37static tree dfs_dcast_hint_post (tree, void *);
38static tree dfs_debug_mark (tree, void *);
39static int check_hidden_convs (tree, int, int, tree, tree, tree);
40static tree split_conversions (tree, tree, tree, tree);
41static int lookup_conversions_r (tree, int, int, tree, tree, tree *);
42static int look_for_overrides_r (tree, tree);
43static tree lookup_field_r (tree, void *);
44static tree dfs_accessible_post (tree, void *);
45static tree dfs_walk_once_accessible (tree, bool,
46 tree (*pre_fn) (tree, void *),
47 tree (*post_fn) (tree, void *),
48 void *data);
49static tree dfs_access_in_type (tree, void *);
50static access_kind access_in_type (tree, tree);
51static tree dfs_get_pure_virtuals (tree, void *);
52
53
54/* Data for lookup_base and its workers. */
55
56struct lookup_base_data_s
57{
58 tree t; /* type being searched. */
59 tree base; /* The base type we're looking for. */
60 tree binfo; /* Found binfo. */
61 bool via_virtual; /* Found via a virtual path. */
62 bool ambiguous; /* Found multiply ambiguous */
63 bool repeated_base; /* Whether there are repeated bases in the
64 hierarchy. */
65 bool want_any; /* Whether we want any matching binfo. */
66};
67
68/* Worker function for lookup_base. See if we've found the desired
69 base and update DATA_ (a pointer to LOOKUP_BASE_DATA_S). */
70
71static tree
72dfs_lookup_base (tree binfo, void *data_)
73{
74 struct lookup_base_data_s *data = (struct lookup_base_data_s *) data_;
75
76 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->base)((((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 76, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 76, __FUNCTION__))->typed.type)) == (data->base))
)
77 {
78 if (!data->binfo)
79 {
80 data->binfo = binfo;
81 data->via_virtual
82 = binfo_via_virtual (data->binfo, data->t) != NULL_TREE(tree) __null;
83
84 if (!data->repeated_base)
85 /* If there are no repeated bases, we can stop now. */
86 return binfo;
87
88 if (data->want_any && !data->via_virtual)
89 /* If this is a non-virtual base, then we can't do
90 better. */
91 return binfo;
92
93 return dfs_skip_bases((tree)1);
94 }
95 else
96 {
97 gcc_assert (binfo != data->binfo)((void)(!(binfo != data->binfo) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 97, __FUNCTION__), 0 : 0))
;
98
99 /* We've found more than one matching binfo. */
100 if (!data->want_any)
101 {
102 /* This is immediately ambiguous. */
103 data->binfo = NULL_TREE(tree) __null;
104 data->ambiguous = true;
105 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
106 }
107
108 /* Prefer one via a non-virtual path. */
109 if (!binfo_via_virtual (binfo, data->t))
110 {
111 data->binfo = binfo;
112 data->via_virtual = false;
113 return binfo;
114 }
115
116 /* There must be repeated bases, otherwise we'd have stopped
117 on the first base we found. */
118 return dfs_skip_bases((tree)1);
119 }
120 }
121
122 return NULL_TREE(tree) __null;
123}
124
125/* This deals with bug PR17314.
126
127 DECL is a declaration and BINFO represents a class that has attempted (but
128 failed) to access DECL.
129
130 Examine the parent binfos of BINFO and determine whether any of them had
131 private access to DECL. If they did, return the parent binfo. This helps
132 in figuring out the correct error message to show (if the parents had
133 access, it's their fault for not giving sufficient access to BINFO).
134
135 If no parents had access, return NULL_TREE. */
136
137tree
138get_parent_with_private_access (tree decl, tree binfo)
139{
140 /* Only BINFOs should come through here. */
141 gcc_assert (TREE_CODE (binfo) == TREE_BINFO)((void)(!(((enum tree_code) (binfo)->base.code) == TREE_BINFO
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 141, __FUNCTION__), 0 : 0))
;
142
143 tree base_binfo = NULL_TREE(tree) __null;
144
145 /* Iterate through immediate parent classes. */
146 for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 146, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((i), &(base_binfo)))
; i++)
147 {
148 /* This parent had private access. Therefore that's why BINFO can't
149 access DECL. */
150 if (access_in_type (BINFO_TYPE (base_binfo)((contains_struct_check (((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 150, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 150, __FUNCTION__))->typed.type)
, decl) == ak_private)
151 return base_binfo;
152 }
153
154 /* None of the parents had access. Note: it's impossible for one of the
155 parents to have had public or protected access to DECL, since then
156 BINFO would have been able to access DECL too. */
157 return NULL_TREE(tree) __null;
158}
159
160/* Returns true if type BASE is accessible in T. (BASE is known to be
161 a (possibly non-proper) base class of T.) If CONSIDER_LOCAL_P is
162 true, consider any special access of the current scope, or access
163 bestowed by friendship. */
164
165bool
166accessible_base_p (tree t, tree base, bool consider_local_p)
167{
168 tree decl;
169
170 /* [class.access.base]
171
172 A base class is said to be accessible if an invented public
173 member of the base class is accessible.
174
175 If BASE is a non-proper base, this condition is trivially
176 true. */
177 if (same_type_p (t, base)comptypes ((t), (base), 0))
178 return true;
179 /* Rather than inventing a public member, we use the implicit
180 public typedef created in the scope of every class. */
181 decl = TYPE_FIELDS (base)((tree_check3 ((base), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 181, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
;
182 while (!DECL_SELF_REFERENCE_P (decl)(((enum tree_code) (decl)->base.code) == TYPE_DECL &&
((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 182, __FUNCTION__))->decl_common.lang_flag_4))
)
183 decl = DECL_CHAIN (decl)(((contains_struct_check (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 183, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 183, __FUNCTION__))->common.chain))
;
184 while (ANON_AGGR_TYPE_P (t)((((((enum tree_code) (t)->base.code)) == RECORD_TYPE || (
((enum tree_code) (t)->base.code)) == UNION_TYPE) &&
((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 184, __FUNCTION__))->type_common.lang_flag_5)) &&
(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 184, __FUNCTION__))->type_with_lang_specific.lang_specific
))->anon_aggr)
)
185 t = TYPE_CONTEXT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 185, __FUNCTION__))->type_common.context)
;
186 return accessible_p (t, decl, consider_local_p);
187}
188
189/* Lookup BASE in the hierarchy dominated by T. Do access checking as
190 ACCESS specifies. Return the binfo we discover. If KIND_PTR is
191 non-NULL, fill with information about what kind of base we
192 discovered.
193
194 If the base is inaccessible, or ambiguous, then error_mark_node is
195 returned. If the tf_error bit of COMPLAIN is not set, no error
196 is issued. */
197
198tree
199lookup_base (tree t, tree base, base_access access,
200 base_kind *kind_ptr, tsubst_flags_t complain)
201{
202 tree binfo;
203 tree t_binfo;
204 base_kind bk;
205
206 /* "Nothing" is definitely not derived from Base. */
207 if (t == NULL_TREE(tree) __null)
208 {
209 if (kind_ptr)
210 *kind_ptr = bk_not_base;
211 return NULL_TREE(tree) __null;
212 }
213
214 if (t == error_mark_nodeglobal_trees[TI_ERROR_MARK] || base == error_mark_nodeglobal_trees[TI_ERROR_MARK])
215 {
216 if (kind_ptr)
217 *kind_ptr = bk_not_base;
218 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
219 }
220 gcc_assert (TYPE_P (base))((void)(!((tree_code_type[(int) (((enum tree_code) (base)->
base.code))] == tcc_type)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 220, __FUNCTION__), 0 : 0))
;
221
222 if (!TYPE_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_type)
)
223 {
224 t_binfo = t;
225 t = BINFO_TYPE (t)((contains_struct_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 225, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 225, __FUNCTION__))->typed.type)
;
226 }
227 else
228 {
229 t = complete_type (TYPE_MAIN_VARIANT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 229, __FUNCTION__))->type_common.main_variant)
);
230 if (dependent_type_p (t))
231 if (tree open = currently_open_class (t))
232 t = open;
233 t_binfo = TYPE_BINFO (t)((tree_check3 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 233, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
234 }
235
236 base = TYPE_MAIN_VARIANT (base)((tree_class_check ((base), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 236, __FUNCTION__))->type_common.main_variant)
;
237
238 /* If BASE is incomplete, it can't be a base of T--and instantiating it
239 might cause an error. */
240 if (t_binfo && CLASS_TYPE_P (base)(((((enum tree_code) (base)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (base)->base.code)) == UNION_TYPE) &&
((tree_class_check ((base), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 240, __FUNCTION__))->type_common.lang_flag_5))
&& COMPLETE_OR_OPEN_TYPE_P (base)((((tree_class_check ((base), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 240, __FUNCTION__))->type_common.size) != (tree) __null)
|| ((((((enum tree_code) (base)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (base)->base.code)) == UNION_TYPE) &&
((tree_class_check ((base), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 240, __FUNCTION__))->type_common.lang_flag_5)) &&
((((tree_class_check ((base), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 240, __FUNCTION__))->type_with_lang_specific.lang_specific
))->being_defined)))
)
241 {
242 struct lookup_base_data_s data;
243
244 data.t = t;
245 data.base = base;
246 data.binfo = NULL_TREE(tree) __null;
247 data.ambiguous = data.via_virtual = false;
248 data.repeated_base = CLASSTYPE_REPEATED_BASE_P (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 248, __FUNCTION__))->type_with_lang_specific.lang_specific
))->repeated_base)
;
249 data.want_any = access == ba_any;
250
251 dfs_walk_once (t_binfo, dfs_lookup_base, NULL__null, &data);
252 binfo = data.binfo;
253
254 if (!binfo)
255 bk = data.ambiguous ? bk_ambig : bk_not_base;
256 else if (binfo == t_binfo)
257 bk = bk_same_type;
258 else if (data.via_virtual)
259 bk = bk_via_virtual;
260 else
261 bk = bk_proper_base;
262 }
263 else
264 {
265 binfo = NULL_TREE(tree) __null;
266 bk = bk_not_base;
267 }
268
269 /* Check that the base is unambiguous and accessible. */
270 if (access != ba_any)
271 switch (bk)
272 {
273 case bk_not_base:
274 break;
275
276 case bk_ambig:
277 if (complain & tf_error)
278 error ("%qT is an ambiguous base of %qT", base, t);
279 binfo = error_mark_nodeglobal_trees[TI_ERROR_MARK];
280 break;
281
282 default:
283 if ((access & ba_check_bit)
284 /* If BASE is incomplete, then BASE and TYPE are probably
285 the same, in which case BASE is accessible. If they
286 are not the same, then TYPE is invalid. In that case,
287 there's no need to issue another error here, and
288 there's no implicit typedef to use in the code that
289 follows, so we skip the check. */
290 && COMPLETE_TYPE_P (base)(((tree_class_check ((base), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 290, __FUNCTION__))->type_common.size) != (tree) __null)
291 && !accessible_base_p (t, base, !(access & ba_ignore_scope)))
292 {
293 if (complain & tf_error)
294 error ("%qT is an inaccessible base of %qT", base, t);
295 binfo = error_mark_nodeglobal_trees[TI_ERROR_MARK];
296 bk = bk_inaccessible;
297 }
298 break;
299 }
300
301 if (kind_ptr)
302 *kind_ptr = bk;
303
304 return binfo;
305}
306
307/* Data for dcast_base_hint walker. */
308
309struct dcast_data_s
310{
311 tree subtype; /* The base type we're looking for. */
312 int virt_depth; /* Number of virtual bases encountered from most
313 derived. */
314 tree offset; /* Best hint offset discovered so far. */
315 bool repeated_base; /* Whether there are repeated bases in the
316 hierarchy. */
317};
318
319/* Worker for dcast_base_hint. Search for the base type being cast
320 from. */
321
322static tree
323dfs_dcast_hint_pre (tree binfo, void *data_)
324{
325 struct dcast_data_s *data = (struct dcast_data_s *) data_;
326
327 if (BINFO_VIRTUAL_P (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 327, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
328 data->virt_depth++;
329
330 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->subtype)((((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 330, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 330, __FUNCTION__))->typed.type)) == (data->subtype))
)
331 {
332 if (data->virt_depth)
333 {
334 data->offset = ssize_int (-1)size_int_kind (-1, stk_ssizetype);
335 return data->offset;
336 }
337 if (data->offset)
338 data->offset = ssize_int (-3)size_int_kind (-3, stk_ssizetype);
339 else
340 data->offset = BINFO_OFFSET (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 340, __FUNCTION__, (TREE_BINFO)))->binfo.offset)
;
341
342 return data->repeated_base ? dfs_skip_bases((tree)1) : data->offset;
343 }
344
345 return NULL_TREE(tree) __null;
346}
347
348/* Worker for dcast_base_hint. Track the virtual depth. */
349
350static tree
351dfs_dcast_hint_post (tree binfo, void *data_)
352{
353 struct dcast_data_s *data = (struct dcast_data_s *) data_;
354
355 if (BINFO_VIRTUAL_P (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 355, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
356 data->virt_depth--;
357
358 return NULL_TREE(tree) __null;
359}
360
361/* The dynamic cast runtime needs a hint about how the static SUBTYPE type
362 started from is related to the required TARGET type, in order to optimize
363 the inheritance graph search. This information is independent of the
364 current context, and ignores private paths, hence get_base_distance is
365 inappropriate. Return a TREE specifying the base offset, BOFF.
366 BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset BOFF,
367 and there are no public virtual SUBTYPE bases.
368 BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
369 BOFF == -2, SUBTYPE is not a public base.
370 BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases. */
371
372tree
373dcast_base_hint (tree subtype, tree target)
374{
375 struct dcast_data_s data;
376
377 data.subtype = subtype;
378 data.virt_depth = 0;
379 data.offset = NULL_TREE(tree) __null;
380 data.repeated_base = CLASSTYPE_REPEATED_BASE_P (target)((((tree_class_check ((target), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 380, __FUNCTION__))->type_with_lang_specific.lang_specific
))->repeated_base)
;
381
382 dfs_walk_once_accessible (TYPE_BINFO (target)((tree_check3 ((target), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 382, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
, /*friends=*/false,
383 dfs_dcast_hint_pre, dfs_dcast_hint_post, &data);
384 return data.offset ? data.offset : ssize_int (-2)size_int_kind (-2, stk_ssizetype);
385}
386
387/* Search for a member with name NAME in a multiple inheritance
388 lattice specified by TYPE. If it does not exist, return NULL_TREE.
389 If the member is ambiguously referenced, return `error_mark_node'.
390 Otherwise, return a DECL with the indicated name. If WANT_TYPE is
391 true, type declarations are preferred. */
392
393/* Return the FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, or
394 NAMESPACE_DECL corresponding to the innermost non-block scope. */
395
396tree
397current_scope (void)
398{
399 /* There are a number of cases we need to be aware of here:
400 current_class_type current_function_decl
401 global NULL NULL
402 fn-local NULL SET
403 class-local SET NULL
404 class->fn SET SET
405 fn->class SET SET
406
407 Those last two make life interesting. If we're in a function which is
408 itself inside a class, we need decls to go into the fn's decls (our
409 second case below). But if we're in a class and the class itself is
410 inside a function, we need decls to go into the decls for the class. To
411 achieve this last goal, we must see if, when both current_class_ptr and
412 current_function_decl are set, the class was declared inside that
413 function. If so, we know to put the decls into the class's scope. */
414 if (current_function_decl && current_class_typescope_chain->class_type
415 && ((DECL_FUNCTION_MEMBER_P (current_function_decl)((((enum tree_code) (((contains_struct_check ((current_function_decl
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 415, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
) || (__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (current_function_decl)->base.code) ==
TEMPLATE_DECL ? ((struct tree_template_decl *)(const_cast<
union tree_node *> ((((tree_check ((current_function_decl)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 415, __FUNCTION__, (TEMPLATE_DECL))))))))->result : current_function_decl
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 415, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (current_function_decl)->base.code) == FUNCTION_DECL
|| (((enum tree_code) (current_function_decl)->base.code)
== TEMPLATE_DECL && ((struct tree_template_decl *)(const_cast
<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 415, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 415, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 415, __FUNCTION__); &lt->u.fn; })->static_function
))
416 && same_type_p (DECL_CONTEXT (current_function_decl),comptypes ((((contains_struct_check ((current_function_decl),
(TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 416, __FUNCTION__))->decl_minimal.context)), (scope_chain
->class_type), 0)
417 current_class_type)comptypes ((((contains_struct_check ((current_function_decl),
(TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 416, __FUNCTION__))->decl_minimal.context)), (scope_chain
->class_type), 0)
)
418 || (DECL_FRIEND_CONTEXT (current_function_decl)(((((enum tree_code) (current_function_decl)->base.code) ==
FUNCTION_DECL || (((enum tree_code) (current_function_decl)->
base.code) == TEMPLATE_DECL && ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) && !((contains_struct_check
((current_function_decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__))->decl_common.virtual_flag) &&
!((tree_check (((((enum tree_code) (current_function_decl)->
base.code) == TEMPLATE_DECL ? ((struct tree_template_decl *)(
const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__, (TEMPLATE_DECL))))))))->result : current_function_decl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)) ? __extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (current_function_decl)->base.code) ==
TEMPLATE_DECL ? ((struct tree_template_decl *)(const_cast<
union tree_node *> ((((tree_check ((current_function_decl)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__, (TEMPLATE_DECL))))))))->result : current_function_decl
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (current_function_decl)->base.code) == FUNCTION_DECL
|| (((enum tree_code) (current_function_decl)->base.code)
== TEMPLATE_DECL && ((struct tree_template_decl *)(const_cast
<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 418, __FUNCTION__); &lt->u.fn; })->context : (tree
) __null)
419 && same_type_p (DECL_FRIEND_CONTEXT (current_function_decl),comptypes (((((((enum tree_code) (current_function_decl)->
base.code) == FUNCTION_DECL || (((enum tree_code) (current_function_decl
)->base.code) == TEMPLATE_DECL && ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) && !((contains_struct_check
((current_function_decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__))->decl_common.virtual_flag) &&
!((tree_check (((((enum tree_code) (current_function_decl)->
base.code) == TEMPLATE_DECL ? ((struct tree_template_decl *)(
const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result : current_function_decl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)) ? __extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (current_function_decl)->base.code) ==
TEMPLATE_DECL ? ((struct tree_template_decl *)(const_cast<
union tree_node *> ((((tree_check ((current_function_decl)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result : current_function_decl
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (current_function_decl)->base.code) == FUNCTION_DECL
|| (((enum tree_code) (current_function_decl)->base.code)
== TEMPLATE_DECL && ((struct tree_template_decl *)(const_cast
<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__); &lt->u.fn; })->context : (tree
) __null)), (scope_chain->class_type), 0)
420 current_class_type)comptypes (((((((enum tree_code) (current_function_decl)->
base.code) == FUNCTION_DECL || (((enum tree_code) (current_function_decl
)->base.code) == TEMPLATE_DECL && ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) && !((contains_struct_check
((current_function_decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__))->decl_common.virtual_flag) &&
!((tree_check (((((enum tree_code) (current_function_decl)->
base.code) == TEMPLATE_DECL ? ((struct tree_template_decl *)(
const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result : current_function_decl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)) ? __extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (current_function_decl)->base.code) ==
TEMPLATE_DECL ? ((struct tree_template_decl *)(const_cast<
union tree_node *> ((((tree_check ((current_function_decl)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result : current_function_decl
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (current_function_decl)->base.code) == FUNCTION_DECL
|| (((enum tree_code) (current_function_decl)->base.code)
== TEMPLATE_DECL && ((struct tree_template_decl *)(const_cast
<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 419, __FUNCTION__); &lt->u.fn; })->context : (tree
) __null)), (scope_chain->class_type), 0)
)))
421 return current_function_decl;
422
423 if (current_class_typescope_chain->class_type)
424 return current_class_typescope_chain->class_type;
425
426 if (current_function_decl)
427 return current_function_decl;
428
429 return current_namespacescope_chain->old_namespace;
430}
431
432/* Returns nonzero if we are currently in a function scope. Note
433 that this function returns zero if we are within a local class, but
434 not within a member function body of the local class. */
435
436int
437at_function_scope_p (void)
438{
439 tree cs = current_scope ();
440 /* Also check cfun to make sure that we're really compiling
441 this function (as opposed to having set current_function_decl
442 for access checking or some such). */
443 return (cs && TREE_CODE (cs)((enum tree_code) (cs)->base.code) == FUNCTION_DECL
444 && cfun(cfun + 0) && cfun(cfun + 0)->decl == current_function_decl);
445}
446
447/* Returns true if the innermost active scope is a class scope. */
448
449bool
450at_class_scope_p (void)
451{
452 tree cs = current_scope ();
453 return cs && TYPE_P (cs)(tree_code_type[(int) (((enum tree_code) (cs)->base.code))
] == tcc_type)
;
454}
455
456/* Returns true if the innermost active scope is a namespace scope. */
457
458bool
459at_namespace_scope_p (void)
460{
461 tree cs = current_scope ();
462 return cs && TREE_CODE (cs)((enum tree_code) (cs)->base.code) == NAMESPACE_DECL;
463}
464
465/* Return the scope of DECL, as appropriate when doing name-lookup. */
466
467tree
468context_for_name_lookup (tree decl)
469{
470 /* [class.union]
471
472 For the purposes of name lookup, after the anonymous union
473 definition, the members of the anonymous union are considered to
474 have been defined in the scope in which the anonymous union is
475 declared. */
476 tree context = DECL_CONTEXT (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 476, __FUNCTION__))->decl_minimal.context)
;
477
478 while (context && TYPE_P (context)(tree_code_type[(int) (((enum tree_code) (context)->base.code
))] == tcc_type)
479 && (ANON_AGGR_TYPE_P (context)((((((enum tree_code) (context)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (context)->base.code)) == UNION_TYPE
) && ((tree_class_check ((context), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 479, __FUNCTION__))->type_common.lang_flag_5)) &&
(((tree_class_check ((context), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 479, __FUNCTION__))->type_with_lang_specific.lang_specific
))->anon_aggr)
|| UNSCOPED_ENUM_P (context)(((enum tree_code) (context)->base.code) == ENUMERAL_TYPE &&
!((tree_check ((context), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 479, __FUNCTION__, (ENUMERAL_TYPE)))->base.static_flag))
))
480 context = TYPE_CONTEXT (context)((tree_class_check ((context), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 480, __FUNCTION__))->type_common.context)
;
481 if (!context)
482 context = global_namespacecp_global_trees[CPTI_GLOBAL];
483
484 return context;
485}
486
487/* Returns true iff DECL is declared in TYPE. */
488
489static bool
490member_declared_in_type (tree decl, tree type)
491{
492 /* A normal declaration obviously counts. */
493 if (context_for_name_lookup (decl) == type)
494 return true;
495 /* So does a using or access declaration. */
496 if (DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 496, __FUNCTION__))->decl_common.lang_specific)
&& !DECL_DISCRIMINATOR_P (decl)(((((enum tree_code) (decl)->base.code) == VAR_DECL &&
((decl)->base.static_flag)) || (((enum tree_code) (decl)->
base.code) == TYPE_DECL && ((contains_struct_check ((
decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 496, __FUNCTION__))->decl_common.lang_flag_2))) &&
(((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 496, __FUNCTION__))->decl_minimal.context) && ((
enum tree_code) (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 496, __FUNCTION__))->decl_minimal.context))->base.code
) == FUNCTION_DECL))
497 && purpose_member (type, DECL_ACCESS (decl)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 497, __FUNCTION__))->decl_common.lang_specific); if (!((
((enum tree_code) (decl)->base.code) == VAR_DECL || ((enum
tree_code) (decl)->base.code) == FUNCTION_DECL) || ((enum
tree_code) (decl)->base.code) == FIELD_DECL || ((enum tree_code
) (decl)->base.code) == CONST_DECL || ((enum tree_code) (decl
)->base.code) == TYPE_DECL || ((enum tree_code) (decl)->
base.code) == TEMPLATE_DECL || ((enum tree_code) (decl)->base
.code) == USING_DECL || ((enum tree_code) (decl)->base.code
) == CONCEPT_DECL)) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 497, __FUNCTION__); &lt->u.min; })->access)
))
498 return true;
499 return false;
500}
501
502/* The accessibility routines use BINFO_ACCESS for scratch space
503 during the computation of the accessibility of some declaration. */
504
505/* Avoid walking up past a declaration of the member. */
506
507static tree
508dfs_access_in_type_pre (tree binfo, void *data)
509{
510 tree decl = (tree) data;
511 tree type = BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 511, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 511, __FUNCTION__))->typed.type)
;
512 if (member_declared_in_type (decl, type))
513 return dfs_skip_bases((tree)1);
514 return NULL_TREE(tree) __null;
515}
516
517#define BINFO_ACCESS(NODE)((access_kind) ((((NODE)->base.public_flag) << 1) | (
(NODE)->base.private_flag)))
\
518 ((access_kind) ((TREE_PUBLIC (NODE)((NODE)->base.public_flag) << 1) | TREE_PRIVATE (NODE)((NODE)->base.private_flag)))
519
520/* Set the access associated with NODE to ACCESS. */
521
522#define SET_BINFO_ACCESS(NODE, ACCESS)((((NODE)->base.public_flag) = ((ACCESS) & 2) != 0), (
((NODE)->base.private_flag) = ((ACCESS) & 1) != 0))
\
523 ((TREE_PUBLIC (NODE)((NODE)->base.public_flag) = ((ACCESS) & 2) != 0), \
524 (TREE_PRIVATE (NODE)((NODE)->base.private_flag) = ((ACCESS) & 1) != 0))
525
526/* Called from access_in_type via dfs_walk. Calculate the access to
527 DATA (which is really a DECL) in BINFO. */
528
529static tree
530dfs_access_in_type (tree binfo, void *data)
531{
532 tree decl = (tree) data;
533 tree type = BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 533, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 533, __FUNCTION__))->typed.type)
;
534 access_kind access = ak_none;
535
536 if (context_for_name_lookup (decl) == type)
537 {
538 /* If we have descended to the scope of DECL, just note the
539 appropriate access. */
540 if (TREE_PRIVATE (decl)((decl)->base.private_flag))
541 access = ak_private;
542 else if (TREE_PROTECTED (decl)((decl)->base.protected_flag))
543 access = ak_protected;
544 else
545 access = ak_public;
546 }
547 else
548 {
549 /* First, check for an access-declaration that gives us more
550 access to the DECL. */
551 if (DECL_LANG_SPECIFIC (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 551, __FUNCTION__))->decl_common.lang_specific)
&& !DECL_DISCRIMINATOR_P (decl)(((((enum tree_code) (decl)->base.code) == VAR_DECL &&
((decl)->base.static_flag)) || (((enum tree_code) (decl)->
base.code) == TYPE_DECL && ((contains_struct_check ((
decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 551, __FUNCTION__))->decl_common.lang_flag_2))) &&
(((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 551, __FUNCTION__))->decl_minimal.context) && ((
enum tree_code) (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 551, __FUNCTION__))->decl_minimal.context))->base.code
) == FUNCTION_DECL))
)
552 {
553 tree decl_access = purpose_member (type, DECL_ACCESS (decl)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 553, __FUNCTION__))->decl_common.lang_specific); if (!((
((enum tree_code) (decl)->base.code) == VAR_DECL || ((enum
tree_code) (decl)->base.code) == FUNCTION_DECL) || ((enum
tree_code) (decl)->base.code) == FIELD_DECL || ((enum tree_code
) (decl)->base.code) == CONST_DECL || ((enum tree_code) (decl
)->base.code) == TYPE_DECL || ((enum tree_code) (decl)->
base.code) == TEMPLATE_DECL || ((enum tree_code) (decl)->base
.code) == USING_DECL || ((enum tree_code) (decl)->base.code
) == CONCEPT_DECL)) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 553, __FUNCTION__); &lt->u.min; })->access)
);
554
555 if (decl_access)
556 {
557 decl_access = TREE_VALUE (decl_access)((tree_check ((decl_access), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 557, __FUNCTION__, (TREE_LIST)))->list.value)
;
558
559 if (decl_access == access_public_nodeglobal_trees[TI_PUBLIC])
560 access = ak_public;
561 else if (decl_access == access_protected_nodeglobal_trees[TI_PROTECTED])
562 access = ak_protected;
563 else if (decl_access == access_private_nodeglobal_trees[TI_PRIVATE])
564 access = ak_private;
565 else
566 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 566, __FUNCTION__))
;
567 }
568 }
569
570 if (!access)
571 {
572 int i;
573 tree base_binfo;
574 vec<tree, va_gc> *accesses;
575
576 /* Otherwise, scan our baseclasses, and pick the most favorable
577 access. */
578 accesses = BINFO_BASE_ACCESSES (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 578, __FUNCTION__, (TREE_BINFO)))->binfo.base_accesses)
;
579 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 579, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((i), &(base_binfo)))
; i++)
580 {
581 tree base_access = (*accesses)[i];
582 access_kind base_access_now = BINFO_ACCESS (base_binfo)((access_kind) ((((base_binfo)->base.public_flag) <<
1) | ((base_binfo)->base.private_flag)))
;
583
584 if (base_access_now == ak_none || base_access_now == ak_private)
585 /* If it was not accessible in the base, or only
586 accessible as a private member, we can't access it
587 all. */
588 base_access_now = ak_none;
589 else if (base_access == access_protected_nodeglobal_trees[TI_PROTECTED])
590 /* Public and protected members in the base become
591 protected here. */
592 base_access_now = ak_protected;
593 else if (base_access == access_private_nodeglobal_trees[TI_PRIVATE])
594 /* Public and protected members in the base become
595 private here. */
596 base_access_now = ak_private;
597
598 /* See if the new access, via this base, gives more
599 access than our previous best access. */
600 if (base_access_now != ak_none
601 && (access == ak_none || base_access_now < access))
602 {
603 access = base_access_now;
604
605 /* If the new access is public, we can't do better. */
606 if (access == ak_public)
607 break;
608 }
609 }
610 }
611 }
612
613 /* Note the access to DECL in TYPE. */
614 SET_BINFO_ACCESS (binfo, access)((((binfo)->base.public_flag) = ((access) & 2) != 0), (
((binfo)->base.private_flag) = ((access) & 1) != 0))
;
615
616 return NULL_TREE(tree) __null;
617}
618
619/* Return the access to DECL in TYPE. */
620
621static access_kind
622access_in_type (tree type, tree decl)
623{
624 tree binfo = TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 624, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
625
626 /* We must take into account
627
628 [class.paths]
629
630 If a name can be reached by several paths through a multiple
631 inheritance graph, the access is that of the path that gives
632 most access.
633
634 The algorithm we use is to make a post-order depth-first traversal
635 of the base-class hierarchy. As we come up the tree, we annotate
636 each node with the most lenient access. */
637 dfs_walk_once (binfo, dfs_access_in_type_pre, dfs_access_in_type, decl);
638
639 return BINFO_ACCESS (binfo)((access_kind) ((((binfo)->base.public_flag) << 1) |
((binfo)->base.private_flag)))
;
640}
641
642/* Returns nonzero if it is OK to access DECL named in TYPE through an object
643 of OTYPE in the context of DERIVED. */
644
645static int
646protected_accessible_p (tree decl, tree derived, tree type, tree otype)
647{
648 /* We're checking this clause from [class.access.base]
649
650 m as a member of N is protected, and the reference occurs in a
651 member or friend of class N, or in a member or friend of a
652 class P derived from N, where m as a member of P is public, private
653 or protected.
654
655 Here DERIVED is a possible P, DECL is m and TYPE is N. */
656
657 /* If DERIVED isn't derived from N, then it can't be a P. */
658 if (!DERIVED_FROM_P (type, derived)(lookup_base ((derived), (type), ba_any, __null, tf_none) != (
tree) __null)
)
659 return 0;
660
661 /* DECL_NONSTATIC_MEMBER_P won't work for USING_DECLs. */
662 decl = strip_using_decl (decl);
663 /* We don't expect or support dependent decls. */
664 gcc_assert (TREE_CODE (decl) != USING_DECL)((void)(!(((enum tree_code) (decl)->base.code) != USING_DECL
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 664, __FUNCTION__), 0 : 0))
;
665
666 /* [class.protected]
667
668 When a friend or a member function of a derived class references
669 a protected non-static member of a base class, an access check
670 applies in addition to those described earlier in clause
671 _class.access_) Except when forming a pointer to member
672 (_expr.unary.op_), the access must be through a pointer to,
673 reference to, or object of the derived class itself (or any class
674 derived from that class) (_expr.ref_). If the access is to form
675 a pointer to member, the nested-name-specifier shall name the
676 derived class (or any class derived from that class). */
677 if (DECL_NONSTATIC_MEMBER_P (decl)((((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 677, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
) || ((enum tree_code) (decl)->base.code) == FIELD_DECL)
678 && !DERIVED_FROM_P (derived, otype)(lookup_base ((otype), (derived), ba_any, __null, tf_none) !=
(tree) __null)
)
679 return 0;
680
681 return 1;
682}
683
684/* Returns nonzero if SCOPE is a type or a friend of a type which would be able
685 to access DECL through TYPE. OTYPE is the type of the object. */
686
687static int
688friend_accessible_p (tree scope, tree decl, tree type, tree otype)
689{
690 /* We're checking this clause from [class.access.base]
691
692 m as a member of N is protected, and the reference occurs in a
693 member or friend of class N, or in a member or friend of a
694 class P derived from N, where m as a member of P is public, private
695 or protected.
696
697 Here DECL is m and TYPE is N. SCOPE is the current context,
698 and we check all its possible Ps. */
699 tree befriending_classes;
700 tree t;
701
702 if (!scope)
703 return 0;
704
705 if (is_global_friend (scope))
706 return 1;
707
708 /* Is SCOPE itself a suitable P? */
709 if (TYPE_P (scope)(tree_code_type[(int) (((enum tree_code) (scope)->base.code
))] == tcc_type)
&& protected_accessible_p (decl, scope, type, otype))
710 return 1;
711
712 if (DECL_DECLARES_FUNCTION_P (scope)(((enum tree_code) (scope)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (scope)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 712, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((scope
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 712, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL))
)
713 befriending_classes = DECL_BEFRIENDING_CLASSES (scope)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (scope)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 713, __FUNCTION__, (TEMPLATE_DECL))))))))->result : scope
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 713, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (scope)->base.code) == FUNCTION_DECL || (
((enum tree_code) (scope)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 713, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((scope
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 713, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 713, __FUNCTION__); &lt->u.fn; })->befriending_classes
)
;
714 else if (TYPE_P (scope)(tree_code_type[(int) (((enum tree_code) (scope)->base.code
))] == tcc_type)
)
715 befriending_classes = CLASSTYPE_BEFRIENDING_CLASSES (scope)((((tree_class_check ((scope), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 715, __FUNCTION__))->type_with_lang_specific.lang_specific
))->befriending_classes)
;
716 else
717 return 0;
718
719 for (t = befriending_classes; t; t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 719, __FUNCTION__))->common.chain)
)
720 if (protected_accessible_p (decl, TREE_VALUE (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 720, __FUNCTION__, (TREE_LIST)))->list.value)
, type, otype))
721 return 1;
722
723 /* Nested classes have the same access as their enclosing types, as
724 per DR 45 (this is a change from C++98). */
725 if (TYPE_P (scope)(tree_code_type[(int) (((enum tree_code) (scope)->base.code
))] == tcc_type)
)
726 if (friend_accessible_p (TYPE_CONTEXT (scope)((tree_class_check ((scope), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 726, __FUNCTION__))->type_common.context)
, decl, type, otype))
727 return 1;
728
729 if (DECL_DECLARES_FUNCTION_P (scope)(((enum tree_code) (scope)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (scope)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 729, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((scope
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 729, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL))
)
730 {
731 /* Perhaps this SCOPE is a member of a class which is a
732 friend. */
733 if (DECL_CLASS_SCOPE_P (scope)(((contains_struct_check ((scope), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 733, __FUNCTION__))->decl_minimal.context) && (tree_code_type
[(int) (((enum tree_code) (((contains_struct_check ((scope), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 733, __FUNCTION__))->decl_minimal.context))->base.code
))] == tcc_type))
734 && friend_accessible_p (DECL_CONTEXT (scope)((contains_struct_check ((scope), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 734, __FUNCTION__))->decl_minimal.context)
, decl, type, otype))
735 return 1;
736 /* Perhaps SCOPE is a friend function defined inside a class from which
737 DECL is accessible. Checking this is necessary only when the class
738 is dependent, for otherwise add_friend will already have added the
739 class to SCOPE's DECL_BEFRIENDING_CLASSES. */
740 if (tree fctx = DECL_FRIEND_CONTEXT (scope)(((((enum tree_code) (scope)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (scope)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((scope
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) && !((contains_struct_check
((scope), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__))->decl_common.virtual_flag) &&
!((tree_check (((((enum tree_code) (scope)->base.code) ==
TEMPLATE_DECL ? ((struct tree_template_decl *)(const_cast<
union tree_node *> ((((tree_check ((scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__, (TEMPLATE_DECL))))))))->result : scope
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)) ? __extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (scope)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__, (TEMPLATE_DECL))))))))->result : scope
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (scope)->base.code) == FUNCTION_DECL || (
((enum tree_code) (scope)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((scope
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 740, __FUNCTION__); &lt->u.fn; })->context : (tree
) __null)
)
741 if (dependent_type_p (fctx)
742 && protected_accessible_p (decl, fctx, type, otype))
743 return 1;
744 }
745
746 /* Maybe scope's template is a friend. */
747 if (tree tinfo = get_template_info (scope))
748 {
749 tree tmpl = TI_TEMPLATE (tinfo)((struct tree_template_info*)(tree_check ((tinfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 749, __FUNCTION__, (TEMPLATE_INFO))))->tmpl
;
750 if (DECL_CLASS_TEMPLATE_P (tmpl)((((enum tree_code) (tmpl)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((tmpl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 750, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((tmpl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 750, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == TYPE_DECL) && (((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((tmpl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 750, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == TYPE_DECL && ((contains_struct_check ((((struct
tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((tmpl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 750, __FUNCTION__, (TEMPLATE_DECL))))))))->result), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 750, __FUNCTION__))->decl_common.lang_flag_2)))
)
751 tmpl = TREE_TYPE (tmpl)((contains_struct_check ((tmpl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 751, __FUNCTION__))->typed.type)
;
752 else
753 tmpl = DECL_TEMPLATE_RESULT (tmpl)((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((tmpl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 753, __FUNCTION__, (TEMPLATE_DECL))))))))->result
;
754 if (tmpl != scope)
755 {
756 /* Increment processing_template_decl to make sure that
757 dependent_type_p works correctly. */
758 ++processing_template_declscope_chain->x_processing_template_decl;
759 int ret = friend_accessible_p (tmpl, decl, type, otype);
760 --processing_template_declscope_chain->x_processing_template_decl;
761 if (ret)
762 return 1;
763 }
764 }
765
766 /* If is_friend is true, we should have found a befriending class. */
767 gcc_checking_assert (!is_friend (type, scope))((void)(!(!is_friend (type, scope)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 767, __FUNCTION__), 0 : 0))
;
768
769 return 0;
770}
771
772struct dfs_accessible_data
773{
774 tree decl;
775 tree object_type;
776};
777
778/* Avoid walking up past a declaration of the member. */
779
780static tree
781dfs_accessible_pre (tree binfo, void *data)
782{
783 dfs_accessible_data *d = (dfs_accessible_data *)data;
784 tree type = BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 784, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 784, __FUNCTION__))->typed.type)
;
785 if (member_declared_in_type (d->decl, type))
786 return dfs_skip_bases((tree)1);
787 return NULL_TREE(tree) __null;
788}
789
790/* Called via dfs_walk_once_accessible from accessible_p */
791
792static tree
793dfs_accessible_post (tree binfo, void *data)
794{
795 /* access_in_type already set BINFO_ACCESS for us. */
796 access_kind access = BINFO_ACCESS (binfo)((access_kind) ((((binfo)->base.public_flag) << 1) |
((binfo)->base.private_flag)))
;
797 tree N = BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 797, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 797, __FUNCTION__))->typed.type)
;
798 dfs_accessible_data *d = (dfs_accessible_data *)data;
799 tree decl = d->decl;
800 tree scope = current_nonlambda_scope ();
801
802 /* A member m is accessible at the point R when named in class N if */
803 switch (access)
804 {
805 case ak_none:
806 return NULL_TREE(tree) __null;
807
808 case ak_public:
809 /* m as a member of N is public, or */
810 return binfo;
811
812 case ak_private:
813 {
814 /* m as a member of N is private, and R occurs in a member or friend of
815 class N, or */
816 if (scope && TREE_CODE (scope)((enum tree_code) (scope)->base.code) != NAMESPACE_DECL
817 && is_friend (N, scope))
818 return binfo;
819 return NULL_TREE(tree) __null;
820 }
821
822 case ak_protected:
823 {
824 /* m as a member of N is protected, and R occurs in a member or friend
825 of class N, or in a member or friend of a class P derived from N,
826 where m as a member of P is public, private, or protected */
827 if (friend_accessible_p (scope, decl, N, d->object_type))
828 return binfo;
829 return NULL_TREE(tree) __null;
830 }
831
832 default:
833 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 833, __FUNCTION__))
;
834 }
835}
836
837/* Like accessible_p below, but within a template returns true iff DECL is
838 accessible in TYPE to all possible instantiations of the template. */
839
840int
841accessible_in_template_p (tree type, tree decl)
842{
843 int save_ptd = processing_template_declscope_chain->x_processing_template_decl;
844 processing_template_declscope_chain->x_processing_template_decl = 0;
845 int val = accessible_p (type, decl, false);
846 processing_template_declscope_chain->x_processing_template_decl = save_ptd;
847 return val;
848}
849
850/* DECL is a declaration from a base class of TYPE, which was the
851 class used to name DECL. Return nonzero if, in the current
852 context, DECL is accessible. If TYPE is actually a BINFO node,
853 then we can tell in what context the access is occurring by looking
854 at the most derived class along the path indicated by BINFO. If
855 CONSIDER_LOCAL is true, do consider special access the current
856 scope or friendship thereof we might have. */
857
858int
859accessible_p (tree type, tree decl, bool consider_local_p)
860{
861 tree binfo;
862 access_kind access;
863
864 /* If this declaration is in a block or namespace scope, there's no
865 access control. */
866 if (!TYPE_P (context_for_name_lookup (decl))(tree_code_type[(int) (((enum tree_code) (context_for_name_lookup
(decl))->base.code))] == tcc_type)
)
867 return 1;
868
869 /* There is no need to perform access checks inside a thunk. */
870 if (current_function_decl && DECL_THUNK_P (current_function_decl)(((enum tree_code) (current_function_decl)->base.code) == FUNCTION_DECL
&& ((contains_struct_check ((current_function_decl),
(TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 870, __FUNCTION__))->decl_common.lang_specific) &&
__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (current_function_decl)->base.code) ==
TEMPLATE_DECL ? ((struct tree_template_decl *)(const_cast<
union tree_node *> ((((tree_check ((current_function_decl)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 870, __FUNCTION__, (TEMPLATE_DECL))))))))->result : current_function_decl
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 870, __FUNCTION__))->decl_common.lang_specific); if (!((
(enum tree_code) (current_function_decl)->base.code) == FUNCTION_DECL
|| (((enum tree_code) (current_function_decl)->base.code)
== TEMPLATE_DECL && ((struct tree_template_decl *)(const_cast
<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 870, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 870, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->base
.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 870, __FUNCTION__); &lt->u.fn; })->thunk_p)
)
871 return 1;
872
873 tree otype = NULL_TREE(tree) __null;
874 if (!TYPE_P (type)(tree_code_type[(int) (((enum tree_code) (type)->base.code
))] == tcc_type)
)
875 {
876 /* When accessing a non-static member, the most derived type in the
877 binfo chain is the type of the object; remember that type for
878 protected_accessible_p. */
879 for (tree b = type; b; b = BINFO_INHERITANCE_CHAIN (b)((tree_check ((b), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 879, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
)
880 otype = BINFO_TYPE (b)((contains_struct_check (((tree_check ((b), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 880, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 880, __FUNCTION__))->typed.type)
;
881 type = BINFO_TYPE (type)((contains_struct_check (((tree_check ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 881, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 881, __FUNCTION__))->typed.type)
;
882 }
883 else
884 otype = type;
885
886 /* [class.access.base]
887
888 A member m is accessible when named in class N if
889
890 --m as a member of N is public, or
891
892 --m as a member of N is private, and the reference occurs in a
893 member or friend of class N, or
894
895 --m as a member of N is protected, and the reference occurs in a
896 member or friend of class N, or in a member or friend of a
897 class P derived from N, where m as a member of P is public, private or
898 protected, or
899
900 --there exists a base class B of N that is accessible at the point
901 of reference, and m is accessible when named in class B.
902
903 We walk the base class hierarchy, checking these conditions. */
904
905 /* We walk using TYPE_BINFO (type) because access_in_type will set
906 BINFO_ACCESS on it and its bases. */
907 binfo = TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 907, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
908
909 /* Compute the accessibility of DECL in the class hierarchy
910 dominated by type. */
911 access = access_in_type (type, decl);
912 if (access == ak_public)
913 return 1;
914
915 /* If we aren't considering the point of reference, only the first bullet
916 applies. */
917 if (!consider_local_p)
918 return 0;
919
920 dfs_accessible_data d = { decl, otype };
921
922 /* Walk the hierarchy again, looking for a base class that allows
923 access. */
924 return dfs_walk_once_accessible (binfo, /*friends=*/true,
925 dfs_accessible_pre,
926 dfs_accessible_post, &d)
927 != NULL_TREE(tree) __null;
928}
929
930struct lookup_field_info {
931 /* The type in which we're looking. */
932 tree type;
933 /* The name of the field for which we're looking. */
934 tree name;
935 /* If non-NULL, the current result of the lookup. */
936 tree rval;
937 /* The path to RVAL. */
938 tree rval_binfo;
939 /* If non-NULL, the lookup was ambiguous, and this is a list of the
940 candidates. */
941 tree ambiguous;
942 /* If nonzero, we are looking for types, not data members. */
943 int want_type;
944 /* If something went wrong, a message indicating what. */
945 const char *errstr;
946};
947
948/* True for a class member means that it is shared between all objects
949 of that class.
950
951 [class.member.lookup]:If the resulting set of declarations are not all
952 from sub-objects of the same type, or the set has a non-static member
953 and includes members from distinct sub-objects, there is an ambiguity
954 and the program is ill-formed.
955
956 This function checks that T contains no non-static members. */
957
958bool
959shared_member_p (tree t)
960{
961 if (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL) || TREE_CODE (t)((enum tree_code) (t)->base.code) == TYPE_DECL
962 || TREE_CODE (t)((enum tree_code) (t)->base.code) == CONST_DECL)
963 return true;
964 if (is_overloaded_fn (t))
965 {
966 for (ovl_iterator iter (get_fns (t)); iter; ++iter)
967 {
968 tree decl = strip_using_decl (*iter);
969 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == USING_DECL)
970 /* Conservatively assume a dependent using-declaration
971 might resolve to a non-static member. */
972 return false;
973 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)(((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 973, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
)
)
974 return false;
975 }
976 return true;
977 }
978 return false;
979}
980
981/* Routine to see if the sub-object denoted by the binfo PARENT can be
982 found as a base class and sub-object of the object denoted by
983 BINFO. */
984
985static int
986is_subobject_of_p (tree parent, tree binfo)
987{
988 tree probe;
989
990 for (probe = parent; probe; probe = BINFO_INHERITANCE_CHAIN (probe)((tree_check ((probe), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 990, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
)
991 {
992 if (probe == binfo)
993 return 1;
994 if (BINFO_VIRTUAL_P (probe)((tree_check ((probe), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 994, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
995 return (binfo_for_vbase (BINFO_TYPE (probe)((contains_struct_check (((tree_check ((probe), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 995, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 995, __FUNCTION__))->typed.type)
, BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 995, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 995, __FUNCTION__))->typed.type)
)
996 != NULL_TREE(tree) __null);
997 }
998 return 0;
999}
1000
1001/* DATA is really a struct lookup_field_info. Look for a field with
1002 the name indicated there in BINFO. If this function returns a
1003 non-NULL value it is the result of the lookup. Called from
1004 lookup_field via breadth_first_search. */
1005
1006static tree
1007lookup_field_r (tree binfo, void *data)
1008{
1009 struct lookup_field_info *lfi = (struct lookup_field_info *) data;
1010 tree type = BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1010, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1010, __FUNCTION__))->typed.type)
;
1011 tree nval = NULL_TREE(tree) __null;
1012
1013 /* If this is a dependent base, don't look in it. */
1014 if (BINFO_DEPENDENT_BASE_P (binfo)((tree_not_check2 (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1014, __FUNCTION__, (TREE_BINFO)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1014, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
)
1015 return NULL_TREE(tree) __null;
1016
1017 /* If this base class is hidden by the best-known value so far, we
1018 don't need to look. */
1019 if (lfi->rval_binfo && BINFO_INHERITANCE_CHAIN (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1019, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
== lfi->rval_binfo
1020 && !BINFO_VIRTUAL_P (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1020, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
1021 return dfs_skip_bases((tree)1);
1022
1023 nval = get_class_binding (type, lfi->name, lfi->want_type);
1024
1025 /* If there is no declaration with the indicated name in this type,
1026 then there's nothing to do. */
1027 if (!nval)
1028 goto done;
1029
1030 /* If the lookup already found a match, and the new value doesn't
1031 hide the old one, we might have an ambiguity. */
1032 if (lfi->rval_binfo
1033 && !is_subobject_of_p (lfi->rval_binfo, binfo))
1034
1035 {
1036 if (nval == lfi->rval && shared_member_p (nval))
1037 /* The two things are really the same. */
1038 ;
1039 else if (is_subobject_of_p (binfo, lfi->rval_binfo))
1040 /* The previous value hides the new one. */
1041 ;
1042 else
1043 {
1044 /* We have a real ambiguity. We keep a chain of all the
1045 candidates. */
1046 if (!lfi->ambiguous && lfi->rval)
1047 {
1048 /* This is the first time we noticed an ambiguity. Add
1049 what we previously thought was a reasonable candidate
1050 to the list. */
1051 lfi->ambiguous = tree_cons (NULL_TREE(tree) __null, lfi->rval, NULL_TREE(tree) __null);
1052 TREE_TYPE (lfi->ambiguous)((contains_struct_check ((lfi->ambiguous), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1052, __FUNCTION__))->typed.type)
= error_mark_nodeglobal_trees[TI_ERROR_MARK];
1053 }
1054
1055 /* Add the new value. */
1056 lfi->ambiguous = tree_cons (NULL_TREE(tree) __null, nval, lfi->ambiguous);
1057 TREE_TYPE (lfi->ambiguous)((contains_struct_check ((lfi->ambiguous), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1057, __FUNCTION__))->typed.type)
= error_mark_nodeglobal_trees[TI_ERROR_MARK];
1058 lfi->errstr = G_("request for member %qD is ambiguous")"request for member %qD is ambiguous";
1059 }
1060 }
1061 else
1062 {
1063 lfi->rval = nval;
1064 lfi->rval_binfo = binfo;
1065 }
1066
1067 done:
1068 /* Don't look for constructors or destructors in base classes. */
1069 if (IDENTIFIER_CDTOR_P (lfi->name)((!((tree_not_check2 (((tree_check ((lfi->name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1069, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1069, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((lfi->
name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1069, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1069, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1))
)
1070 return dfs_skip_bases((tree)1);
1071 return NULL_TREE(tree) __null;
1072}
1073
1074/* Return a "baselink" with BASELINK_BINFO, BASELINK_ACCESS_BINFO,
1075 BASELINK_FUNCTIONS, and BASELINK_OPTYPE set to BINFO, ACCESS_BINFO,
1076 FUNCTIONS, and OPTYPE respectively. */
1077
1078tree
1079build_baselink (tree binfo, tree access_binfo, tree functions, tree optype)
1080{
1081 tree baselink;
1082
1083 gcc_assert (OVL_P (functions) || TREE_CODE (functions) == TEMPLATE_ID_EXPR)((void)(!((((enum tree_code) (functions)->base.code) == FUNCTION_DECL
|| ((enum tree_code) (functions)->base.code) == OVERLOAD)
|| ((enum tree_code) (functions)->base.code) == TEMPLATE_ID_EXPR
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1083, __FUNCTION__), 0 : 0))
;
1084 gcc_assert (!optype || TYPE_P (optype))((void)(!(!optype || (tree_code_type[(int) (((enum tree_code)
(optype)->base.code))] == tcc_type)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1084, __FUNCTION__), 0 : 0))
;
1085 gcc_assert (TREE_TYPE (functions))((void)(!(((contains_struct_check ((functions), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1085, __FUNCTION__))->typed.type)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1085, __FUNCTION__), 0 : 0))
;
1086
1087 baselink = make_node (BASELINK);
1088 TREE_TYPE (baselink)((contains_struct_check ((baselink), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1088, __FUNCTION__))->typed.type)
= TREE_TYPE (functions)((contains_struct_check ((functions), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1088, __FUNCTION__))->typed.type)
;
1089 BASELINK_BINFO (baselink)(((struct tree_baselink*) (tree_check ((baselink), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1089, __FUNCTION__, (BASELINK))))->binfo)
= binfo;
1090 BASELINK_ACCESS_BINFO (baselink)(((struct tree_baselink*) (tree_check ((baselink), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1090, __FUNCTION__, (BASELINK))))->access_binfo)
= access_binfo;
1091 BASELINK_FUNCTIONS (baselink)(((struct tree_baselink*) (tree_check ((baselink), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1091, __FUNCTION__, (BASELINK))))->functions)
= functions;
1092 BASELINK_OPTYPE (baselink)(((contains_struct_check (((tree_check ((baselink), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1092, __FUNCTION__, (BASELINK)))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1092, __FUNCTION__))->common.chain))
= optype;
1093
1094 return baselink;
1095}
1096
1097/* Look for a member named NAME in an inheritance lattice dominated by
1098 XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
1099 is 1, we enforce accessibility. If PROTECT is zero, then, for an
1100 ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
1101 messages about inaccessible or ambiguous lookup. If PROTECT is 2,
1102 we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
1103 TREE_VALUEs are the list of ambiguous candidates.
1104
1105 WANT_TYPE is 1 when we should only return TYPE_DECLs.
1106
1107 If nothing can be found return NULL_TREE and do not issue an error.
1108
1109 If non-NULL, failure information is written back to AFI. */
1110
1111tree
1112lookup_member (tree xbasetype, tree name, int protect, bool want_type,
1113 tsubst_flags_t complain, access_failure_info *afi)
1114{
1115 tree rval, rval_binfo = NULL_TREE(tree) __null;
1116 tree type = NULL_TREE(tree) __null, basetype_path = NULL_TREE(tree) __null;
1117 struct lookup_field_info lfi;
1118
1119 /* rval_binfo is the binfo associated with the found member, note,
1120 this can be set with useful information, even when rval is not
1121 set, because it must deal with ALL members, not just non-function
1122 members. It is used for ambiguity checking and the hidden
1123 checks. Whereas rval is only set if a proper (not hidden)
1124 non-function member is found. */
1125
1126 const char *errstr = 0;
1127
1128 if (name == error_mark_nodeglobal_trees[TI_ERROR_MARK]
1129 || xbasetype == NULL_TREE(tree) __null
1130 || xbasetype == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1131 return NULL_TREE(tree) __null;
1132
1133 gcc_assert (identifier_p (name))((void)(!(identifier_p (name)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1133, __FUNCTION__), 0 : 0))
;
1134
1135 if (TREE_CODE (xbasetype)((enum tree_code) (xbasetype)->base.code) == TREE_BINFO)
1136 {
1137 type = BINFO_TYPE (xbasetype)((contains_struct_check (((tree_check ((xbasetype), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1137, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1137, __FUNCTION__))->typed.type)
;
1138 basetype_path = xbasetype;
1139 }
1140 else
1141 {
1142 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype))((((enum tree_code) (xbasetype)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (xbasetype)->base.code)) == UNION_TYPE
)
)
1143 return NULL_TREE(tree) __null;
1144 type = xbasetype;
1145 xbasetype = NULL_TREE(tree) __null;
1146 }
1147
1148 type = complete_type (type);
1149
1150 /* Make sure we're looking for a member of the current instantiation in the
1151 right partial specialization. */
1152 if (dependent_type_p (type))
1153 if (tree t = currently_open_class (type))
1154 type = t;
1155
1156 if (!basetype_path)
1157 basetype_path = TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1157, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
1158
1159 if (!basetype_path)
1160 return NULL_TREE(tree) __null;
1161
1162 memset (&lfi, 0, sizeof (lfi));
1163 lfi.type = type;
1164 lfi.name = name;
1165 lfi.want_type = want_type;
1166 dfs_walk_all (basetype_path, &lookup_field_r, NULL__null, &lfi);
1167 rval = lfi.rval;
1168 rval_binfo = lfi.rval_binfo;
1169 if (rval_binfo)
1170 type = BINFO_TYPE (rval_binfo)((contains_struct_check (((tree_check ((rval_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1170, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1170, __FUNCTION__))->typed.type)
;
1171 errstr = lfi.errstr;
1172
1173 /* If we are not interested in ambiguities, don't report them;
1174 just return NULL_TREE. */
1175 if (!protect && lfi.ambiguous)
1176 return NULL_TREE(tree) __null;
1177
1178 if (protect == 2)
1179 {
1180 if (lfi.ambiguous)
1181 return lfi.ambiguous;
1182 else
1183 protect = 0;
1184 }
1185
1186 /* [class.access]
1187
1188 In the case of overloaded function names, access control is
1189 applied to the function selected by overloaded resolution.
1190
1191 We cannot check here, even if RVAL is only a single non-static
1192 member function, since we do not know what the "this" pointer
1193 will be. For:
1194
1195 class A { protected: void f(); };
1196 class B : public A {
1197 void g(A *p) {
1198 f(); // OK
1199 p->f(); // Not OK.
1200 }
1201 };
1202
1203 only the first call to "f" is valid. However, if the function is
1204 static, we can check. */
1205 if (rval && protect
1206 && !really_overloaded_fn (rval))
1207 {
1208 tree decl = is_overloaded_fn (rval) ? get_first_fn (rval) : rval;
1209 decl = strip_using_decl (decl);
1210 /* A dependent USING_DECL will be checked after tsubsting. */
1211 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) != USING_DECL
1212 && !DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)(((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1212, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
)
1213 && !perform_or_defer_access_check (basetype_path, decl, decl,
1214 complain, afi))
1215 rval = error_mark_nodeglobal_trees[TI_ERROR_MARK];
1216 }
1217
1218 if (errstr && protect)
1219 {
1220 if (complain & tf_error)
1221 {
1222 error (errstr, name, type);
1223 if (lfi.ambiguous)
1224 print_candidates (lfi.ambiguous);
1225 }
1226 rval = error_mark_nodeglobal_trees[TI_ERROR_MARK];
1227 }
1228
1229 if (rval && is_overloaded_fn (rval)
1230 /* Don't use a BASELINK for class-scope deduction guides since
1231 they're not actually member functions. */
1232 && !dguide_name_p (name))
1233 rval = build_baselink (rval_binfo, basetype_path, rval,
1234 (IDENTIFIER_CONV_OP_P (name)((((tree_not_check2 (((tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1234, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1234, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((name),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1234, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1234, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((name)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1234, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1234, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))
1235 ? TREE_TYPE (name)((contains_struct_check ((name), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1235, __FUNCTION__))->typed.type)
: NULL_TREE(tree) __null));
1236 return rval;
1237}
1238
1239/* Helper class for lookup_member_fuzzy. */
1240
1241class lookup_field_fuzzy_info
1242{
1243 public:
1244 lookup_field_fuzzy_info (bool want_type_p) :
1245 m_want_type_p (want_type_p), m_candidates () {}
1246
1247 void fuzzy_lookup_field (tree type);
1248
1249 /* If true, we are looking for types, not data members. */
1250 bool m_want_type_p;
1251 /* The result: a vec of identifiers. */
1252 auto_vec<tree> m_candidates;
1253};
1254
1255/* Locate all fields within TYPE, append them to m_candidates. */
1256
1257void
1258lookup_field_fuzzy_info::fuzzy_lookup_field (tree type)
1259{
1260 if (!CLASS_TYPE_P (type)(((((enum tree_code) (type)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1260, __FUNCTION__))->type_common.lang_flag_5))
)
1261 return;
1262
1263 for (tree field = TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1263, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
; field; field = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1263, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1263, __FUNCTION__))->common.chain))
)
1264 {
1265 if (m_want_type_p && !DECL_DECLARES_TYPE_P (field)(((enum tree_code) (field)->base.code) == TYPE_DECL || (((
enum tree_code) (field)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1265, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((field
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1265, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == TYPE_DECL))
)
1266 continue;
1267
1268 if (!DECL_NAME (field)((contains_struct_check ((field), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1268, __FUNCTION__))->decl_minimal.name)
)
1269 continue;
1270
1271 if (is_lambda_ignored_entity (field))
1272 continue;
1273
1274 m_candidates.safe_push (DECL_NAME (field)((contains_struct_check ((field), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1274, __FUNCTION__))->decl_minimal.name)
);
1275 }
1276}
1277
1278
1279/* Helper function for lookup_member_fuzzy, called via dfs_walk_all
1280 DATA is really a lookup_field_fuzzy_info. Look for a field with
1281 the name indicated there in BINFO. Gathers pertinent identifiers into
1282 m_candidates. */
1283
1284static tree
1285lookup_field_fuzzy_r (tree binfo, void *data)
1286{
1287 lookup_field_fuzzy_info *lffi = (lookup_field_fuzzy_info *) data;
1288 tree type = BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1288, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1288, __FUNCTION__))->typed.type)
;
1289
1290 lffi->fuzzy_lookup_field (type);
1291
1292 return NULL_TREE(tree) __null;
1293}
1294
1295/* Like lookup_member, but try to find the closest match for NAME,
1296 rather than an exact match, and return an identifier (or NULL_TREE).
1297 Do not complain. */
1298
1299tree
1300lookup_member_fuzzy (tree xbasetype, tree name, bool want_type_p)
1301{
1302 tree type = NULL_TREE(tree) __null, basetype_path = NULL_TREE(tree) __null;
1303 class lookup_field_fuzzy_info lffi (want_type_p);
1304
1305 /* rval_binfo is the binfo associated with the found member, note,
1306 this can be set with useful information, even when rval is not
1307 set, because it must deal with ALL members, not just non-function
1308 members. It is used for ambiguity checking and the hidden
1309 checks. Whereas rval is only set if a proper (not hidden)
1310 non-function member is found. */
1311
1312 if (name == error_mark_nodeglobal_trees[TI_ERROR_MARK]
1313 || xbasetype == NULL_TREE(tree) __null
1314 || xbasetype == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1315 return NULL_TREE(tree) __null;
1316
1317 gcc_assert (identifier_p (name))((void)(!(identifier_p (name)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1317, __FUNCTION__), 0 : 0))
;
1318
1319 if (TREE_CODE (xbasetype)((enum tree_code) (xbasetype)->base.code) == TREE_BINFO)
1320 {
1321 type = BINFO_TYPE (xbasetype)((contains_struct_check (((tree_check ((xbasetype), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1321, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1321, __FUNCTION__))->typed.type)
;
1322 basetype_path = xbasetype;
1323 }
1324 else
1325 {
1326 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (xbasetype))((((enum tree_code) (xbasetype)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (xbasetype)->base.code)) == UNION_TYPE
)
)
1327 return NULL_TREE(tree) __null;
1328 type = xbasetype;
1329 xbasetype = NULL_TREE(tree) __null;
1330 }
1331
1332 type = complete_type (type);
1333
1334 /* Make sure we're looking for a member of the current instantiation in the
1335 right partial specialization. */
1336 if (flag_conceptsglobal_options.x_flag_concepts && dependent_type_p (type))
1337 type = currently_open_class (type);
1338
1339 if (!basetype_path)
1340 basetype_path = TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1340, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
1341
1342 if (!basetype_path)
1343 return NULL_TREE(tree) __null;
1344
1345 /* Populate lffi.m_candidates. */
1346 dfs_walk_all (basetype_path, &lookup_field_fuzzy_r, NULL__null, &lffi);
1347
1348 return find_closest_identifier (name, &lffi.m_candidates);
1349}
1350
1351/* Like lookup_member, except that if we find a function member we
1352 return NULL_TREE. */
1353
1354tree
1355lookup_field (tree xbasetype, tree name, int protect, bool want_type)
1356{
1357 tree rval = lookup_member (xbasetype, name, protect, want_type,
1358 tf_warning_or_error);
1359
1360 /* Ignore functions, but propagate the ambiguity list. */
1361 if (!error_operand_p (rval)
1362 && (rval && BASELINK_P (rval)(((enum tree_code) (rval)->base.code) == BASELINK)))
1363 return NULL_TREE(tree) __null;
1364
1365 return rval;
1366}
1367
1368/* Like lookup_member, except that if we find a non-function member we
1369 return NULL_TREE. */
1370
1371tree
1372lookup_fnfields (tree xbasetype, tree name, int protect,
1373 tsubst_flags_t complain)
1374{
1375 tree rval = lookup_member (xbasetype, name, protect, /*want_type=*/false,
1376 complain);
1377
1378 /* Ignore non-functions, but propagate the ambiguity list. */
1379 if (!error_operand_p (rval)
1380 && (rval && !BASELINK_P (rval)(((enum tree_code) (rval)->base.code) == BASELINK)))
1381 return NULL_TREE(tree) __null;
1382
1383 return rval;
1384}
1385
1386/* DECL is the result of a qualified name lookup. QUALIFYING_SCOPE is
1387 the class or namespace used to qualify the name. CONTEXT_CLASS is
1388 the class corresponding to the object in which DECL will be used.
1389 Return a possibly modified version of DECL that takes into account
1390 the CONTEXT_CLASS.
1391
1392 In particular, consider an expression like `B::m' in the context of
1393 a derived class `D'. If `B::m' has been resolved to a BASELINK,
1394 then the most derived class indicated by the BASELINK_BINFO will be
1395 `B', not `D'. This function makes that adjustment. */
1396
1397tree
1398adjust_result_of_qualified_name_lookup (tree decl,
1399 tree qualifying_scope,
1400 tree context_class)
1401{
1402 if (context_class && context_class != error_mark_nodeglobal_trees[TI_ERROR_MARK]
1403 && CLASS_TYPE_P (context_class)(((((enum tree_code) (context_class)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (context_class)->base.code)) == UNION_TYPE
) && ((tree_class_check ((context_class), (tcc_type),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1403, __FUNCTION__))->type_common.lang_flag_5))
1404 && CLASS_TYPE_P (qualifying_scope)(((((enum tree_code) (qualifying_scope)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (qualifying_scope)->base.code)) == UNION_TYPE
) && ((tree_class_check ((qualifying_scope), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1404, __FUNCTION__))->type_common.lang_flag_5))
1405 && DERIVED_FROM_P (qualifying_scope, context_class)(lookup_base ((context_class), (qualifying_scope), ba_any, __null
, tf_none) != (tree) __null)
1406 && BASELINK_P (decl)(((enum tree_code) (decl)->base.code) == BASELINK))
1407 {
1408 tree base;
1409
1410 /* Look for the QUALIFYING_SCOPE as a base of the CONTEXT_CLASS.
1411 Because we do not yet know which function will be chosen by
1412 overload resolution, we cannot yet check either accessibility
1413 or ambiguity -- in either case, the choice of a static member
1414 function might make the usage valid. */
1415 base = lookup_base (context_class, qualifying_scope,
1416 ba_unique, NULL__null, tf_none);
1417 if (base && base != error_mark_nodeglobal_trees[TI_ERROR_MARK])
1418 {
1419 BASELINK_ACCESS_BINFO (decl)(((struct tree_baselink*) (tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1419, __FUNCTION__, (BASELINK))))->access_binfo)
= base;
1420 tree decl_binfo
1421 = lookup_base (base, BINFO_TYPE (BASELINK_BINFO (decl))((contains_struct_check (((tree_check (((((struct tree_baselink
*) (tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1421, __FUNCTION__, (BASELINK))))->binfo)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1421, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1421, __FUNCTION__))->typed.type)
,
1422 ba_unique, NULL__null, tf_none);
1423 if (decl_binfo && decl_binfo != error_mark_nodeglobal_trees[TI_ERROR_MARK])
1424 BASELINK_BINFO (decl)(((struct tree_baselink*) (tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1424, __FUNCTION__, (BASELINK))))->binfo)
= decl_binfo;
1425 }
1426 }
1427
1428 if (BASELINK_P (decl)(((enum tree_code) (decl)->base.code) == BASELINK))
1429 BASELINK_QUALIFIED_P (decl)((tree_not_check2 (((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1429, __FUNCTION__, (BASELINK)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1429, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
= true;
1430
1431 return decl;
1432}
1433
1434
1435/* Walk the class hierarchy within BINFO, in a depth-first traversal.
1436 PRE_FN is called in preorder, while POST_FN is called in postorder.
1437 If PRE_FN returns DFS_SKIP_BASES, child binfos will not be
1438 walked. If PRE_FN or POST_FN returns a different non-NULL value,
1439 that value is immediately returned and the walk is terminated. One
1440 of PRE_FN and POST_FN can be NULL. At each node, PRE_FN and
1441 POST_FN are passed the binfo to examine and the caller's DATA
1442 value. All paths are walked, thus virtual and morally virtual
1443 binfos can be multiply walked. */
1444
1445tree
1446dfs_walk_all (tree binfo, tree (*pre_fn) (tree, void *),
1447 tree (*post_fn) (tree, void *), void *data)
1448{
1449 tree rval;
1450 unsigned ix;
1451 tree base_binfo;
1452
1453 /* Call the pre-order walking function. */
1454 if (pre_fn)
1455 {
1456 rval = pre_fn (binfo, data);
1457 if (rval)
1458 {
1459 if (rval == dfs_skip_bases((tree)1))
1460 goto skip_bases;
1461 return rval;
1462 }
1463 }
1464
1465 /* Find the next child binfo to walk. */
1466 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1466, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((ix), &(base_binfo)))
; ix++)
1467 {
1468 rval = dfs_walk_all (base_binfo, pre_fn, post_fn, data);
1469 if (rval)
1470 return rval;
1471 }
1472
1473 skip_bases:
1474 /* Call the post-order walking function. */
1475 if (post_fn)
1476 {
1477 rval = post_fn (binfo, data);
1478 gcc_assert (rval != dfs_skip_bases)((void)(!(rval != ((tree)1)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1478, __FUNCTION__), 0 : 0))
;
1479 return rval;
1480 }
1481
1482 return NULL_TREE(tree) __null;
1483}
1484
1485/* Worker for dfs_walk_once. This behaves as dfs_walk_all, except
1486 that binfos are walked at most once. */
1487
1488static tree
1489dfs_walk_once_r (tree binfo, tree (*pre_fn) (tree, void *),
1490 tree (*post_fn) (tree, void *), hash_set<tree> *pset,
1491 void *data)
1492{
1493 tree rval;
1494 unsigned ix;
1495 tree base_binfo;
1496
1497 /* Call the pre-order walking function. */
1498 if (pre_fn
18.1
'pre_fn' is null
18.1
'pre_fn' is null
18.1
'pre_fn' is null
)
19
Taking false branch
1499 {
1500 rval = pre_fn (binfo, data);
1501 if (rval)
1502 {
1503 if (rval == dfs_skip_bases((tree)1))
1504 goto skip_bases;
1505
1506 return rval;
1507 }
1508 }
1509
1510 /* Find the next child binfo to walk. */
1511 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1511, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((ix), &(base_binfo)))
; ix++)
20
Calling 'tree_check'
24
Returning from 'tree_check'
25
Loop condition is false. Execution continues on line 1524
1512 {
1513 if (BINFO_VIRTUAL_P (base_binfo)((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1513, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
1514 if (pset->add (base_binfo))
1515 continue;
1516
1517 rval = dfs_walk_once_r (base_binfo, pre_fn, post_fn, pset, data);
1518 if (rval)
1519 return rval;
1520 }
1521
1522 skip_bases:
1523 /* Call the post-order walking function. */
1524 if (post_fn
25.1
'post_fn' is non-null
25.1
'post_fn' is non-null
25.1
'post_fn' is non-null
)
26
Taking true branch
1525 {
1526 rval = post_fn (binfo, data);
27
Calling 'dfs_get_pure_virtuals'
1527 gcc_assert (rval != dfs_skip_bases)((void)(!(rval != ((tree)1)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1527, __FUNCTION__), 0 : 0))
;
1528 return rval;
1529 }
1530
1531 return NULL_TREE(tree) __null;
1532}
1533
1534/* Like dfs_walk_all, except that binfos are not multiply walked. For
1535 non-diamond shaped hierarchies this is the same as dfs_walk_all.
1536 For diamond shaped hierarchies we must mark the virtual bases, to
1537 avoid multiple walks. */
1538
1539tree
1540dfs_walk_once (tree binfo, tree (*pre_fn) (tree, void *),
1541 tree (*post_fn) (tree, void *), void *data)
1542{
1543 static int active = 0; /* We must not be called recursively. */
1544 tree rval;
1545
1546 gcc_assert (pre_fn || post_fn)((void)(!(pre_fn || post_fn) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1546, __FUNCTION__), 0 : 0))
;
2
'?' condition is false
1547 gcc_assert (!active)((void)(!(!active) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1547, __FUNCTION__), 0 : 0))
;
3
'?' condition is false
1548 active++;
1549
1550 if (!CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo))((((tree_class_check ((((contains_struct_check (((tree_check (
(binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1550, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1550, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1550, __FUNCTION__))->type_with_lang_specific.lang_specific
))->diamond_shaped)
)
4
Calling 'tree_check'
9
Returning from 'tree_check'
10
Calling 'contains_struct_check'
15
Returning from 'contains_struct_check'
16
Assuming field 'diamond_shaped' is not equal to 0
17
Taking false branch
1551 /* We are not diamond shaped, and therefore cannot encounter the
1552 same binfo twice. */
1553 rval = dfs_walk_all (binfo, pre_fn, post_fn, data);
1554 else
1555 {
1556 hash_set<tree> pset;
1557 rval = dfs_walk_once_r (binfo, pre_fn, post_fn, &pset, data);
18
Calling 'dfs_walk_once_r'
1558 }
1559
1560 active--;
1561
1562 return rval;
1563}
1564
1565/* Worker function for dfs_walk_once_accessible. Behaves like
1566 dfs_walk_once_r, except (a) FRIENDS_P is true if special
1567 access given by the current context should be considered, (b) ONCE
1568 indicates whether bases should be marked during traversal. */
1569
1570static tree
1571dfs_walk_once_accessible_r (tree binfo, bool friends_p, hash_set<tree> *pset,
1572 tree (*pre_fn) (tree, void *),
1573 tree (*post_fn) (tree, void *), void *data)
1574{
1575 tree rval = NULL_TREE(tree) __null;
1576 unsigned ix;
1577 tree base_binfo;
1578
1579 /* Call the pre-order walking function. */
1580 if (pre_fn)
1581 {
1582 rval = pre_fn (binfo, data);
1583 if (rval)
1584 {
1585 if (rval == dfs_skip_bases((tree)1))
1586 goto skip_bases;
1587
1588 return rval;
1589 }
1590 }
1591
1592 /* Find the next child binfo to walk. */
1593 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1593, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((ix), &(base_binfo)))
; ix++)
1594 {
1595 bool mark = pset && BINFO_VIRTUAL_P (base_binfo)((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1595, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
;
1596
1597 if (mark && pset->contains (base_binfo))
1598 continue;
1599
1600 /* If the base is inherited via private or protected
1601 inheritance, then we can't see it, unless we are a friend of
1602 the current binfo. */
1603 if (BINFO_BASE_ACCESS (binfo, ix)(*((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1603, __FUNCTION__, (TREE_BINFO)))->binfo.base_accesses)
)[(ix)]
!= access_public_nodeglobal_trees[TI_PUBLIC])
1604 {
1605 tree scope;
1606 if (!friends_p)
1607 continue;
1608 scope = current_scope ();
1609 if (!scope
1610 || TREE_CODE (scope)((enum tree_code) (scope)->base.code) == NAMESPACE_DECL
1611 || !is_friend (BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1611, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1611, __FUNCTION__))->typed.type)
, scope))
1612 continue;
1613 }
1614
1615 if (mark)
1616 pset->add (base_binfo);
1617
1618 rval = dfs_walk_once_accessible_r (base_binfo, friends_p, pset,
1619 pre_fn, post_fn, data);
1620 if (rval)
1621 return rval;
1622 }
1623
1624 skip_bases:
1625 /* Call the post-order walking function. */
1626 if (post_fn)
1627 {
1628 rval = post_fn (binfo, data);
1629 gcc_assert (rval != dfs_skip_bases)((void)(!(rval != ((tree)1)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1629, __FUNCTION__), 0 : 0))
;
1630 return rval;
1631 }
1632
1633 return NULL_TREE(tree) __null;
1634}
1635
1636/* Like dfs_walk_once except that only accessible bases are walked.
1637 FRIENDS_P indicates whether friendship of the local context
1638 should be considered when determining accessibility. */
1639
1640static tree
1641dfs_walk_once_accessible (tree binfo, bool friends_p,
1642 tree (*pre_fn) (tree, void *),
1643 tree (*post_fn) (tree, void *), void *data)
1644{
1645 hash_set<tree> *pset = NULL__null;
1646 if (CLASSTYPE_DIAMOND_SHAPED_P (BINFO_TYPE (binfo))((((tree_class_check ((((contains_struct_check (((tree_check (
(binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1646, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1646, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1646, __FUNCTION__))->type_with_lang_specific.lang_specific
))->diamond_shaped)
)
1647 pset = new hash_set<tree>;
1648 tree rval = dfs_walk_once_accessible_r (binfo, friends_p, pset,
1649 pre_fn, post_fn, data);
1650
1651 if (pset)
1652 delete pset;
1653 return rval;
1654}
1655
1656/* Return true iff the code of T is CODE, and it has compatible
1657 type with TYPE. */
1658
1659static bool
1660matches_code_and_type_p (tree t, enum tree_code code, tree type)
1661{
1662 if (TREE_CODE (t)((enum tree_code) (t)->base.code) != code)
1663 return false;
1664 if (!cxx_types_compatible_p (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1664, __FUNCTION__))->typed.type)
, type))
1665 return false;
1666 return true;
1667}
1668
1669/* Subroutine of direct_accessor_p and reference_accessor_p.
1670 Determine if COMPONENT_REF is a simple field lookup of this->FIELD_DECL.
1671 We expect a tree of the form:
1672 <component_ref:
1673 <indirect_ref:S>
1674 <nop_expr:P*
1675 <parm_decl (this)>
1676 <field_decl (FIELD_DECL)>>>. */
1677
1678static bool
1679field_access_p (tree component_ref, tree field_decl, tree field_type)
1680{
1681 if (!matches_code_and_type_p (component_ref, COMPONENT_REF, field_type))
1682 return false;
1683
1684 tree indirect_ref = TREE_OPERAND (component_ref, 0)(*((const_cast<tree*> (tree_operand_check ((component_ref
), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1684, __FUNCTION__)))))
;
1685 if (!INDIRECT_REF_P (indirect_ref)(((enum tree_code) (indirect_ref)->base.code) == INDIRECT_REF
)
)
1686 return false;
1687
1688 tree ptr = STRIP_NOPS (TREE_OPERAND (indirect_ref, 0))((*((const_cast<tree*> (tree_operand_check ((indirect_ref
), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1688, __FUNCTION__)))))) = tree_strip_nop_conversions ((const_cast
<union tree_node *> ((((*((const_cast<tree*> (tree_operand_check
((indirect_ref), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1688, __FUNCTION__))))))))))
;
1689 if (!is_this_parameter (ptr))
1690 return false;
1691
1692 /* Must access the correct field. */
1693 if (TREE_OPERAND (component_ref, 1)(*((const_cast<tree*> (tree_operand_check ((component_ref
), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1693, __FUNCTION__)))))
!= field_decl)
1694 return false;
1695 return true;
1696}
1697
1698/* Subroutine of field_accessor_p.
1699
1700 Assuming that INIT_EXPR has already had its code and type checked,
1701 determine if it is a simple accessor for FIELD_DECL
1702 (of type FIELD_TYPE).
1703
1704 Specifically, a simple accessor within struct S of the form:
1705 T get_field () { return m_field; }
1706 should have a constexpr_fn_retval (saved_tree) of the form:
1707 <init_expr:T
1708 <result_decl:T
1709 <nop_expr:T
1710 <component_ref:
1711 <indirect_ref:S>
1712 <nop_expr:P*
1713 <parm_decl (this)>
1714 <field_decl (FIELD_DECL)>>>>>. */
1715
1716static bool
1717direct_accessor_p (tree init_expr, tree field_decl, tree field_type)
1718{
1719 tree result_decl = TREE_OPERAND (init_expr, 0)(*((const_cast<tree*> (tree_operand_check ((init_expr),
(0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1719, __FUNCTION__)))))
;
1720 if (!matches_code_and_type_p (result_decl, RESULT_DECL, field_type))
1721 return false;
1722
1723 tree component_ref = STRIP_NOPS (TREE_OPERAND (init_expr, 1))((*((const_cast<tree*> (tree_operand_check ((init_expr)
, (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1723, __FUNCTION__)))))) = tree_strip_nop_conversions ((const_cast
<union tree_node *> ((((*((const_cast<tree*> (tree_operand_check
((init_expr), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1723, __FUNCTION__))))))))))
;
1724 if (!field_access_p (component_ref, field_decl, field_type))
1725 return false;
1726
1727 return true;
1728}
1729
1730/* Subroutine of field_accessor_p.
1731
1732 Assuming that INIT_EXPR has already had its code and type checked,
1733 determine if it is a "reference" accessor for FIELD_DECL
1734 (of type FIELD_REFERENCE_TYPE).
1735
1736 Specifically, a simple accessor within struct S of the form:
1737 T& get_field () { return m_field; }
1738 should have a constexpr_fn_retval (saved_tree) of the form:
1739 <init_expr:T&
1740 <result_decl:T&
1741 <nop_expr: T&
1742 <addr_expr: T*
1743 <component_ref:T
1744 <indirect_ref:S
1745 <nop_expr
1746 <parm_decl (this)>>
1747 <field (FIELD_DECL)>>>>>>. */
1748static bool
1749reference_accessor_p (tree init_expr, tree field_decl, tree field_type,
1750 tree field_reference_type)
1751{
1752 tree result_decl = TREE_OPERAND (init_expr, 0)(*((const_cast<tree*> (tree_operand_check ((init_expr),
(0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1752, __FUNCTION__)))))
;
1753 if (!matches_code_and_type_p (result_decl, RESULT_DECL, field_reference_type))
1754 return false;
1755
1756 tree field_pointer_type = build_pointer_type (field_type);
1757 tree addr_expr = STRIP_NOPS (TREE_OPERAND (init_expr, 1))((*((const_cast<tree*> (tree_operand_check ((init_expr)
, (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1757, __FUNCTION__)))))) = tree_strip_nop_conversions ((const_cast
<union tree_node *> ((((*((const_cast<tree*> (tree_operand_check
((init_expr), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1757, __FUNCTION__))))))))))
;
1758 if (!matches_code_and_type_p (addr_expr, ADDR_EXPR, field_pointer_type))
1759 return false;
1760
1761 tree component_ref = STRIP_NOPS (TREE_OPERAND (addr_expr, 0))((*((const_cast<tree*> (tree_operand_check ((addr_expr)
, (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1761, __FUNCTION__)))))) = tree_strip_nop_conversions ((const_cast
<union tree_node *> ((((*((const_cast<tree*> (tree_operand_check
((addr_expr), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1761, __FUNCTION__))))))))))
;
1762
1763 if (!field_access_p (component_ref, field_decl, field_type))
1764 return false;
1765
1766 return true;
1767}
1768
1769/* Return true if FN is an accessor method for FIELD_DECL.
1770 i.e. a method of the form { return FIELD; }, with no
1771 conversions.
1772
1773 If CONST_P, then additionally require that FN be a const
1774 method. */
1775
1776static bool
1777field_accessor_p (tree fn, tree field_decl, bool const_p)
1778{
1779 if (TREE_CODE (fn)((enum tree_code) (fn)->base.code) != FUNCTION_DECL)
1780 return false;
1781
1782 /* We don't yet support looking up static data, just fields. */
1783 if (TREE_CODE (field_decl)((enum tree_code) (field_decl)->base.code) != FIELD_DECL)
1784 return false;
1785
1786 tree fntype = TREE_TYPE (fn)((contains_struct_check ((fn), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1786, __FUNCTION__))->typed.type)
;
1787 if (TREE_CODE (fntype)((enum tree_code) (fntype)->base.code) != METHOD_TYPE)
1788 return false;
1789
1790 /* If the field is accessed via a const "this" argument, verify
1791 that the "this" parameter is const. */
1792 if (const_p)
1793 {
1794 tree this_class = class_of_this_parm (fntype);
1795 if (!TYPE_READONLY (this_class)((tree_class_check ((this_class), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1795, __FUNCTION__))->base.readonly_flag)
)
1796 return false;
1797 }
1798
1799 tree saved_tree = DECL_SAVED_TREE (fn)((tree_check ((fn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1799, __FUNCTION__, (FUNCTION_DECL)))->function_decl.saved_tree
)
;
1800
1801 if (saved_tree == NULL_TREE(tree) __null)
1802 return false;
1803
1804 /* Attempt to extract a single return value from the function,
1805 if it has one. */
1806 tree retval = constexpr_fn_retval (saved_tree);
1807 if (retval == NULL_TREE(tree) __null || retval == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1808 return false;
1809 /* Require an INIT_EXPR. */
1810 if (TREE_CODE (retval)((enum tree_code) (retval)->base.code) != INIT_EXPR)
1811 return false;
1812 tree init_expr = retval;
1813
1814 /* Determine if this is a simple accessor within struct S of the form:
1815 T get_field () { return m_field; }. */
1816 tree field_type = TREE_TYPE (field_decl)((contains_struct_check ((field_decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1816, __FUNCTION__))->typed.type)
;
1817 if (cxx_types_compatible_p (TREE_TYPE (init_expr)((contains_struct_check ((init_expr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1817, __FUNCTION__))->typed.type)
, field_type))
1818 return direct_accessor_p (init_expr, field_decl, field_type);
1819
1820 /* Failing that, determine if it is an accessor of the form:
1821 T& get_field () { return m_field; }. */
1822 tree field_reference_type = cp_build_reference_type (field_type, false);
1823 if (cxx_types_compatible_p (TREE_TYPE (init_expr)((contains_struct_check ((init_expr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1823, __FUNCTION__))->typed.type)
, field_reference_type))
1824 return reference_accessor_p (init_expr, field_decl, field_type,
1825 field_reference_type);
1826
1827 return false;
1828}
1829
1830/* Callback data for dfs_locate_field_accessor_pre. */
1831
1832class locate_field_data
1833{
1834public:
1835 locate_field_data (tree field_decl_, bool const_p_)
1836 : field_decl (field_decl_), const_p (const_p_) {}
1837
1838 tree field_decl;
1839 bool const_p;
1840};
1841
1842/* Return a FUNCTION_DECL that is an "accessor" method for DATA, a FIELD_DECL,
1843 callable via binfo, if one exists, otherwise return NULL_TREE.
1844
1845 Callback for dfs_walk_once_accessible for use within
1846 locate_field_accessor. */
1847
1848static tree
1849dfs_locate_field_accessor_pre (tree binfo, void *data)
1850{
1851 locate_field_data *lfd = (locate_field_data *)data;
1852 tree type = BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1852, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1852, __FUNCTION__))->typed.type)
;
1853
1854 vec<tree, va_gc> *member_vec;
1855 tree fn;
1856 size_t i;
1857
1858 if (!CLASS_TYPE_P (type)(((((enum tree_code) (type)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1858, __FUNCTION__))->type_common.lang_flag_5))
)
1859 return NULL_TREE(tree) __null;
1860
1861 member_vec = CLASSTYPE_MEMBER_VEC (type)((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1861, __FUNCTION__))->type_with_lang_specific.lang_specific
))->members)
;
1862 if (!member_vec)
1863 return NULL_TREE(tree) __null;
1864
1865 for (i = 0; vec_safe_iterate (member_vec, i, &fn); ++i)
1866 if (fn)
1867 if (field_accessor_p (fn, lfd->field_decl, lfd->const_p))
1868 return fn;
1869
1870 return NULL_TREE(tree) __null;
1871}
1872
1873/* Return a FUNCTION_DECL that is an "accessor" method for FIELD_DECL,
1874 callable via BASETYPE_PATH, if one exists, otherwise return NULL_TREE. */
1875
1876tree
1877locate_field_accessor (tree basetype_path, tree field_decl, bool const_p)
1878{
1879 if (TREE_CODE (basetype_path)((enum tree_code) (basetype_path)->base.code) != TREE_BINFO)
1880 return NULL_TREE(tree) __null;
1881
1882 /* Walk the hierarchy, looking for a method of some base class that allows
1883 access to the field. */
1884 locate_field_data lfd (field_decl, const_p);
1885 return dfs_walk_once_accessible (basetype_path, /*friends=*/true,
1886 dfs_locate_field_accessor_pre,
1887 NULL__null, &lfd);
1888}
1889
1890/* Check throw specifier of OVERRIDER is at least as strict as
1891 the one of BASEFN. */
1892
1893bool
1894maybe_check_overriding_exception_spec (tree overrider, tree basefn)
1895{
1896 maybe_instantiate_noexcept (basefn);
1897 maybe_instantiate_noexcept (overrider);
1898 tree base_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (basefn))((tree_class_check (((tree_check2 ((((contains_struct_check (
(basefn), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1898, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1898, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1898, __FUNCTION__))->type_non_common.lang_1)
;
1899 tree over_throw = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (overrider))((tree_class_check (((tree_check2 ((((contains_struct_check (
(overrider), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1899, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1899, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1899, __FUNCTION__))->type_non_common.lang_1)
;
1900
1901 if (DECL_INVALID_OVERRIDER_P (overrider)(((contains_struct_check ((overrider), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1901, __FUNCTION__))->decl_common.lang_flag_4))
)
1902 return true;
1903
1904 /* Can't check this yet. Pretend this is fine and let
1905 noexcept_override_late_checks check this later. */
1906 if (UNPARSED_NOEXCEPT_SPEC_P (base_throw)((base_throw) && (((tree_check ((base_throw), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1906, __FUNCTION__, (TREE_LIST)))->list.purpose)) &&
(((enum tree_code) (((tree_check ((base_throw), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1906, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code) == DEFERRED_PARSE))
1907 || UNPARSED_NOEXCEPT_SPEC_P (over_throw)((over_throw) && (((tree_check ((over_throw), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1907, __FUNCTION__, (TREE_LIST)))->list.purpose)) &&
(((enum tree_code) (((tree_check ((over_throw), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1907, __FUNCTION__, (TREE_LIST)))->list.purpose))->base
.code) == DEFERRED_PARSE))
)
1908 return true;
1909
1910 if (!comp_except_specs (base_throw, over_throw, ce_derived))
1911 {
1912 auto_diagnostic_group d;
1913 error ("looser exception specification on overriding virtual function "
1914 "%q+#F", overrider);
1915 inform (DECL_SOURCE_LOCATION (basefn)((contains_struct_check ((basefn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1915, __FUNCTION__))->decl_minimal.locus)
,
1916 "overridden function is %q#F", basefn);
1917 DECL_INVALID_OVERRIDER_P (overrider)(((contains_struct_check ((overrider), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1917, __FUNCTION__))->decl_common.lang_flag_4))
= 1;
1918 return false;
1919 }
1920 return true;
1921}
1922
1923/* Check that virtual overrider OVERRIDER is acceptable for base function
1924 BASEFN. Issue diagnostic, and return zero, if unacceptable. */
1925
1926static int
1927check_final_overrider (tree overrider, tree basefn)
1928{
1929 tree over_type = TREE_TYPE (overrider)((contains_struct_check ((overrider), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1929, __FUNCTION__))->typed.type)
;
1930 tree base_type = TREE_TYPE (basefn)((contains_struct_check ((basefn), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1930, __FUNCTION__))->typed.type)
;
1931 tree over_return = fndecl_declared_return_type (overrider);
1932 tree base_return = fndecl_declared_return_type (basefn);
1933
1934 int fail = 0;
1935
1936 if (DECL_INVALID_OVERRIDER_P (overrider)(((contains_struct_check ((overrider), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1936, __FUNCTION__))->decl_common.lang_flag_4))
)
1937 return 0;
1938
1939 if (same_type_p (base_return, over_return)comptypes ((base_return), (over_return), 0))
1940 /* OK */;
1941 else if ((CLASS_TYPE_P (over_return)(((((enum tree_code) (over_return)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (over_return)->base.code)) == UNION_TYPE
) && ((tree_class_check ((over_return), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1941, __FUNCTION__))->type_common.lang_flag_5))
&& CLASS_TYPE_P (base_return)(((((enum tree_code) (base_return)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (base_return)->base.code)) == UNION_TYPE
) && ((tree_class_check ((base_return), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1941, __FUNCTION__))->type_common.lang_flag_5))
)
1942 || (TREE_CODE (base_return)((enum tree_code) (base_return)->base.code) == TREE_CODE (over_return)((enum tree_code) (over_return)->base.code)
1943 && INDIRECT_TYPE_P (base_return)((((enum tree_code) (base_return)->base.code) == POINTER_TYPE
) || (((enum tree_code) (base_return)->base.code) == REFERENCE_TYPE
))
))
1944 {
1945 /* Potentially covariant. */
1946 unsigned base_quals, over_quals;
1947
1948 fail = !INDIRECT_TYPE_P (base_return)((((enum tree_code) (base_return)->base.code) == POINTER_TYPE
) || (((enum tree_code) (base_return)->base.code) == REFERENCE_TYPE
))
;
1949 if (!fail)
1950 {
1951 if (cp_type_quals (base_return) != cp_type_quals (over_return))
1952 fail = 1;
1953
1954 if (TYPE_REF_P (base_return)(((enum tree_code) (base_return)->base.code) == REFERENCE_TYPE
)
1955 && (TYPE_REF_IS_RVALUE (base_return)((tree_check ((base_return), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1955, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
)
1956 != TYPE_REF_IS_RVALUE (over_return)((tree_check ((over_return), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1956, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
)
))
1957 fail = 1;
1958
1959 base_return = TREE_TYPE (base_return)((contains_struct_check ((base_return), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1959, __FUNCTION__))->typed.type)
;
1960 over_return = TREE_TYPE (over_return)((contains_struct_check ((over_return), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1960, __FUNCTION__))->typed.type)
;
1961 }
1962 base_quals = cp_type_quals (base_return);
1963 over_quals = cp_type_quals (over_return);
1964
1965 if ((base_quals & over_quals) != over_quals)
1966 fail = 1;
1967
1968 if (CLASS_TYPE_P (base_return)(((((enum tree_code) (base_return)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (base_return)->base.code)) == UNION_TYPE
) && ((tree_class_check ((base_return), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1968, __FUNCTION__))->type_common.lang_flag_5))
&& CLASS_TYPE_P (over_return)(((((enum tree_code) (over_return)->base.code)) == RECORD_TYPE
|| (((enum tree_code) (over_return)->base.code)) == UNION_TYPE
) && ((tree_class_check ((over_return), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1968, __FUNCTION__))->type_common.lang_flag_5))
)
1969 {
1970 /* Strictly speaking, the standard requires the return type to be
1971 complete even if it only differs in cv-quals, but that seems
1972 like a bug in the wording. */
1973 if (!same_type_ignoring_top_level_qualifiers_p (base_return,
1974 over_return))
1975 {
1976 tree binfo = lookup_base (over_return, base_return,
1977 ba_check, NULL__null, tf_none);
1978
1979 if (!binfo || binfo == error_mark_nodeglobal_trees[TI_ERROR_MARK])
1980 fail = 1;
1981 }
1982 }
1983 else if (can_convert_standard (TREE_TYPE (base_type)((contains_struct_check ((base_type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1983, __FUNCTION__))->typed.type)
,
1984 TREE_TYPE (over_type)((contains_struct_check ((over_type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1984, __FUNCTION__))->typed.type)
,
1985 tf_warning_or_error))
1986 /* GNU extension, allow trivial pointer conversions such as
1987 converting to void *, or qualification conversion. */
1988 {
1989 auto_diagnostic_group d;
1990 if (pedwarn (DECL_SOURCE_LOCATION (overrider)((contains_struct_check ((overrider), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1990, __FUNCTION__))->decl_minimal.locus)
, 0,
1991 "invalid covariant return type for %q#D", overrider))
1992 inform (DECL_SOURCE_LOCATION (basefn)((contains_struct_check ((basefn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 1992, __FUNCTION__))->decl_minimal.locus)
,
1993 "overridden function is %q#D", basefn);
1994 }
1995 else
1996 fail = 2;
1997 }
1998 else
1999 fail = 2;
2000 if (!fail)
2001 /* OK */;
2002 else
2003 {
2004 auto_diagnostic_group d;
2005 if (fail == 1)
2006 error ("invalid covariant return type for %q+#D", overrider);
2007 else
2008 error ("conflicting return type specified for %q+#D", overrider);
2009 inform (DECL_SOURCE_LOCATION (basefn)((contains_struct_check ((basefn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2009, __FUNCTION__))->decl_minimal.locus)
,
2010 "overridden function is %q#D", basefn);
2011 DECL_INVALID_OVERRIDER_P (overrider)(((contains_struct_check ((overrider), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2011, __FUNCTION__))->decl_common.lang_flag_4))
= 1;
2012 return 0;
2013 }
2014
2015 if (!maybe_check_overriding_exception_spec (overrider, basefn))
2016 return 0;
2017
2018 /* Check for conflicting type attributes. But leave transaction_safe for
2019 set_one_vmethod_tm_attributes. */
2020 if (!comp_type_attributes (over_type, base_type)
2021 && !tx_safe_fn_type_p (base_type)
2022 && !tx_safe_fn_type_p (over_type))
2023 {
2024 auto_diagnostic_group d;
2025 error ("conflicting type attributes specified for %q+#D", overrider);
2026 inform (DECL_SOURCE_LOCATION (basefn)((contains_struct_check ((basefn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2026, __FUNCTION__))->decl_minimal.locus)
,
2027 "overridden function is %q#D", basefn);
2028 DECL_INVALID_OVERRIDER_P (overrider)(((contains_struct_check ((overrider), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2028, __FUNCTION__))->decl_common.lang_flag_4))
= 1;
2029 return 0;
2030 }
2031
2032 /* A consteval virtual function shall not override a virtual function that is
2033 not consteval. A consteval virtual function shall not be overridden by a
2034 virtual function that is not consteval. */
2035 if (DECL_IMMEDIATE_FUNCTION_P (overrider)(((contains_struct_check (((tree_check (((((enum tree_code) (
overrider)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((overrider
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2035, __FUNCTION__, (TEMPLATE_DECL))))))))->result : overrider
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2035, __FUNCTION__, (FUNCTION_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2035, __FUNCTION__))->decl_common.lang_specific) ? __extension__
({ struct lang_decl *lt = ((contains_struct_check (((((enum tree_code
) (overrider)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((overrider
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2035, __FUNCTION__, (TEMPLATE_DECL))))))))->result : overrider
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2035, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (overrider)->base.code) == FUNCTION_DECL
|| (((enum tree_code) (overrider)->base.code) == TEMPLATE_DECL
&& ((struct tree_template_decl *)(const_cast<union
tree_node *> ((((tree_check ((overrider), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2035, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((overrider
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2035, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2035, __FUNCTION__); &lt->u.fn; })->immediate_fn_p
: false)
2036 != DECL_IMMEDIATE_FUNCTION_P (basefn)(((contains_struct_check (((tree_check (((((enum tree_code) (
basefn)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((basefn
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2036, __FUNCTION__, (TEMPLATE_DECL))))))))->result : basefn
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2036, __FUNCTION__, (FUNCTION_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2036, __FUNCTION__))->decl_common.lang_specific) ? __extension__
({ struct lang_decl *lt = ((contains_struct_check (((((enum tree_code
) (basefn)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((basefn
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2036, __FUNCTION__, (TEMPLATE_DECL))))))))->result : basefn
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2036, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (basefn)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (basefn)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((basefn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2036, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((basefn
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2036, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2036, __FUNCTION__); &lt->u.fn; })->immediate_fn_p
: false)
)
2037 {
2038 auto_diagnostic_group d;
2039 if (DECL_IMMEDIATE_FUNCTION_P (overrider)(((contains_struct_check (((tree_check (((((enum tree_code) (
overrider)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((overrider
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2039, __FUNCTION__, (TEMPLATE_DECL))))))))->result : overrider
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2039, __FUNCTION__, (FUNCTION_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2039, __FUNCTION__))->decl_common.lang_specific) ? __extension__
({ struct lang_decl *lt = ((contains_struct_check (((((enum tree_code
) (overrider)->base.code) == TEMPLATE_DECL ? ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((overrider
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2039, __FUNCTION__, (TEMPLATE_DECL))))))))->result : overrider
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2039, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (overrider)->base.code) == FUNCTION_DECL
|| (((enum tree_code) (overrider)->base.code) == TEMPLATE_DECL
&& ((struct tree_template_decl *)(const_cast<union
tree_node *> ((((tree_check ((overrider), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2039, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((overrider
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2039, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2039, __FUNCTION__); &lt->u.fn; })->immediate_fn_p
: false)
)
2040 error ("%<consteval%> function %q+D overriding non-%<consteval%> "
2041 "function", overrider);
2042 else
2043 error ("non-%<consteval%> function %q+D overriding %<consteval%> "
2044 "function", overrider);
2045 inform (DECL_SOURCE_LOCATION (basefn)((contains_struct_check ((basefn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2045, __FUNCTION__))->decl_minimal.locus)
,
2046 "overridden function is %qD", basefn);
2047 DECL_INVALID_OVERRIDER_P (overrider)(((contains_struct_check ((overrider), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2047, __FUNCTION__))->decl_common.lang_flag_4))
= 1;
2048 return 0;
2049 }
2050
2051 /* A function declared transaction_safe_dynamic that overrides a function
2052 declared transaction_safe (but not transaction_safe_dynamic) is
2053 ill-formed. */
2054 if (tx_safe_fn_type_p (base_type)
2055 && lookup_attribute ("transaction_safe_dynamic",
2056 DECL_ATTRIBUTES (overrider)((contains_struct_check ((overrider), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2056, __FUNCTION__))->decl_common.attributes)
)
2057 && !lookup_attribute ("transaction_safe_dynamic",
2058 DECL_ATTRIBUTES (basefn)((contains_struct_check ((basefn), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2058, __FUNCTION__))->decl_common.attributes)
))
2059 {
2060 auto_diagnostic_group d;
2061 error_at (DECL_SOURCE_LOCATION (overrider)((contains_struct_check ((overrider), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2061, __FUNCTION__))->decl_minimal.locus)
,
2062 "%qD declared %<transaction_safe_dynamic%>", overrider);
2063 inform (DECL_SOURCE_LOCATION (basefn)((contains_struct_check ((basefn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2063, __FUNCTION__))->decl_minimal.locus)
,
2064 "overriding %qD declared %<transaction_safe%>", basefn);
2065 }
2066
2067 if (DECL_DELETED_FN (basefn)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (basefn)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((basefn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__, (TEMPLATE_DECL))))))))->result : basefn
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (basefn)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (basefn)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((basefn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((basefn
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__); &lt->u.fn; })->min.base.threadprivate_or_deleted_p
)
!= DECL_DELETED_FN (overrider)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (overrider)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((overrider), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__, (TEMPLATE_DECL))))))))->result : overrider
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (overrider)->base.code) == FUNCTION_DECL
|| (((enum tree_code) (overrider)->base.code) == TEMPLATE_DECL
&& ((struct tree_template_decl *)(const_cast<union
tree_node *> ((((tree_check ((overrider), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((overrider
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2067, __FUNCTION__); &lt->u.fn; })->min.base.threadprivate_or_deleted_p
)
)
2068 {
2069 if (DECL_DELETED_FN (overrider)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (overrider)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((overrider), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2069, __FUNCTION__, (TEMPLATE_DECL))))))))->result : overrider
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2069, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (overrider)->base.code) == FUNCTION_DECL
|| (((enum tree_code) (overrider)->base.code) == TEMPLATE_DECL
&& ((struct tree_template_decl *)(const_cast<union
tree_node *> ((((tree_check ((overrider), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2069, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((overrider
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2069, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2069, __FUNCTION__); &lt->u.fn; })->min.base.threadprivate_or_deleted_p
)
)
2070 {
2071 auto_diagnostic_group d;
2072 error ("deleted function %q+D overriding non-deleted function",
2073 overrider);
2074 inform (DECL_SOURCE_LOCATION (basefn)((contains_struct_check ((basefn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2074, __FUNCTION__))->decl_minimal.locus)
,
2075 "overridden function is %qD", basefn);
2076 maybe_explain_implicit_delete (overrider);
2077 }
2078 else
2079 {
2080 auto_diagnostic_group d;
2081 error ("non-deleted function %q+D overriding deleted function",
2082 overrider);
2083 inform (DECL_SOURCE_LOCATION (basefn)((contains_struct_check ((basefn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2083, __FUNCTION__))->decl_minimal.locus)
,
2084 "overridden function is %qD", basefn);
2085 }
2086 return 0;
2087 }
2088 if (DECL_FINAL_P (basefn)((tree_check ((basefn), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2088, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.final
)
)
2089 {
2090 auto_diagnostic_group d;
2091 error ("virtual function %q+D overriding final function", overrider);
2092 inform (DECL_SOURCE_LOCATION (basefn)((contains_struct_check ((basefn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2092, __FUNCTION__))->decl_minimal.locus)
,
2093 "overridden function is %qD", basefn);
2094 return 0;
2095 }
2096 return 1;
2097}
2098
2099/* Given a class TYPE, and a function decl FNDECL, look for
2100 virtual functions in TYPE's hierarchy which FNDECL overrides.
2101 We do not look in TYPE itself, only its bases.
2102
2103 Returns nonzero, if we find any. Set FNDECL's DECL_VIRTUAL_P, if we
2104 find that it overrides anything.
2105
2106 We check that every function which is overridden, is correctly
2107 overridden. */
2108
2109int
2110look_for_overrides (tree type, tree fndecl)
2111{
2112 tree binfo = TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2112, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
;
2113 tree base_binfo;
2114 int ix;
2115 int found = 0;
2116
2117 /* A constructor for a class T does not override a function T
2118 in a base class. */
2119 if (DECL_CONSTRUCTOR_P (fndecl)((tree_check (((((enum tree_code) (fndecl)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2119, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fndecl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2119, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)
)
2120 return 0;
2121
2122 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2122, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((ix), &(base_binfo)))
; ix++)
2123 {
2124 tree basetype = BINFO_TYPE (base_binfo)((contains_struct_check (((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2124, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2124, __FUNCTION__))->typed.type)
;
2125
2126 if (TYPE_POLYMORPHIC_P (basetype)(((tree_not_check2 ((basetype), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2126, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2))
)
2127 found += look_for_overrides_r (basetype, fndecl);
2128 }
2129 return found;
2130}
2131
2132/* Look in TYPE for virtual functions with the same signature as
2133 FNDECL. */
2134
2135tree
2136look_for_overrides_here (tree type, tree fndecl)
2137{
2138 tree ovl = get_class_binding (type, DECL_NAME (fndecl)((contains_struct_check ((fndecl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2138, __FUNCTION__))->decl_minimal.name)
);
2139
2140 for (ovl_iterator iter (ovl); iter; ++iter)
2141 {
2142 tree fn = *iter;
2143
2144 if (!DECL_VIRTUAL_P (fn)((contains_struct_check ((fn), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2144, __FUNCTION__))->decl_common.virtual_flag)
)
2145 /* Not a virtual. */;
2146 else if (DECL_CONTEXT (fn)((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2146, __FUNCTION__))->decl_minimal.context)
!= type)
2147 /* Introduced with a using declaration. */;
2148 else if (DECL_STATIC_FUNCTION_P (fndecl)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (fndecl)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2148, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fndecl
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2148, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (fndecl)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (fndecl)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2148, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fndecl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2148, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2148, __FUNCTION__); &lt->u.fn; })->static_function
)
)
2149 {
2150 tree btypes = TYPE_ARG_TYPES (TREE_TYPE (fn))((tree_check2 ((((contains_struct_check ((fn), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2150, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2150, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)
;
2151 tree dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl))((tree_check2 ((((contains_struct_check ((fndecl), (TS_TYPED)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2151, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2151, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)
;
2152 if (compparms (TREE_CHAIN (btypes)((contains_struct_check ((btypes), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2152, __FUNCTION__))->common.chain)
, dtypes))
2153 return fn;
2154 }
2155 else if (same_signature_p (fndecl, fn))
2156 return fn;
2157 }
2158
2159 return NULL_TREE(tree) __null;
2160}
2161
2162/* Look in TYPE for virtual functions overridden by FNDECL. Check both
2163 TYPE itself and its bases. */
2164
2165static int
2166look_for_overrides_r (tree type, tree fndecl)
2167{
2168 tree fn = look_for_overrides_here (type, fndecl);
2169 if (fn)
2170 {
2171 if (DECL_STATIC_FUNCTION_P (fndecl)(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) (fndecl)->base.code) == TEMPLATE_DECL
? ((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2171, __FUNCTION__, (TEMPLATE_DECL))))))))->result : fndecl
)), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2171, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) (fndecl)->base.code) == FUNCTION_DECL ||
(((enum tree_code) (fndecl)->base.code) == TEMPLATE_DECL &&
((struct tree_template_decl *)(const_cast<union tree_node
*> ((((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2171, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check ((fndecl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2171, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2171, __FUNCTION__); &lt->u.fn; })->static_function
)
)
2172 {
2173 /* A static member function cannot match an inherited
2174 virtual member function. */
2175 auto_diagnostic_group d;
2176 error ("%q+#D cannot be declared", fndecl);
2177 error (" since %q+#D declared in base class", fn);
2178 }
2179 else
2180 {
2181 /* It's definitely virtual, even if not explicitly set. */
2182 DECL_VIRTUAL_P (fndecl)((contains_struct_check ((fndecl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2182, __FUNCTION__))->decl_common.virtual_flag)
= 1;
2183 check_final_overrider (fndecl, fn);
2184 }
2185 return 1;
2186 }
2187
2188 /* We failed to find one declared in this class. Look in its bases. */
2189 return look_for_overrides (type, fndecl);
2190}
2191
2192/* Called via dfs_walk from dfs_get_pure_virtuals. */
2193
2194static tree
2195dfs_get_pure_virtuals (tree binfo, void *data)
2196{
2197 tree type = (tree) data;
2198
2199 /* We're not interested in primary base classes; the derived class
2200 of which they are a primary base will contain the information we
2201 need. */
2202 if (!BINFO_PRIMARY_P (binfo)((tree_not_check2 (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2202, __FUNCTION__, (TREE_BINFO)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2202, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
)
28
Calling 'tree_check'
32
Returning from 'tree_check'
33
Calling 'tree_not_check2'
37
Returning from 'tree_not_check2'
38
Assuming field 'lang_flag_5' is 0
39
Taking true branch
2203 {
2204 tree virtuals;
2205
2206 for (virtuals = BINFO_VIRTUALS (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2206, __FUNCTION__, (TREE_BINFO)))->binfo.virtuals)
;
40
Calling 'tree_check'
43
Returning from 'tree_check'
44
Loop condition is true. Entering loop body
2207 virtuals;
2208 virtuals = TREE_CHAIN (virtuals)((contains_struct_check ((virtuals), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2208, __FUNCTION__))->common.chain)
)
2209 if (DECL_PURE_VIRTUAL_P (BV_FN (virtuals))(__extension__ ({ struct lang_decl *lt = ((contains_struct_check
(((((enum tree_code) ((((tree_check ((virtuals), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TREE_LIST)))->list.value)))->base
.code) == TEMPLATE_DECL ? ((struct tree_template_decl *)(const_cast
<union tree_node *> ((((tree_check (((((tree_check ((virtuals
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TREE_LIST)))->list.value))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TEMPLATE_DECL))))))))->result : (((
tree_check ((virtuals), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TREE_LIST)))->list.value)))), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__))->decl_common.lang_specific); if (!(
((enum tree_code) ((((tree_check ((virtuals), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TREE_LIST)))->list.value)))->base
.code) == FUNCTION_DECL || (((enum tree_code) ((((tree_check (
(virtuals), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TREE_LIST)))->list.value)))->base
.code) == TEMPLATE_DECL && ((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check (((((tree_check
((virtuals), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TREE_LIST)))->list.value))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
*)(const_cast<union tree_node *> ((((tree_check (((((tree_check
((virtuals), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TREE_LIST)))->list.value))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == FUNCTION_DECL)) || lt->u.base.selector != lds_fn
) lang_check_failed ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2209, __FUNCTION__); &lt->u.fn; })->pure_virtual)
)
45
Assuming field 'code' is not equal to TEMPLATE_DECL
46
'?' condition is false
47
Assuming field 'code' is equal to FUNCTION_DECL
48
Assuming field 'selector' is equal to lds_fn
49
Taking false branch
50
Assuming field 'pure_virtual' is not equal to 0
51
Taking true branch
2210 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (type)((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2210, __FUNCTION__))->type_with_lang_specific.lang_specific
))->pure_virtuals)
, BV_FN (virtuals)(((tree_check ((virtuals), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2210, __FUNCTION__, (TREE_LIST)))->list.value))
)
;
52
Passing value via 1st parameter 'v'
53
Calling 'vec_safe_push<tree_node *, va_gc>'
2211 }
2212
2213 return NULL_TREE(tree) __null;
2214}
2215
2216/* Set CLASSTYPE_PURE_VIRTUALS for TYPE. */
2217
2218void
2219get_pure_virtuals (tree type)
2220{
2221 /* Clear the CLASSTYPE_PURE_VIRTUALS list; whatever is already there
2222 is going to be overridden. */
2223 CLASSTYPE_PURE_VIRTUALS (type)((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2223, __FUNCTION__))->type_with_lang_specific.lang_specific
))->pure_virtuals)
= NULL__null;
2224 /* Now, run through all the bases which are not primary bases, and
2225 collect the pure virtual functions. We look at the vtable in
2226 each class to determine what pure virtual functions are present.
2227 (A primary base is not interesting because the derived class of
2228 which it is a primary base will contain vtable entries for the
2229 pure virtuals in the base class. */
2230 dfs_walk_once (TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2230, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
, NULL__null, dfs_get_pure_virtuals, type)
;
1
Calling 'dfs_walk_once'
2231}
2232
2233/* Debug info for C++ classes can get very large; try to avoid
2234 emitting it everywhere.
2235
2236 Note that this optimization wins even when the target supports
2237 BINCL (if only slightly), and reduces the amount of work for the
2238 linker. */
2239
2240void
2241maybe_suppress_debug_info (tree t)
2242{
2243 if (write_symbolsglobal_options.x_write_symbols == NO_DEBUG(0U))
2244 return;
2245
2246 /* We might have set this earlier in cp_finish_decl. */
2247 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t))((tree_check ((((((contains_struct_check (((tree_class_check (
(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2247, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2247, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2247, __FUNCTION__))->common.chain)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2247, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
= 0;
2248
2249 /* Always emit the information for each class every time. */
2250 if (flag_emit_class_debug_alwaysglobal_options.x_flag_emit_class_debug_always)
2251 return;
2252
2253 /* If we already know how we're handling this class, handle debug info
2254 the same way. */
2255 if (CLASSTYPE_INTERFACE_KNOWN (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2255, __FUNCTION__))->type_with_lang_specific.lang_specific
))->interface_unknown == 0)
)
2256 {
2257 if (CLASSTYPE_INTERFACE_ONLY (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2257, __FUNCTION__))->type_with_lang_specific.lang_specific
))->interface_only)
)
2258 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t))((tree_check ((((((contains_struct_check (((tree_class_check (
(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2258, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2258, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2258, __FUNCTION__))->common.chain)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2258, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
= 1;
2259 /* else don't set it. */
2260 }
2261 /* If the class has a vtable, write out the debug info along with
2262 the vtable. */
2263 else if (TYPE_CONTAINS_VPTR_P (t)((((tree_not_check2 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2263, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) || ((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2263, __FUNCTION__))->type_with_lang_specific.lang_specific
))->vbases))
)
2264 TYPE_DECL_SUPPRESS_DEBUG (TYPE_MAIN_DECL (t))((tree_check ((((((contains_struct_check (((tree_class_check (
(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2264, __FUNCTION__))->type_common.main_variant)), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2264, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2264, __FUNCTION__))->common.chain)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2264, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
= 1;
2265
2266 /* Otherwise, just emit the debug info normally. */
2267}
2268
2269/* Note that we want debugging information for a base class of a class
2270 whose vtable is being emitted. Normally, this would happen because
2271 calling the constructor for a derived class implies calling the
2272 constructors for all bases, which involve initializing the
2273 appropriate vptr with the vtable for the base class; but in the
2274 presence of optimization, this initialization may be optimized
2275 away, so we tell finish_vtable_vardecl that we want the debugging
2276 information anyway. */
2277
2278static tree
2279dfs_debug_mark (tree binfo, void * /*data*/)
2280{
2281 tree t = BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2281, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2281, __FUNCTION__))->typed.type)
;
2282
2283 if (CLASSTYPE_DEBUG_REQUESTED (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2283, __FUNCTION__))->type_with_lang_specific.lang_specific
))->debug_requested)
)
2284 return dfs_skip_bases((tree)1);
2285
2286 CLASSTYPE_DEBUG_REQUESTED (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2286, __FUNCTION__))->type_with_lang_specific.lang_specific
))->debug_requested)
= 1;
2287
2288 return NULL_TREE(tree) __null;
2289}
2290
2291/* Write out the debugging information for TYPE, whose vtable is being
2292 emitted. Also walk through our bases and note that we want to
2293 write out information for them. This avoids the problem of not
2294 writing any debug info for intermediate basetypes whose
2295 constructors, and thus the references to their vtables, and thus
2296 the vtables themselves, were optimized away. */
2297
2298void
2299note_debug_info_needed (tree type)
2300{
2301 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type))((tree_check ((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2301, __FUNCTION__))->type_common.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2301, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
)
2302 {
2303 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type))((tree_check ((((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2303, __FUNCTION__))->type_common.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2303, __FUNCTION__, (TYPE_DECL)))->decl_common.decl_flag_1
)
= 0;
2304 rest_of_type_compilation (type, namespace_bindings_p ());
2305 }
2306
2307 dfs_walk_all (TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2307, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
, dfs_debug_mark, NULL__null, 0);
2308}
2309
2310/* Helper for lookup_conversions_r. TO_TYPE is the type converted to
2311 by a conversion op in base BINFO. VIRTUAL_DEPTH is nonzero if
2312 BINFO is morally virtual, and VIRTUALNESS is nonzero if virtual
2313 bases have been encountered already in the tree walk. PARENT_CONVS
2314 is the list of lists of conversion functions that could hide CONV
2315 and OTHER_CONVS is the list of lists of conversion functions that
2316 could hide or be hidden by CONV, should virtualness be involved in
2317 the hierarchy. Merely checking the conversion op's name is not
2318 enough because two conversion operators to the same type can have
2319 different names. Return nonzero if we are visible. */
2320
2321static int
2322check_hidden_convs (tree binfo, int virtual_depth, int virtualness,
2323 tree to_type, tree parent_convs, tree other_convs)
2324{
2325 tree level, probe;
2326
2327 /* See if we are hidden by a parent conversion. */
2328 for (level = parent_convs; level; level = TREE_CHAIN (level)((contains_struct_check ((level), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2328, __FUNCTION__))->common.chain)
)
2329 for (probe = TREE_VALUE (level)((tree_check ((level), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2329, __FUNCTION__, (TREE_LIST)))->list.value)
; probe; probe = TREE_CHAIN (probe)((contains_struct_check ((probe), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2329, __FUNCTION__))->common.chain)
)
2330 if (same_type_p (to_type, TREE_TYPE (probe))comptypes ((to_type), (((contains_struct_check ((probe), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2330, __FUNCTION__))->typed.type)), 0)
)
2331 return 0;
2332
2333 if (virtual_depth || virtualness)
2334 {
2335 /* In a virtual hierarchy, we could be hidden, or could hide a
2336 conversion function on the other_convs list. */
2337 for (level = other_convs; level; level = TREE_CHAIN (level)((contains_struct_check ((level), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2337, __FUNCTION__))->common.chain)
)
2338 {
2339 int we_hide_them;
2340 int they_hide_us;
2341 tree *prev, other;
2342
2343 if (!(virtual_depth || TREE_STATIC (level)((level)->base.static_flag)))
2344 /* Neither is morally virtual, so cannot hide each other. */
2345 continue;
2346
2347 if (!TREE_VALUE (level)((tree_check ((level), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2347, __FUNCTION__, (TREE_LIST)))->list.value)
)
2348 /* They evaporated away already. */
2349 continue;
2350
2351 they_hide_us = (virtual_depth
2352 && original_binfo (binfo, TREE_PURPOSE (level)((tree_check ((level), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2352, __FUNCTION__, (TREE_LIST)))->list.purpose)
));
2353 we_hide_them = (!they_hide_us && TREE_STATIC (level)((level)->base.static_flag)
2354 && original_binfo (TREE_PURPOSE (level)((tree_check ((level), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2354, __FUNCTION__, (TREE_LIST)))->list.purpose)
, binfo));
2355
2356 if (!(we_hide_them || they_hide_us))
2357 /* Neither is within the other, so no hiding can occur. */
2358 continue;
2359
2360 for (prev = &TREE_VALUE (level)((tree_check ((level), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2360, __FUNCTION__, (TREE_LIST)))->list.value)
, other = *prev; other;)
2361 {
2362 if (same_type_p (to_type, TREE_TYPE (other))comptypes ((to_type), (((contains_struct_check ((other), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2362, __FUNCTION__))->typed.type)), 0)
)
2363 {
2364 if (they_hide_us)
2365 /* We are hidden. */
2366 return 0;
2367
2368 if (we_hide_them)
2369 {
2370 /* We hide the other one. */
2371 other = TREE_CHAIN (other)((contains_struct_check ((other), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2371, __FUNCTION__))->common.chain)
;
2372 *prev = other;
2373 continue;
2374 }
2375 }
2376 prev = &TREE_CHAIN (other)((contains_struct_check ((other), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2376, __FUNCTION__))->common.chain)
;
2377 other = *prev;
2378 }
2379 }
2380 }
2381 return 1;
2382}
2383
2384/* Helper for lookup_conversions_r. PARENT_CONVS is a list of lists
2385 of conversion functions, the first slot will be for the current
2386 binfo, if MY_CONVS is non-NULL. CHILD_CONVS is the list of lists
2387 of conversion functions from children of the current binfo,
2388 concatenated with conversions from elsewhere in the hierarchy --
2389 that list begins with OTHER_CONVS. Return a single list of lists
2390 containing only conversions from the current binfo and its
2391 children. */
2392
2393static tree
2394split_conversions (tree my_convs, tree parent_convs,
2395 tree child_convs, tree other_convs)
2396{
2397 tree t;
2398 tree prev;
2399
2400 /* Remove the original other_convs portion from child_convs. */
2401 for (prev = NULL__null, t = child_convs;
2402 t != other_convs; prev = t, t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2402, __FUNCTION__))->common.chain)
)
2403 continue;
2404
2405 if (prev)
2406 TREE_CHAIN (prev)((contains_struct_check ((prev), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2406, __FUNCTION__))->common.chain)
= NULL_TREE(tree) __null;
2407 else
2408 child_convs = NULL_TREE(tree) __null;
2409
2410 /* Attach the child convs to any we had at this level. */
2411 if (my_convs)
2412 {
2413 my_convs = parent_convs;
2414 TREE_CHAIN (my_convs)((contains_struct_check ((my_convs), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2414, __FUNCTION__))->common.chain)
= child_convs;
2415 }
2416 else
2417 my_convs = child_convs;
2418
2419 return my_convs;
2420}
2421
2422/* Worker for lookup_conversions. Lookup conversion functions in
2423 BINFO and its children. VIRTUAL_DEPTH is nonzero, if BINFO is in a
2424 morally virtual base, and VIRTUALNESS is nonzero, if we've
2425 encountered virtual bases already in the tree walk. PARENT_CONVS
2426 is a list of conversions within parent binfos. OTHER_CONVS are
2427 conversions found elsewhere in the tree. Return the conversions
2428 found within this portion of the graph in CONVS. Return nonzero if
2429 we encountered virtualness. We keep template and non-template
2430 conversions separate, to avoid unnecessary type comparisons.
2431
2432 The located conversion functions are held in lists of lists. The
2433 TREE_VALUE of the outer list is the list of conversion functions
2434 found in a particular binfo. The TREE_PURPOSE of both the outer
2435 and inner lists is the binfo at which those conversions were
2436 found. TREE_STATIC is set for those lists within of morally
2437 virtual binfos. The TREE_VALUE of the inner list is the conversion
2438 function or overload itself. The TREE_TYPE of each inner list node
2439 is the converted-to type. */
2440
2441static int
2442lookup_conversions_r (tree binfo, int virtual_depth, int virtualness,
2443 tree parent_convs, tree other_convs, tree *convs)
2444{
2445 int my_virtualness = 0;
2446 tree my_convs = NULL_TREE(tree) __null;
2447 tree child_convs = NULL_TREE(tree) __null;
2448
2449 /* If we have no conversion operators, then don't look. */
2450 if (!TYPE_HAS_CONVERSION (BINFO_TYPE (binfo))((((tree_class_check ((((contains_struct_check (((tree_check (
(binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2450, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2450, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2450, __FUNCTION__))->type_with_lang_specific.lang_specific
))->has_type_conversion)
)
2451 {
2452 *convs = NULL_TREE(tree) __null;
2453
2454 return 0;
2455 }
2456
2457 if (BINFO_VIRTUAL_P (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2457, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
2458 virtual_depth++;
2459
2460 /* First, locate the unhidden ones at this level. */
2461 if (tree conv = get_class_binding (BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2461, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2461, __FUNCTION__))->typed.type)
, conv_op_identifiercp_global_trees[CPTI_CONV_OP_IDENTIFIER]))
2462 for (ovl_iterator iter (conv); iter; ++iter)
2463 {
2464 tree fn = *iter;
2465 tree type = DECL_CONV_FN_TYPE (fn)((contains_struct_check (((((void)(!(((((tree_not_check2 (((tree_check
((((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((((contains_struct_check
((fn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((((contains_struct_check
((fn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__), 0 : 0)), ((contains_struct_check ((fn)
, (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__))->decl_minimal.name))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2465, __FUNCTION__))->typed.type)
;
2466
2467 if (TREE_CODE (fn)((enum tree_code) (fn)->base.code) != TEMPLATE_DECL && type_uses_auto (type))
2468 {
2469 mark_used (fn);
2470 type = DECL_CONV_FN_TYPE (fn)((contains_struct_check (((((void)(!(((((tree_not_check2 (((tree_check
((((contains_struct_check ((fn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & ((tree_not_check2 (((tree_check ((((contains_struct_check
((fn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) & (!((tree_not_check2 (((tree_check ((((contains_struct_check
((fn), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__), 0 : 0)), ((contains_struct_check ((fn)
, (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__))->decl_minimal.name))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2470, __FUNCTION__))->typed.type)
;
2471 }
2472
2473 if (check_hidden_convs (binfo, virtual_depth, virtualness,
2474 type, parent_convs, other_convs))
2475 {
2476 my_convs = tree_cons (binfo, fn, my_convs);
2477 TREE_TYPE (my_convs)((contains_struct_check ((my_convs), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2477, __FUNCTION__))->typed.type)
= type;
2478 if (virtual_depth)
2479 {
2480 TREE_STATIC (my_convs)((my_convs)->base.static_flag) = 1;
2481 my_virtualness = 1;
2482 }
2483 }
2484 }
2485
2486 if (my_convs)
2487 {
2488 parent_convs = tree_cons (binfo, my_convs, parent_convs);
2489 if (virtual_depth)
2490 TREE_STATIC (parent_convs)((parent_convs)->base.static_flag) = 1;
2491 }
2492
2493 child_convs = other_convs;
2494
2495 /* Now iterate over each base, looking for more conversions. */
2496 unsigned i;
2497 tree base_binfo;
2498 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo)((&(tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2498, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((i), &(base_binfo)))
; i++)
2499 {
2500 tree base_convs;
2501 unsigned base_virtualness;
2502
2503 base_virtualness = lookup_conversions_r (base_binfo,
2504 virtual_depth, virtualness,
2505 parent_convs, child_convs,
2506 &base_convs);
2507 if (base_virtualness)
2508 my_virtualness = virtualness = 1;
2509 child_convs = chainon (base_convs, child_convs);
2510 }
2511
2512 *convs = split_conversions (my_convs, parent_convs,
2513 child_convs, other_convs);
2514
2515 return my_virtualness;
2516}
2517
2518/* Return a TREE_LIST containing all the non-hidden user-defined
2519 conversion functions for TYPE (and its base-classes). The
2520 TREE_VALUE of each node is the FUNCTION_DECL of the conversion
2521 function. The TREE_PURPOSE is the BINFO from which the conversion
2522 functions in this node were selected. This function is effectively
2523 performing a set of member lookups as lookup_fnfield does, but
2524 using the type being converted to as the unique key, rather than the
2525 field name. */
2526
2527tree
2528lookup_conversions (tree type)
2529{
2530 tree convs;
2531
2532 complete_type (type);
2533 if (!CLASS_TYPE_P (type)(((((enum tree_code) (type)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2533, __FUNCTION__))->type_common.lang_flag_5))
|| !TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2533, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
)
2534 return NULL_TREE(tree) __null;
2535
2536 lookup_conversions_r (TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2536, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
, 0, 0, NULL_TREE(tree) __null, NULL_TREE(tree) __null, &convs);
2537
2538 tree list = NULL_TREE(tree) __null;
2539
2540 /* Flatten the list-of-lists */
2541 for (; convs; convs = TREE_CHAIN (convs)((contains_struct_check ((convs), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2541, __FUNCTION__))->common.chain)
)
2542 {
2543 tree probe, next;
2544
2545 for (probe = TREE_VALUE (convs)((tree_check ((convs), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2545, __FUNCTION__, (TREE_LIST)))->list.value)
; probe; probe = next)
2546 {
2547 next = TREE_CHAIN (probe)((contains_struct_check ((probe), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2547, __FUNCTION__))->common.chain)
;
2548
2549 TREE_CHAIN (probe)((contains_struct_check ((probe), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2549, __FUNCTION__))->common.chain)
= list;
2550 list = probe;
2551 }
2552 }
2553
2554 return list;
2555}
2556
2557/* Returns the binfo of the first direct or indirect virtual base derived
2558 from BINFO, or NULL if binfo is not via virtual. */
2559
2560tree
2561binfo_from_vbase (tree binfo)
2562{
2563 for (; binfo; binfo = BINFO_INHERITANCE_CHAIN (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2563, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
)
2564 {
2565 if (BINFO_VIRTUAL_P (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2565, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
2566 return binfo;
2567 }
2568 return NULL_TREE(tree) __null;
2569}
2570
2571/* Returns the binfo of the first direct or indirect virtual base derived
2572 from BINFO up to the TREE_TYPE, LIMIT, or NULL if binfo is not
2573 via virtual. */
2574
2575tree
2576binfo_via_virtual (tree binfo, tree limit)
2577{
2578 if (limit && !CLASSTYPE_VBASECLASSES (limit)((((tree_class_check ((limit), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2578, __FUNCTION__))->type_with_lang_specific.lang_specific
))->vbases)
)
2579 /* LIMIT has no virtual bases, so BINFO cannot be via one. */
2580 return NULL_TREE(tree) __null;
2581
2582 for (; binfo && !SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), limit)((((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2582, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2582, __FUNCTION__))->typed.type)) == (limit))
;
2583 binfo = BINFO_INHERITANCE_CHAIN (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2583, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
)
2584 {
2585 if (BINFO_VIRTUAL_P (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2585, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
2586 return binfo;
2587 }
2588 return NULL_TREE(tree) __null;
2589}
2590
2591/* BINFO is for a base class in some hierarchy. Return true iff it is a
2592 direct base. */
2593
2594bool
2595binfo_direct_p (tree binfo)
2596{
2597 tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2597, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
;
2598 if (BINFO_INHERITANCE_CHAIN (d_binfo)((tree_check ((d_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2598, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
)
2599 /* A second inheritance chain means indirect. */
2600 return false;
2601 if (!BINFO_VIRTUAL_P (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2601, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
2602 /* Non-virtual, so only one inheritance chain means direct. */
2603 return true;
2604 /* A virtual base looks like a direct base, so we need to look through the
2605 direct bases to see if it's there. */
2606 tree b_binfo;
2607 for (int i = 0; BINFO_BASE_ITERATE (d_binfo, i, b_binfo)((&(tree_check ((d_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2607, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((i), &(b_binfo)))
; ++i)
2608 if (b_binfo == binfo)
2609 return true;
2610 return false;
2611}
2612
2613/* BINFO is a base binfo in the complete type BINFO_TYPE (HERE).
2614 Find the equivalent binfo within whatever graph HERE is located.
2615 This is the inverse of original_binfo. */
2616
2617tree
2618copied_binfo (tree binfo, tree here)
2619{
2620 tree result = NULL_TREE(tree) __null;
2621
2622 if (BINFO_VIRTUAL_P (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2622, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
2623 {
2624 tree t;
2625
2626 for (t = here; BINFO_INHERITANCE_CHAIN (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2626, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
;
2627 t = BINFO_INHERITANCE_CHAIN (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2627, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
)
2628 continue;
2629
2630 result = binfo_for_vbase (BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2630, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2630, __FUNCTION__))->typed.type)
, BINFO_TYPE (t)((contains_struct_check (((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2630, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2630, __FUNCTION__))->typed.type)
);
2631 }
2632 else if (BINFO_INHERITANCE_CHAIN (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2632, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
)
2633 {
2634 tree cbinfo;
2635 tree base_binfo;
2636 int ix;
2637
2638 cbinfo = copied_binfo (BINFO_INHERITANCE_CHAIN (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2638, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
, here);
2639 for (ix = 0; BINFO_BASE_ITERATE (cbinfo, ix, base_binfo)((&(tree_check ((cbinfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2639, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)->
iterate ((ix), &(base_binfo)))
; ix++)
2640 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), BINFO_TYPE (binfo))((((contains_struct_check (((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2640, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2640, __FUNCTION__))->typed.type)) == (((contains_struct_check
(((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2640, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2640, __FUNCTION__))->typed.type)))
)
2641 {
2642 result = base_binfo;
2643 break;
2644 }
2645 }
2646 else
2647 {
2648 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (here), BINFO_TYPE (binfo)))((void)(!(((((contains_struct_check (((tree_check ((here), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2648, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2648, __FUNCTION__))->typed.type)) == (((contains_struct_check
(((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2648, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2648, __FUNCTION__))->typed.type)))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2648, __FUNCTION__), 0 : 0))
;
2649 result = here;
2650 }
2651
2652 gcc_assert (result)((void)(!(result) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2652, __FUNCTION__), 0 : 0))
;
2653 return result;
2654}
2655
2656tree
2657binfo_for_vbase (tree base, tree t)
2658{
2659 unsigned ix;
2660 tree binfo;
2661 vec<tree, va_gc> *vbases;
2662
2663 for (vbases = CLASSTYPE_VBASECLASSES (t)((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2663, __FUNCTION__))->type_with_lang_specific.lang_specific
))->vbases)
, ix = 0;
2664 vec_safe_iterate (vbases, ix, &binfo); ix++)
2665 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), base)((((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2665, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2665, __FUNCTION__))->typed.type)) == (base))
)
2666 return binfo;
2667 return NULL__null;
2668}
2669
2670/* BINFO is some base binfo of HERE, within some other
2671 hierarchy. Return the equivalent binfo, but in the hierarchy
2672 dominated by HERE. This is the inverse of copied_binfo. If BINFO
2673 is not a base binfo of HERE, returns NULL_TREE. */
2674
2675tree
2676original_binfo (tree binfo, tree here)
2677{
2678 tree result = NULL__null;
2679
2680 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (here))((((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2680, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2680, __FUNCTION__))->typed.type)) == (((contains_struct_check
(((tree_check ((here), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2680, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2680, __FUNCTION__))->typed.type)))
)
2681 result = here;
2682 else if (BINFO_VIRTUAL_P (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2682, __FUNCTION__, (TREE_BINFO)))->base.static_flag)
)
2683 result = (CLASSTYPE_VBASECLASSES (BINFO_TYPE (here))((((tree_class_check ((((contains_struct_check (((tree_check (
(here), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2683, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2683, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2683, __FUNCTION__))->type_with_lang_specific.lang_specific
))->vbases)
2684 ? binfo_for_vbase (BINFO_TYPE (binfo)((contains_struct_check (((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2684, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2684, __FUNCTION__))->typed.type)
, BINFO_TYPE (here)((contains_struct_check (((tree_check ((here), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2684, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2684, __FUNCTION__))->typed.type)
)
2685 : NULL_TREE(tree) __null);
2686 else if (BINFO_INHERITANCE_CHAIN (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2686, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
)
2687 {
2688 tree base_binfos;
2689
2690 base_binfos = original_binfo (BINFO_INHERITANCE_CHAIN (binfo)((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2690, __FUNCTION__, (TREE_BINFO)))->binfo.inheritance)
, here);
2691 if (base_binfos)
2692 {
2693 int ix;
2694 tree base_binfo;
2695
2696 for (ix = 0; (base_binfo = BINFO_BASE_BINFO (base_binfos, ix)((*(&(tree_check ((base_binfos), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2696, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos))[
(ix)])
); ix++)
2697 if (SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),((((contains_struct_check (((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2697, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2697, __FUNCTION__))->typed.type)) == (((contains_struct_check
(((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2698, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2698, __FUNCTION__))->typed.type)))
2698 BINFO_TYPE (binfo))((((contains_struct_check (((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2697, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2697, __FUNCTION__))->typed.type)) == (((contains_struct_check
(((tree_check ((binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2698, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2698, __FUNCTION__))->typed.type)))
)
2699 {
2700 result = base_binfo;
2701 break;
2702 }
2703 }
2704 }
2705
2706 return result;
2707}
2708
2709/* True iff TYPE has any dependent bases (and therefore we can't say
2710 definitively that another class is not a base of an instantiation of
2711 TYPE). */
2712
2713bool
2714any_dependent_bases_p (tree type)
2715{
2716 if (!type || !CLASS_TYPE_P (type)(((((enum tree_code) (type)->base.code)) == RECORD_TYPE ||
(((enum tree_code) (type)->base.code)) == UNION_TYPE) &&
((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2716, __FUNCTION__))->type_common.lang_flag_5))
|| !uses_template_parms (type))
2717 return false;
2718
2719 /* If we haven't set TYPE_BINFO yet, we don't know anything about the bases.
2720 Return false because in this situation we aren't actually looking up names
2721 in the scope of the class, so it doesn't matter whether it has dependent
2722 bases. */
2723 if (!TYPE_BINFO (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2723, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
)
2724 return false;
2725
2726 unsigned i;
2727 tree base_binfo;
2728 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_BINFOS (TYPE_BINFO (type)), i, base_binfo)for (i = 0; vec_safe_iterate (((&(tree_check ((((tree_check3
((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2728, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2728, __FUNCTION__, (TREE_BINFO)))->binfo.base_binfos)),
(i), &(base_binfo)); ++(i))
2729 if (BINFO_DEPENDENT_BASE_P (base_binfo)((tree_not_check2 (((tree_check ((base_binfo), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2729, __FUNCTION__, (TREE_BINFO)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/search.c"
, 2729, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
)
2730 return true;
2731
2732 return false;
2733}

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h

1/* Definitions for the ubiquitous 'tree' type for GNU compilers.
2 Copyright (C) 1989-2021 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for 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#ifndef GCC_TREE_H
21#define GCC_TREE_H
22
23#include "tree-core.h"
24#include "options.h"
25
26/* Convert a target-independent built-in function code to a combined_fn. */
27
28inline combined_fn
29as_combined_fn (built_in_function fn)
30{
31 return combined_fn (int (fn));
32}
33
34/* Convert an internal function code to a combined_fn. */
35
36inline combined_fn
37as_combined_fn (internal_fn fn)
38{
39 return combined_fn (int (fn) + int (END_BUILTINS));
40}
41
42/* Return true if CODE is a target-independent built-in function. */
43
44inline bool
45builtin_fn_p (combined_fn code)
46{
47 return int (code) < int (END_BUILTINS);
48}
49
50/* Return the target-independent built-in function represented by CODE.
51 Only valid if builtin_fn_p (CODE). */
52
53inline built_in_function
54as_builtin_fn (combined_fn code)
55{
56 gcc_checking_assert (builtin_fn_p (code))((void)(!(builtin_fn_p (code)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 56, __FUNCTION__), 0 : 0))
;
57 return built_in_function (int (code));
58}
59
60/* Return true if CODE is an internal function. */
61
62inline bool
63internal_fn_p (combined_fn code)
64{
65 return int (code) >= int (END_BUILTINS);
66}
67
68/* Return the internal function represented by CODE. Only valid if
69 internal_fn_p (CODE). */
70
71inline internal_fn
72as_internal_fn (combined_fn code)
73{
74 gcc_checking_assert (internal_fn_p (code))((void)(!(internal_fn_p (code)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 74, __FUNCTION__), 0 : 0))
;
75 return internal_fn (int (code) - int (END_BUILTINS));
76}
77
78/* Macros for initializing `tree_contains_struct'. */
79#define MARK_TS_BASE(C)(tree_contains_struct[C][TS_BASE] = true) \
80 (tree_contains_struct[C][TS_BASE] = true)
81
82#define MARK_TS_TYPED(C)((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true)
\
83 (MARK_TS_BASE (C)(tree_contains_struct[C][TS_BASE] = true), \
84 tree_contains_struct[C][TS_TYPED] = true)
85
86#define MARK_TS_COMMON(C)(((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
)
\
87 (MARK_TS_TYPED (C)((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true)
, \
88 tree_contains_struct[C][TS_COMMON] = true)
89
90#define MARK_TS_TYPE_COMMON(C)((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true)
\
91 (MARK_TS_COMMON (C)(((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
)
, \
92 tree_contains_struct[C][TS_TYPE_COMMON] = true)
93
94#define MARK_TS_TYPE_WITH_LANG_SPECIFIC(C)(((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true), tree_contains_struct
[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
\
95 (MARK_TS_TYPE_COMMON (C)((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true)
, \
96 tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
97
98#define MARK_TS_TYPE_NON_COMMON(C)((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true), tree_contains_struct
[C][TS_TYPE_WITH_LANG_SPECIFIC] = true), tree_contains_struct
[C][TS_TYPE_NON_COMMON] = true)
\
99 (MARK_TS_TYPE_WITH_LANG_SPECIFIC (C)(((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_TYPE_COMMON] = true), tree_contains_struct
[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
, \
100 tree_contains_struct[C][TS_TYPE_NON_COMMON] = true) \
101
102#define MARK_TS_DECL_MINIMAL(C)((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true)
\
103 (MARK_TS_COMMON (C)(((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
)
, \
104 tree_contains_struct[C][TS_DECL_MINIMAL] = true)
105
106#define MARK_TS_DECL_COMMON(C)(((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true)
\
107 (MARK_TS_DECL_MINIMAL (C)((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true)
, \
108 tree_contains_struct[C][TS_DECL_COMMON] = true)
109
110#define MARK_TS_DECL_WRTL(C)((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true)
\
111 (MARK_TS_DECL_COMMON (C)(((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true)
, \
112 tree_contains_struct[C][TS_DECL_WRTL] = true)
113
114#define MARK_TS_DECL_WITH_VIS(C)(((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true), tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
\
115 (MARK_TS_DECL_WRTL (C)((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true)
, \
116 tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
117
118#define MARK_TS_DECL_NON_COMMON(C)((((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true), tree_contains_struct[C][TS_DECL_WITH_VIS] = true),
tree_contains_struct[C][TS_DECL_NON_COMMON] = true)
\
119 (MARK_TS_DECL_WITH_VIS (C)(((((((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_COMMON] = true
), tree_contains_struct[C][TS_DECL_MINIMAL] = true), tree_contains_struct
[C][TS_DECL_COMMON] = true), tree_contains_struct[C][TS_DECL_WRTL
] = true), tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
, \
120 tree_contains_struct[C][TS_DECL_NON_COMMON] = true)
121
122#define MARK_TS_EXP(C)(((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true), tree_contains_struct[C][TS_EXP] = true
)
\
123 (MARK_TS_TYPED (C)((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true)
, \
124 tree_contains_struct[C][TS_EXP] = true)
125
126/* Returns the string representing CLASS. */
127
128#define TREE_CODE_CLASS_STRING(CLASS)tree_code_class_strings[(int) (CLASS)]\
129 tree_code_class_strings[(int) (CLASS)]
130
131#define TREE_CODE_CLASS(CODE)tree_code_type[(int) (CODE)] tree_code_type[(int) (CODE)]
132
133/* Nonzero if NODE represents an exceptional code. */
134
135#define EXCEPTIONAL_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_exceptional)
\
136 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_exceptional)
137
138/* Nonzero if NODE represents a constant. */
139
140#define CONSTANT_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_constant)
\
141 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_constant)
142
143/* Nonzero if NODE represents a constant, or is a location wrapper
144 around such a node. */
145
146#define CONSTANT_CLASS_OR_WRAPPER_P(NODE)((tree_code_type[(int) (((enum tree_code) (tree_strip_any_location_wrapper
(NODE))->base.code))] == tcc_constant))
\
147 (CONSTANT_CLASS_P (tree_strip_any_location_wrapper (NODE))(tree_code_type[(int) (((enum tree_code) (tree_strip_any_location_wrapper
(NODE))->base.code))] == tcc_constant)
)
148
149/* Nonzero if NODE represents a type. */
150
151#define TYPE_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_type)
\
152 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_type)
153
154/* Nonzero if NODE represents a declaration. */
155
156#define DECL_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_declaration)
\
157 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_declaration)
158
159/* True if NODE designates a variable declaration. */
160#define VAR_P(NODE)(((enum tree_code) (NODE)->base.code) == VAR_DECL) \
161 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == VAR_DECL)
162
163/* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL. */
164
165#define VAR_OR_FUNCTION_DECL_P(DECL)(((enum tree_code) (DECL)->base.code) == VAR_DECL || ((enum
tree_code) (DECL)->base.code) == FUNCTION_DECL)
\
166 (TREE_CODE (DECL)((enum tree_code) (DECL)->base.code) == VAR_DECL || TREE_CODE (DECL)((enum tree_code) (DECL)->base.code) == FUNCTION_DECL)
167
168/* Nonzero if NODE represents a INDIRECT_REF. Keep these checks in
169 ascending code order. */
170
171#define INDIRECT_REF_P(NODE)(((enum tree_code) (NODE)->base.code) == INDIRECT_REF)\
172 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == INDIRECT_REF)
173
174/* Nonzero if NODE represents a reference. */
175
176#define REFERENCE_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_reference)
\
177 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_reference)
178
179/* Nonzero if NODE represents a comparison. */
180
181#define COMPARISON_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_comparison)
\
182 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_comparison)
183
184/* Nonzero if NODE represents a unary arithmetic expression. */
185
186#define UNARY_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_unary)
\
187 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_unary)
188
189/* Nonzero if NODE represents a binary arithmetic expression. */
190
191#define BINARY_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_binary)
\
192 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_binary)
193
194/* Nonzero if NODE represents a statement expression. */
195
196#define STATEMENT_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_statement)
\
197 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_statement)
198
199/* Nonzero if NODE represents a function call-like expression with a
200 variable-length operand vector. */
201
202#define VL_EXP_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_vl_exp)
\
203 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_vl_exp)
204
205/* Nonzero if NODE represents any other expression. */
206
207#define EXPRESSION_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_expression)
\
208 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_expression)
209
210/* Returns nonzero iff NODE represents a type or declaration. */
211
212#define IS_TYPE_OR_DECL_P(NODE)((tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_type) || (tree_code_type[(int) (((enum tree_code) (
NODE)->base.code))] == tcc_declaration))
\
213 (TYPE_P (NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_type)
|| DECL_P (NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_declaration)
)
214
215/* Returns nonzero iff CLASS is the tree-code class of an
216 expression. */
217
218#define IS_EXPR_CODE_CLASS(CLASS)((CLASS) >= tcc_reference && (CLASS) <= tcc_expression
)
\
219 ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
220
221/* Returns nonzero iff NODE is an expression of some kind. */
222
223#define EXPR_P(NODE)((tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (NODE)->base.code))]) <= tcc_expression
)
IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))((tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (NODE)->base.code))]) <= tcc_expression
)
224
225#define TREE_CODE_LENGTH(CODE)tree_code_length[(int) (CODE)] tree_code_length[(int) (CODE)]
226
227
228/* Helper macros for math builtins. */
229
230#define CASE_FLT_FN(FN)case FN: case FNF: case FNL case FN: case FN##F: case FN##L
231#define CASE_FLT_FN_FLOATN_NX(FN)case FNF16: case FNF32: case FNF64: case FNF128: case FNF32X:
case FNF64X: case FNF128X
\
232 case FN##F16: case FN##F32: case FN##F64: case FN##F128: \
233 case FN##F32X: case FN##F64X: case FN##F128X
234#define CASE_FLT_FN_REENT(FN)case FN_R: case FNF_R: case FNL_R case FN##_R: case FN##F_R: case FN##L_R
235#define CASE_INT_FN(FN)case FN: case FNL: case FNLL: case FNIMAX case FN: case FN##L: case FN##LL: case FN##IMAX
236
237#define NULL_TREE(tree) __null (tree) NULL__null
238
239/* Define accessors for the fields that all tree nodes have
240 (though some fields are not used for all kinds of nodes). */
241
242/* The tree-code says what kind of node it is.
243 Codes are defined in tree.def. */
244#define TREE_CODE(NODE)((enum tree_code) (NODE)->base.code) ((enum tree_code) (NODE)->base.code)
245#define TREE_SET_CODE(NODE, VALUE)((NODE)->base.code = (VALUE)) ((NODE)->base.code = (VALUE))
246
247/* When checking is enabled, errors will be generated if a tree node
248 is accessed incorrectly. The macros die with a fatal error. */
249#if defined ENABLE_TREE_CHECKING1 && (GCC_VERSION(4 * 1000 + 2) >= 2007)
250
251#define TREE_CHECK(T, CODE)(tree_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 251, __FUNCTION__, (CODE)))
\
252(tree_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__252, __FUNCTION__, (CODE)))
253
254#define TREE_NOT_CHECK(T, CODE)(tree_not_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 254, __FUNCTION__, (CODE)))
\
255(tree_not_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__255, __FUNCTION__, (CODE)))
256
257#define TREE_CHECK2(T, CODE1, CODE2)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 257, __FUNCTION__, (CODE1), (CODE2)))
\
258(tree_check2 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__258, __FUNCTION__, (CODE1), (CODE2)))
259
260#define TREE_NOT_CHECK2(T, CODE1, CODE2)(tree_not_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 260, __FUNCTION__, (CODE1), (CODE2)))
\
261(tree_not_check2 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__261, __FUNCTION__, (CODE1), (CODE2)))
262
263#define TREE_CHECK3(T, CODE1, CODE2, CODE3)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 263, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
\
264(tree_check3 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__264, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
265
266#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3)(tree_not_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 266, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
\
267(tree_not_check3 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__267, __FUNCTION__, \
268 (CODE1), (CODE2), (CODE3)))
269
270#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4)(tree_check4 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 270, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
\
271(tree_check4 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__271, __FUNCTION__, \
272 (CODE1), (CODE2), (CODE3), (CODE4)))
273
274#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4)(tree_not_check4 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 274, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
\
275(tree_not_check4 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__275, __FUNCTION__, \
276 (CODE1), (CODE2), (CODE3), (CODE4)))
277
278#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 278, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
\
279(tree_check5 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__279, __FUNCTION__, \
280 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
281
282#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)(tree_not_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 282, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
\
283(tree_not_check5 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__283, __FUNCTION__, \
284 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
285
286#define CONTAINS_STRUCT_CHECK(T, STRUCT)(contains_struct_check ((T), (STRUCT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 286, __FUNCTION__))
\
287(contains_struct_check ((T), (STRUCT), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__287, __FUNCTION__))
288
289#define TREE_CLASS_CHECK(T, CLASS)(tree_class_check ((T), (CLASS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 289, __FUNCTION__))
\
290(tree_class_check ((T), (CLASS), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__290, __FUNCTION__))
291
292#define TREE_RANGE_CHECK(T, CODE1, CODE2)(tree_range_check ((T), (CODE1), (CODE2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 292, __FUNCTION__))
\
293(tree_range_check ((T), (CODE1), (CODE2), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__293, __FUNCTION__))
294
295#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)(omp_clause_subcode_check ((T), (CODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 295, __FUNCTION__))
\
296(omp_clause_subcode_check ((T), (CODE), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__296, __FUNCTION__))
297
298#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2)(omp_clause_range_check ((T), (CODE1), (CODE2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 298, __FUNCTION__))
\
299(omp_clause_range_check ((T), (CODE1), (CODE2), \
300 __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__300, __FUNCTION__))
301
302/* These checks have to be special cased. */
303#define EXPR_CHECK(T)(expr_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 303, __FUNCTION__))
\
304(expr_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__304, __FUNCTION__))
305
306/* These checks have to be special cased. */
307#define NON_TYPE_CHECK(T)(non_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 307, __FUNCTION__))
\
308(non_type_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__308, __FUNCTION__))
309
310/* These checks have to be special cased. */
311#define ANY_INTEGRAL_TYPE_CHECK(T)(any_integral_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 311, __FUNCTION__))
\
312(any_integral_type_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__312, __FUNCTION__))
313
314#define TREE_INT_CST_ELT_CHECK(T, I)(*tree_int_cst_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 314, __FUNCTION__))
\
315(*tree_int_cst_elt_check ((T), (I), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__315, __FUNCTION__))
316
317#define TREE_VEC_ELT_CHECK(T, I)(*((const_cast<tree *> (tree_vec_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 317, __FUNCTION__)))))
\
318(*(CONST_CAST2 (tree *, typeof (T)*, \(const_cast<tree *> (tree_vec_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 319, __FUNCTION__)))
319 tree_vec_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))(const_cast<tree *> (tree_vec_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 319, __FUNCTION__)))
))
320
321#define OMP_CLAUSE_ELT_CHECK(T, I)(*(omp_clause_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 321, __FUNCTION__)))
\
322(*(omp_clause_elt_check ((T), (I), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__322, __FUNCTION__)))
323
324/* Special checks for TREE_OPERANDs. */
325#define TREE_OPERAND_CHECK(T, I)(*((const_cast<tree*> (tree_operand_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 325, __FUNCTION__)))))
\
326(*(CONST_CAST2 (tree*, typeof (T)*, \(const_cast<tree*> (tree_operand_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 327, __FUNCTION__)))
327 tree_operand_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))(const_cast<tree*> (tree_operand_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 327, __FUNCTION__)))
))
328
329#define TREE_OPERAND_CHECK_CODE(T, CODE, I)(*(tree_operand_check_code ((T), (CODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 329, __FUNCTION__)))
\
330(*(tree_operand_check_code ((T), (CODE), (I), \
331 __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__331, __FUNCTION__)))
332
333/* Nodes are chained together for many purposes.
334 Types are chained together to record them for being output to the debugger
335 (see the function `chain_type').
336 Decls in the same scope are chained together to record the contents
337 of the scope.
338 Statement nodes for successive statements used to be chained together.
339 Often lists of things are represented by TREE_LIST nodes that
340 are chained together. */
341
342#define TREE_CHAIN(NODE)((contains_struct_check ((NODE), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 342, __FUNCTION__))->common.chain)
\
343(CONTAINS_STRUCT_CHECK (NODE, TS_COMMON)(contains_struct_check ((NODE), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 343, __FUNCTION__))
->common.chain)
344
345/* In all nodes that are expressions, this is the data type of the expression.
346 In POINTER_TYPE nodes, this is the type that the pointer points to.
347 In ARRAY_TYPE nodes, this is the type of the elements.
348 In VECTOR_TYPE nodes, this is the type of the elements. */
349#define TREE_TYPE(NODE)((contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 349, __FUNCTION__))->typed.type)
\
350(CONTAINS_STRUCT_CHECK (NODE, TS_TYPED)(contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 350, __FUNCTION__))
->typed.type)
351
352extern void tree_contains_struct_check_failed (const_tree,
353 const enum tree_node_structure_enum,
354 const char *, int, const char *)
355 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
356
357extern void tree_check_failed (const_tree, const char *, int, const char *,
358 ...) ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
359extern void tree_not_check_failed (const_tree, const char *, int, const char *,
360 ...) ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
361extern void tree_class_check_failed (const_tree, const enum tree_code_class,
362 const char *, int, const char *)
363 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
364extern void tree_range_check_failed (const_tree, const char *, int,
365 const char *, enum tree_code,
366 enum tree_code)
367 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
368extern void tree_not_class_check_failed (const_tree,
369 const enum tree_code_class,
370 const char *, int, const char *)
371 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
372extern void tree_int_cst_elt_check_failed (int, int, const char *,
373 int, const char *)
374 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
375extern void tree_vec_elt_check_failed (int, int, const char *,
376 int, const char *)
377 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
378extern void phi_node_elt_check_failed (int, int, const char *,
379 int, const char *)
380 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
381extern void tree_operand_check_failed (int, const_tree,
382 const char *, int, const char *)
383 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
384extern void omp_clause_check_failed (const_tree, const char *, int,
385 const char *, enum omp_clause_code)
386 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
387extern void omp_clause_operand_check_failed (int, const_tree, const char *,
388 int, const char *)
389 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
390extern void omp_clause_range_check_failed (const_tree, const char *, int,
391 const char *, enum omp_clause_code,
392 enum omp_clause_code)
393 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
394
395#else /* not ENABLE_TREE_CHECKING, or not gcc */
396
397#define CONTAINS_STRUCT_CHECK(T, ENUM)(contains_struct_check ((T), (ENUM), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 397, __FUNCTION__))
(T)
398#define TREE_CHECK(T, CODE)(tree_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 398, __FUNCTION__, (CODE)))
(T)
399#define TREE_NOT_CHECK(T, CODE)(tree_not_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 399, __FUNCTION__, (CODE)))
(T)
400#define TREE_CHECK2(T, CODE1, CODE2)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 400, __FUNCTION__, (CODE1), (CODE2)))
(T)
401#define TREE_NOT_CHECK2(T, CODE1, CODE2)(tree_not_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 401, __FUNCTION__, (CODE1), (CODE2)))
(T)
402#define TREE_CHECK3(T, CODE1, CODE2, CODE3)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 402, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
(T)
403#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3)(tree_not_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 403, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
(T)
404#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4)(tree_check4 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 404, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
(T)
405#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4)(tree_not_check4 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 405, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
(T)
406#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 406, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
(T)
407#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)(tree_not_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 407, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
(T)
408#define TREE_CLASS_CHECK(T, CODE)(tree_class_check ((T), (CODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 408, __FUNCTION__))
(T)
409#define TREE_RANGE_CHECK(T, CODE1, CODE2)(tree_range_check ((T), (CODE1), (CODE2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 409, __FUNCTION__))
(T)
410#define EXPR_CHECK(T)(expr_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 410, __FUNCTION__))
(T)
411#define NON_TYPE_CHECK(T)(non_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 411, __FUNCTION__))
(T)
412#define TREE_INT_CST_ELT_CHECK(T, I)(*tree_int_cst_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 412, __FUNCTION__))
((T)->int_cst.val[I])
413#define TREE_VEC_ELT_CHECK(T, I)(*((const_cast<tree *> (tree_vec_elt_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 413, __FUNCTION__)))))
((T)->vec.a[I])
414#define TREE_OPERAND_CHECK(T, I)(*((const_cast<tree*> (tree_operand_check ((T), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 414, __FUNCTION__)))))
((T)->exp.operands[I])
415#define TREE_OPERAND_CHECK_CODE(T, CODE, I)(*(tree_operand_check_code ((T), (CODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 415, __FUNCTION__)))
((T)->exp.operands[I])
416#define OMP_CLAUSE_ELT_CHECK(T, i)(*(omp_clause_elt_check ((T), (i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 416, __FUNCTION__)))
((T)->omp_clause.ops[i])
417#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2)(omp_clause_range_check ((T), (CODE1), (CODE2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 417, __FUNCTION__))
(T)
418#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)(omp_clause_subcode_check ((T), (CODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 418, __FUNCTION__))
(T)
419#define ANY_INTEGRAL_TYPE_CHECK(T)(any_integral_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 419, __FUNCTION__))
(T)
420
421#define TREE_CHAIN(NODE)((contains_struct_check ((NODE), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 421, __FUNCTION__))->common.chain)
((NODE)->common.chain)
422#define TREE_TYPE(NODE)((contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 422, __FUNCTION__))->typed.type)
((NODE)->typed.type)
423
424#endif
425
426#define TREE_BLOCK(NODE)(tree_block (NODE)) (tree_block (NODE))
427#define TREE_SET_BLOCK(T, B)(tree_set_block ((T), (B))) (tree_set_block ((T), (B)))
428
429#include "tree-check.h"
430
431#define TYPE_CHECK(T)(tree_class_check ((T), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 431, __FUNCTION__))
TREE_CLASS_CHECK (T, tcc_type)(tree_class_check ((T), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 431, __FUNCTION__))
432#define DECL_MINIMAL_CHECK(T)(contains_struct_check ((T), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 432, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)(contains_struct_check ((T), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 432, __FUNCTION__))
433#define DECL_COMMON_CHECK(T)(contains_struct_check ((T), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 433, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)(contains_struct_check ((T), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 433, __FUNCTION__))
434#define DECL_WRTL_CHECK(T)(contains_struct_check ((T), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 434, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)(contains_struct_check ((T), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 434, __FUNCTION__))
435#define DECL_WITH_VIS_CHECK(T)(contains_struct_check ((T), (TS_DECL_WITH_VIS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 435, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)(contains_struct_check ((T), (TS_DECL_WITH_VIS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 435, __FUNCTION__))
436#define DECL_NON_COMMON_CHECK(T)(contains_struct_check ((T), (TS_DECL_NON_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 436, __FUNCTION__))
CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)(contains_struct_check ((T), (TS_DECL_NON_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 436, __FUNCTION__))
437#define CST_CHECK(T)(tree_class_check ((T), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 437, __FUNCTION__))
TREE_CLASS_CHECK (T, tcc_constant)(tree_class_check ((T), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 437, __FUNCTION__))
438#define STMT_CHECK(T)(tree_class_check ((T), (tcc_statement), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 438, __FUNCTION__))
TREE_CLASS_CHECK (T, tcc_statement)(tree_class_check ((T), (tcc_statement), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 438, __FUNCTION__))
439#define VL_EXP_CHECK(T)(tree_class_check ((T), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 439, __FUNCTION__))
TREE_CLASS_CHECK (T, tcc_vl_exp)(tree_class_check ((T), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 439, __FUNCTION__))
440#define FUNC_OR_METHOD_CHECK(T)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 440, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))
TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 440, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))
441#define PTR_OR_REF_CHECK(T)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 441, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))
TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 441, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))
442
443#define RECORD_OR_UNION_CHECK(T)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 443, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
\
444 TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 444, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
445#define NOT_RECORD_OR_UNION_CHECK(T)(tree_not_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 445, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
\
446 TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)(tree_not_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 446, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
447#define ARRAY_OR_INTEGER_TYPE_CHECK(T)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 447, __FUNCTION__, (ARRAY_TYPE), (INTEGER_TYPE)))
\
448 TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 448, __FUNCTION__, (ARRAY_TYPE), (INTEGER_TYPE)))
449
450#define NUMERICAL_TYPE_CHECK(T)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 450, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))
\
451 TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 452, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))
452 FIXED_POINT_TYPE)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 452, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))
453
454/* Here is how primitive or already-canonicalized types' hash codes
455 are made. */
456#define TYPE_HASH(TYPE)(((tree_class_check ((TYPE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 456, __FUNCTION__))->type_common.uid))
(TYPE_UID (TYPE)((tree_class_check ((TYPE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 456, __FUNCTION__))->type_common.uid)
)
457
458/* A simple hash function for an arbitrary tree node. This must not be
459 used in hash tables which are saved to a PCH. */
460#define TREE_HASH(NODE)((size_t) (NODE) & 0777777) ((size_t) (NODE) & 0777777)
461
462/* Tests if CODE is a conversion expr (NOP_EXPR or CONVERT_EXPR). */
463#define CONVERT_EXPR_CODE_P(CODE)((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR) \
464 ((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR)
465
466/* Similarly, but accept an expression instead of a tree code. */
467#define CONVERT_EXPR_P(EXP)((((enum tree_code) (EXP)->base.code)) == NOP_EXPR || (((enum
tree_code) (EXP)->base.code)) == CONVERT_EXPR)
CONVERT_EXPR_CODE_P (TREE_CODE (EXP))((((enum tree_code) (EXP)->base.code)) == NOP_EXPR || (((enum
tree_code) (EXP)->base.code)) == CONVERT_EXPR)
468
469/* Generate case for NOP_EXPR, CONVERT_EXPR. */
470
471#define CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR \
472 case NOP_EXPR: \
473 case CONVERT_EXPR
474
475/* Given an expression as a tree, strip any conversion that generates
476 no instruction. Accepts both tree and const_tree arguments since
477 we are not modifying the tree itself. */
478
479#define STRIP_NOPS(EXP)(EXP) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((EXP)))))
\
480 (EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP)(const_cast<union tree_node *> (((EXP)))))
481
482/* Like STRIP_NOPS, but don't let the signedness change either. */
483
484#define STRIP_SIGN_NOPS(EXP)(EXP) = tree_strip_sign_nop_conversions ((const_cast<union
tree_node *> (((EXP)))))
\
485 (EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP)(const_cast<union tree_node *> (((EXP)))))
486
487/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
488
489#define STRIP_TYPE_NOPS(EXP)while ((((((enum tree_code) (EXP)->base.code)) == NOP_EXPR
|| (((enum tree_code) (EXP)->base.code)) == CONVERT_EXPR)
|| ((enum tree_code) (EXP)->base.code) == NON_LVALUE_EXPR
) && (*((const_cast<tree*> (tree_operand_check (
(EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 489, __FUNCTION__))))) != global_trees[TI_ERROR_MARK] &&
(((contains_struct_check ((EXP), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 489, __FUNCTION__))->typed.type) == ((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((EXP), (0
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 489, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 489, __FUNCTION__))->typed.type))) (EXP) = (*((const_cast
<tree*> (tree_operand_check ((EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 489, __FUNCTION__)))))
\
490 while ((CONVERT_EXPR_P (EXP)((((enum tree_code) (EXP)->base.code)) == NOP_EXPR || (((enum
tree_code) (EXP)->base.code)) == CONVERT_EXPR)
\
491 || TREE_CODE (EXP)((enum tree_code) (EXP)->base.code) == NON_LVALUE_EXPR) \
492 && TREE_OPERAND (EXP, 0)(*((const_cast<tree*> (tree_operand_check ((EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 492, __FUNCTION__)))))
!= error_mark_nodeglobal_trees[TI_ERROR_MARK] \
493 && (TREE_TYPE (EXP)((contains_struct_check ((EXP), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 493, __FUNCTION__))->typed.type)
\
494 == TREE_TYPE (TREE_OPERAND (EXP, 0))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 494, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 494, __FUNCTION__))->typed.type)
)) \
495 (EXP) = TREE_OPERAND (EXP, 0)(*((const_cast<tree*> (tree_operand_check ((EXP), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 495, __FUNCTION__)))))
496
497/* Remove unnecessary type conversions according to
498 tree_ssa_useless_type_conversion. */
499
500#define STRIP_USELESS_TYPE_CONVERSION(EXP)(EXP) = tree_ssa_strip_useless_type_conversions (EXP) \
501 (EXP) = tree_ssa_strip_useless_type_conversions (EXP)
502
503/* Remove any VIEW_CONVERT_EXPR or NON_LVALUE_EXPR that's purely
504 in use to provide a location_t. */
505
506#define STRIP_ANY_LOCATION_WRAPPER(EXP)(EXP) = tree_strip_any_location_wrapper ((const_cast<union
tree_node *> (((EXP)))))
\
507 (EXP) = tree_strip_any_location_wrapper (CONST_CAST_TREE (EXP)(const_cast<union tree_node *> (((EXP)))))
508
509/* Nonzero if TYPE represents a vector type. */
510
511#define VECTOR_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)
512
513/* Nonzero if TYPE represents a vector of booleans. */
514
515#define VECTOR_BOOLEAN_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 515, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)
\
516 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE \
517 && TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 517, __FUNCTION__))->typed.type))->base.code)
== BOOLEAN_TYPE)
518
519/* Nonzero if TYPE represents an integral type. Note that we do not
520 include COMPLEX types here. Keep these checks in ascending code
521 order. */
522
523#define INTEGRAL_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (TYPE)->base.code) == INTEGER_TYPE)
\
524 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE \
525 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE \
526 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == INTEGER_TYPE)
527
528/* Nonzero if TYPE represents an integral type, including complex
529 and vector integer types. */
530
531#define ANY_INTEGRAL_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (TYPE)->base.code) == INTEGER_TYPE) || ((
((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 531, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 531, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 531, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
\
532 (INTEGRAL_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (TYPE)->base.code) == INTEGER_TYPE)
\
533 || ((TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE \
534 || VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) \
535 && INTEGRAL_TYPE_P (TREE_TYPE (TYPE))(((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 535, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 535, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 535, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
))
536
537/* Nonzero if TYPE represents a non-saturating fixed-point type. */
538
539#define NON_SAT_FIXED_POINT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE &&
!((tree_not_check4 ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 539, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag))
\
540 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE)((tree_not_check4 ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 540, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
)
541
542/* Nonzero if TYPE represents a saturating fixed-point type. */
543
544#define SAT_FIXED_POINT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE &&
((tree_not_check4 ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 544, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag))
\
545 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE)((tree_not_check4 ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 545, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
)
546
547/* Nonzero if TYPE represents a fixed-point type. */
548
549#define FIXED_POINT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE) (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == FIXED_POINT_TYPE)
550
551/* Nonzero if TYPE represents a scalar floating-point type. */
552
553#define SCALAR_FLOAT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == REAL_TYPE) (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == REAL_TYPE)
554
555/* Nonzero if TYPE represents a complex floating-point type. */
556
557#define COMPLEX_FLOAT_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 557, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
\
558 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE \
559 && TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 559, __FUNCTION__))->typed.type))->base.code)
== REAL_TYPE)
560
561/* Nonzero if TYPE represents a vector integer type. */
562
563#define VECTOR_INTEGER_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 563, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
\
564 (VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) \
565 && TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 565, __FUNCTION__))->typed.type))->base.code)
== INTEGER_TYPE)
566
567
568/* Nonzero if TYPE represents a vector floating-point type. */
569
570#define VECTOR_FLOAT_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 570, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
\
571 (VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) \
572 && TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 572, __FUNCTION__))->typed.type))->base.code)
== REAL_TYPE)
573
574/* Nonzero if TYPE represents a floating-point type, including complex
575 and vector floating-point types. The vector and complex check does
576 not use the previous two macros to enable early folding. */
577
578#define FLOAT_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == REAL_TYPE) || ((
((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 578, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
\
579 (SCALAR_FLOAT_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == REAL_TYPE) \
580 || ((TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE \
581 || VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) \
582 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))(((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 582, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
))
583
584/* Nonzero if TYPE represents a decimal floating-point type. */
585#define DECIMAL_FLOAT_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == REAL_TYPE) &&
(((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((TYPE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 585, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(TYPE) : (TYPE)->type_common.mode)]) == MODE_DECIMAL_FLOAT
))
\
586 (SCALAR_FLOAT_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == REAL_TYPE) \
587 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE))(((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((TYPE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 587, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(TYPE) : (TYPE)->type_common.mode)]) == MODE_DECIMAL_FLOAT
)
)
588
589/* Nonzero if TYPE is a record or union type. */
590#define RECORD_OR_UNION_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == RECORD_TYPE || ((
enum tree_code) (TYPE)->base.code) == UNION_TYPE || ((enum
tree_code) (TYPE)->base.code) == QUAL_UNION_TYPE)
\
591 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == RECORD_TYPE \
592 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == UNION_TYPE \
593 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == QUAL_UNION_TYPE)
594
595/* Nonzero if TYPE represents an aggregate (multi-component) type.
596 Keep these checks in ascending code order. */
597
598#define AGGREGATE_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == ARRAY_TYPE || (((
enum tree_code) (TYPE)->base.code) == RECORD_TYPE || ((enum
tree_code) (TYPE)->base.code) == UNION_TYPE || ((enum tree_code
) (TYPE)->base.code) == QUAL_UNION_TYPE))
\
599 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == RECORD_TYPE || ((
enum tree_code) (TYPE)->base.code) == UNION_TYPE || ((enum
tree_code) (TYPE)->base.code) == QUAL_UNION_TYPE)
)
600
601/* Nonzero if TYPE represents a pointer or reference type.
602 (It should be renamed to INDIRECT_TYPE_P.) Keep these checks in
603 ascending code order. */
604
605#define POINTER_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
\
606 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
607
608/* Nonzero if TYPE represents a pointer to function. */
609#define FUNCTION_POINTER_TYPE_P(TYPE)((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) &&
((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 609, __FUNCTION__))->typed.type))->base.code) == FUNCTION_TYPE
)
\
610 (POINTER_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
&& TREE_CODE (TREE_TYPE (TYPE))((enum tree_code) (((contains_struct_check ((TYPE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 610, __FUNCTION__))->typed.type))->base.code)
== FUNCTION_TYPE)
611
612/* Nonzero if this type is a complete type. */
613#define COMPLETE_TYPE_P(NODE)(((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 613, __FUNCTION__))->type_common.size) != (tree) __null)
(TYPE_SIZE (NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 613, __FUNCTION__))->type_common.size)
!= NULL_TREE(tree) __null)
614
615/* Nonzero if this type is the (possibly qualified) void type. */
616#define VOID_TYPE_P(NODE)(((enum tree_code) (NODE)->base.code) == VOID_TYPE) (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == VOID_TYPE)
617
618/* Nonzero if this type is complete or is cv void. */
619#define COMPLETE_OR_VOID_TYPE_P(NODE)((((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 619, __FUNCTION__))->type_common.size) != (tree) __null)
|| (((enum tree_code) (NODE)->base.code) == VOID_TYPE))
\
620 (COMPLETE_TYPE_P (NODE)(((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 620, __FUNCTION__))->type_common.size) != (tree) __null)
|| VOID_TYPE_P (NODE)(((enum tree_code) (NODE)->base.code) == VOID_TYPE))
621
622/* Nonzero if this type is complete or is an array with unspecified bound. */
623#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE)((((tree_class_check ((((enum tree_code) (NODE)->base.code
) == ARRAY_TYPE ? ((contains_struct_check ((NODE), (TS_TYPED)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 623, __FUNCTION__))->typed.type) : (NODE)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 623, __FUNCTION__))->type_common.size) != (tree) __null)
)
\
624 (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE))(((tree_class_check ((((enum tree_code) (NODE)->base.code)
== ARRAY_TYPE ? ((contains_struct_check ((NODE), (TS_TYPED),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 624, __FUNCTION__))->typed.type) : (NODE)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 624, __FUNCTION__))->type_common.size) != (tree) __null)
)
625
626#define FUNC_OR_METHOD_TYPE_P(NODE)(((enum tree_code) (NODE)->base.code) == FUNCTION_TYPE || (
(enum tree_code) (NODE)->base.code) == METHOD_TYPE)
\
627 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == FUNCTION_TYPE || TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == METHOD_TYPE)
628
629#define OPAQUE_TYPE_P(NODE)(((enum tree_code) (NODE)->base.code) == OPAQUE_TYPE) \
630 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == OPAQUE_TYPE)
631
632/* Define many boolean fields that all tree nodes have. */
633
634/* In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address
635 of this is needed. So it cannot be in a register.
636 In a FUNCTION_DECL it has no meaning.
637 In LABEL_DECL nodes, it means a goto for this label has been seen
638 from a place outside all binding contours that restore stack levels.
639 In an artificial SSA_NAME that points to a stack partition with at least
640 two variables, it means that at least one variable has TREE_ADDRESSABLE.
641 In ..._TYPE nodes, it means that objects of this type must be fully
642 addressable. This means that pieces of this object cannot go into
643 register parameters, for example. If this a function type, this
644 means that the value must be returned in memory.
645 In CONSTRUCTOR nodes, it means object constructed must be in memory.
646 In IDENTIFIER_NODEs, this means that some extern decl for this name
647 had its address taken. That matters for inline functions.
648 In a STMT_EXPR, it means we want the result of the enclosed expression. */
649#define TREE_ADDRESSABLE(NODE)((NODE)->base.addressable_flag) ((NODE)->base.addressable_flag)
650
651/* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
652 exit of a function. Calls for which this is true are candidates for tail
653 call optimizations. */
654#define CALL_EXPR_TAILCALL(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 654, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag)
\
655 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 655, __FUNCTION__, (CALL_EXPR)))
->base.addressable_flag)
656
657/* Set on a CALL_EXPR if the call has been marked as requiring tail call
658 optimization for correctness. */
659#define CALL_EXPR_MUST_TAIL_CALL(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 659, __FUNCTION__, (CALL_EXPR)))->base.static_flag)
\
660 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 660, __FUNCTION__, (CALL_EXPR)))
->base.static_flag)
661
662/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
663 CASE_LOW operand has been processed. */
664#define CASE_LOW_SEEN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 664, __FUNCTION__, (CASE_LABEL_EXPR)))->base.addressable_flag
)
\
665 (CASE_LABEL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 665, __FUNCTION__, (CASE_LABEL_EXPR)))
->base.addressable_flag)
666
667#define PREDICT_EXPR_OUTCOME(NODE)((enum prediction) ((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 667, __FUNCTION__, (PREDICT_EXPR)))->base.addressable_flag
))
\
668 ((enum prediction) (PREDICT_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 668, __FUNCTION__, (PREDICT_EXPR)))
->base.addressable_flag))
669#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 669, __FUNCTION__, (PREDICT_EXPR)))->base.addressable_flag
= (int) OUTCOME)
\
670 (PREDICT_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 670, __FUNCTION__, (PREDICT_EXPR)))
->base.addressable_flag = (int) OUTCOME)
671#define PREDICT_EXPR_PREDICTOR(NODE)((enum br_predictor)tree_to_shwi ((*((const_cast<tree*>
(tree_operand_check (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 671, __FUNCTION__, (PREDICT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 671, __FUNCTION__)))))))
\
672 ((enum br_predictor)tree_to_shwi (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 672, __FUNCTION__, (PREDICT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 672, __FUNCTION__)))))
))
673
674/* In a VAR_DECL, nonzero means allocate static storage.
675 In a FUNCTION_DECL, nonzero if function has been defined.
676 In a CONSTRUCTOR, nonzero means allocate static storage. */
677#define TREE_STATIC(NODE)((NODE)->base.static_flag) ((NODE)->base.static_flag)
678
679/* In an ADDR_EXPR, nonzero means do not use a trampoline. */
680#define TREE_NO_TRAMPOLINE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 680, __FUNCTION__, (ADDR_EXPR)))->base.static_flag)
(ADDR_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 680, __FUNCTION__, (ADDR_EXPR)))
->base.static_flag)
681
682/* In a TARGET_EXPR or WITH_CLEANUP_EXPR, means that the pertinent cleanup
683 should only be executed if an exception is thrown, not on normal exit
684 of its scope. */
685#define CLEANUP_EH_ONLY(NODE)((NODE)->base.static_flag) ((NODE)->base.static_flag)
686
687/* In a TRY_CATCH_EXPR, means that the handler should be considered a
688 separate cleanup in honor_protect_cleanup_actions. */
689#define TRY_CATCH_IS_CLEANUP(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 689, __FUNCTION__, (TRY_CATCH_EXPR)))->base.static_flag)
\
690 (TRY_CATCH_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 690, __FUNCTION__, (TRY_CATCH_EXPR)))
->base.static_flag)
691
692/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
693 CASE_HIGH operand has been processed. */
694#define CASE_HIGH_SEEN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 694, __FUNCTION__, (CASE_LABEL_EXPR)))->base.static_flag
)
\
695 (CASE_LABEL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 695, __FUNCTION__, (CASE_LABEL_EXPR)))
->base.static_flag)
696
697/* Used to mark scoped enums. */
698#define ENUM_IS_SCOPED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 698, __FUNCTION__, (ENUMERAL_TYPE)))->base.static_flag)
(ENUMERAL_TYPE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 698, __FUNCTION__, (ENUMERAL_TYPE)))
->base.static_flag)
699
700/* Determines whether an ENUMERAL_TYPE has defined the list of constants. */
701#define ENUM_IS_OPAQUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 701, __FUNCTION__, (ENUMERAL_TYPE)))->base.private_flag)
(ENUMERAL_TYPE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 701, __FUNCTION__, (ENUMERAL_TYPE)))
->base.private_flag)
702
703/* In an expr node (usually a conversion) this means the node was made
704 implicitly and should not lead to any sort of warning. In a decl node,
705 warnings concerning the decl should be suppressed. This is used at
706 least for used-before-set warnings, and it set after one warning is
707 emitted. */
708#define TREE_NO_WARNING(NODE)((NODE)->base.nowarning_flag) ((NODE)->base.nowarning_flag)
709
710/* Nonzero if we should warn about the change in empty class parameter
711 passing ABI in this TU. */
712#define TRANSLATION_UNIT_WARN_EMPTY_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 712, __FUNCTION__, (TRANSLATION_UNIT_DECL)))->decl_common
.decl_flag_0)
\
713 (TRANSLATION_UNIT_DECL_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 713, __FUNCTION__, (TRANSLATION_UNIT_DECL)))
->decl_common.decl_flag_0)
714
715/* Nonzero if this type is "empty" according to the particular psABI. */
716#define TYPE_EMPTY_P(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 716, __FUNCTION__))->type_common.empty_flag)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 716, __FUNCTION__))
->type_common.empty_flag)
717
718/* Used to indicate that this TYPE represents a compiler-generated entity. */
719#define TYPE_ARTIFICIAL(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 719, __FUNCTION__))->base.nowarning_flag)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 719, __FUNCTION__))
->base.nowarning_flag)
720
721/* True if the type is indivisible at the source level, i.e. if its
722 component parts cannot be accessed directly. This is used to suppress
723 normal GNU extensions for target-specific vector types. */
724#define TYPE_INDIVISIBLE_P(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 724, __FUNCTION__))->type_common.indivisible_p)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 724, __FUNCTION__))
->type_common.indivisible_p)
725
726/* In an IDENTIFIER_NODE, this means that assemble_name was called with
727 this string as an argument. */
728#define TREE_SYMBOL_REFERENCED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 728, __FUNCTION__, (IDENTIFIER_NODE)))->base.static_flag
)
\
729 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 729, __FUNCTION__, (IDENTIFIER_NODE)))
->base.static_flag)
730
731/* Nonzero in a pointer or reference type means the data pointed to
732 by this type can alias anything. */
733#define TYPE_REF_CAN_ALIAS_ALL(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 733, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))->base
.static_flag)
\
734 (PTR_OR_REF_CHECK (NODE)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 734, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))
->base.static_flag)
735
736/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
737 there was an overflow in folding. */
738
739#define TREE_OVERFLOW(NODE)((tree_class_check ((NODE), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 739, __FUNCTION__))->base.public_flag)
(CST_CHECK (NODE)(tree_class_check ((NODE), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 739, __FUNCTION__))
->base.public_flag)
740
741/* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P. */
742
743#define TREE_OVERFLOW_P(EXPR)((tree_code_type[(int) (((enum tree_code) (EXPR)->base.code
))] == tcc_constant) && ((tree_class_check ((EXPR), (
tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 743, __FUNCTION__))->base.public_flag))
\
744 (CONSTANT_CLASS_P (EXPR)(tree_code_type[(int) (((enum tree_code) (EXPR)->base.code
))] == tcc_constant)
&& TREE_OVERFLOW (EXPR)((tree_class_check ((EXPR), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 744, __FUNCTION__))->base.public_flag)
)
745
746/* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL,
747 nonzero means name is to be accessible from outside this translation unit.
748 In an IDENTIFIER_NODE, nonzero means an external declaration
749 accessible from outside this translation unit was previously seen
750 for this name in an inner scope. */
751#define TREE_PUBLIC(NODE)((NODE)->base.public_flag) ((NODE)->base.public_flag)
752
753/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
754 of cached values, or is something else. */
755#define TYPE_CACHED_VALUES_P(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 755, __FUNCTION__))->base.public_flag)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 755, __FUNCTION__))
->base.public_flag)
756
757/* In a SAVE_EXPR, indicates that the original expression has already
758 been substituted with a VAR_DECL that contains the value. */
759#define SAVE_EXPR_RESOLVED_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 759, __FUNCTION__, (SAVE_EXPR)))->base.public_flag)
\
760 (SAVE_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 760, __FUNCTION__, (SAVE_EXPR)))
->base.public_flag)
761
762/* Set on a CALL_EXPR if this stdarg call should be passed the argument
763 pack. */
764#define CALL_EXPR_VA_ARG_PACK(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 764, __FUNCTION__, (CALL_EXPR)))->base.public_flag)
\
765 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 765, __FUNCTION__, (CALL_EXPR)))
->base.public_flag)
766
767/* In any expression, decl, or constant, nonzero means it has side effects or
768 reevaluation of the whole expression could produce a different value.
769 This is set if any subexpression is a function call, a side effect or a
770 reference to a volatile variable. In a ..._DECL, this is set only if the
771 declaration said `volatile'. This will never be set for a constant. */
772#define TREE_SIDE_EFFECTS(NODE)((non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 772, __FUNCTION__))->base.side_effects_flag)
\
773 (NON_TYPE_CHECK (NODE)(non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 773, __FUNCTION__))
->base.side_effects_flag)
774
775/* In a LABEL_DECL, nonzero means this label had its address taken
776 and therefore can never be deleted and is a jump target for
777 computed gotos. */
778#define FORCED_LABEL(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 778, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
)
(LABEL_DECL_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 778, __FUNCTION__, (LABEL_DECL)))
->base.side_effects_flag)
779
780/* Whether a case or a user-defined label is allowed to fall through to.
781 This is used to implement -Wimplicit-fallthrough. */
782#define FALLTHROUGH_LABEL_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 782, __FUNCTION__, (LABEL_DECL)))->base.private_flag)
\
783 (LABEL_DECL_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 783, __FUNCTION__, (LABEL_DECL)))
->base.private_flag)
784
785/* Set on the artificial label created for break; stmt from a switch.
786 This is used to implement -Wimplicit-fallthrough. */
787#define SWITCH_BREAK_LABEL_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 787, __FUNCTION__, (LABEL_DECL)))->base.protected_flag)
\
788 (LABEL_DECL_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 788, __FUNCTION__, (LABEL_DECL)))
->base.protected_flag)
789
790/* Nonzero means this expression is volatile in the C sense:
791 its address should be of type `volatile WHATEVER *'.
792 In other words, the declared item is volatile qualified.
793 This is used in _DECL nodes and _REF nodes.
794 On a FUNCTION_DECL node, this means the function does not
795 return normally. This is the same effect as setting
796 the attribute noreturn on the function in C.
797
798 In a ..._TYPE node, means this type is volatile-qualified.
799 But use TYPE_VOLATILE instead of this macro when the node is a type,
800 because eventually we may make that a different bit.
801
802 If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */
803#define TREE_THIS_VOLATILE(NODE)((NODE)->base.volatile_flag) ((NODE)->base.volatile_flag)
804
805/* Nonzero means this node will not trap. In an INDIRECT_REF, means
806 accessing the memory pointed to won't generate a trap. However,
807 this only applies to an object when used appropriately: it doesn't
808 mean that writing a READONLY mem won't trap.
809
810 In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
811 (or slice of the array) always belongs to the range of the array.
812 I.e. that the access will not trap, provided that the access to
813 the base to the array will not trap. */
814#define TREE_THIS_NOTRAP(NODE)((tree_check5 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 814, __FUNCTION__, (INDIRECT_REF), (MEM_REF), (TARGET_MEM_REF
), (ARRAY_REF), (ARRAY_RANGE_REF)))->base.nothrow_flag)
\
815 (TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, \(tree_check5 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 816, __FUNCTION__, (INDIRECT_REF), (MEM_REF), (TARGET_MEM_REF
), (ARRAY_REF), (ARRAY_RANGE_REF)))
816 ARRAY_RANGE_REF)(tree_check5 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 816, __FUNCTION__, (INDIRECT_REF), (MEM_REF), (TARGET_MEM_REF
), (ARRAY_REF), (ARRAY_RANGE_REF)))
->base.nothrow_flag)
817
818/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
819 nonzero means it may not be the lhs of an assignment.
820 Nonzero in a FUNCTION_DECL means this function should be treated
821 as "const" function (can only read its arguments). */
822#define TREE_READONLY(NODE)((non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 822, __FUNCTION__))->base.readonly_flag)
(NON_TYPE_CHECK (NODE)(non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 822, __FUNCTION__))
->base.readonly_flag)
823
824/* Value of expression is constant. Always on in all ..._CST nodes. May
825 also appear in an expression or decl where the value is constant. */
826#define TREE_CONSTANT(NODE)((non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 826, __FUNCTION__))->base.constant_flag)
(NON_TYPE_CHECK (NODE)(non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 826, __FUNCTION__))
->base.constant_flag)
827
828/* Nonzero if NODE, a type, has had its sizes gimplified. */
829#define TYPE_SIZES_GIMPLIFIED(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 829, __FUNCTION__))->base.constant_flag)
\
830 (TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 830, __FUNCTION__))
->base.constant_flag)
831
832/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
833#define DECL_UNSIGNED(NODE)((contains_struct_check ((NODE), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 833, __FUNCTION__))->base.u.bits.unsigned_flag)
\
834 (DECL_COMMON_CHECK (NODE)(contains_struct_check ((NODE), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 834, __FUNCTION__))
->base.u.bits.unsigned_flag)
835
836/* In integral and pointer types, means an unsigned type. */
837#define TYPE_UNSIGNED(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 837, __FUNCTION__))->base.u.bits.unsigned_flag)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 837, __FUNCTION__))
->base.u.bits.unsigned_flag)
838
839/* Same as TYPE_UNSIGNED but converted to SIGNOP. */
840#define TYPE_SIGN(NODE)((signop) ((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 840, __FUNCTION__))->base.u.bits.unsigned_flag))
((signop) TYPE_UNSIGNED (NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 840, __FUNCTION__))->base.u.bits.unsigned_flag)
)
841
842/* True if overflow wraps around for the given integral or pointer type. That
843 is, TYPE_MAX + 1 == TYPE_MIN. */
844#define TYPE_OVERFLOW_WRAPS(TYPE)((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 844, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
\
845 (POINTER_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
\
846 ? flag_wrapv_pointerglobal_options.x_flag_wrapv_pointer \
847 : (ANY_INTEGRAL_TYPE_CHECK(TYPE)(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 847, __FUNCTION__))
->base.u.bits.unsigned_flag \
848 || flag_wrapvglobal_options.x_flag_wrapv))
849
850/* True if overflow is undefined for the given integral or pointer type.
851 We may optimize on the assumption that values in the type never overflow.
852
853 IMPORTANT NOTE: Any optimization based on TYPE_OVERFLOW_UNDEFINED
854 must issue a warning based on warn_strict_overflow. In some cases
855 it will be appropriate to issue the warning immediately, and in
856 other cases it will be appropriate to simply set a flag and let the
857 caller decide whether a warning is appropriate or not. */
858#define TYPE_OVERFLOW_UNDEFINED(TYPE)((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) ? !
global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 858, __FUNCTION__))->base.u.bits.unsigned_flag &&
!global_options.x_flag_wrapv && !global_options.x_flag_trapv
))
\
859 (POINTER_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
\
860 ? !flag_wrapv_pointerglobal_options.x_flag_wrapv_pointer \
861 : (!ANY_INTEGRAL_TYPE_CHECK(TYPE)(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 861, __FUNCTION__))
->base.u.bits.unsigned_flag \
862 && !flag_wrapvglobal_options.x_flag_wrapv && !flag_trapvglobal_options.x_flag_trapv))
863
864/* True if overflow for the given integral type should issue a
865 trap. */
866#define TYPE_OVERFLOW_TRAPS(TYPE)(!(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 866, __FUNCTION__))->base.u.bits.unsigned_flag &&
global_options.x_flag_trapv)
\
867 (!ANY_INTEGRAL_TYPE_CHECK(TYPE)(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 867, __FUNCTION__))
->base.u.bits.unsigned_flag && flag_trapvglobal_options.x_flag_trapv)
868
869/* True if an overflow is to be preserved for sanitization. */
870#define TYPE_OVERFLOW_SANITIZED(TYPE)((((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE ||
((enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (TYPE)->base.code) == INTEGER_TYPE) &&
!((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE ||
((enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) ?
global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 870, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv)) && (global_options.x_flag_sanitize &
SANITIZE_SI_OVERFLOW))
\
871 (INTEGRAL_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (TYPE)->base.code) == INTEGER_TYPE)
\
872 && !TYPE_OVERFLOW_WRAPS (TYPE)((((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 872, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
\
873 && (flag_sanitizeglobal_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
874
875/* Nonzero in a VAR_DECL or STRING_CST means assembler code has been written.
876 Nonzero in a FUNCTION_DECL means that the function has been compiled.
877 This is interesting in an inline function, since it might not need
878 to be compiled separately.
879 Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ENUMERAL_TYPE
880 or TYPE_DECL if the debugging info for the type has been written.
881 In a BLOCK node, nonzero if reorder_blocks has already seen this block.
882 In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
883 PHI node. */
884#define TREE_ASM_WRITTEN(NODE)((NODE)->base.asm_written_flag) ((NODE)->base.asm_written_flag)
885
886/* Nonzero in a _DECL if the name is used in its scope.
887 Nonzero in an expr node means inhibit warning if value is unused.
888 In IDENTIFIER_NODEs, this means that some extern decl for this name
889 was used.
890 In a BLOCK, this means that the block contains variables that are used. */
891#define TREE_USED(NODE)((NODE)->base.used_flag) ((NODE)->base.used_flag)
892
893/* In a FUNCTION_DECL, nonzero means a call to the function cannot
894 throw an exception. In a CALL_EXPR, nonzero means the call cannot
895 throw. We can't easily check the node type here as the C++
896 frontend also uses this flag (for AGGR_INIT_EXPR). */
897#define TREE_NOTHROW(NODE)((NODE)->base.nothrow_flag) ((NODE)->base.nothrow_flag)
898
899/* In a CALL_EXPR, means that it's safe to use the target of the call
900 expansion as the return slot for a call that returns in memory. */
901#define CALL_EXPR_RETURN_SLOT_OPT(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 901, __FUNCTION__, (CALL_EXPR)))->base.private_flag)
\
902 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 902, __FUNCTION__, (CALL_EXPR)))
->base.private_flag)
903
904/* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that it is
905 passed by invisible reference (and the TREE_TYPE is a pointer to the true
906 type). */
907#define DECL_BY_REFERENCE(NODE)((tree_check3 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 907, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
\
908 (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \(tree_check3 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 909, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
909 RESULT_DECL)(tree_check3 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 909, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
910
911/* In VAR_DECL and PARM_DECL, set when the decl has been used except for
912 being set. */
913#define DECL_READ_P(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 913, __FUNCTION__, (VAR_DECL), (PARM_DECL)))->decl_common
.decl_read_flag)
\
914 (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 914, __FUNCTION__, (VAR_DECL), (PARM_DECL)))
->decl_common.decl_read_flag)
915
916/* In VAR_DECL or RESULT_DECL, set when significant code movement precludes
917 attempting to share the stack slot with some other variable. */
918#define DECL_NONSHAREABLE(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 918, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))->decl_common
.decl_nonshareable_flag)
\
919 (TREE_CHECK2 (NODE, VAR_DECL, \(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 920, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))
920 RESULT_DECL)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 920, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))
->decl_common.decl_nonshareable_flag)
921
922/* In a PARM_DECL, set for Fortran hidden string length arguments that some
923 buggy callers don't pass to the callee. */
924#define DECL_HIDDEN_STRING_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 924, __FUNCTION__, (PARM_DECL)))->decl_common.decl_nonshareable_flag
)
\
925 (TREE_CHECK (NODE, PARM_DECL)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 925, __FUNCTION__, (PARM_DECL)))
->decl_common.decl_nonshareable_flag)
926
927/* In a CALL_EXPR, means that the call is the jump from a thunk to the
928 thunked-to function. Be careful to avoid using this macro when one of the
929 next two applies instead. */
930#define CALL_FROM_THUNK_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 930, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
(CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 930, __FUNCTION__, (CALL_EXPR)))
->base.protected_flag)
931
932/* In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that
933 it has been built for the declaration of a variable-sized object and, if the
934 function being called is BUILT_IN_MEMCPY, means that it has been built for
935 the assignment of a variable-sized object. */
936#define CALL_ALLOCA_FOR_VAR_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 936, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
\
937 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 937, __FUNCTION__, (CALL_EXPR)))
->base.protected_flag)
938
939/* In a CALL_EXPR, if the function being called is DECL_IS_OPERATOR_NEW_P or
940 DECL_IS_OPERATOR_DELETE_P, true for allocator calls from C++ new or delete
941 expressions. Not set for C++20 destroying delete operators. */
942#define CALL_FROM_NEW_OR_DELETE_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 942, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
\
943 (CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 943, __FUNCTION__, (CALL_EXPR)))
->base.protected_flag)
944
945/* Used in classes in C++. */
946#define TREE_PRIVATE(NODE)((NODE)->base.private_flag) ((NODE)->base.private_flag)
947/* Used in classes in C++. */
948#define TREE_PROTECTED(NODE)((NODE)->base.protected_flag) ((NODE)->base.protected_flag)
949
950/* True if reference type NODE is a C++ rvalue reference. */
951#define TYPE_REF_IS_RVALUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 951, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
)
\
952 (REFERENCE_TYPE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 952, __FUNCTION__, (REFERENCE_TYPE)))
->base.private_flag)
953
954/* Nonzero in a _DECL if the use of the name is defined as a
955 deprecated feature by __attribute__((deprecated)). */
956#define TREE_DEPRECATED(NODE)((NODE)->base.deprecated_flag) \
957 ((NODE)->base.deprecated_flag)
958
959/* Nonzero in a _DECL if the use of the name is defined as an
960 unavailable feature by __attribute__((unavailable)). */
961#define TREE_UNAVAILABLE(NODE)((NODE)->base.u.bits.unavailable_flag) \
962 ((NODE)->base.u.bits.unavailable_flag)
963
964/* Nonzero indicates an IDENTIFIER_NODE that names an anonymous
965 aggregate, (as created by anon_aggr_name_format). */
966#define IDENTIFIER_ANON_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 966, __FUNCTION__, (IDENTIFIER_NODE)))->base.private_flag
)
\
967 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 967, __FUNCTION__, (IDENTIFIER_NODE)))
->base.private_flag)
968
969/* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
970 uses are to be substituted for uses of the TREE_CHAINed identifier. */
971#define IDENTIFIER_TRANSPARENT_ALIAS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 971, __FUNCTION__, (IDENTIFIER_NODE)))->base.deprecated_flag
)
\
972 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 972, __FUNCTION__, (IDENTIFIER_NODE)))
->base.deprecated_flag)
973
974/* In an aggregate type, indicates that the scalar fields of the type are
975 stored in reverse order from the target order. This effectively
976 toggles BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN within the type. */
977#define TYPE_REVERSE_STORAGE_ORDER(NODE)((tree_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 977, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
\
978 (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)(tree_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 978, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))
->base.u.bits.saturating_flag)
979
980/* In a non-aggregate type, indicates a saturating type. */
981#define TYPE_SATURATING(NODE)((tree_not_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 981, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
\
982 (TREE_NOT_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)(tree_not_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 982, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))
->base.u.bits.saturating_flag)
983
984/* In a BIT_FIELD_REF and MEM_REF, indicates that the reference is to a group
985 of bits stored in reverse order from the target order. This effectively
986 toggles both BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN for the reference.
987
988 The overall strategy is to preserve the invariant that every scalar in
989 memory is associated with a single storage order, i.e. all accesses to
990 this scalar are done with the same storage order. This invariant makes
991 it possible to factor out the storage order in most transformations, as
992 only the address and/or the value (in target order) matter for them.
993 But, of course, the storage order must be preserved when the accesses
994 themselves are rewritten or transformed. */
995#define REF_REVERSE_STORAGE_ORDER(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 995, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))->base.default_def_flag
)
\
996 (TREE_CHECK2 (NODE, BIT_FIELD_REF, MEM_REF)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 996, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))
->base.default_def_flag)
997
998 /* In an ADDR_EXPR, indicates that this is a pointer to nested function
999 represented by a descriptor instead of a trampoline. */
1000#define FUNC_ADDR_BY_DESCRIPTOR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1000, __FUNCTION__, (ADDR_EXPR)))->base.default_def_flag
)
\
1001 (TREE_CHECK (NODE, ADDR_EXPR)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1001, __FUNCTION__, (ADDR_EXPR)))
->base.default_def_flag)
1002
1003/* In a CALL_EXPR, indicates that this is an indirect call for which
1004 pointers to nested function are descriptors instead of trampolines. */
1005#define CALL_EXPR_BY_DESCRIPTOR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1005, __FUNCTION__, (CALL_EXPR)))->base.default_def_flag
)
\
1006 (TREE_CHECK (NODE, CALL_EXPR)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1006, __FUNCTION__, (CALL_EXPR)))
->base.default_def_flag)
1007
1008/* These flags are available for each language front end to use internally. */
1009#define TREE_LANG_FLAG_0(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1009, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
\
1010 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1010, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_0)
1011#define TREE_LANG_FLAG_1(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1011, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
\
1012 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1012, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_1)
1013#define TREE_LANG_FLAG_2(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1013, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
\
1014 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1014, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_2)
1015#define TREE_LANG_FLAG_3(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1015, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_3)
\
1016 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1016, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_3)
1017#define TREE_LANG_FLAG_4(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1017, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_4)
\
1018 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1018, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_4)
1019#define TREE_LANG_FLAG_5(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1019, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_5)
\
1020 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1020, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_5)
1021#define TREE_LANG_FLAG_6(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1021, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_6)
\
1022 (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)(tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1022, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_6)
1023
1024/* Define additional fields and accessors for nodes representing constants. */
1025
1026#define TREE_INT_CST_NUNITS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1026, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.unextended
)
\
1027 (INTEGER_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1027, __FUNCTION__, (INTEGER_CST)))
->base.u.int_length.unextended)
1028#define TREE_INT_CST_EXT_NUNITS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1028, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.extended
)
\
1029 (INTEGER_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1029, __FUNCTION__, (INTEGER_CST)))
->base.u.int_length.extended)
1030#define TREE_INT_CST_OFFSET_NUNITS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1030, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.offset
)
\
1031 (INTEGER_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1031, __FUNCTION__, (INTEGER_CST)))
->base.u.int_length.offset)
1032#define TREE_INT_CST_ELT(NODE, I)(*tree_int_cst_elt_check ((NODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1032, __FUNCTION__))
TREE_INT_CST_ELT_CHECK (NODE, I)(*tree_int_cst_elt_check ((NODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1032, __FUNCTION__))
1033#define TREE_INT_CST_LOW(NODE)((unsigned long) (*tree_int_cst_elt_check ((NODE), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1033, __FUNCTION__)))
\
1034 ((unsigned HOST_WIDE_INTlong) TREE_INT_CST_ELT (NODE, 0)(*tree_int_cst_elt_check ((NODE), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1034, __FUNCTION__))
)
1035
1036/* Return true if NODE is a POLY_INT_CST. This is only ever true on
1037 targets with variable-sized modes. */
1038#define POLY_INT_CST_P(NODE)(1 > 1 && ((enum tree_code) (NODE)->base.code) ==
POLY_INT_CST)
\
1039 (NUM_POLY_INT_COEFFS1 > 1 && TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == POLY_INT_CST)
1040
1041/* In a POLY_INT_CST node. */
1042#define POLY_INT_CST_COEFF(NODE, I)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1042, __FUNCTION__, (POLY_INT_CST)))->poly_int_cst.coeffs
[I])
\
1043 (POLY_INT_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1043, __FUNCTION__, (POLY_INT_CST)))
->poly_int_cst.coeffs[I])
1044
1045#define TREE_REAL_CST_PTR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1045, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
(REAL_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1045, __FUNCTION__, (REAL_CST)))
->real_cst.real_cst_ptr)
1046#define TREE_REAL_CST(NODE)(*((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1046, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)
(*TREE_REAL_CST_PTR (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1046, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)
1047
1048#define TREE_FIXED_CST_PTR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1048, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
)
\
1049 (FIXED_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1049, __FUNCTION__, (FIXED_CST)))
->fixed_cst.fixed_cst_ptr)
1050#define TREE_FIXED_CST(NODE)(*((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1050, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
))
(*TREE_FIXED_CST_PTR (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1050, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
)
)
1051
1052/* In a STRING_CST */
1053/* In C terms, this is sizeof, not strlen. */
1054#define TREE_STRING_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1054, __FUNCTION__, (STRING_CST)))->string.length)
(STRING_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1054, __FUNCTION__, (STRING_CST)))
->string.length)
1055#define TREE_STRING_POINTER(NODE)((const char *)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1055, __FUNCTION__, (STRING_CST)))->string.str))
\
1056 ((const char *)(STRING_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1056, __FUNCTION__, (STRING_CST)))
->string.str))
1057
1058/* In a COMPLEX_CST node. */
1059#define TREE_REALPART(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1059, __FUNCTION__, (COMPLEX_CST)))->complex.real)
(COMPLEX_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1059, __FUNCTION__, (COMPLEX_CST)))
->complex.real)
1060#define TREE_IMAGPART(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1060, __FUNCTION__, (COMPLEX_CST)))->complex.imag)
(COMPLEX_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1060, __FUNCTION__, (COMPLEX_CST)))
->complex.imag)
1061
1062/* In a VECTOR_CST node. See generic.texi for details. */
1063#define VECTOR_CST_NELTS(NODE)(TYPE_VECTOR_SUBPARTS (((contains_struct_check ((NODE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1063, __FUNCTION__))->typed.type)))
(TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE)((contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1063, __FUNCTION__))->typed.type)
))
1064#define VECTOR_CST_ELT(NODE,IDX)vector_cst_elt (NODE, IDX) vector_cst_elt (NODE, IDX)
1065
1066#define VECTOR_CST_LOG2_NPATTERNS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1066, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
)
\
1067 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1067, __FUNCTION__, (VECTOR_CST)))
->base.u.vector_cst.log2_npatterns)
1068#define VECTOR_CST_NPATTERNS(NODE)(1U << ((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1068, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
))
\
1069 (1U << VECTOR_CST_LOG2_NPATTERNS (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1069, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
)
)
1070#define VECTOR_CST_NELTS_PER_PATTERN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1070, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
)
\
1071 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1071, __FUNCTION__, (VECTOR_CST)))
->base.u.vector_cst.nelts_per_pattern)
1072#define VECTOR_CST_DUPLICATE_P(NODE)(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1072, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
) == 1)
\
1073 (VECTOR_CST_NELTS_PER_PATTERN (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1073, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
)
== 1)
1074#define VECTOR_CST_STEPPED_P(NODE)(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1074, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
) == 3)
\
1075 (VECTOR_CST_NELTS_PER_PATTERN (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1075, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
)
== 3)
1076#define VECTOR_CST_ENCODED_ELTS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1076, __FUNCTION__, (VECTOR_CST)))->vector.elts)
\
1077 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1077, __FUNCTION__, (VECTOR_CST)))
->vector.elts)
1078#define VECTOR_CST_ENCODED_ELT(NODE, ELT)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1078, __FUNCTION__, (VECTOR_CST)))->vector.elts[ELT])
\
1079 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1079, __FUNCTION__, (VECTOR_CST)))
->vector.elts[ELT])
1080
1081/* Define fields and accessors for some special-purpose tree nodes. */
1082
1083#define IDENTIFIER_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1083, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)
\
1084 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1084, __FUNCTION__, (IDENTIFIER_NODE)))
->identifier.id.len)
1085#define IDENTIFIER_POINTER(NODE)((const char *) (tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1085, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
\
1086 ((const char *) IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1086, __FUNCTION__, (IDENTIFIER_NODE)))
->identifier.id.str)
1087#define IDENTIFIER_HASH_VALUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1087, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.hash_value
)
\
1088 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1088, __FUNCTION__, (IDENTIFIER_NODE)))
->identifier.id.hash_value)
1089
1090/* Translate a hash table identifier pointer to a tree_identifier
1091 pointer, and vice versa. */
1092
1093#define HT_IDENT_TO_GCC_IDENT(NODE)((tree) ((char *) (NODE) - sizeof (struct tree_common))) \
1094 ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
1095#define GCC_IDENT_TO_HT_IDENT(NODE)(&((struct tree_identifier *) (NODE))->id) (&((struct tree_identifier *) (NODE))->id)
1096
1097/* In a TREE_LIST node. */
1098#define TREE_PURPOSE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1098, __FUNCTION__, (TREE_LIST)))->list.purpose)
(TREE_LIST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1098, __FUNCTION__, (TREE_LIST)))
->list.purpose)
1099#define TREE_VALUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1099, __FUNCTION__, (TREE_LIST)))->list.value)
(TREE_LIST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1099, __FUNCTION__, (TREE_LIST)))
->list.value)
1100
1101/* In a TREE_VEC node. */
1102#define TREE_VEC_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1102, __FUNCTION__, (TREE_VEC)))->base.u.length)
(TREE_VEC_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1102, __FUNCTION__, (TREE_VEC)))
->base.u.length)
1103#define TREE_VEC_END(NODE)((void) (tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1103, __FUNCTION__, (TREE_VEC))), &((NODE)->vec.a[(NODE
)->vec.base.u.length]))
\
1104 ((void) TREE_VEC_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1104, __FUNCTION__, (TREE_VEC)))
, &((NODE)->vec.a[(NODE)->vec.base.u.length]))
1105
1106#define TREE_VEC_ELT(NODE,I)(*((const_cast<tree *> (tree_vec_elt_check ((NODE), (I)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1106, __FUNCTION__)))))
TREE_VEC_ELT_CHECK (NODE, I)(*((const_cast<tree *> (tree_vec_elt_check ((NODE), (I)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1106, __FUNCTION__)))))
1107
1108/* In a CONSTRUCTOR node. */
1109#define CONSTRUCTOR_ELTS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1109, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)
(CONSTRUCTOR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1109, __FUNCTION__, (CONSTRUCTOR)))
->constructor.elts)
1110#define CONSTRUCTOR_ELT(NODE,IDX)(&(*((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1110, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))[
IDX])
\
1111 (&(*CONSTRUCTOR_ELTS (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1111, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)
)[IDX])
1112#define CONSTRUCTOR_NELTS(NODE)(vec_safe_length (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1112, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
\
1113 (vec_safe_length (CONSTRUCTOR_ELTS (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1113, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)
))
1114#define CONSTRUCTOR_NO_CLEARING(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1114, __FUNCTION__, (CONSTRUCTOR)))->base.public_flag)
\
1115 (CONSTRUCTOR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1115, __FUNCTION__, (CONSTRUCTOR)))
->base.public_flag)
1116
1117/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
1118 value of each element (stored within VAL). IX must be a scratch variable
1119 of unsigned integer type. */
1120#define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL)for (IX = 0; (IX >= vec_safe_length (V)) ? false : ((VAL =
(*(V))[IX].value), true); (IX)++)
\
1121 for (IX = 0; (IX >= vec_safe_length (V)) \
1122 ? false \
1123 : ((VAL = (*(V))[IX].value), \
1124 true); \
1125 (IX)++)
1126
1127/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both
1128 the value of each element (stored within VAL) and its index (stored
1129 within INDEX). IX must be a scratch variable of unsigned integer type. */
1130#define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL)for (IX = 0; (IX >= vec_safe_length (V)) ? false : (((void
) (VAL = (*V)[IX].value)), (INDEX = (*V)[IX].index), true); (
IX)++)
\
1131 for (IX = 0; (IX >= vec_safe_length (V)) \
1132 ? false \
1133 : (((void) (VAL = (*V)[IX].value)), \
1134 (INDEX = (*V)[IX].index), \
1135 true); \
1136 (IX)++)
1137
1138/* Append a new constructor element to V, with the specified INDEX and VAL. */
1139#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE)do { constructor_elt _ce___ = {INDEX, VALUE}; vec_safe_push (
(V), _ce___); } while (0)
\
1140 do { \
1141 constructor_elt _ce___ = {INDEX, VALUE}; \
1142 vec_safe_push ((V), _ce___); \
1143 } while (0)
1144
1145/* True if NODE, a FIELD_DECL, is to be processed as a bitfield for
1146 constructor output purposes. */
1147#define CONSTRUCTOR_BITFIELD_P(NODE)(((tree_check (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1147, __FUNCTION__, (FIELD_DECL)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1147, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
) && ((contains_struct_check ((NODE), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1147, __FUNCTION__))->decl_common.mode) != ((void) 0, E_BLKmode
))
\
1148 (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE))((tree_check (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1148, __FUNCTION__, (FIELD_DECL)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1148, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
)
&& DECL_MODE (NODE)((contains_struct_check ((NODE), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1148, __FUNCTION__))->decl_common.mode)
!= BLKmode((void) 0, E_BLKmode))
1149
1150/* True if NODE is a clobber right hand side, an expression of indeterminate
1151 value that clobbers the LHS in a copy instruction. We use a volatile
1152 empty CONSTRUCTOR for this, as it matches most of the necessary semantic.
1153 In particular the volatile flag causes us to not prematurely remove
1154 such clobber instructions. */
1155#define TREE_CLOBBER_P(NODE)(((enum tree_code) (NODE)->base.code) == CONSTRUCTOR &&
((NODE)->base.volatile_flag))
\
1156 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE)((NODE)->base.volatile_flag))
1157
1158/* Define fields and accessors for some nodes that represent expressions. */
1159
1160/* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */
1161#define IS_EMPTY_STMT(NODE)(((enum tree_code) (NODE)->base.code) == NOP_EXPR &&
(((enum tree_code) (((contains_struct_check ((NODE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1161, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
) && integer_zerop ((*((const_cast<tree*> (tree_operand_check
((NODE), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1161, __FUNCTION__)))))))
(TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == NOP_EXPR \
1162 && VOID_TYPE_P (TREE_TYPE (NODE))(((enum tree_code) (((contains_struct_check ((NODE), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1162, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
\
1163 && integer_zerop (TREE_OPERAND (NODE, 0)(*((const_cast<tree*> (tree_operand_check ((NODE), (0),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1163, __FUNCTION__)))))
))
1164
1165/* In ordinary expression nodes. */
1166#define TREE_OPERAND_LENGTH(NODE)tree_operand_length (NODE) tree_operand_length (NODE)
1167#define TREE_OPERAND(NODE, I)(*((const_cast<tree*> (tree_operand_check ((NODE), (I),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1167, __FUNCTION__)))))
TREE_OPERAND_CHECK (NODE, I)(*((const_cast<tree*> (tree_operand_check ((NODE), (I),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1167, __FUNCTION__)))))
1168
1169/* In a tcc_vl_exp node, operand 0 is an INT_CST node holding the operand
1170 length. Its value includes the length operand itself; that is,
1171 the minimum valid length is 1.
1172 Note that we have to bypass the use of TREE_OPERAND to access
1173 that field to avoid infinite recursion in expanding the macros. */
1174#define VL_EXP_OPERAND_LENGTH(NODE)((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
((NODE), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1174, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1174, __FUNCTION__))))
\
1175 ((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0])((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
((NODE), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1175, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1175, __FUNCTION__)))
)
1176
1177/* Nonzero if gimple_debug_nonbind_marker_p() may possibly hold. */
1178#define MAY_HAVE_DEBUG_MARKER_STMTSglobal_options.x_debug_nonbind_markers_p debug_nonbind_markers_pglobal_options.x_debug_nonbind_markers_p
1179/* Nonzero if gimple_debug_bind_p() (and thus
1180 gimple_debug_source_bind_p()) may possibly hold. */
1181#define MAY_HAVE_DEBUG_BIND_STMTSglobal_options.x_flag_var_tracking_assignments flag_var_tracking_assignmentsglobal_options.x_flag_var_tracking_assignments
1182/* Nonzero if is_gimple_debug() may possibly hold. */
1183#define MAY_HAVE_DEBUG_STMTS(global_options.x_debug_nonbind_markers_p || global_options.x_flag_var_tracking_assignments
)
\
1184 (MAY_HAVE_DEBUG_MARKER_STMTSglobal_options.x_debug_nonbind_markers_p || MAY_HAVE_DEBUG_BIND_STMTSglobal_options.x_flag_var_tracking_assignments)
1185
1186/* In a LOOP_EXPR node. */
1187#define LOOP_EXPR_BODY(NODE)(*(tree_operand_check_code ((NODE), (LOOP_EXPR), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1187, __FUNCTION__)))
TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)(*(tree_operand_check_code ((NODE), (LOOP_EXPR), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1187, __FUNCTION__)))
1188
1189/* The source location of this expression. Non-tree_exp nodes such as
1190 decls and constants can be shared among multiple locations, so
1191 return nothing. */
1192#define EXPR_LOCATION(NODE)((((NODE)) && ((tree_code_type[(int) (((enum tree_code
) ((NODE))->base.code))]) >= tcc_reference && (
tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression)) ? (NODE)->exp.locus : ((location_t
) 0))
\
1193 (CAN_HAVE_LOCATION_P ((NODE))(((NODE)) && ((tree_code_type[(int) (((enum tree_code
) ((NODE))->base.code))]) >= tcc_reference && (
tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression))
? (NODE)->exp.locus : UNKNOWN_LOCATION((location_t) 0))
1194#define SET_EXPR_LOCATION(NODE, LOCUS)(expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1194, __FUNCTION__))->exp.locus = (LOCUS)
EXPR_CHECK ((NODE))(expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1194, __FUNCTION__))
->exp.locus = (LOCUS)
1195#define EXPR_HAS_LOCATION(NODE)(((IS_ADHOC_LOC (((((NODE)) && ((tree_code_type[(int)
(((enum tree_code) ((NODE))->base.code))]) >= tcc_reference
&& (tree_code_type[(int) (((enum tree_code) ((NODE))
->base.code))]) <= tcc_expression)) ? (NODE)->exp.locus
: ((location_t) 0)))) ? get_location_from_adhoc_loc (line_table
, ((((NODE)) && ((tree_code_type[(int) (((enum tree_code
) ((NODE))->base.code))]) >= tcc_reference && (
tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression)) ? (NODE)->exp.locus : ((location_t
) 0))) : (((((NODE)) && ((tree_code_type[(int) (((enum
tree_code) ((NODE))->base.code))]) >= tcc_reference &&
(tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression)) ? (NODE)->exp.locus : ((location_t
) 0)))) != ((location_t) 0))
(LOCATION_LOCUS (EXPR_LOCATION (NODE))((IS_ADHOC_LOC (((((NODE)) && ((tree_code_type[(int) (
((enum tree_code) ((NODE))->base.code))]) >= tcc_reference
&& (tree_code_type[(int) (((enum tree_code) ((NODE))
->base.code))]) <= tcc_expression)) ? (NODE)->exp.locus
: ((location_t) 0)))) ? get_location_from_adhoc_loc (line_table
, ((((NODE)) && ((tree_code_type[(int) (((enum tree_code
) ((NODE))->base.code))]) >= tcc_reference && (
tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression)) ? (NODE)->exp.locus : ((location_t
) 0))) : (((((NODE)) && ((tree_code_type[(int) (((enum
tree_code) ((NODE))->base.code))]) >= tcc_reference &&
(tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression)) ? (NODE)->exp.locus : ((location_t
) 0))))
\
1196 != UNKNOWN_LOCATION((location_t) 0))
1197/* The location to be used in a diagnostic about this expression. Do not
1198 use this macro if the location will be assigned to other expressions. */
1199#define EXPR_LOC_OR_LOC(NODE, LOCUS)((((IS_ADHOC_LOC (((((NODE)) && ((tree_code_type[(int
) (((enum tree_code) ((NODE))->base.code))]) >= tcc_reference
&& (tree_code_type[(int) (((enum tree_code) ((NODE))
->base.code))]) <= tcc_expression)) ? (NODE)->exp.locus
: ((location_t) 0)))) ? get_location_from_adhoc_loc (line_table
, ((((NODE)) && ((tree_code_type[(int) (((enum tree_code
) ((NODE))->base.code))]) >= tcc_reference && (
tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression)) ? (NODE)->exp.locus : ((location_t
) 0))) : (((((NODE)) && ((tree_code_type[(int) (((enum
tree_code) ((NODE))->base.code))]) >= tcc_reference &&
(tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression)) ? (NODE)->exp.locus : ((location_t
) 0)))) != ((location_t) 0)) ? (NODE)->exp.locus : (LOCUS)
)
(EXPR_HAS_LOCATION (NODE)(((IS_ADHOC_LOC (((((NODE)) && ((tree_code_type[(int)
(((enum tree_code) ((NODE))->base.code))]) >= tcc_reference
&& (tree_code_type[(int) (((enum tree_code) ((NODE))
->base.code))]) <= tcc_expression)) ? (NODE)->exp.locus
: ((location_t) 0)))) ? get_location_from_adhoc_loc (line_table
, ((((NODE)) && ((tree_code_type[(int) (((enum tree_code
) ((NODE))->base.code))]) >= tcc_reference && (
tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression)) ? (NODE)->exp.locus : ((location_t
) 0))) : (((((NODE)) && ((tree_code_type[(int) (((enum
tree_code) ((NODE))->base.code))]) >= tcc_reference &&
(tree_code_type[(int) (((enum tree_code) ((NODE))->base.code
))]) <= tcc_expression)) ? (NODE)->exp.locus : ((location_t
) 0)))) != ((location_t) 0))
\
1200 ? (NODE)->exp.locus : (LOCUS))
1201#define EXPR_FILENAME(NODE)((expand_location ((expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1201, __FUNCTION__))->exp.locus)).file)
LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus)((expand_location ((expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1201, __FUNCTION__))->exp.locus)).file)
1202#define EXPR_LINENO(NODE)((expand_location ((expr_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1202, __FUNCTION__))->exp.locus)).line)
LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus)((expand_location ((expr_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1202, __FUNCTION__))->exp.locus)).line)
1203
1204#define CAN_HAVE_RANGE_P(NODE)(((NODE) && ((tree_code_type[(int) (((enum tree_code)
(NODE)->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) (NODE)->base.code))]) <= tcc_expression
)))
(CAN_HAVE_LOCATION_P (NODE)((NODE) && ((tree_code_type[(int) (((enum tree_code) (
NODE)->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) (NODE)->base.code))]) <= tcc_expression
))
)
1205#define EXPR_LOCATION_RANGE(NODE)(get_expr_source_range ((expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1205, __FUNCTION__))))
(get_expr_source_range (EXPR_CHECK ((NODE))(expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1205, __FUNCTION__))
))
1206
1207#define EXPR_HAS_RANGE(NODE)((((NODE) && ((tree_code_type[(int) (((enum tree_code
) (NODE)->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) (NODE)->base.code))]) <= tcc_expression
))) ? (get_expr_source_range ((expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1207, __FUNCTION__)))).m_start != ((location_t) 0) : false)
\
1208 (CAN_HAVE_RANGE_P (NODE)(((NODE) && ((tree_code_type[(int) (((enum tree_code)
(NODE)->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) (NODE)->base.code))]) <= tcc_expression
)))
\
1209 ? EXPR_LOCATION_RANGE (NODE)(get_expr_source_range ((expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1209, __FUNCTION__))))
.m_start != UNKNOWN_LOCATION((location_t) 0) \
1210 : false)
1211
1212/* True if a tree is an expression or statement that can have a
1213 location. */
1214#define CAN_HAVE_LOCATION_P(NODE)((NODE) && ((tree_code_type[(int) (((enum tree_code) (
NODE)->base.code))]) >= tcc_reference && (tree_code_type
[(int) (((enum tree_code) (NODE)->base.code))]) <= tcc_expression
))
((NODE) && EXPR_P (NODE)((tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (NODE)->base.code))]) <= tcc_expression
)
)
1215
1216static inline source_range
1217get_expr_source_range (tree expr)
1218{
1219 location_t loc = EXPR_LOCATION (expr)((((expr)) && ((tree_code_type[(int) (((enum tree_code
) ((expr))->base.code))]) >= tcc_reference && (
tree_code_type[(int) (((enum tree_code) ((expr))->base.code
))]) <= tcc_expression)) ? (expr)->exp.locus : ((location_t
) 0))
;
1220 return get_range_from_loc (line_table, loc);
1221}
1222
1223extern void protected_set_expr_location (tree, location_t);
1224extern void protected_set_expr_location_if_unset (tree, location_t);
1225
1226WARN_UNUSED_RESULT__attribute__ ((__warn_unused_result__)) extern tree maybe_wrap_with_location (tree, location_t);
1227
1228extern int suppress_location_wrappers;
1229
1230/* A class for suppressing the creation of location wrappers.
1231 Location wrappers will not be created during the lifetime
1232 of an instance of this class. */
1233
1234class auto_suppress_location_wrappers
1235{
1236 public:
1237 auto_suppress_location_wrappers () { ++suppress_location_wrappers; }
1238 ~auto_suppress_location_wrappers () { --suppress_location_wrappers; }
1239};
1240
1241/* In a TARGET_EXPR node. */
1242#define TARGET_EXPR_SLOT(NODE)(*(tree_operand_check_code ((NODE), (TARGET_EXPR), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1242, __FUNCTION__)))
TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)(*(tree_operand_check_code ((NODE), (TARGET_EXPR), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1242, __FUNCTION__)))
1243#define TARGET_EXPR_INITIAL(NODE)(*(tree_operand_check_code ((NODE), (TARGET_EXPR), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1243, __FUNCTION__)))
TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)(*(tree_operand_check_code ((NODE), (TARGET_EXPR), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1243, __FUNCTION__)))
1244#define TARGET_EXPR_CLEANUP(NODE)(*(tree_operand_check_code ((NODE), (TARGET_EXPR), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1244, __FUNCTION__)))
TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)(*(tree_operand_check_code ((NODE), (TARGET_EXPR), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1244, __FUNCTION__)))
1245/* Don't elide the initialization of TARGET_EXPR_SLOT for this TARGET_EXPR
1246 on rhs of MODIFY_EXPR. */
1247#define TARGET_EXPR_NO_ELIDE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1247, __FUNCTION__, (TARGET_EXPR)))->base.private_flag)
(TARGET_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1247, __FUNCTION__, (TARGET_EXPR)))
->base.private_flag)
1248
1249/* DECL_EXPR accessor. This gives access to the DECL associated with
1250 the given declaration statement. */
1251#define DECL_EXPR_DECL(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1251, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1251, __FUNCTION__)))))
TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1251, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1251, __FUNCTION__)))))
1252
1253#define EXIT_EXPR_COND(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1253, __FUNCTION__, (EXIT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1253, __FUNCTION__)))))
TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1253, __FUNCTION__, (EXIT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1253, __FUNCTION__)))))
1254
1255/* COMPOUND_LITERAL_EXPR accessors. */
1256#define COMPOUND_LITERAL_EXPR_DECL_EXPR(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1256, __FUNCTION__, (COMPOUND_LITERAL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1256, __FUNCTION__)))))
\
1257 TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1257, __FUNCTION__, (COMPOUND_LITERAL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1257, __FUNCTION__)))))
1258#define COMPOUND_LITERAL_EXPR_DECL(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
(((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1258, __FUNCTION__, (COMPOUND_LITERAL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1258, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1258, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1258, __FUNCTION__)))))
\
1259 DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_EXPR (NODE))(*((const_cast<tree*> (tree_operand_check (((tree_check
(((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1259, __FUNCTION__, (COMPOUND_LITERAL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1259, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1259, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1259, __FUNCTION__)))))
1260
1261/* SWITCH_EXPR accessors. These give access to the condition and body. */
1262#define SWITCH_COND(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1262, __FUNCTION__, (SWITCH_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1262, __FUNCTION__)))))
TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1262, __FUNCTION__, (SWITCH_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1262, __FUNCTION__)))))
1263#define SWITCH_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1263, __FUNCTION__, (SWITCH_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1263, __FUNCTION__)))))
TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1263, __FUNCTION__, (SWITCH_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1263, __FUNCTION__)))))
1264/* True if there are case labels for all possible values of SWITCH_COND, either
1265 because there is a default: case label or because the case label ranges cover
1266 all values. */
1267#define SWITCH_ALL_CASES_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1267, __FUNCTION__, (SWITCH_EXPR)))->base.private_flag)
(SWITCH_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1267, __FUNCTION__, (SWITCH_EXPR)))
->base.private_flag)
1268
1269/* CASE_LABEL_EXPR accessors. These give access to the high and low values
1270 of a case label, respectively. */
1271#define CASE_LOW(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1271, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1271, __FUNCTION__)))))
TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1271, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1271, __FUNCTION__)))))
1272#define CASE_HIGH(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1272, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1272, __FUNCTION__)))))
TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1272, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1272, __FUNCTION__)))))
1273#define CASE_LABEL(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1273, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1273, __FUNCTION__)))))
TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1273, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1273, __FUNCTION__)))))
1274#define CASE_CHAIN(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1274, __FUNCTION__, (CASE_LABEL_EXPR)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1274, __FUNCTION__)))))
TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 3)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1274, __FUNCTION__, (CASE_LABEL_EXPR)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1274, __FUNCTION__)))))
1275
1276/* The operands of a TARGET_MEM_REF. Operands 0 and 1 have to match
1277 corresponding MEM_REF operands. */
1278#define TMR_BASE(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1278, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1278, __FUNCTION__))))))
(TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1278, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1278, __FUNCTION__)))))
)
1279#define TMR_OFFSET(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1279, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1279, __FUNCTION__))))))
(TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1279, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1279, __FUNCTION__)))))
)
1280#define TMR_INDEX(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1280, __FUNCTION__, (TARGET_MEM_REF)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1280, __FUNCTION__))))))
(TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1280, __FUNCTION__, (TARGET_MEM_REF)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1280, __FUNCTION__)))))
)
1281#define TMR_STEP(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1281, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1281, __FUNCTION__))))))
(TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1281, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1281, __FUNCTION__)))))
)
1282#define TMR_INDEX2(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1282, __FUNCTION__, (TARGET_MEM_REF)))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1282, __FUNCTION__))))))
(TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1282, __FUNCTION__, (TARGET_MEM_REF)))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1282, __FUNCTION__)))))
)
1283
1284#define MR_DEPENDENCE_CLIQUE(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1284, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique)
\
1285 (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1285, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))
->base.u.dependence_info.clique)
1286#define MR_DEPENDENCE_BASE(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1286, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.base)
\
1287 (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1287, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))
->base.u.dependence_info.base)
1288
1289/* The operands of a BIND_EXPR. */
1290#define BIND_EXPR_VARS(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1290, __FUNCTION__, (BIND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1290, __FUNCTION__))))))
(TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1290, __FUNCTION__, (BIND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1290, __FUNCTION__)))))
)
1291#define BIND_EXPR_BODY(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1291, __FUNCTION__, (BIND_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1291, __FUNCTION__))))))
(TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1291, __FUNCTION__, (BIND_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1291, __FUNCTION__)))))
)
1292#define BIND_EXPR_BLOCK(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1292, __FUNCTION__, (BIND_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1292, __FUNCTION__))))))
(TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1292, __FUNCTION__, (BIND_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1292, __FUNCTION__)))))
)
1293
1294/* GOTO_EXPR accessor. This gives access to the label associated with
1295 a goto statement. */
1296#define GOTO_DESTINATION(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1296, __FUNCTION__, (GOTO_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1296, __FUNCTION__)))))
TREE_OPERAND (GOTO_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1296, __FUNCTION__, (GOTO_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1296, __FUNCTION__)))))
1297
1298/* ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the
1299 instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
1300 ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
1301 statement. */
1302#define ASM_STRING(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1302, __FUNCTION__, (ASM_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1302, __FUNCTION__)))))
TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1302, __FUNCTION__, (ASM_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1302, __FUNCTION__)))))
1303#define ASM_OUTPUTS(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1303, __FUNCTION__, (ASM_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1303, __FUNCTION__)))))
TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1303, __FUNCTION__, (ASM_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1303, __FUNCTION__)))))
1304#define ASM_INPUTS(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1304, __FUNCTION__, (ASM_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1304, __FUNCTION__)))))
TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1304, __FUNCTION__, (ASM_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1304, __FUNCTION__)))))
1305#define ASM_CLOBBERS(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1305, __FUNCTION__, (ASM_EXPR)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1305, __FUNCTION__)))))
TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1305, __FUNCTION__, (ASM_EXPR)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1305, __FUNCTION__)))))
1306#define ASM_LABELS(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1306, __FUNCTION__, (ASM_EXPR)))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1306, __FUNCTION__)))))
TREE_OPERAND (ASM_EXPR_CHECK (NODE), 4)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1306, __FUNCTION__, (ASM_EXPR)))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1306, __FUNCTION__)))))
1307/* Nonzero if we want to create an ASM_INPUT instead of an
1308 ASM_OPERAND with no operands. */
1309#define ASM_INPUT_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1309, __FUNCTION__, (ASM_EXPR)))->base.static_flag)
(ASM_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1309, __FUNCTION__, (ASM_EXPR)))
->base.static_flag)
1310#define ASM_VOLATILE_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1310, __FUNCTION__, (ASM_EXPR)))->base.public_flag)
(ASM_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1310, __FUNCTION__, (ASM_EXPR)))
->base.public_flag)
1311/* Nonzero if we want to consider this asm as minimum length and cost
1312 for inlining decisions. */
1313#define ASM_INLINE_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1313, __FUNCTION__, (ASM_EXPR)))->base.protected_flag)
(ASM_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1313, __FUNCTION__, (ASM_EXPR)))
->base.protected_flag)
1314
1315/* COND_EXPR accessors. */
1316#define COND_EXPR_COND(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1316, __FUNCTION__, (COND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1316, __FUNCTION__))))))
(TREE_OPERAND (COND_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1316, __FUNCTION__, (COND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1316, __FUNCTION__)))))
)
1317#define COND_EXPR_THEN(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1317, __FUNCTION__, (COND_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1317, __FUNCTION__))))))
(TREE_OPERAND (COND_EXPR_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1317, __FUNCTION__, (COND_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1317, __FUNCTION__)))))
)
1318#define COND_EXPR_ELSE(NODE)((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1318, __FUNCTION__, (COND_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1318, __FUNCTION__))))))
(TREE_OPERAND (COND_EXPR_CHECK (NODE), 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1318, __FUNCTION__, (COND_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1318, __FUNCTION__)))))
)
1319
1320/* Accessors for the chains of recurrences. */
1321#define CHREC_LEFT(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1321, __FUNCTION__, (POLYNOMIAL_CHREC)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1321, __FUNCTION__)))))
TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1321, __FUNCTION__, (POLYNOMIAL_CHREC)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1321, __FUNCTION__)))))
1322#define CHREC_RIGHT(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1322, __FUNCTION__, (POLYNOMIAL_CHREC)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1322, __FUNCTION__)))))
TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1322, __FUNCTION__, (POLYNOMIAL_CHREC)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1322, __FUNCTION__)))))
1323#define CHREC_VARIABLE(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1323, __FUNCTION__, (POLYNOMIAL_CHREC)))->base.u.chrec_var
POLYNOMIAL_CHREC_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1323, __FUNCTION__, (POLYNOMIAL_CHREC)))
->base.u.chrec_var
1324
1325/* LABEL_EXPR accessor. This gives access to the label associated with
1326 the given label expression. */
1327#define LABEL_EXPR_LABEL(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1327, __FUNCTION__, (LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1327, __FUNCTION__)))))
TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1327, __FUNCTION__, (LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1327, __FUNCTION__)))))
1328
1329/* CATCH_EXPR accessors. */
1330#define CATCH_TYPES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1330, __FUNCTION__, (CATCH_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1330, __FUNCTION__)))))
TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1330, __FUNCTION__, (CATCH_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1330, __FUNCTION__)))))
1331#define CATCH_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1331, __FUNCTION__, (CATCH_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1331, __FUNCTION__)))))
TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1331, __FUNCTION__, (CATCH_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1331, __FUNCTION__)))))
1332
1333/* EH_FILTER_EXPR accessors. */
1334#define EH_FILTER_TYPES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1334, __FUNCTION__, (EH_FILTER_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1334, __FUNCTION__)))))
TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1334, __FUNCTION__, (EH_FILTER_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1334, __FUNCTION__)))))
1335#define EH_FILTER_FAILURE(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1335, __FUNCTION__, (EH_FILTER_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1335, __FUNCTION__)))))
TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1335, __FUNCTION__, (EH_FILTER_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1335, __FUNCTION__)))))
1336
1337/* OBJ_TYPE_REF accessors. */
1338#define OBJ_TYPE_REF_EXPR(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1338, __FUNCTION__, (OBJ_TYPE_REF)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1338, __FUNCTION__)))))
TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1338, __FUNCTION__, (OBJ_TYPE_REF)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1338, __FUNCTION__)))))
1339#define OBJ_TYPE_REF_OBJECT(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1339, __FUNCTION__, (OBJ_TYPE_REF)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1339, __FUNCTION__)))))
TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1339, __FUNCTION__, (OBJ_TYPE_REF)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1339, __FUNCTION__)))))
1340#define OBJ_TYPE_REF_TOKEN(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1340, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1340, __FUNCTION__)))))
TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1340, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1340, __FUNCTION__)))))
1341
1342/* ASSERT_EXPR accessors. */
1343#define ASSERT_EXPR_VAR(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1343, __FUNCTION__, (ASSERT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1343, __FUNCTION__)))))
TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1343, __FUNCTION__, (ASSERT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1343, __FUNCTION__)))))
1344#define ASSERT_EXPR_COND(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1344, __FUNCTION__, (ASSERT_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1344, __FUNCTION__)))))
TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1344, __FUNCTION__, (ASSERT_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1344, __FUNCTION__)))))
1345
1346/* CALL_EXPR accessors. */
1347#define CALL_EXPR_FN(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1347, __FUNCTION__, (CALL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1347, __FUNCTION__)))))
TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1347, __FUNCTION__, (CALL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1347, __FUNCTION__)))))
1348#define CALL_EXPR_STATIC_CHAIN(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1348, __FUNCTION__, (CALL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1348, __FUNCTION__)))))
TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1348, __FUNCTION__, (CALL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1348, __FUNCTION__)))))
1349#define CALL_EXPR_ARG(NODE, I)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1349, __FUNCTION__, (CALL_EXPR)))), ((I) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1349, __FUNCTION__)))))
TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1349, __FUNCTION__, (CALL_EXPR)))), ((I) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1349, __FUNCTION__)))))
1350#define call_expr_nargs(NODE)(((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
((NODE), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1350, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1350, __FUNCTION__)))) - 3)
(VL_EXP_OPERAND_LENGTH (NODE)((int)((unsigned long) (*tree_int_cst_elt_check (((tree_class_check
((NODE), (tcc_vl_exp), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1350, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1350, __FUNCTION__))))
- 3)
1351#define CALL_EXPR_IFN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1351, __FUNCTION__, (CALL_EXPR)))->base.u.ifn)
(CALL_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1351, __FUNCTION__, (CALL_EXPR)))
->base.u.ifn)
1352
1353/* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE.
1354 We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if
1355 the argument count is zero when checking is enabled. Instead, do
1356 the pointer arithmetic to advance past the 3 fixed operands in a
1357 CALL_EXPR. That produces a valid pointer to just past the end of the
1358 operand array, even if it's not valid to dereference it. */
1359#define CALL_EXPR_ARGP(NODE)(&((*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1359, __FUNCTION__, (CALL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1359, __FUNCTION__)))))) + 3)
\
1360 (&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1360, __FUNCTION__, (CALL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1360, __FUNCTION__)))))
) + 3)
1361
1362/* TM directives and accessors. */
1363#define TRANSACTION_EXPR_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1363, __FUNCTION__, (TRANSACTION_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1363, __FUNCTION__)))))
\
1364 TREE_OPERAND (TRANSACTION_EXPR_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1364, __FUNCTION__, (TRANSACTION_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1364, __FUNCTION__)))))
1365#define TRANSACTION_EXPR_OUTER(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1365, __FUNCTION__, (TRANSACTION_EXPR)))->base.static_flag
)
\
1366 (TRANSACTION_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1366, __FUNCTION__, (TRANSACTION_EXPR)))
->base.static_flag)
1367#define TRANSACTION_EXPR_RELAXED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1367, __FUNCTION__, (TRANSACTION_EXPR)))->base.public_flag
)
\
1368 (TRANSACTION_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1368, __FUNCTION__, (TRANSACTION_EXPR)))
->base.public_flag)
1369
1370/* OpenMP and OpenACC directive and clause accessors. */
1371
1372/* Generic accessors for OMP nodes that keep the body as operand 0, and clauses
1373 as operand 1. */
1374#define OMP_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OACC_PARALLEL), (OMP_MASTER), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1374, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1374, __FUNCTION__)))))
\
1375 TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_MASTER), 0)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OACC_PARALLEL), (OMP_MASTER), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1375, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1375, __FUNCTION__)))))
1376#define OMP_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OACC_PARALLEL), (OMP_SCAN), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1376, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1376, __FUNCTION__)))))
\
1377 TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_SCAN), 1)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OACC_PARALLEL), (OMP_SCAN), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1377, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1377, __FUNCTION__)))))
1378
1379/* Generic accessors for OMP nodes that keep clauses as operand 0. */
1380#define OMP_STANDALONE_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OACC_CACHE), (OMP_TARGET_EXIT_DATA), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1380, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1380, __FUNCTION__)))))
\
1381 TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_CACHE, OMP_TARGET_EXIT_DATA), 0)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OACC_CACHE), (OMP_TARGET_EXIT_DATA), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1381, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1381, __FUNCTION__)))))
1382
1383#define OACC_DATA_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1383, __FUNCTION__, (OACC_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1383, __FUNCTION__)))))
\
1384 TREE_OPERAND (OACC_DATA_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1384, __FUNCTION__, (OACC_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1384, __FUNCTION__)))))
1385#define OACC_DATA_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1385, __FUNCTION__, (OACC_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1385, __FUNCTION__)))))
\
1386 TREE_OPERAND (OACC_DATA_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1386, __FUNCTION__, (OACC_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1386, __FUNCTION__)))))
1387
1388#define OACC_HOST_DATA_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1388, __FUNCTION__, (OACC_HOST_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1388, __FUNCTION__)))))
\
1389 TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1389, __FUNCTION__, (OACC_HOST_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1389, __FUNCTION__)))))
1390#define OACC_HOST_DATA_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1390, __FUNCTION__, (OACC_HOST_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1390, __FUNCTION__)))))
\
1391 TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1391, __FUNCTION__, (OACC_HOST_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1391, __FUNCTION__)))))
1392
1393#define OACC_CACHE_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1393, __FUNCTION__, (OACC_CACHE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1393, __FUNCTION__)))))
\
1394 TREE_OPERAND (OACC_CACHE_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1394, __FUNCTION__, (OACC_CACHE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1394, __FUNCTION__)))))
1395
1396#define OACC_DECLARE_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1396, __FUNCTION__, (OACC_DECLARE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1396, __FUNCTION__)))))
\
1397 TREE_OPERAND (OACC_DECLARE_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1397, __FUNCTION__, (OACC_DECLARE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1397, __FUNCTION__)))))
1398
1399#define OACC_ENTER_DATA_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1399, __FUNCTION__, (OACC_ENTER_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1399, __FUNCTION__)))))
\
1400 TREE_OPERAND (OACC_ENTER_DATA_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1400, __FUNCTION__, (OACC_ENTER_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1400, __FUNCTION__)))))
1401
1402#define OACC_EXIT_DATA_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1402, __FUNCTION__, (OACC_EXIT_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1402, __FUNCTION__)))))
\
1403 TREE_OPERAND (OACC_EXIT_DATA_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1403, __FUNCTION__, (OACC_EXIT_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1403, __FUNCTION__)))))
1404
1405#define OACC_UPDATE_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1405, __FUNCTION__, (OACC_UPDATE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1405, __FUNCTION__)))))
\
1406 TREE_OPERAND (OACC_UPDATE_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1406, __FUNCTION__, (OACC_UPDATE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1406, __FUNCTION__)))))
1407
1408#define OMP_PARALLEL_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1408, __FUNCTION__, (OMP_PARALLEL)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1408, __FUNCTION__)))))
TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1408, __FUNCTION__, (OMP_PARALLEL)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1408, __FUNCTION__)))))
1409#define OMP_PARALLEL_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1409, __FUNCTION__, (OMP_PARALLEL)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1409, __FUNCTION__)))))
TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1409, __FUNCTION__, (OMP_PARALLEL)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1409, __FUNCTION__)))))
1410
1411#define OMP_TASK_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1411, __FUNCTION__, (OMP_TASK)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1411, __FUNCTION__)))))
TREE_OPERAND (OMP_TASK_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1411, __FUNCTION__, (OMP_TASK)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1411, __FUNCTION__)))))
1412#define OMP_TASK_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1412, __FUNCTION__, (OMP_TASK)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1412, __FUNCTION__)))))
TREE_OPERAND (OMP_TASK_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1412, __FUNCTION__, (OMP_TASK)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1412, __FUNCTION__)))))
1413
1414#define OMP_TASKREG_CHECK(NODE)(tree_range_check ((NODE), (OMP_PARALLEL), (OMP_TASK), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1414, __FUNCTION__))
TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_TASK)(tree_range_check ((NODE), (OMP_PARALLEL), (OMP_TASK), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1414, __FUNCTION__))
1415#define OMP_TASKREG_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_PARALLEL), (OMP_TASK), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1415, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1415, __FUNCTION__)))))
TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_PARALLEL), (OMP_TASK), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1415, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1415, __FUNCTION__)))))
1416#define OMP_TASKREG_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_PARALLEL), (OMP_TASK), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1416, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1416, __FUNCTION__)))))
TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_PARALLEL), (OMP_TASK), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1416, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1416, __FUNCTION__)))))
1417
1418#define OMP_LOOPING_CHECK(NODE)(tree_range_check ((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1418, __FUNCTION__))
TREE_RANGE_CHECK (NODE, OMP_FOR, OACC_LOOP)(tree_range_check ((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1418, __FUNCTION__))
1419#define OMP_FOR_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1419, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1419, __FUNCTION__)))))
TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1419, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1419, __FUNCTION__)))))
1420#define OMP_FOR_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1420, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1420, __FUNCTION__)))))
TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1420, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1420, __FUNCTION__)))))
1421#define OMP_FOR_INIT(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1421, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1421, __FUNCTION__)))))
TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 2)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1421, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1421, __FUNCTION__)))))
1422#define OMP_FOR_COND(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1422, __FUNCTION__))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1422, __FUNCTION__)))))
TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 3)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1422, __FUNCTION__))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1422, __FUNCTION__)))))
1423#define OMP_FOR_INCR(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1423, __FUNCTION__))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1423, __FUNCTION__)))))
TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 4)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1423, __FUNCTION__))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1423, __FUNCTION__)))))
1424#define OMP_FOR_PRE_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1424, __FUNCTION__))), (5), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1424, __FUNCTION__)))))
TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 5)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1424, __FUNCTION__))), (5), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1424, __FUNCTION__)))))
1425#define OMP_FOR_ORIG_DECLS(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1425, __FUNCTION__))), (6), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1425, __FUNCTION__)))))
TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 6)(*((const_cast<tree*> (tree_operand_check (((tree_range_check
((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1425, __FUNCTION__))), (6), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1425, __FUNCTION__)))))
1426
1427#define OMP_SECTIONS_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1427, __FUNCTION__, (OMP_SECTIONS)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1427, __FUNCTION__)))))
TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1427, __FUNCTION__, (OMP_SECTIONS)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1427, __FUNCTION__)))))
1428#define OMP_SECTIONS_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1428, __FUNCTION__, (OMP_SECTIONS)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1428, __FUNCTION__)))))
TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1428, __FUNCTION__, (OMP_SECTIONS)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1428, __FUNCTION__)))))
1429
1430#define OMP_SECTION_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1430, __FUNCTION__, (OMP_SECTION)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1430, __FUNCTION__)))))
TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1430, __FUNCTION__, (OMP_SECTION)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1430, __FUNCTION__)))))
1431
1432#define OMP_SINGLE_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1432, __FUNCTION__, (OMP_SINGLE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1432, __FUNCTION__)))))
TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1432, __FUNCTION__, (OMP_SINGLE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1432, __FUNCTION__)))))
1433#define OMP_SINGLE_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1433, __FUNCTION__, (OMP_SINGLE)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1433, __FUNCTION__)))))
TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1433, __FUNCTION__, (OMP_SINGLE)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1433, __FUNCTION__)))))
1434
1435#define OMP_SCOPE_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1435, __FUNCTION__, (OMP_SCOPE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1435, __FUNCTION__)))))
TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1435, __FUNCTION__, (OMP_SCOPE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1435, __FUNCTION__)))))
1436#define OMP_SCOPE_CLAUSES(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1436, __FUNCTION__, (OMP_SCOPE)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1436, __FUNCTION__)))))
TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 1)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1436, __FUNCTION__, (OMP_SCOPE)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1436, __FUNCTION__)))))
1437
1438#define OMP_MASTER_BODY(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1438, __FUNCTION__, (OMP_MASTER)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1438, __FUNCTION__)))))
TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1438, __FUNCTION__, (OMP_MASTER)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1438, __FUNCTION__)))))
1439
1440#define OMP_MASKED_BODY(NODE)