Bug Summary

File:build/gcc/vec.h
Warning:line 815, 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 ipa-split.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 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -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/. -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/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/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 -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-yetZgZ.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c

1/* Function splitting pass
2 Copyright (C) 2010-2021 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka <jh@suse.cz>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21/* The purpose of this pass is to split function bodies to improve
22 inlining. I.e. for function of the form:
23
24 func (...)
25 {
26 if (cheap_test)
27 something_small
28 else
29 something_big
30 }
31
32 Produce:
33
34 func.part (...)
35 {
36 something_big
37 }
38
39 func (...)
40 {
41 if (cheap_test)
42 something_small
43 else
44 func.part (...);
45 }
46
47 When func becomes inlinable and when cheap_test is often true, inlining func,
48 but not fund.part leads to performance improvement similar as inlining
49 original func while the code size growth is smaller.
50
51 The pass is organized in three stages:
52 1) Collect local info about basic block into BB_INFO structure and
53 compute function body estimated size and time.
54 2) Via DFS walk find all possible basic blocks where we can split
55 and chose best one.
56 3) If split point is found, split at the specified BB by creating a clone
57 and updating function to call it.
58
59 The decisions what functions to split are in execute_split_functions
60 and consider_split.
61
62 There are several possible future improvements for this pass including:
63
64 1) Splitting to break up large functions
65 2) Splitting to reduce stack frame usage
66 3) Allow split part of function to use values computed in the header part.
67 The values needs to be passed to split function, perhaps via same
68 interface as for nested functions or as argument.
69 4) Support for simple rematerialization. I.e. when split part use
70 value computed in header from function parameter in very cheap way, we
71 can just recompute it.
72 5) Support splitting of nested functions.
73 6) Support non-SSA arguments.
74 7) There is nothing preventing us from producing multiple parts of single function
75 when needed or splitting also the parts. */
76
77#include "config.h"
78#include "system.h"
79#include "coretypes.h"
80#include "backend.h"
81#include "rtl.h"
82#include "tree.h"
83#include "gimple.h"
84#include "cfghooks.h"
85#include "alloc-pool.h"
86#include "tree-pass.h"
87#include "ssa.h"
88#include "cgraph.h"
89#include "diagnostic.h"
90#include "fold-const.h"
91#include "cfganal.h"
92#include "calls.h"
93#include "gimplify.h"
94#include "gimple-iterator.h"
95#include "gimplify-me.h"
96#include "gimple-walk.h"
97#include "symbol-summary.h"
98#include "ipa-prop.h"
99#include "tree-cfg.h"
100#include "tree-into-ssa.h"
101#include "tree-dfa.h"
102#include "tree-inline.h"
103#include "gimple-pretty-print.h"
104#include "ipa-fnsummary.h"
105#include "cfgloop.h"
106#include "attribs.h"
107
108/* Per basic block info. */
109
110class split_bb_info
111{
112public:
113 unsigned int size;
114 sreal time;
115};
116
117static vec<split_bb_info> bb_info_vec;
118
119/* Description of split point. */
120
121class split_point
122{
123public:
124 /* Size of the partitions. */
125 sreal header_time, split_time;
126 unsigned int header_size, split_size;
127
128 /* SSA names that need to be passed into spit function. */
129 bitmap ssa_names_to_pass;
130
131 /* Basic block where we split (that will become entry point of new function. */
132 basic_block entry_bb;
133
134 /* Count for entering the split part.
135 This is not count of the entry_bb because it may be in loop. */
136 profile_count count;
137
138 /* Basic blocks we are splitting away. */
139 bitmap split_bbs;
140
141 /* True when return value is computed on split part and thus it needs
142 to be returned. */
143 bool split_part_set_retval;
144};
145
146/* Best split point found. */
147
148class split_point best_split_point;
149
150/* Set of basic blocks that are not allowed to dominate a split point. */
151
152static bitmap forbidden_dominators;
153
154static tree find_retval (basic_block return_bb);
155
156/* Callback for walk_stmt_load_store_addr_ops. If T is non-SSA automatic
157 variable, check it if it is present in bitmap passed via DATA. */
158
159static bool
160test_nonssa_use (gimple *, tree t, tree, void *data)
161{
162 t = get_base_address (t);
163
164 if (!t || is_gimple_reg (t))
165 return false;
166
167 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == PARM_DECL
168 || (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL)
169 && auto_var_in_fn_p (t, current_function_decl))
170 || TREE_CODE (t)((enum tree_code) (t)->base.code) == RESULT_DECL
171 /* Normal labels are part of CFG and will be handled gratefully.
172 Forced labels however can be used directly by statements and
173 need to stay in one partition along with their uses. */
174 || (TREE_CODE (t)((enum tree_code) (t)->base.code) == LABEL_DECL
175 && FORCED_LABEL (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 175, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
)
))
176 return bitmap_bit_p ((bitmap)data, DECL_UID (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 176, __FUNCTION__))->decl_minimal.uid)
);
177
178 /* For DECL_BY_REFERENCE, the return value is actually a pointer. We want
179 to pretend that the value pointed to is actual result decl. */
180 if ((TREE_CODE (t)((enum tree_code) (t)->base.code) == MEM_REF || INDIRECT_REF_P (t)(((enum tree_code) (t)->base.code) == INDIRECT_REF))
181 && TREE_CODE (TREE_OPERAND (t, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 181, __FUNCTION__))))))->base.code)
== SSA_NAME
182 && SSA_NAME_VAR (TREE_OPERAND (t, 0))((tree_check (((*((const_cast<tree*> (tree_operand_check
((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 182, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 182, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) (((*((const_cast<tree*> (tree_operand_check
((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 182, __FUNCTION__))))))->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : ((*((const_cast<tree*>
(tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 182, __FUNCTION__))))))->ssa_name.var)
183 && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (t, 0)))((enum tree_code) (((tree_check (((*((const_cast<tree*>
(tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 183, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 183, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) (((*((const_cast<tree*> (tree_operand_check
((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 183, __FUNCTION__))))))->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : ((*((const_cast<tree*>
(tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 183, __FUNCTION__))))))->ssa_name.var))->base.code)
== RESULT_DECL
184 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))((tree_check3 ((((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 184, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 184, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
)
185 return
186 bitmap_bit_p ((bitmap)data,
187 DECL_UID (DECL_RESULT (current_function_decl))((contains_struct_check ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 187, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 187, __FUNCTION__))->decl_minimal.uid)
);
188
189 return false;
190}
191
192/* Dump split point CURRENT. */
193
194static void
195dump_split_point (FILE * file, class split_point *current)
196{
197 fprintf (file,
198 "Split point at BB %i\n"
199 " header time: %f header size: %i\n"
200 " split time: %f split size: %i\n bbs: ",
201 current->entry_bb->index, current->header_time.to_double (),
202 current->header_size, current->split_time.to_double (),
203 current->split_size);
204 dump_bitmap (file, current->split_bbs);
205 fprintf (file, " SSA names to pass: ");
206 dump_bitmap (file, current->ssa_names_to_pass);
207}
208
209/* Look for all BBs in header that might lead to the split part and verify
210 that they are not defining any non-SSA var used by the split part.
211 Parameters are the same as for consider_split. */
212
213static bool
214verify_non_ssa_vars (class split_point *current, bitmap non_ssa_vars,
215 basic_block return_bb)
216{
217 bitmap seen = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
218 vec<basic_block> worklist = vNULL;
219 edge e;
220 edge_iterator ei;
221 bool ok = true;
222 basic_block bb;
223
224 FOR_EACH_EDGE (e, ei, current->entry_bb->preds)for ((ei) = ei_start_1 (&((current->entry_bb->preds
))); ei_cond ((ei), &(e)); ei_next (&(ei)))
225 if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
226 && !bitmap_bit_p (current->split_bbs, e->src->index))
227 {
228 worklist.safe_push (e->src);
229 bitmap_set_bit (seen, e->src->index);
230 }
231
232 while (!worklist.is_empty ())
233 {
234 bb = worklist.pop ();
235 FOR_EACH_EDGE (e, ei, bb->preds)for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
236 if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
237 && bitmap_set_bit (seen, e->src->index))
238 {
239 gcc_checking_assert (!bitmap_bit_p (current->split_bbs,((void)(!(!bitmap_bit_p (current->split_bbs, e->src->
index)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 240, __FUNCTION__), 0 : 0))
240 e->src->index))((void)(!(!bitmap_bit_p (current->split_bbs, e->src->
index)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 240, __FUNCTION__), 0 : 0))
;
241 worklist.safe_push (e->src);
242 }
243 for (gimple_stmt_iterator bsi = gsi_start_bb (bb); !gsi_end_p (bsi);
244 gsi_next (&bsi))
245 {
246 gimple *stmt = gsi_stmt (bsi);
247 if (is_gimple_debug (stmt))
248 continue;
249 if (walk_stmt_load_store_addr_ops
250 (stmt, non_ssa_vars, test_nonssa_use, test_nonssa_use,
251 test_nonssa_use))
252 {
253 ok = false;
254 goto done;
255 }
256 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
257 if (test_nonssa_use (stmt, gimple_label_label (label_stmt),
258 NULL_TREE(tree) nullptr, non_ssa_vars))
259 {
260 ok = false;
261 goto done;
262 }
263 }
264 for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
265 gsi_next (&bsi))
266 {
267 if (walk_stmt_load_store_addr_ops
268 (gsi_stmt (bsi), non_ssa_vars, test_nonssa_use, test_nonssa_use,
269 test_nonssa_use))
270 {
271 ok = false;
272 goto done;
273 }
274 }
275 FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
276 {
277 if (e->dest != return_bb)
278 continue;
279 for (gphi_iterator bsi = gsi_start_phis (return_bb);
280 !gsi_end_p (bsi);
281 gsi_next (&bsi))
282 {
283 gphi *stmt = bsi.phi ();
284 tree op = gimple_phi_arg_def (stmt, e->dest_idx);
285
286 if (virtual_operand_p (gimple_phi_result (stmt)))
287 continue;
288 if (TREE_CODE (op)((enum tree_code) (op)->base.code) != SSA_NAME
289 && test_nonssa_use (stmt, op, op, non_ssa_vars))
290 {
291 ok = false;
292 goto done;
293 }
294 }
295 }
296 }
297
298 /* Verify that the rest of function does not define any label
299 used by the split part. */
300 FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
301 if (!bitmap_bit_p (current->split_bbs, bb->index)
302 && !bitmap_bit_p (seen, bb->index))
303 {
304 gimple_stmt_iterator bsi;
305 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
306 if (glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (bsi)))
307 {
308 if (test_nonssa_use (label_stmt,
309 gimple_label_label (label_stmt),
310 NULL_TREE(tree) nullptr, non_ssa_vars))
311 {
312 ok = false;
313 goto done;
314 }
315 }
316 else
317 break;
318 }
319
320done:
321 BITMAP_FREE (seen)((void) (bitmap_obstack_free ((bitmap) seen), (seen) = (bitmap
) nullptr))
;
322 worklist.release ();
323 return ok;
324}
325
326/* If STMT is a call, check the callee against a list of forbidden
327 predicate functions. If a match is found, look for uses of the
328 call result in condition statements that compare against zero.
329 For each such use, find the block targeted by the condition
330 statement for the nonzero result, and set the bit for this block
331 in the forbidden dominators bitmap. The purpose of this is to avoid
332 selecting a split point where we are likely to lose the chance
333 to optimize away an unused function call. */
334
335static void
336check_forbidden_calls (gimple *stmt)
337{
338 imm_use_iterator use_iter;
339 use_operand_p use_p;
340 tree lhs;
341
342 /* At the moment, __builtin_constant_p is the only forbidden
343 predicate function call (see PR49642). */
344 if (!gimple_call_builtin_p (stmt, BUILT_IN_CONSTANT_P))
345 return;
346
347 lhs = gimple_call_lhs (stmt);
348
349 if (!lhs || TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) != SSA_NAME)
350 return;
351
352 FOR_EACH_IMM_USE_FAST (use_p, use_iter, lhs)for ((use_p) = first_readonly_imm_use (&(use_iter), (lhs)
); !end_readonly_imm_use_p (&(use_iter)); (void) ((use_p)
= next_readonly_imm_use (&(use_iter))))
353 {
354 tree op1;
355 basic_block use_bb, forbidden_bb;
356 enum tree_code code;
357 edge true_edge, false_edge;
358 gcond *use_stmt;
359
360 use_stmt = dyn_cast <gcond *> (USE_STMT (use_p)(use_p)->loc.stmt);
361 if (!use_stmt)
362 continue;
363
364 /* Assuming canonical form for GIMPLE_COND here, with constant
365 in second position. */
366 op1 = gimple_cond_rhs (use_stmt);
367 code = gimple_cond_code (use_stmt);
368 use_bb = gimple_bb (use_stmt);
369
370 extract_true_false_edges_from_block (use_bb, &true_edge, &false_edge);
371
372 /* We're only interested in comparisons that distinguish
373 unambiguously from zero. */
374 if (!integer_zerop (op1) || code == LE_EXPR || code == GE_EXPR)
375 continue;
376
377 if (code == EQ_EXPR)
378 forbidden_bb = false_edge->dest;
379 else
380 forbidden_bb = true_edge->dest;
381
382 bitmap_set_bit (forbidden_dominators, forbidden_bb->index);
383 }
384}
385
386/* If BB is dominated by any block in the forbidden dominators set,
387 return TRUE; else FALSE. */
388
389static bool
390dominated_by_forbidden (basic_block bb)
391{
392 unsigned dom_bb;
393 bitmap_iterator bi;
394
395 EXECUTE_IF_SET_IN_BITMAP (forbidden_dominators, 1, dom_bb, bi)for (bmp_iter_set_init (&(bi), (forbidden_dominators), (1
), &(dom_bb)); bmp_iter_set (&(bi), &(dom_bb)); bmp_iter_next
(&(bi), &(dom_bb)))
396 {
397 if (dominated_by_p (CDI_DOMINATORS, bb,
398 BASIC_BLOCK_FOR_FN (cfun, dom_bb)((*(((cfun + 0))->cfg->x_basic_block_info))[(dom_bb)])))
399 return true;
400 }
401
402 return false;
403}
404
405/* For give split point CURRENT and return block RETURN_BB return 1
406 if ssa name VAL is set by split part and 0 otherwise. */
407static bool
408split_part_set_ssa_name_p (tree val, class split_point *current,
409 basic_block return_bb)
410{
411 if (TREE_CODE (val)((enum tree_code) (val)->base.code) != SSA_NAME)
412 return false;
413
414 return (!SSA_NAME_IS_DEFAULT_DEF (val)(tree_check ((val), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 414, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
415 && (bitmap_bit_p (current->split_bbs,
416 gimple_bb (SSA_NAME_DEF_STMT (val)(tree_check ((val), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 416, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
)->index)
417 || gimple_bb (SSA_NAME_DEF_STMT (val)(tree_check ((val), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 417, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
) == return_bb));
418}
419
420/* We found an split_point CURRENT. NON_SSA_VARS is bitmap of all non ssa
421 variables used and RETURN_BB is return basic block.
422 See if we can split function here. */
423
424static void
425consider_split (class split_point *current, bitmap non_ssa_vars,
426 basic_block return_bb)
427{
428 tree parm;
429 unsigned int num_args = 0;
430 unsigned int call_overhead;
431 edge e;
432 edge_iterator ei;
433 gphi_iterator bsi;
434 unsigned int i;
435 tree retval;
436 bool back_edge = false;
437
438 if (dump_file && (dump_flags & TDF_DETAILS))
439 dump_split_point (dump_file, current);
440
441 current->count = profile_count::zero ();
442 FOR_EACH_EDGE (e, ei, current->entry_bb->preds)for ((ei) = ei_start_1 (&((current->entry_bb->preds
))); ei_cond ((ei), &(e)); ei_next (&(ei)))
443 {
444 if (e->flags & EDGE_DFS_BACK)
445 back_edge = true;
446 if (!bitmap_bit_p (current->split_bbs, e->src->index))
447 current->count += e->count ();
448 }
449
450 /* Do not split when we would end up calling function anyway.
451 Compares are three state, use !(...<...) to also give up when outcome
452 is unknown. */
453 if (!(current->count
454 < (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count.apply_scale
455 (param_partial_inlining_entry_probabilityglobal_options.x_param_partial_inlining_entry_probability, 100))))
456 {
457 /* When profile is guessed, we cannot expect it to give us
458 realistic estimate on likeliness of function taking the
459 complex path. As a special case, when tail of the function is
460 a loop, enable splitting since inlining code skipping the loop
461 is likely noticeable win. */
462 if (back_edge
463 && profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) != PROFILE_READ
464 && current->count
465 < ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count)
466 {
467 if (dump_file && (dump_flags & TDF_DETAILS))
468 {
469 fprintf (dump_file,
470 " Split before loop, accepting despite low counts");
471 current->count.dump (dump_file);
472 fprintf (dump_file, " ");
473 ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count.dump (dump_file);
474 }
475 }
476 else
477 {
478 if (dump_file && (dump_flags & TDF_DETAILS))
479 fprintf (dump_file,
480 " Refused: incoming frequency is too large.\n");
481 return;
482 }
483 }
484
485 if (!current->header_size)
486 {
487 if (dump_file && (dump_flags & TDF_DETAILS))
488 fprintf (dump_file, " Refused: header empty\n");
489 return;
490 }
491
492 /* Verify that PHI args on entry are either virtual or all their operands
493 incoming from header are the same. */
494 for (bsi = gsi_start_phis (current->entry_bb); !gsi_end_p (bsi); gsi_next (&bsi))
495 {
496 gphi *stmt = bsi.phi ();
497 tree val = NULLnullptr;
498
499 if (virtual_operand_p (gimple_phi_result (stmt)))
500 continue;
501 for (i = 0; i < gimple_phi_num_args (stmt); i++)
502 {
503 edge e = gimple_phi_arg_edge (stmt, i);
504 if (!bitmap_bit_p (current->split_bbs, e->src->index))
505 {
506 tree edge_val = gimple_phi_arg_def (stmt, i);
507 if (val && edge_val != val)
508 {
509 if (dump_file && (dump_flags & TDF_DETAILS))
510 fprintf (dump_file,
511 " Refused: entry BB has PHI with multiple variants\n");
512 return;
513 }
514 val = edge_val;
515 }
516 }
517 }
518
519
520 /* See what argument we will pass to the split function and compute
521 call overhead. */
522 call_overhead = eni_size_weights.call_cost;
523 for (parm = DECL_ARGUMENTS (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 523, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
)
; parm;
524 parm = DECL_CHAIN (parm)(((contains_struct_check (((contains_struct_check ((parm), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 524, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 524, __FUNCTION__))->common.chain))
)
525 {
526 if (!is_gimple_reg (parm))
527 {
528 if (bitmap_bit_p (non_ssa_vars, DECL_UID (parm)((contains_struct_check ((parm), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 528, __FUNCTION__))->decl_minimal.uid)
))
529 {
530 if (dump_file && (dump_flags & TDF_DETAILS))
531 fprintf (dump_file,
532 " Refused: need to pass non-ssa param values\n");
533 return;
534 }
535 }
536 else
537 {
538 tree ddef = ssa_default_def (cfun(cfun + 0), parm);
539 if (ddef
540 && bitmap_bit_p (current->ssa_names_to_pass,
541 SSA_NAME_VERSION (ddef)(tree_check ((ddef), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 541, __FUNCTION__, (SSA_NAME)))->base.u.version
))
542 {
543 if (!VOID_TYPE_P (TREE_TYPE (parm))(((enum tree_code) (((contains_struct_check ((parm), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 543, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
)
544 call_overhead += estimate_move_cost (TREE_TYPE (parm)((contains_struct_check ((parm), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 544, __FUNCTION__))->typed.type)
, false);
545 num_args++;
546 }
547 }
548 }
549 if (!VOID_TYPE_P (TREE_TYPE (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/ipa-split.c"
, 549, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
)
550 call_overhead += estimate_move_cost (TREE_TYPE (current_function_decl)((contains_struct_check ((current_function_decl), (TS_TYPED),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 550, __FUNCTION__))->typed.type)
,
551 false);
552
553 if (current->split_size <= call_overhead)
554 {
555 if (dump_file && (dump_flags & TDF_DETAILS))
556 fprintf (dump_file,
557 " Refused: split size is smaller than call overhead\n");
558 return;
559 }
560 /* FIXME: The logic here is not very precise, because inliner does use
561 inline predicates to reduce function body size. We add 10 to anticipate
562 that. Next stage1 we should try to be more meaningful here. */
563 if (current->header_size + call_overhead
564 >= (unsigned int)(DECL_DECLARED_INLINE_P (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 564, __FUNCTION__, (FUNCTION_DECL)))->function_decl.declared_inline_flag
)
565 ? param_max_inline_insns_singleglobal_options.x_param_max_inline_insns_single
566 : param_max_inline_insns_autoglobal_options.x_param_max_inline_insns_auto) + 10)
567 {
568 if (dump_file && (dump_flags & TDF_DETAILS))
569 fprintf (dump_file,
570 " Refused: header size is too large for inline candidate\n");
571 return;
572 }
573
574 /* Splitting functions brings the target out of comdat group; this will
575 lead to code duplication if the function is reused by other unit.
576 Limit this duplication. This is consistent with limit in tree-sra.c
577 FIXME: with LTO we ought to be able to do better! */
578 if (DECL_ONE_ONLY (current_function_decl)(decl_comdat_group (current_function_decl) != (tree) nullptr &&
(((current_function_decl)->base.public_flag) || ((contains_struct_check
((current_function_decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 578, __FUNCTION__))->decl_common.decl_flag_1)))
579 && current->split_size >= (unsigned int) param_max_inline_insns_autoglobal_options.x_param_max_inline_insns_auto + 10)
580 {
581 if (dump_file && (dump_flags & TDF_DETAILS))
582 fprintf (dump_file,
583 " Refused: function is COMDAT and tail is too large\n");
584 return;
585 }
586 /* For comdat functions also reject very small tails; those will likely get
587 inlined back and we do not want to risk the duplication overhead.
588 FIXME: with LTO we ought to be able to do better! */
589 if (DECL_ONE_ONLY (current_function_decl)(decl_comdat_group (current_function_decl) != (tree) nullptr &&
(((current_function_decl)->base.public_flag) || ((contains_struct_check
((current_function_decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 589, __FUNCTION__))->decl_common.decl_flag_1)))
590 && current->split_size
591 <= (unsigned int) param_early_inlining_insnsglobal_options.x_param_early_inlining_insns / 2)
592 {
593 if (dump_file && (dump_flags & TDF_DETAILS))
594 fprintf (dump_file,
595 " Refused: function is COMDAT and tail is too small\n");
596 return;
597 }
598
599 /* FIXME: we currently can pass only SSA function parameters to the split
600 arguments. Once parm_adjustment infrastructure is supported by cloning,
601 we can pass more than that. */
602 if (num_args != bitmap_count_bits (current->ssa_names_to_pass))
603 {
604
605 if (dump_file && (dump_flags & TDF_DETAILS))
606 fprintf (dump_file,
607 " Refused: need to pass non-param values\n");
608 return;
609 }
610
611 /* When there are non-ssa vars used in the split region, see if they
612 are used in the header region. If so, reject the split.
613 FIXME: we can use nested function support to access both. */
614 if (!bitmap_empty_p (non_ssa_vars)
615 && !verify_non_ssa_vars (current, non_ssa_vars, return_bb))
616 {
617 if (dump_file && (dump_flags & TDF_DETAILS))
618 fprintf (dump_file,
619 " Refused: split part has non-ssa uses\n");
620 return;
621 }
622
623 /* If the split point is dominated by a forbidden block, reject
624 the split. */
625 if (!bitmap_empty_p (forbidden_dominators)
626 && dominated_by_forbidden (current->entry_bb))
627 {
628 if (dump_file && (dump_flags & TDF_DETAILS))
629 fprintf (dump_file,
630 " Refused: split point dominated by forbidden block\n");
631 return;
632 }
633
634 /* See if retval used by return bb is computed by header or split part.
635 When it is computed by split part, we need to produce return statement
636 in the split part and add code to header to pass it around.
637
638 This is bit tricky to test:
639 1) When there is no return_bb or no return value, we always pass
640 value around.
641 2) Invariants are always computed by caller.
642 3) For SSA we need to look if defining statement is in header or split part
643 4) For non-SSA we need to look where the var is computed. */
644 retval = find_retval (return_bb);
645 if (!retval)
646 {
647 /* If there is a return_bb with no return value in function returning
648 value by reference, also make the split part return void, otherwise
649 we expansion would try to create a non-POD temporary, which is
650 invalid. */
651 if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
652 && DECL_RESULT (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 652, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)
653 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))((tree_check3 ((((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 653, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 653, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
)
654 current->split_part_set_retval = false;
655 else
656 current->split_part_set_retval = true;
657 }
658 else if (is_gimple_min_invariant (retval))
659 current->split_part_set_retval = false;
660 /* Special case is value returned by reference we record as if it was non-ssa
661 set to result_decl. */
662 else if (TREE_CODE (retval)((enum tree_code) (retval)->base.code) == SSA_NAME
663 && SSA_NAME_VAR (retval)((tree_check ((retval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 663, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((retval)->ssa_name.var)->base.code
) == IDENTIFIER_NODE ? (tree) nullptr : (retval)->ssa_name
.var)
664 && TREE_CODE (SSA_NAME_VAR (retval))((enum tree_code) (((tree_check ((retval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 664, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((retval)->ssa_name.var)->base.code
) == IDENTIFIER_NODE ? (tree) nullptr : (retval)->ssa_name
.var))->base.code)
== RESULT_DECL
665 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))((tree_check3 ((((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 665, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 665, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
)
666 current->split_part_set_retval
667 = bitmap_bit_p (non_ssa_vars, DECL_UID (SSA_NAME_VAR (retval))((contains_struct_check ((((tree_check ((retval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 667, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) ((retval)->ssa_name.var)->base.code
) == IDENTIFIER_NODE ? (tree) nullptr : (retval)->ssa_name
.var)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 667, __FUNCTION__))->decl_minimal.uid)
);
668 else if (TREE_CODE (retval)((enum tree_code) (retval)->base.code) == SSA_NAME)
669 current->split_part_set_retval
670 = split_part_set_ssa_name_p (retval, current, return_bb);
671 else if (TREE_CODE (retval)((enum tree_code) (retval)->base.code) == PARM_DECL)
672 current->split_part_set_retval = false;
673 else if (VAR_P (retval)(((enum tree_code) (retval)->base.code) == VAR_DECL)
674 || TREE_CODE (retval)((enum tree_code) (retval)->base.code) == RESULT_DECL)
675 current->split_part_set_retval
676 = bitmap_bit_p (non_ssa_vars, DECL_UID (retval)((contains_struct_check ((retval), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 676, __FUNCTION__))->decl_minimal.uid)
);
677 else
678 current->split_part_set_retval = true;
679
680 /* split_function fixes up at most one PHI non-virtual PHI node in return_bb,
681 for the return value. If there are other PHIs, give up. */
682 if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
683 {
684 gphi_iterator psi;
685
686 for (psi = gsi_start_phis (return_bb); !gsi_end_p (psi); gsi_next (&psi))
687 if (!virtual_operand_p (gimple_phi_result (psi.phi ()))
688 && !(retval
689 && current->split_part_set_retval
690 && TREE_CODE (retval)((enum tree_code) (retval)->base.code) == SSA_NAME
691 && !DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))((tree_check3 ((((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 691, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 691, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
692 && SSA_NAME_DEF_STMT (retval)(tree_check ((retval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 692, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
== psi.phi ()))
693 {
694 if (dump_file && (dump_flags & TDF_DETAILS))
695 fprintf (dump_file,
696 " Refused: return bb has extra PHIs\n");
697 return;
698 }
699 }
700
701 if (dump_file && (dump_flags & TDF_DETAILS))
702 fprintf (dump_file, " Accepted!\n");
703
704 /* At the moment chose split point with lowest count and that leaves
705 out smallest size of header.
706 In future we might re-consider this heuristics. */
707 if (!best_split_point.split_bbs
708 || best_split_point.count
709 > current->count
710 || (best_split_point.count == current->count
711 && best_split_point.split_size < current->split_size))
712
713 {
714 if (dump_file && (dump_flags & TDF_DETAILS))
715 fprintf (dump_file, " New best split point!\n");
716 if (best_split_point.ssa_names_to_pass)
717 {
718 BITMAP_FREE (best_split_point.ssa_names_to_pass)((void) (bitmap_obstack_free ((bitmap) best_split_point.ssa_names_to_pass
), (best_split_point.ssa_names_to_pass) = (bitmap) nullptr))
;
719 BITMAP_FREE (best_split_point.split_bbs)((void) (bitmap_obstack_free ((bitmap) best_split_point.split_bbs
), (best_split_point.split_bbs) = (bitmap) nullptr))
;
720 }
721 best_split_point = *current;
722 best_split_point.ssa_names_to_pass = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
723 bitmap_copy (best_split_point.ssa_names_to_pass,
724 current->ssa_names_to_pass);
725 best_split_point.split_bbs = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
726 bitmap_copy (best_split_point.split_bbs, current->split_bbs);
727 }
728}
729
730/* Return basic block containing RETURN statement. We allow basic blocks
731 of the form:
732 <retval> = tmp_var;
733 return <retval>
734 but return_bb cannot be more complex than this (except for
735 -fsanitize=thread we allow TSAN_FUNC_EXIT () internal call in there).
736 If nothing is found, return the exit block.
737
738 When there are multiple RETURN statement, chose one with return value,
739 since that one is more likely shared by multiple code paths.
740
741 Return BB is special, because for function splitting it is the only
742 basic block that is duplicated in between header and split part of the
743 function.
744
745 TODO: We might support multiple return blocks. */
746
747static basic_block
748find_return_bb (void)
749{
750 edge e;
751 basic_block return_bb = EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr);
752 gimple_stmt_iterator bsi;
753 bool found_return = false;
754 tree retval = NULL_TREE(tree) nullptr;
755
756 if (!single_pred_p (EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)))
757 return return_bb;
758
759 e = single_pred_edge (EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr));
760 for (bsi = gsi_last_bb (e->src); !gsi_end_p (bsi); gsi_prev (&bsi))
761 {
762 gimple *stmt = gsi_stmt (bsi);
763 if (gimple_code (stmt) == GIMPLE_LABEL
764 || is_gimple_debug (stmt)
765 || gimple_clobber_p (stmt))
766 ;
767 else if (gimple_code (stmt) == GIMPLE_ASSIGN
768 && found_return
769 && gimple_assign_single_p (stmt)
770 && (auto_var_in_fn_p (gimple_assign_rhs1 (stmt),
771 current_function_decl)
772 || is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
773 && retval == gimple_assign_lhs (stmt))
774 ;
775 else if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
776 {
777 found_return = true;
778 retval = gimple_return_retval (return_stmt);
779 }
780 /* For -fsanitize=thread, allow also TSAN_FUNC_EXIT () in the return
781 bb. */
782 else if ((flag_sanitizeglobal_options.x_flag_sanitize & SANITIZE_THREAD)
783 && gimple_call_internal_p (stmt, IFN_TSAN_FUNC_EXIT))
784 ;
785 else
786 break;
787 }
788 if (gsi_end_p (bsi) && found_return)
789 return_bb = e->src;
790
791 return return_bb;
792}
793
794/* Given return basic block RETURN_BB, see where return value is really
795 stored. */
796static tree
797find_retval (basic_block return_bb)
798{
799 gimple_stmt_iterator bsi;
800 for (bsi = gsi_start_bb (return_bb); !gsi_end_p (bsi); gsi_next (&bsi))
801 if (greturn *return_stmt = dyn_cast <greturn *> (gsi_stmt (bsi)))
802 return gimple_return_retval (return_stmt);
803 else if (gimple_code (gsi_stmt (bsi)) == GIMPLE_ASSIGN
804 && !gimple_clobber_p (gsi_stmt (bsi)))
805 return gimple_assign_rhs1 (gsi_stmt (bsi));
806 return NULLnullptr;
807}
808
809/* Callback for walk_stmt_load_store_addr_ops. If T is non-SSA automatic
810 variable, mark it as used in bitmap passed via DATA.
811 Return true when access to T prevents splitting the function. */
812
813static bool
814mark_nonssa_use (gimple *, tree t, tree, void *data)
815{
816 t = get_base_address (t);
817
818 if (!t || is_gimple_reg (t))
819 return false;
820
821 /* At present we can't pass non-SSA arguments to split function.
822 FIXME: this can be relaxed by passing references to arguments. */
823 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == PARM_DECL)
824 {
825 if (dump_file && (dump_flags & TDF_DETAILS))
826 fprintf (dump_file,
827 "Cannot split: use of non-ssa function parameter.\n");
828 return true;
829 }
830
831 if ((VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL) && auto_var_in_fn_p (t, current_function_decl))
832 || TREE_CODE (t)((enum tree_code) (t)->base.code) == RESULT_DECL
833 || (TREE_CODE (t)((enum tree_code) (t)->base.code) == LABEL_DECL && FORCED_LABEL (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 833, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
)
))
834 bitmap_set_bit ((bitmap)data, DECL_UID (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 834, __FUNCTION__))->decl_minimal.uid)
);
835
836 /* For DECL_BY_REFERENCE, the return value is actually a pointer. We want
837 to pretend that the value pointed to is actual result decl. */
838 if ((TREE_CODE (t)((enum tree_code) (t)->base.code) == MEM_REF || INDIRECT_REF_P (t)(((enum tree_code) (t)->base.code) == INDIRECT_REF))
839 && TREE_CODE (TREE_OPERAND (t, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 839, __FUNCTION__))))))->base.code)
== SSA_NAME
840 && SSA_NAME_VAR (TREE_OPERAND (t, 0))((tree_check (((*((const_cast<tree*> (tree_operand_check
((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 840, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 840, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) (((*((const_cast<tree*> (tree_operand_check
((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 840, __FUNCTION__))))))->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : ((*((const_cast<tree*>
(tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 840, __FUNCTION__))))))->ssa_name.var)
841 && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (t, 0)))((enum tree_code) (((tree_check (((*((const_cast<tree*>
(tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 841, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 841, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
|| ((enum tree_code) (((*((const_cast<tree*> (tree_operand_check
((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 841, __FUNCTION__))))))->ssa_name.var)->base.code) ==
IDENTIFIER_NODE ? (tree) nullptr : ((*((const_cast<tree*>
(tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 841, __FUNCTION__))))))->ssa_name.var))->base.code)
== RESULT_DECL
842 && DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))((tree_check3 ((((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 842, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 842, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
)
843 return
844 bitmap_bit_p ((bitmap)data,
845 DECL_UID (DECL_RESULT (current_function_decl))((contains_struct_check ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 845, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 845, __FUNCTION__))->decl_minimal.uid)
);
846
847 return false;
848}
849
850/* Compute local properties of basic block BB we collect when looking for
851 split points. We look for ssa defs and store them in SET_SSA_NAMES,
852 for ssa uses and store them in USED_SSA_NAMES and for any non-SSA automatic
853 vars stored in NON_SSA_VARS.
854
855 When BB has edge to RETURN_BB, collect uses in RETURN_BB too.
856
857 Return false when BB contains something that prevents it from being put into
858 split function. */
859
860static bool
861visit_bb (basic_block bb, basic_block return_bb,
862 bitmap set_ssa_names, bitmap used_ssa_names,
863 bitmap non_ssa_vars)
864{
865 edge e;
866 edge_iterator ei;
867 bool can_split = true;
868
869 for (gimple_stmt_iterator bsi = gsi_start_bb (bb); !gsi_end_p (bsi);
870 gsi_next (&bsi))
871 {
872 gimple *stmt = gsi_stmt (bsi);
873 tree op;
874 ssa_op_iter iter;
875 tree decl;
876
877 if (is_gimple_debug (stmt))
878 continue;
879
880 if (gimple_clobber_p (stmt))
881 continue;
882
883 /* FIXME: We can split regions containing EH. We cannot however
884 split RESX, EH_DISPATCH and EH_POINTER referring to same region
885 into different partitions. This would require tracking of
886 EH regions and checking in consider_split_point if they
887 are not used elsewhere. */
888 if (gimple_code (stmt) == GIMPLE_RESX)
889 {
890 if (dump_file && (dump_flags & TDF_DETAILS))
891 fprintf (dump_file, "Cannot split: resx.\n");
892 can_split = false;
893 }
894 if (gimple_code (stmt) == GIMPLE_EH_DISPATCH)
895 {
896 if (dump_file && (dump_flags & TDF_DETAILS))
897 fprintf (dump_file, "Cannot split: eh dispatch.\n");
898 can_split = false;
899 }
900
901 /* Check builtins that prevent splitting. */
902 if (gimple_code (stmt) == GIMPLE_CALL
903 && (decl = gimple_call_fndecl (stmt)) != NULL_TREE(tree) nullptr
904 && fndecl_built_in_p (decl, BUILT_IN_NORMAL))
905 switch (DECL_FUNCTION_CODE (decl))
906 {
907 /* FIXME: once we will allow passing non-parm values to split part,
908 we need to be sure to handle correct builtin_stack_save and
909 builtin_stack_restore. At the moment we are safe; there is no
910 way to store builtin_stack_save result in non-SSA variable
911 since all calls to those are compiler generated. */
912 case BUILT_IN_APPLY:
913 case BUILT_IN_APPLY_ARGS:
914 case BUILT_IN_VA_START:
915 if (dump_file && (dump_flags & TDF_DETAILS))
916 fprintf (dump_file,
917 "Cannot split: builtin_apply and va_start.\n");
918 can_split = false;
919 break;
920 case BUILT_IN_EH_POINTER:
921 if (dump_file && (dump_flags & TDF_DETAILS))
922 fprintf (dump_file, "Cannot split: builtin_eh_pointer.\n");
923 can_split = false;
924 break;
925 default:
926 break;
927 }
928
929 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)for (op = op_iter_init_tree (&(iter), stmt, 0x02); !op_iter_done
(&(iter)); (void) (op = op_iter_next_tree (&(iter)))
)
930 bitmap_set_bit (set_ssa_names, SSA_NAME_VERSION (op)(tree_check ((op), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 930, __FUNCTION__, (SSA_NAME)))->base.u.version
);
931 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)for (op = op_iter_init_tree (&(iter), stmt, 0x01); !op_iter_done
(&(iter)); (void) (op = op_iter_next_tree (&(iter)))
)
932 bitmap_set_bit (used_ssa_names, SSA_NAME_VERSION (op)(tree_check ((op), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 932, __FUNCTION__, (SSA_NAME)))->base.u.version
);
933 can_split &= !walk_stmt_load_store_addr_ops (stmt, non_ssa_vars,
934 mark_nonssa_use,
935 mark_nonssa_use,
936 mark_nonssa_use);
937 }
938 for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
939 gsi_next (&bsi))
940 {
941 gphi *stmt = bsi.phi ();
942 unsigned int i;
943
944 if (virtual_operand_p (gimple_phi_result (stmt)))
945 continue;
946 bitmap_set_bit (set_ssa_names,
947 SSA_NAME_VERSION (gimple_phi_result (stmt))(tree_check ((gimple_phi_result (stmt)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 947, __FUNCTION__, (SSA_NAME)))->base.u.version
);
948 for (i = 0; i < gimple_phi_num_args (stmt); i++)
949 {
950 tree op = gimple_phi_arg_def (stmt, i);
951 if (TREE_CODE (op)((enum tree_code) (op)->base.code) == SSA_NAME)
952 bitmap_set_bit (used_ssa_names, SSA_NAME_VERSION (op)(tree_check ((op), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 952, __FUNCTION__, (SSA_NAME)))->base.u.version
);
953 }
954 can_split &= !walk_stmt_load_store_addr_ops (stmt, non_ssa_vars,
955 mark_nonssa_use,
956 mark_nonssa_use,
957 mark_nonssa_use);
958 }
959 /* Record also uses coming from PHI operand in return BB. */
960 FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
961 if (e->dest == return_bb)
962 {
963 for (gphi_iterator bsi = gsi_start_phis (return_bb);
964 !gsi_end_p (bsi);
965 gsi_next (&bsi))
966 {
967 gphi *stmt = bsi.phi ();
968 tree op = gimple_phi_arg_def (stmt, e->dest_idx);
969
970 if (virtual_operand_p (gimple_phi_result (stmt)))
971 continue;
972 if (TREE_CODE (op)((enum tree_code) (op)->base.code) == SSA_NAME)
973 bitmap_set_bit (used_ssa_names, SSA_NAME_VERSION (op)(tree_check ((op), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 973, __FUNCTION__, (SSA_NAME)))->base.u.version
);
974 else
975 can_split &= !mark_nonssa_use (stmt, op, op, non_ssa_vars);
976 }
977 }
978 return can_split;
979}
980
981/* Stack entry for recursive DFS walk in find_split_point. */
982
983class stack_entry
984{
985public:
986 /* Basic block we are examining. */
987 basic_block bb;
988
989 /* SSA names set and used by the BB and all BBs reachable
990 from it via DFS walk. */
991 bitmap set_ssa_names, used_ssa_names;
992 bitmap non_ssa_vars;
993
994 /* All BBS visited from this BB via DFS walk. */
995 bitmap bbs_visited;
996
997 /* Last examined edge in DFS walk. Since we walk unoriented graph,
998 the value is up to sum of incoming and outgoing edges of BB. */
999 unsigned int edge_num;
1000
1001 /* Stack entry index of earliest BB reachable from current BB
1002 or any BB visited later in DFS walk. */
1003 int earliest;
1004
1005 /* Overall time and size of all BBs reached from this BB in DFS walk. */
1006 sreal overall_time;
1007 int overall_size;
1008
1009 /* When false we cannot split on this BB. */
1010 bool can_split;
1011};
1012
1013
1014/* Find all articulations and call consider_split on them.
1015 OVERALL_TIME and OVERALL_SIZE is time and size of the function.
1016
1017 We perform basic algorithm for finding an articulation in a graph
1018 created from CFG by considering it to be an unoriented graph.
1019
1020 The articulation is discovered via DFS walk. We collect earliest
1021 basic block on stack that is reachable via backward edge. Articulation
1022 is any basic block such that there is no backward edge bypassing it.
1023 To reduce stack usage we maintain heap allocated stack in STACK vector.
1024 AUX pointer of BB is set to index it appears in the stack or -1 once
1025 it is visited and popped off the stack.
1026
1027 The algorithm finds articulation after visiting the whole component
1028 reachable by it. This makes it convenient to collect information about
1029 the component used by consider_split. */
1030
1031static void
1032find_split_points (basic_block return_bb, sreal overall_time, int overall_size)
1033{
1034 stack_entry first;
1035 vec<stack_entry> stack = vNULL;
1036 basic_block bb;
1037 class split_point current;
1038
1039 current.header_time = overall_time;
1040 current.header_size = overall_size;
1041 current.split_time = 0;
1042 current.split_size = 0;
1043 current.ssa_names_to_pass = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
1044
1045 first.bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr);
1046 first.edge_num = 0;
1047 first.overall_time = 0;
1048 first.overall_size = 0;
1049 first.earliest = INT_MAX2147483647;
1050 first.set_ssa_names = 0;
1051 first.used_ssa_names = 0;
1052 first.non_ssa_vars = 0;
1053 first.bbs_visited = 0;
1054 first.can_split = false;
1055 stack.safe_push (first);
1056 ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->aux = (void *)(intptr_t)-1;
1057
1058 while (!stack.is_empty ())
1059 {
1060 stack_entry *entry = &stack.last ();
1061
1062 /* We are walking an acyclic graph, so edge_num counts
1063 succ and pred edges together. However when considering
1064 articulation, we want to have processed everything reachable
1065 from articulation but nothing that reaches into it. */
1066 if (entry->edge_num == EDGE_COUNT (entry->bb->succs)vec_safe_length (entry->bb->succs)
1067 && entry->bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr))
1068 {
1069 int pos = stack.length ();
1070 entry->can_split &= visit_bb (entry->bb, return_bb,
1071 entry->set_ssa_names,
1072 entry->used_ssa_names,
1073 entry->non_ssa_vars);
1074 if (pos <= entry->earliest && !entry->can_split
1075 && dump_file && (dump_flags & TDF_DETAILS))
1076 fprintf (dump_file,
1077 "found articulation at bb %i but cannot split\n",
1078 entry->bb->index);
1079 if (pos <= entry->earliest && entry->can_split)
1080 {
1081 if (dump_file && (dump_flags & TDF_DETAILS))
1082 fprintf (dump_file, "found articulation at bb %i\n",
1083 entry->bb->index);
1084 current.entry_bb = entry->bb;
1085 current.ssa_names_to_pass = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
1086 bitmap_and_compl (current.ssa_names_to_pass,
1087 entry->used_ssa_names, entry->set_ssa_names);
1088 current.header_time = overall_time - entry->overall_time;
1089 current.header_size = overall_size - entry->overall_size;
1090 current.split_time = entry->overall_time;
1091 current.split_size = entry->overall_size;
1092 current.split_bbs = entry->bbs_visited;
1093 consider_split (&current, entry->non_ssa_vars, return_bb);
1094 BITMAP_FREE (current.ssa_names_to_pass)((void) (bitmap_obstack_free ((bitmap) current.ssa_names_to_pass
), (current.ssa_names_to_pass) = (bitmap) nullptr))
;
1095 }
1096 }
1097 /* Do actual DFS walk. */
1098 if (entry->edge_num
1099 < (EDGE_COUNT (entry->bb->succs)vec_safe_length (entry->bb->succs)
1100 + EDGE_COUNT (entry->bb->preds)vec_safe_length (entry->bb->preds)))
1101 {
1102 edge e;
1103 basic_block dest;
1104 if (entry->edge_num < EDGE_COUNT (entry->bb->succs)vec_safe_length (entry->bb->succs))
1105 {
1106 e = EDGE_SUCC (entry->bb, entry->edge_num)(*(entry->bb)->succs)[(entry->edge_num)];
1107 dest = e->dest;
1108 }
1109 else
1110 {
1111 e = EDGE_PRED (entry->bb, entry->edge_num(*(entry->bb)->preds)[(entry->edge_num - vec_safe_length
(entry->bb->succs))]
1112 - EDGE_COUNT (entry->bb->succs))(*(entry->bb)->preds)[(entry->edge_num - vec_safe_length
(entry->bb->succs))]
;
1113 dest = e->src;
1114 }
1115
1116 entry->edge_num++;
1117
1118 /* New BB to visit, push it to the stack. */
1119 if (dest != return_bb && dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
1120 && !dest->aux)
1121 {
1122 stack_entry new_entry;
1123
1124 new_entry.bb = dest;
1125 new_entry.edge_num = 0;
1126 new_entry.overall_time
1127 = bb_info_vec[dest->index].time;
1128 new_entry.overall_size
1129 = bb_info_vec[dest->index].size;
1130 new_entry.earliest = INT_MAX2147483647;
1131 new_entry.set_ssa_names = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
1132 new_entry.used_ssa_names = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
1133 new_entry.bbs_visited = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
1134 new_entry.non_ssa_vars = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
1135 new_entry.can_split = true;
1136 bitmap_set_bit (new_entry.bbs_visited, dest->index);
1137 stack.safe_push (new_entry);
1138 dest->aux = (void *)(intptr_t)stack.length ();
1139 }
1140 /* Back edge found, record the earliest point. */
1141 else if ((intptr_t)dest->aux > 0
1142 && (intptr_t)dest->aux < entry->earliest)
1143 entry->earliest = (intptr_t)dest->aux;
1144 }
1145 /* We are done with examining the edges. Pop off the value from stack
1146 and merge stuff we accumulate during the walk. */
1147 else if (entry->bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr))
1148 {
1149 stack_entry *prev = &stack[stack.length () - 2];
1150
1151 entry->bb->aux = (void *)(intptr_t)-1;
1152 prev->can_split &= entry->can_split;
1153 if (prev->set_ssa_names)
1154 {
1155 bitmap_ior_into (prev->set_ssa_names, entry->set_ssa_names);
1156 bitmap_ior_into (prev->used_ssa_names, entry->used_ssa_names);
1157 bitmap_ior_into (prev->bbs_visited, entry->bbs_visited);
1158 bitmap_ior_into (prev->non_ssa_vars, entry->non_ssa_vars);
1159 }
1160 if (prev->earliest > entry->earliest)
1161 prev->earliest = entry->earliest;
1162 prev->overall_time += entry->overall_time;
1163 prev->overall_size += entry->overall_size;
1164 BITMAP_FREE (entry->set_ssa_names)((void) (bitmap_obstack_free ((bitmap) entry->set_ssa_names
), (entry->set_ssa_names) = (bitmap) nullptr))
;
1165 BITMAP_FREE (entry->used_ssa_names)((void) (bitmap_obstack_free ((bitmap) entry->used_ssa_names
), (entry->used_ssa_names) = (bitmap) nullptr))
;
1166 BITMAP_FREE (entry->bbs_visited)((void) (bitmap_obstack_free ((bitmap) entry->bbs_visited)
, (entry->bbs_visited) = (bitmap) nullptr))
;
1167 BITMAP_FREE (entry->non_ssa_vars)((void) (bitmap_obstack_free ((bitmap) entry->non_ssa_vars
), (entry->non_ssa_vars) = (bitmap) nullptr))
;
1168 stack.pop ();
1169 }
1170 else
1171 stack.pop ();
1172 }
1173 ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->aux = NULLnullptr;
1174 FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
1175 bb->aux = NULLnullptr;
1176 stack.release ();
1177 BITMAP_FREE (current.ssa_names_to_pass)((void) (bitmap_obstack_free ((bitmap) current.ssa_names_to_pass
), (current.ssa_names_to_pass) = (bitmap) nullptr))
;
1178}
1179
1180/* Split function at SPLIT_POINT. */
1181
1182static void
1183split_function (basic_block return_bb, class split_point *split_point,
1184 bool add_tsan_func_exit)
1185{
1186 vec<tree> args_to_pass = vNULL;
1187 bitmap args_to_skip;
1188 tree parm;
1189 int num = 0;
1190 cgraph_node *node, *cur_node = cgraph_node::get (current_function_decl);
1191 basic_block call_bb;
1192 gcall *call, *tsan_func_exit_call = NULLnullptr;
1193 edge e;
1194 edge_iterator ei;
1195 tree retval = NULLnullptr, real_retval = NULLnullptr;
1196 gimple *last_stmt = NULLnullptr;
1197 unsigned int i;
1198 tree arg, ddef;
1199
1200 if (dump_file)
1
Assuming 'dump_file' is null
2
Taking false branch
1201 {
1202 fprintf (dump_file, "\n\nSplitting function at:\n");
1203 dump_split_point (dump_file, split_point);
1204 }
1205
1206 if (cur_node->can_change_signature)
3
Assuming field 'can_change_signature' is 0
4
Taking false branch
1207 args_to_skip = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
1208 else
1209 args_to_skip = NULLnullptr;
1210
1211 /* Collect the parameters of new function and args_to_skip bitmap. */
1212 for (parm = DECL_ARGUMENTS (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1212, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
)
;
5
Loop condition is false. Execution continues on line 1235
1213 parm; parm = DECL_CHAIN (parm)(((contains_struct_check (((contains_struct_check ((parm), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1213, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1213, __FUNCTION__))->common.chain))
, num++)
1214 if (args_to_skip
1215 && (!is_gimple_reg (parm)
1216 || (ddef = ssa_default_def (cfun(cfun + 0), parm)) == NULL_TREE(tree) nullptr
1217 || !bitmap_bit_p (split_point->ssa_names_to_pass,
1218 SSA_NAME_VERSION (ddef)(tree_check ((ddef), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1218, __FUNCTION__, (SSA_NAME)))->base.u.version
)))
1219 bitmap_set_bit (args_to_skip, num);
1220 else
1221 {
1222 /* This parm might not have been used up to now, but is going to be
1223 used, hence register it. */
1224 if (is_gimple_reg (parm))
1225 arg = get_or_create_ssa_default_def (cfun(cfun + 0), parm);
1226 else
1227 arg = parm;
1228
1229 if (!useless_type_conversion_p (DECL_ARG_TYPE (parm)((tree_check ((parm), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1229, __FUNCTION__, (PARM_DECL)))->decl_common.initial)
, TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1229, __FUNCTION__))->typed.type)
))
1230 arg = fold_convert (DECL_ARG_TYPE (parm), arg)fold_convert_loc (((location_t) 0), ((tree_check ((parm), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1230, __FUNCTION__, (PARM_DECL)))->decl_common.initial),
arg)
;
1231 args_to_pass.safe_push (arg);
1232 }
1233
1234 /* See if the split function will return. */
1235 bool split_part_return_p = false;
1236 FOR_EACH_EDGE (e, ei, return_bb->preds)for ((ei) = ei_start_1 (&((return_bb->preds))); ei_cond
((ei), &(e)); ei_next (&(ei)))
6
Loop condition is false. Execution continues on line 1244
1237 {
1238 if (bitmap_bit_p (split_point->split_bbs, e->src->index))
1239 split_part_return_p = true;
1240 }
1241
1242 /* Add return block to what will become the split function.
1243 We do not return; no return block is needed. */
1244 if (!split_part_return_p
6.1
'split_part_return_p' is false
6.1
'split_part_return_p' is false
6.1
'split_part_return_p' is false
)
7
Taking true branch
1245 ;
1246 /* We have no return block, so nothing is needed. */
1247 else if (return_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
1248 ;
1249 /* When we do not want to return value, we need to construct
1250 new return block with empty return statement.
1251 FIXME: Once we are able to change return type, we should change function
1252 to return void instead of just outputting function with undefined return
1253 value. For structures this affects quality of codegen. */
1254 else if ((retval = find_retval (return_bb))
1255 && !split_point->split_part_set_retval)
1256 {
1257 bool redirected = true;
1258 basic_block new_return_bb = create_basic_block (NULLnullptr, 0, return_bb);
1259 gimple_stmt_iterator gsi = gsi_start_bb (new_return_bb);
1260 gsi_insert_after (&gsi, gimple_build_return (NULLnullptr), GSI_NEW_STMT);
1261 new_return_bb->count = profile_count::zero ();
1262 while (redirected)
1263 {
1264 redirected = false;
1265 FOR_EACH_EDGE (e, ei, return_bb->preds)for ((ei) = ei_start_1 (&((return_bb->preds))); ei_cond
((ei), &(e)); ei_next (&(ei)))
1266 if (bitmap_bit_p (split_point->split_bbs, e->src->index))
1267 {
1268 new_return_bb->count += e->count ();
1269 redirect_edge_and_branch (e, new_return_bb);
1270 redirected = true;
1271 break;
1272 }
1273 }
1274 e = make_single_succ_edge (new_return_bb, EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr), 0);
1275 add_bb_to_loop (new_return_bb, current_loops((cfun + 0)->x_current_loops)->tree_root);
1276 bitmap_set_bit (split_point->split_bbs, new_return_bb->index);
1277 }
1278 /* When we pass around the value, use existing return block. */
1279 else
1280 bitmap_set_bit (split_point->split_bbs, return_bb->index);
1281
1282 /* If RETURN_BB has virtual operand PHIs, they must be removed and the
1283 virtual operand marked for renaming as we change the CFG in a way that
1284 tree-inline is not able to compensate for.
1285
1286 Note this can happen whether or not we have a return value. If we have
1287 a return value, then RETURN_BB may have PHIs for real operands too. */
1288 if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
8
Assuming 'return_bb' is equal to field 'x_exit_block_ptr'
9
Taking false branch
1289 {
1290 bool phi_p = false;
1291 for (gphi_iterator gsi = gsi_start_phis (return_bb);
1292 !gsi_end_p (gsi);)
1293 {
1294 gphi *stmt = gsi.phi ();
1295 if (!virtual_operand_p (gimple_phi_result (stmt)))
1296 {
1297 gsi_next (&gsi);
1298 continue;
1299 }
1300 mark_virtual_phi_result_for_renaming (stmt);
1301 remove_phi_node (&gsi, true);
1302 phi_p = true;
1303 }
1304 /* In reality we have to rename the reaching definition of the
1305 virtual operand at return_bb as we will eventually release it
1306 when we remove the code region we outlined.
1307 So we have to rename all immediate virtual uses of that region
1308 if we didn't see a PHI definition yet. */
1309 /* ??? In real reality we want to set the reaching vdef of the
1310 entry of the SESE region as the vuse of the call and the reaching
1311 vdef of the exit of the SESE region as the vdef of the call. */
1312 if (!phi_p)
1313 for (gimple_stmt_iterator gsi = gsi_start_bb (return_bb);
1314 !gsi_end_p (gsi);
1315 gsi_next (&gsi))
1316 {
1317 gimple *stmt = gsi_stmt (gsi);
1318 if (gimple_vuse (stmt))
1319 {
1320 gimple_set_vuse (stmt, NULL_TREE(tree) nullptr);
1321 update_stmt (stmt);
1322 }
1323 if (gimple_vdef (stmt))
1324 break;
1325 }
1326 }
1327
1328 ipa_param_adjustments *adjustments;
1329 bool skip_return = (!split_part_return_p
9.1
'split_part_return_p' is false
9.1
'split_part_return_p' is false
9.1
'split_part_return_p' is false
1330 || !split_point->split_part_set_retval); 1331 /* TODO: Perhaps get rid of args_to_skip entirely, after we make sure the 1332 debug info generation and discrepancy avoiding works well too. */ 1333 if ((args_to_skip
9.2
'args_to_skip' is null
9.2
'args_to_skip' is null
9.2
'args_to_skip' is null
&& !bitmap_empty_p (args_to_skip))
10
Taking true branch
1334 || skip_return
9.3
'skip_return' is true
9.3
'skip_return' is true
9.3
'skip_return' is true
) 1335 { 1336 vec<ipa_adjusted_param, va_gc> *new_params = NULLnullptr; 1337 unsigned j; 1338 for (parm = DECL_ARGUMENTS (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1338, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
)
, j = 0;
11
Calling 'tree_check'
15
Returning from 'tree_check'
16
Loop condition is true. Entering loop body
49
Loop condition is true. Entering loop body
1339 parm; parm = DECL_CHAIN (parm)(((contains_struct_check (((contains_struct_check ((parm), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1339, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1339, __FUNCTION__))->common.chain))
, j++)
39
Calling 'contains_struct_check'
43
Returning from 'contains_struct_check'
44
Calling 'contains_struct_check'
48
Returning from 'contains_struct_check'
1340 if (!args_to_skip
16.1
'args_to_skip' is null
49.1
'args_to_skip' is null
16.1
'args_to_skip' is null
49.1
'args_to_skip' is null
16.1
'args_to_skip' is null
49.1
'args_to_skip' is null
|| !bitmap_bit_p (args_to_skip, j)) 1341 { 1342 ipa_adjusted_param adj; 1343 memset (&adj, 0, sizeof (adj)); 1344 adj.op = IPA_PARAM_OP_COPY; 1345 adj.base_index = j; 1346 adj.prev_clone_index = j; 1347 vec_safe_push (new_params, adj);
17
Calling 'vec_safe_push<ipa_adjusted_param, va_gc>'
38
Returning from 'vec_safe_push<ipa_adjusted_param, va_gc>'
50
Passing value via 1st parameter 'v'
51
Calling 'vec_safe_push<ipa_adjusted_param, va_gc>'
1348 } 1349 adjustments = new ipa_param_adjustments (new_params, j, skip_return); 1350 } 1351 else 1352 adjustments = NULLnullptr; 1353 1354 /* Now create the actual clone. */ 1355 cgraph_edge::rebuild_edges (); 1356 node = cur_node->create_version_clone_with_body 1357 (vNULL, NULLnullptr, adjustments, 1358 split_point->split_bbs, split_point->entry_bb, "part"); 1359 delete adjustments; 1360 node->split_part = true; 1361 1362 if (cur_node->same_comdat_group) 1363 { 1364 /* TODO: call is versionable if we make sure that all 1365 callers are inside of a comdat group. */ 1366 cur_node->calls_comdat_local = true; 1367 node->add_to_same_comdat_group (cur_node); 1368 } 1369 1370 1371 /* Let's take a time profile for splitted function. */ 1372 if (cur_node->tp_first_run) 1373 node->tp_first_run = cur_node->tp_first_run + 1; 1374 1375 /* For usual cloning it is enough to clear builtin only when signature 1376 changes. For partial inlining we however cannot expect the part 1377 of builtin implementation to have same semantic as the whole. */ 1378 if (fndecl_built_in_p (node->decl)) 1379 set_decl_built_in_function (node->decl, NOT_BUILT_IN, 0); 1380 1381 /* If return_bb contains any clobbers that refer to SSA_NAMEs 1382 set in the split part, remove them. Also reset debug stmts that 1383 refer to SSA_NAMEs set in the split part. */ 1384 if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)) 1385 { 1386 gimple_stmt_iterator gsi = gsi_start_bb (return_bb); 1387 while (!gsi_end_p (gsi)) 1388 { 1389 tree op; 1390 ssa_op_iter iter; 1391 gimple *stmt = gsi_stmt (gsi); 1392 bool remove = false; 1393 if (gimple_clobber_p (stmt) || is_gimple_debug (stmt)) 1394 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)for (op = op_iter_init_tree (&(iter), stmt, 0x01); !op_iter_done
(&(iter)); (void) (op = op_iter_next_tree (&(iter)))
)
1395 { 1396 basic_block bb = gimple_bb (SSA_NAME_DEF_STMT (op)(tree_check ((op), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1396, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
); 1397 if (op != retval 1398 && bb 1399 && bb != return_bb 1400 && bitmap_bit_p (split_point->split_bbs, bb->index)) 1401 { 1402 if (is_gimple_debug (stmt)) 1403 { 1404 gimple_debug_bind_reset_value (stmt); 1405 update_stmt (stmt); 1406 } 1407 else 1408 remove = true; 1409 break; 1410 } 1411 } 1412 if (remove) 1413 gsi_remove (&gsi, true); 1414 else 1415 gsi_next (&gsi); 1416 } 1417 } 1418 1419 /* If the original function is declared inline, there is no point in issuing 1420 a warning for the non-inlinable part. */ 1421 DECL_NO_INLINE_WARNING_P (node->decl)((tree_check ((node->decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1421, __FUNCTION__, (FUNCTION_DECL)))->function_decl.no_inline_warning_flag
)
= 1; 1422 cur_node->remove_callees (); 1423 cur_node->remove_all_references (); 1424 if (!split_part_return_p) 1425 TREE_THIS_VOLATILE (node->decl)((node->decl)->base.volatile_flag) = 1; 1426 if (dump_file) 1427 dump_function_to_file (node->decl, dump_file, dump_flags); 1428 1429 /* Create the basic block we place call into. It is the entry basic block 1430 split after last label. */ 1431 call_bb = split_point->entry_bb; 1432 for (gimple_stmt_iterator gsi = gsi_start_bb (call_bb); !gsi_end_p (gsi);) 1433 if (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL) 1434 { 1435 last_stmt = gsi_stmt (gsi); 1436 gsi_next (&gsi); 1437 } 1438 else 1439 break; 1440 call_bb->count = split_point->count; 1441 e = split_block (split_point->entry_bb, last_stmt); 1442 remove_edge (e); 1443 1444 /* Produce the call statement. */ 1445 gimple_stmt_iterator gsi = gsi_last_bb (call_bb); 1446 FOR_EACH_VEC_ELT (args_to_pass, i, arg)for (i = 0; (args_to_pass).iterate ((i), &(arg)); ++(i)) 1447 if (!is_gimple_val (arg)) 1448 { 1449 arg = force_gimple_operand_gsi (&gsi, arg, true, NULL_TREE(tree) nullptr, 1450 false, GSI_CONTINUE_LINKING); 1451 args_to_pass[i] = arg; 1452 } 1453 call = gimple_build_call_vec (node->decl, args_to_pass); 1454 gimple_set_block (call, DECL_INITIAL (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1454, __FUNCTION__))->decl_common.initial)
); 1455 args_to_pass.release (); 1456 1457 /* For optimized away parameters, add on the caller side 1458 before the call 1459 DEBUG D#X => parm_Y(D) 1460 stmts and associate D#X with parm in decl_debug_args_lookup 1461 vector to say for debug info that if parameter parm had been passed, 1462 it would have value parm_Y(D). */ 1463 if (args_to_skip) 1464 { 1465 vec<tree, va_gc> **debug_args = NULLnullptr; 1466 unsigned i = 0, len = 0; 1467 if (MAY_HAVE_DEBUG_BIND_STMTSglobal_options.x_flag_var_tracking_assignments) 1468 { 1469 debug_args = decl_debug_args_lookup (node->decl); 1470 if (debug_args) 1471 len = vec_safe_length (*debug_args); 1472 } 1473 for (parm = DECL_ARGUMENTS (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1473, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
)
, num = 0; 1474 parm; parm = DECL_CHAIN (parm)(((contains_struct_check (((contains_struct_check ((parm), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1474, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1474, __FUNCTION__))->common.chain))
, num++) 1475 if (bitmap_bit_p (args_to_skip, num) && is_gimple_reg (parm)) 1476 { 1477 tree ddecl; 1478 gimple *def_temp; 1479 1480 /* This needs to be done even without 1481 MAY_HAVE_DEBUG_BIND_STMTS, otherwise if it didn't exist 1482 before, we'd end up with different SSA_NAME_VERSIONs 1483 between -g and -g0. */ 1484 arg = get_or_create_ssa_default_def (cfun(cfun + 0), parm); 1485 if (!MAY_HAVE_DEBUG_BIND_STMTSglobal_options.x_flag_var_tracking_assignments || debug_args == NULLnullptr) 1486 continue; 1487 1488 while (i < len && (**debug_args)[i] != DECL_ORIGIN (parm)(((contains_struct_check ((parm), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1488, __FUNCTION__))->decl_common.abstract_origin) ? ((contains_struct_check
((parm), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1488, __FUNCTION__))->decl_common.abstract_origin) : (parm
))
) 1489 i += 2; 1490 if (i >= len) 1491 continue; 1492 ddecl = (**debug_args)[i + 1]; 1493 def_temp 1494 = gimple_build_debug_bind (ddecl, unshare_expr (arg), call); 1495 gsi_insert_after (&gsi, def_temp, GSI_NEW_STMT); 1496 } 1497 BITMAP_FREE (args_to_skip)((void) (bitmap_obstack_free ((bitmap) args_to_skip), (args_to_skip
) = (bitmap) nullptr))
; 1498 } 1499 1500 /* We avoid address being taken on any variable used by split part, 1501 so return slot optimization is always possible. Moreover this is 1502 required to make DECL_BY_REFERENCE work. */ 1503 if (aggregate_value_p (DECL_RESULT (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1503, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)
, 1504 TREE_TYPE (current_function_decl)((contains_struct_check ((current_function_decl), (TS_TYPED),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1504, __FUNCTION__))->typed.type)
) 1505 && (!is_gimple_reg_type (TREE_TYPE (DECL_RESULT (current_function_decl))((contains_struct_check ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1505, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1505, __FUNCTION__))->typed.type)
) 1506 || DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))((tree_check3 ((((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1506, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1506, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
)->decl_common.decl_by_reference_flag)
)) 1507 gimple_call_set_return_slot_opt (call, true); 1508 1509 if (add_tsan_func_exit) 1510 tsan_func_exit_call = gimple_build_call_internal (IFN_TSAN_FUNC_EXIT, 0); 1511 1512 /* Update return value. This is bit tricky. When we do not return, 1513 do nothing. When we return we might need to update return_bb 1514 or produce a new return statement. */ 1515 if (!split_part_return_p) 1516 { 1517 gsi_insert_after (&gsi, call, GSI_NEW_STMT); 1518 if (tsan_func_exit_call) 1519 gsi_insert_after (&gsi, tsan_func_exit_call, GSI_NEW_STMT); 1520 } 1521 else 1522 { 1523 e = make_single_succ_edge (call_bb, return_bb, 1524 return_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr) 1525 ? 0 : EDGE_FALLTHRU); 1526 1527 /* If there is return basic block, see what value we need to store 1528 return value into and put call just before it. */ 1529 if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)) 1530 { 1531 real_retval = retval; 1532 if (real_retval && split_point->split_part_set_retval) 1533 { 1534 gphi_iterator psi; 1535 1536 /* See if we need new SSA_NAME for the result. 1537 When DECL_BY_REFERENCE is true, retval is actually pointer to 1538 return value and it is constant in whole function. */ 1539 if (TREE_CODE (retval)((enum tree_code) (retval)->base.code) == SSA_NAME 1540 && !DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))((tree_check3 ((((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1540, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1540, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
)->decl_common.decl_by_reference_flag)
) 1541 { 1542 retval = copy_ssa_name (retval, call); 1543 1544 /* See if there is PHI defining return value. */ 1545 for (psi = gsi_start_phis (return_bb); 1546 !gsi_end_p (psi); gsi_next (&psi)) 1547 if (!virtual_operand_p (gimple_phi_result (psi.phi ()))) 1548 break; 1549 1550 /* When there is PHI, just update its value. */ 1551 if (TREE_CODE (retval)((enum tree_code) (retval)->base.code) == SSA_NAME 1552 && !gsi_end_p (psi)) 1553 add_phi_arg (psi.phi (), retval, e, UNKNOWN_LOCATION((location_t) 0)); 1554 /* Otherwise update the return BB itself. 1555 find_return_bb allows at most one assignment to return value, 1556 so update first statement. */ 1557 else 1558 { 1559 gimple_stmt_iterator bsi; 1560 for (bsi = gsi_start_bb (return_bb); !gsi_end_p (bsi); 1561 gsi_next (&bsi)) 1562 if (greturn *return_stmt 1563 = dyn_cast <greturn *> (gsi_stmt (bsi))) 1564 { 1565 gimple_return_set_retval (return_stmt, retval); 1566 break; 1567 } 1568 else if (gimple_code (gsi_stmt (bsi)) == GIMPLE_ASSIGN 1569 && !gimple_clobber_p (gsi_stmt (bsi))) 1570 { 1571 gimple_assign_set_rhs1 (gsi_stmt (bsi), retval); 1572 break; 1573 } 1574 update_stmt (gsi_stmt (bsi)); 1575 /* Also adjust clobbers and debug stmts in return_bb. */ 1576 for (bsi = gsi_start_bb (return_bb); !gsi_end_p (bsi); 1577 gsi_next (&bsi)) 1578 { 1579 gimple *stmt = gsi_stmt (bsi); 1580 if (gimple_clobber_p (stmt) 1581 || is_gimple_debug (stmt)) 1582 { 1583 ssa_op_iter iter; 1584 use_operand_p use_p; 1585 bool update = false; 1586 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,for (use_p = op_iter_init_use (&(iter), stmt, 0x01); !op_iter_done
(&(iter)); use_p = op_iter_next_use (&(iter)))
1587 SSA_OP_USE)for (use_p = op_iter_init_use (&(iter), stmt, 0x01); !op_iter_done
(&(iter)); use_p = op_iter_next_use (&(iter)))
1588 if (USE_FROM_PTR (use_p)get_use_from_ptr (use_p) == real_retval) 1589 { 1590 SET_USE (use_p, retval)set_ssa_use_from_ptr (use_p, retval); 1591 update = true; 1592 } 1593 if (update) 1594 update_stmt (stmt); 1595 } 1596 } 1597 } 1598 } 1599 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))((tree_check3 ((((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1599, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1599, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
)->decl_common.decl_by_reference_flag)
) 1600 { 1601 gimple_call_set_lhs (call, build_simple_mem_ref (retval)build_simple_mem_ref_loc (((location_t) 0), retval)); 1602 gsi_insert_after (&gsi, call, GSI_NEW_STMT); 1603 } 1604 else 1605 { 1606 tree restype; 1607 restype = TREE_TYPE (DECL_RESULT (current_function_decl))((contains_struct_check ((((tree_check ((current_function_decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1607, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1607, __FUNCTION__))->typed.type)
; 1608 gsi_insert_after (&gsi, call, GSI_NEW_STMT); 1609 if (!useless_type_conversion_p (TREE_TYPE (retval)((contains_struct_check ((retval), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1609, __FUNCTION__))->typed.type)
, restype)) 1610 { 1611 gimple *cpy; 1612 tree tem = create_tmp_reg (restype); 1613 tem = make_ssa_name (tem, call); 1614 cpy = gimple_build_assign (retval, NOP_EXPR, tem); 1615 gsi_insert_after (&gsi, cpy, GSI_NEW_STMT); 1616 retval = tem; 1617 } 1618 gimple_call_set_lhs (call, retval); 1619 update_stmt (call); 1620 } 1621 } 1622 else 1623 gsi_insert_after (&gsi, call, GSI_NEW_STMT); 1624 if (tsan_func_exit_call) 1625 gsi_insert_after (&gsi, tsan_func_exit_call, GSI_NEW_STMT); 1626 } 1627 /* We don't use return block (there is either no return in function or 1628 multiple of them). So create new basic block with return statement. 1629 */ 1630 else 1631 { 1632 greturn *ret; 1633 if (split_point->split_part_set_retval 1634 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
((current_function_decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1634, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1634, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
) 1635 { 1636 retval = DECL_RESULT (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1636, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)
; 1637 1638 /* We use temporary register to hold value when aggregate_value_p 1639 is false. Similarly for DECL_BY_REFERENCE we must avoid extra 1640 copy. */ 1641 if (!aggregate_value_p (retval, TREE_TYPE (current_function_decl)((contains_struct_check ((current_function_decl), (TS_TYPED),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1641, __FUNCTION__))->typed.type)
) 1642 && !DECL_BY_REFERENCE (retval)((tree_check3 ((retval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1642, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
)->decl_common.decl_by_reference_flag)
) 1643 retval = create_tmp_reg (TREE_TYPE (retval)((contains_struct_check ((retval), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1643, __FUNCTION__))->typed.type)
); 1644 if (is_gimple_reg (retval)) 1645 { 1646 /* When returning by reference, there is only one SSA name 1647 assigned to RESULT_DECL (that is pointer to return value). 1648 Look it up or create new one if it is missing. */ 1649 if (DECL_BY_REFERENCE (retval)((tree_check3 ((retval), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1649, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
)->decl_common.decl_by_reference_flag)
) 1650 retval = get_or_create_ssa_default_def (cfun(cfun + 0), retval); 1651 /* Otherwise produce new SSA name for return value. */ 1652 else 1653 retval = make_ssa_name (retval, call); 1654 } 1655 if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl))((tree_check3 ((((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1655, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1655, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
)->decl_common.decl_by_reference_flag)
) 1656 gimple_call_set_lhs (call, build_simple_mem_ref (retval)build_simple_mem_ref_loc (((location_t) 0), retval)); 1657 else 1658 gimple_call_set_lhs (call, retval); 1659 gsi_insert_after (&gsi, call, GSI_NEW_STMT); 1660 } 1661 else 1662 { 1663 gsi_insert_after (&gsi, call, GSI_NEW_STMT); 1664 if (retval 1665 && is_gimple_reg_type (TREE_TYPE (retval)((contains_struct_check ((retval), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1665, __FUNCTION__))->typed.type)
) 1666 && !is_gimple_val (retval)) 1667 { 1668 gassign *g 1669 = gimple_build_assign (make_ssa_name (TREE_TYPE (retval)((contains_struct_check ((retval), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1669, __FUNCTION__))->typed.type)
), 1670 retval); 1671 retval = gimple_assign_lhs (g); 1672 gsi_insert_after (&gsi, g, GSI_NEW_STMT); 1673 } 1674 } 1675 if (tsan_func_exit_call) 1676 gsi_insert_after (&gsi, tsan_func_exit_call, GSI_NEW_STMT); 1677 ret = gimple_build_return (retval); 1678 gsi_insert_after (&gsi, ret, GSI_NEW_STMT); 1679 } 1680 } 1681 free_dominance_info (CDI_DOMINATORS); 1682 free_dominance_info (CDI_POST_DOMINATORS); 1683 compute_fn_summary (node, true); 1684} 1685 1686/* Execute function splitting pass. */ 1687 1688static unsigned int 1689execute_split_functions (void) 1690{ 1691 gimple_stmt_iterator bsi; 1692 basic_block bb; 1693 sreal overall_time = 0; 1694 int overall_size = 0; 1695 int todo = 0; 1696 struct cgraph_node *node = cgraph_node::get (current_function_decl); 1697 1698 if (flags_from_decl_or_type (current_function_decl) 1699 & (ECF_NORETURN(1 << 3)|ECF_MALLOC(1 << 4))) 1700 { 1701 if (dump_file) 1702 fprintf (dump_file, "Not splitting: noreturn/malloc function.\n"); 1703 return 0; 1704 } 1705 if (MAIN_NAME_P (DECL_NAME (current_function_decl))((tree_check ((((contains_struct_check ((current_function_decl
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1705, __FUNCTION__))->decl_minimal.name)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1705, __FUNCTION__, (IDENTIFIER_NODE))) == global_trees[TI_MAIN_IDENTIFIER
])
) 1706 { 1707 if (dump_file) 1708 fprintf (dump_file, "Not splitting: main function.\n"); 1709 return 0; 1710 } 1711 if (node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED) 1712 { 1713 if (dump_file) 1714 fprintf (dump_file, "Not splitting: function is unlikely executed.\n"); 1715 return 0; 1716 } 1717 /* This can be relaxed; function might become inlinable after splitting 1718 away the uninlinable part. */ 1719 if (ipa_fn_summaries 1720 && ipa_fn_summaries->get (node) 1721 && !ipa_fn_summaries->get (node)->inlinable) 1722 { 1723 if (dump_file) 1724 fprintf (dump_file, "Not splitting: not inlinable.\n"); 1725 return 0; 1726 } 1727 if (DECL_DISREGARD_INLINE_LIMITS (node->decl)((tree_check ((node->decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1727, __FUNCTION__, (FUNCTION_DECL)))->function_decl.disregard_inline_limits
)
) 1728 { 1729 if (dump_file) 1730 fprintf (dump_file, "Not splitting: disregarding inline limits.\n"); 1731 return 0; 1732 } 1733 /* This can be relaxed; most of versioning tests actually prevents 1734 a duplication. */ 1735 if (!tree_versionable_function_p (current_function_decl)) 1736 { 1737 if (dump_file) 1738 fprintf (dump_file, "Not splitting: not versionable.\n"); 1739 return 0; 1740 } 1741 /* FIXME: we could support this. */ 1742 if (DECL_STRUCT_FUNCTION (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1742, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f)
->static_chain_decl) 1743 { 1744 if (dump_file) 1745 fprintf (dump_file, "Not splitting: nested function.\n"); 1746 return 0; 1747 } 1748 1749 /* See if it makes sense to try to split. 1750 It makes sense to split if we inline, that is if we have direct calls to 1751 handle or direct calls are possibly going to appear as result of indirect 1752 inlining or LTO. Also handle -fprofile-generate as LTO to allow non-LTO 1753 training for LTO -fprofile-use build. 1754 1755 Note that we are not completely conservative about disqualifying functions 1756 called once. It is possible that the caller is called more then once and 1757 then inlining would still benefit. */ 1758 if ((!node->callers 1759 /* Local functions called once will be completely inlined most of time. */ 1760 || (!node->callers->next_caller && node->local)) 1761 && !node->address_taken 1762 && !node->has_aliases_p () 1763 && (!flag_ltoglobal_options.x_flag_lto || !node->externally_visible)) 1764 { 1765 if (dump_file) 1766 fprintf (dump_file, "Not splitting: not called directly " 1767 "or called once.\n"); 1768 return 0; 1769 } 1770 1771 /* FIXME: We can actually split if splitting reduces call overhead. */ 1772 if (!flag_inline_small_functionsglobal_options.x_flag_inline_small_functions 1773 && !DECL_DECLARED_INLINE_P (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1773, __FUNCTION__, (FUNCTION_DECL)))->function_decl.declared_inline_flag
)
) 1774 { 1775 if (dump_file) 1776 fprintf (dump_file, "Not splitting: not autoinlining and function" 1777 " is not inline.\n"); 1778 return 0; 1779 } 1780 1781 if (lookup_attribute ("noinline", DECL_ATTRIBUTES (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1781, __FUNCTION__))->decl_common.attributes)
)) 1782 { 1783 if (dump_file) 1784 fprintf (dump_file, "Not splitting: function is noinline.\n"); 1785 return 0; 1786 } 1787 if (lookup_attribute ("section", DECL_ATTRIBUTES (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-split.c"
, 1787, __FUNCTION__))->decl_common.attributes)
)) 1788 { 1789 if (dump_file) 1790 fprintf (dump_file, "Not splitting: function is in user defined " 1791 "section.\n"); 1792 return 0; 1793 } 1794 1795 /* We enforce splitting after loop headers when profile info is not 1796 available. */ 1797 if (profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) != PROFILE_READ) 1798 mark_dfs_back_edges (); 1799 1800 /* Initialize bitmap to track forbidden calls. */ 1801 forbidden_dominators = BITMAP_ALLOCbitmap_alloc (NULLnullptr); 1802 calculate_dominance_info (CDI_DOMINATORS); 1803 1804 /* Compute local info about basic blocks and determine function size/time. */ 1805 bb_info_vec.safe_grow_cleared (last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block) + 1, true); 1806 best_split_point.split_bbs = NULLnullptr; 1807 basic_block return_bb = find_return_bb (); 1808 int tsan_exit_found = -1; 1809 FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
1810 { 1811 sreal time = 0; 1812 int size = 0; 1813 sreal freq = bb->count.to_sreal_scale 1814 (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count); 1815 1816 if (dump_file && (dump_flags & TDF_DETAILS)) 1817 fprintf (dump_file, "Basic block %i\n", bb->index); 1818 1819 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) 1820 { 1821 sreal this_time; 1822 int this_size; 1823 gimple *stmt = gsi_stmt (bsi); 1824 1825 this_size = estimate_num_insns (stmt, &eni_size_weights); 1826 this_time = (sreal)estimate_num_insns (stmt, &eni_time_weights) 1827 * freq; 1828 size += this_size; 1829 time += this_time; 1830 check_forbidden_calls (stmt); 1831 1832 if (dump_file && (dump_flags & TDF_DETAILS)) 1833 { 1834 fprintf (dump_file, " freq:%4.2f size:%3i time:%4.2f ", 1835 freq.to_double (), this_size, this_time.to_double ()); 1836 print_gimple_stmt (dump_file, stmt, 0); 1837 } 1838 1839 if ((flag_sanitizeglobal_options.x_flag_sanitize & SANITIZE_THREAD) 1840 && gimple_call_internal_p (stmt, IFN_TSAN_FUNC_EXIT)) 1841 { 1842 /* We handle TSAN_FUNC_EXIT for splitting either in the 1843 return_bb, or in its immediate predecessors. */ 1844 if ((bb != return_bb && !find_edge (bb, return_bb)) 1845 || (tsan_exit_found != -1 1846 && tsan_exit_found != (bb != return_bb))) 1847 { 1848 if (dump_file) 1849 fprintf (dump_file, "Not splitting: TSAN_FUNC_EXIT" 1850 " in unexpected basic block.\n"); 1851 BITMAP_FREE (forbidden_dominators)((void) (bitmap_obstack_free ((bitmap) forbidden_dominators),
(forbidden_dominators) = (bitmap) nullptr))
; 1852 bb_info_vec.release (); 1853 return 0; 1854 } 1855 tsan_exit_found = bb != return_bb; 1856 } 1857 } 1858 overall_time += time; 1859 overall_size += size; 1860 bb_info_vec[bb->index].time = time; 1861 bb_info_vec[bb->index].size = size; 1862 } 1863 find_split_points (return_bb, overall_time, overall_size); 1864 if (best_split_point.split_bbs) 1865 { 1866 split_function (return_bb, &best_split_point, tsan_exit_found == 1); 1867 BITMAP_FREE (best_split_point.ssa_names_to_pass)((void) (bitmap_obstack_free ((bitmap) best_split_point.ssa_names_to_pass
), (best_split_point.ssa_names_to_pass) = (bitmap) nullptr))
; 1868 BITMAP_FREE (best_split_point.split_bbs)((void) (bitmap_obstack_free ((bitmap) best_split_point.split_bbs
), (best_split_point.split_bbs) = (bitmap) nullptr))
; 1869 todo = TODO_update_ssa(1 << 11) | TODO_cleanup_cfg(1 << 5); 1870 } 1871 BITMAP_FREE (forbidden_dominators)((void) (bitmap_obstack_free ((bitmap) forbidden_dominators),
(forbidden_dominators) = (bitmap) nullptr))
; 1872 bb_info_vec.release (); 1873 return todo; 1874} 1875 1876namespace { 1877 1878const pass_data pass_data_split_functions = 1879{ 1880 GIMPLE_PASS, /* type */ 1881 "fnsplit", /* name */ 1882 OPTGROUP_NONE, /* optinfo_flags */ 1883 TV_IPA_FNSPLIT, /* tv_id */ 1884 PROP_cfg(1 << 3), /* properties_required */ 1885 0, /* properties_provided */ 1886 0, /* properties_destroyed */ 1887 0, /* todo_flags_start */ 1888 0, /* todo_flags_finish */ 1889}; 1890 1891class pass_split_functions : public gimple_opt_pass 1892{ 1893public: 1894 pass_split_functions (gcc::context *ctxt) 1895 : gimple_opt_pass (pass_data_split_functions, ctxt) 1896 {} 1897 1898 /* opt_pass methods: */ 1899 virtual bool gate (function *); 1900 virtual unsigned int execute (function *) 1901 { 1902 return execute_split_functions (); 1903 } 1904 1905}; // class pass_split_functions 1906 1907bool 1908pass_split_functions::gate (function *) 1909{ 1910 /* When doing profile feedback, we want to execute the pass after profiling 1911 is read. So disable one in early optimization. */ 1912 return (flag_partial_inliningglobal_options.x_flag_partial_inlining 1913 && !profile_arc_flagglobal_options.x_profile_arc_flag && !flag_branch_probabilitiesglobal_options.x_flag_branch_probabilities); 1914} 1915 1916} // anon namespace 1917 1918gimple_opt_pass * 1919make_pass_split_functions (gcc::context *ctxt) 1920{ 1921 return new pass_split_functions (ctxt); 1922} 1923 1924/* Execute function splitting pass. */ 1925 1926static unsigned int 1927execute_feedback_split_functions (void) 1928{ 1929 unsigned int retval = execute_split_functions (); 1930 if (retval) 1931 retval |= TODO_rebuild_cgraph_edges(1 << 22); 1932 return retval; 1933} 1934 1935namespace { 1936 1937const pass_data pass_data_feedback_split_functions = 1938{ 1939 GIMPLE_PASS, /* type */ 1940 "feedback_fnsplit", /* name */ 1941 OPTGROUP_NONE, /* optinfo_flags */ 1942 TV_IPA_FNSPLIT, /* tv_id */ 1943 PROP_cfg(1 << 3), /* properties_required */ 1944 0, /* properties_provided */ 1945 0, /* properties_destroyed */ 1946 0, /* todo_flags_start */ 1947 0, /* todo_flags_finish */ 1948}; 1949 1950class pass_feedback_split_functions : public gimple_opt_pass 1951{ 1952public: 1953 pass_feedback_split_functions (gcc::context *ctxt) 1954 : gimple_opt_pass (pass_data_feedback_split_functions, ctxt) 1955 {} 1956 1957 /* opt_pass methods: */ 1958 virtual bool gate (function *); 1959 virtual unsigned int execute (function *) 1960 { 1961 return execute_feedback_split_functions (); 1962 } 1963 1964}; // class pass_feedback_split_functions 1965 1966bool 1967pass_feedback_split_functions::gate (function *) 1968{ 1969 /* We don't need to split when profiling at all, we are producing 1970 lousy code anyway. */ 1971 return (flag_partial_inliningglobal_options.x_flag_partial_inlining 1972 && flag_branch_probabilitiesglobal_options.x_flag_branch_probabilities); 1973} 1974 1975} // anon namespace 1976 1977gimple_opt_pass * 1978make_pass_feedback_split_functions (gcc::context *ctxt) 1979{ 1980 return new pass_feedback_split_functions (ctxt); 1981}

/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
25/* Convert a target-independent built-in function code to a combined_fn. */
26
27inline combined_fn
28as_combined_fn (built_in_function fn)
29{
30 return combined_fn (int (fn));
31}
32
33/* Convert an internal function code to a combined_fn. */
34
35inline combined_fn
36as_combined_fn (internal_fn fn)
37{
38 return combined_fn (int (fn) + int (END_BUILTINS));
39}
40
41/* Return true if CODE is a target-independent built-in function. */
42
43inline bool
44builtin_fn_p (combined_fn code)
45{
46 return int (code) < int (END_BUILTINS);
47}
48
49/* Return the target-independent built-in function represented by CODE.
50 Only valid if builtin_fn_p (CODE). */
51
52inline built_in_function
53as_builtin_fn (combined_fn code)
54{
55 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"
, 55, __FUNCTION__), 0 : 0))
;
56 return built_in_function (int (code));
57}
58
59/* Return true if CODE is an internal function. */
60
61inline bool
62internal_fn_p (combined_fn code)
63{
64 return int (code) >= int (END_BUILTINS);
65}
66
67/* Return the internal function represented by CODE. Only valid if
68 internal_fn_p (CODE). */
69
70inline internal_fn
71as_internal_fn (combined_fn code)
72{
73 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"
, 73, __FUNCTION__), 0 : 0))
;
74 return internal_fn (int (code) - int (END_BUILTINS));
75}
76
77/* Macros for initializing `tree_contains_struct'. */
78#define MARK_TS_BASE(C)(tree_contains_struct[C][TS_BASE] = true) \
79 (tree_contains_struct[C][TS_BASE] = true)
80
81#define MARK_TS_TYPED(C)((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true)
\
82 (MARK_TS_BASE (C)(tree_contains_struct[C][TS_BASE] = true), \
83 tree_contains_struct[C][TS_TYPED] = true)
84
85#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
)
\
86 (MARK_TS_TYPED (C)((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true)
, \
87 tree_contains_struct[C][TS_COMMON] = true)
88
89#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)
\
90 (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
)
, \
91 tree_contains_struct[C][TS_TYPE_COMMON] = true)
92
93#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)
\
94 (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)
, \
95 tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
96
97#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)
\
98 (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)
, \
99 tree_contains_struct[C][TS_TYPE_NON_COMMON] = true) \
100
101#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)
\
102 (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
)
, \
103 tree_contains_struct[C][TS_DECL_MINIMAL] = true)
104
105#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)
\
106 (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)
, \
107 tree_contains_struct[C][TS_DECL_COMMON] = true)
108
109#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)
\
110 (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)
, \
111 tree_contains_struct[C][TS_DECL_WRTL] = true)
112
113#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)
\
114 (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)
, \
115 tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
116
117#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)
\
118 (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)
, \
119 tree_contains_struct[C][TS_DECL_NON_COMMON] = true)
120
121#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
)
\
122 (MARK_TS_TYPED (C)((tree_contains_struct[C][TS_BASE] = true), tree_contains_struct
[C][TS_TYPED] = true)
, \
123 tree_contains_struct[C][TS_EXP] = true)
124
125/* Returns the string representing CLASS. */
126
127#define TREE_CODE_CLASS_STRING(CLASS)tree_code_class_strings[(int) (CLASS)]\
128 tree_code_class_strings[(int) (CLASS)]
129
130#define TREE_CODE_CLASS(CODE)tree_code_type[(int) (CODE)] tree_code_type[(int) (CODE)]
131
132/* Nonzero if NODE represents an exceptional code. */
133
134#define EXCEPTIONAL_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_exceptional)
\
135 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_exceptional)
136
137/* Nonzero if NODE represents a constant. */
138
139#define CONSTANT_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_constant)
\
140 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_constant)
141
142/* Nonzero if NODE represents a constant, or is a location wrapper
143 around such a node. */
144
145#define CONSTANT_CLASS_OR_WRAPPER_P(NODE)((tree_code_type[(int) (((enum tree_code) (tree_strip_any_location_wrapper
(NODE))->base.code))] == tcc_constant))
\
146 (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)
)
147
148/* Nonzero if NODE represents a type. */
149
150#define TYPE_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_type)
\
151 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_type)
152
153/* Nonzero if NODE represents a declaration. */
154
155#define DECL_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_declaration)
\
156 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_declaration)
157
158/* True if NODE designates a variable declaration. */
159#define VAR_P(NODE)(((enum tree_code) (NODE)->base.code) == VAR_DECL) \
160 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == VAR_DECL)
161
162/* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL. */
163
164#define VAR_OR_FUNCTION_DECL_P(DECL)(((enum tree_code) (DECL)->base.code) == VAR_DECL || ((enum
tree_code) (DECL)->base.code) == FUNCTION_DECL)
\
165 (TREE_CODE (DECL)((enum tree_code) (DECL)->base.code) == VAR_DECL || TREE_CODE (DECL)((enum tree_code) (DECL)->base.code) == FUNCTION_DECL)
166
167/* Nonzero if NODE represents a INDIRECT_REF. Keep these checks in
168 ascending code order. */
169
170#define INDIRECT_REF_P(NODE)(((enum tree_code) (NODE)->base.code) == INDIRECT_REF)\
171 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == INDIRECT_REF)
172
173/* Nonzero if NODE represents a reference. */
174
175#define REFERENCE_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_reference)
\
176 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_reference)
177
178/* Nonzero if NODE represents a comparison. */
179
180#define COMPARISON_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_comparison)
\
181 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_comparison)
182
183/* Nonzero if NODE represents a unary arithmetic expression. */
184
185#define UNARY_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_unary)
\
186 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_unary)
187
188/* Nonzero if NODE represents a binary arithmetic expression. */
189
190#define BINARY_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_binary)
\
191 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_binary)
192
193/* Nonzero if NODE represents a statement expression. */
194
195#define STATEMENT_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_statement)
\
196 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_statement)
197
198/* Nonzero if NODE represents a function call-like expression with a
199 variable-length operand vector. */
200
201#define VL_EXP_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_vl_exp)
\
202 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_vl_exp)
203
204/* Nonzero if NODE represents any other expression. */
205
206#define EXPRESSION_CLASS_P(NODE)(tree_code_type[(int) (((enum tree_code) (NODE)->base.code
))] == tcc_expression)
\
207 (TREE_CODE_CLASS (TREE_CODE (NODE))tree_code_type[(int) (((enum tree_code) (NODE)->base.code)
)]
== tcc_expression)
208
209/* Returns nonzero iff NODE represents a type or declaration. */
210
211#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))
\
212 (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)
)
213
214/* Returns nonzero iff CLASS is the tree-code class of an
215 expression. */
216
217#define IS_EXPR_CODE_CLASS(CLASS)((CLASS) >= tcc_reference && (CLASS) <= tcc_expression
)
\
218 ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
219
220/* Returns nonzero iff NODE is an expression of some kind. */
221
222#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
)
223
224#define TREE_CODE_LENGTH(CODE)tree_code_length[(int) (CODE)] tree_code_length[(int) (CODE)]
225
226
227/* Helper macros for math builtins. */
228
229#define CASE_FLT_FN(FN)case FN: case FNF: case FNL case FN: case FN##F: case FN##L
230#define CASE_FLT_FN_FLOATN_NX(FN)case FNF16: case FNF32: case FNF64: case FNF128: case FNF32X:
case FNF64X: case FNF128X
\
231 case FN##F16: case FN##F32: case FN##F64: case FN##F128: \
232 case FN##F32X: case FN##F64X: case FN##F128X
233#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
234#define CASE_INT_FN(FN)case FN: case FNL: case FNLL: case FNIMAX case FN: case FN##L: case FN##LL: case FN##IMAX
235
236#define NULL_TREE(tree) nullptr (tree) NULLnullptr
237
238/* Define accessors for the fields that all tree nodes have
239 (though some fields are not used for all kinds of nodes). */
240
241/* The tree-code says what kind of node it is.
242 Codes are defined in tree.def. */
243#define TREE_CODE(NODE)((enum tree_code) (NODE)->base.code) ((enum tree_code) (NODE)->base.code)
244#define TREE_SET_CODE(NODE, VALUE)((NODE)->base.code = (VALUE)) ((NODE)->base.code = (VALUE))
245
246/* When checking is enabled, errors will be generated if a tree node
247 is accessed incorrectly. The macros die with a fatal error. */
248#if defined ENABLE_TREE_CHECKING1 && (GCC_VERSION(4 * 1000 + 2) >= 2007)
249
250#define TREE_CHECK(T, CODE)(tree_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 250, __FUNCTION__, (CODE)))
\
251(tree_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__251, __FUNCTION__, (CODE)))
252
253#define TREE_NOT_CHECK(T, CODE)(tree_not_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 253, __FUNCTION__, (CODE)))
\
254(tree_not_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__254, __FUNCTION__, (CODE)))
255
256#define TREE_CHECK2(T, CODE1, CODE2)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 256, __FUNCTION__, (CODE1), (CODE2)))
\
257(tree_check2 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__257, __FUNCTION__, (CODE1), (CODE2)))
258
259#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"
, 259, __FUNCTION__, (CODE1), (CODE2)))
\
260(tree_not_check2 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__260, __FUNCTION__, (CODE1), (CODE2)))
261
262#define TREE_CHECK3(T, CODE1, CODE2, CODE3)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 262, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
\
263(tree_check3 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__263, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
264
265#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"
, 265, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
\
266(tree_not_check3 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__266, __FUNCTION__, \
267 (CODE1), (CODE2), (CODE3)))
268
269#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"
, 269, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
\
270(tree_check4 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__270, __FUNCTION__, \
271 (CODE1), (CODE2), (CODE3), (CODE4)))
272
273#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"
, 273, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
\
274(tree_not_check4 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__274, __FUNCTION__, \
275 (CODE1), (CODE2), (CODE3), (CODE4)))
276
277#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"
, 277, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
\
278(tree_check5 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__278, __FUNCTION__, \
279 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
280
281#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"
, 281, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
\
282(tree_not_check5 ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__282, __FUNCTION__, \
283 (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
284
285#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"
, 285, __FUNCTION__))
\
286(contains_struct_check ((T), (STRUCT), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__286, __FUNCTION__))
287
288#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"
, 288, __FUNCTION__))
\
289(tree_class_check ((T), (CLASS), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__289, __FUNCTION__))
290
291#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"
, 291, __FUNCTION__))
\
292(tree_range_check ((T), (CODE1), (CODE2), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__292, __FUNCTION__))
293
294#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"
, 294, __FUNCTION__))
\
295(omp_clause_subcode_check ((T), (CODE), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__295, __FUNCTION__))
296
297#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"
, 297, __FUNCTION__))
\
298(omp_clause_range_check ((T), (CODE1), (CODE2), \
299 __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__299, __FUNCTION__))
300
301/* These checks have to be special cased. */
302#define EXPR_CHECK(T)(expr_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 302, __FUNCTION__))
\
303(expr_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__303, __FUNCTION__))
304
305/* These checks have to be special cased. */
306#define NON_TYPE_CHECK(T)(non_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 306, __FUNCTION__))
\
307(non_type_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__307, __FUNCTION__))
308
309/* These checks have to be special cased. */
310#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"
, 310, __FUNCTION__))
\
311(any_integral_type_check ((T), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__311, __FUNCTION__))
312
313#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"
, 313, __FUNCTION__))
\
314(*tree_int_cst_elt_check ((T), (I), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__314, __FUNCTION__))
315
316#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"
, 316, __FUNCTION__)))))
\
317(*(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"
, 318, __FUNCTION__)))
318 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"
, 318, __FUNCTION__)))
))
319
320#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"
, 320, __FUNCTION__)))
\
321(*(omp_clause_elt_check ((T), (I), __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__321, __FUNCTION__)))
322
323/* Special checks for TREE_OPERANDs. */
324#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"
, 324, __FUNCTION__)))))
\
325(*(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"
, 326, __FUNCTION__)))
326 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"
, 326, __FUNCTION__)))
))
327
328#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"
, 328, __FUNCTION__)))
\
329(*(tree_operand_check_code ((T), (CODE), (I), \
330 __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h", __LINE__330, __FUNCTION__)))
331
332/* Nodes are chained together for many purposes.
333 Types are chained together to record them for being output to the debugger
334 (see the function `chain_type').
335 Decls in the same scope are chained together to record the contents
336 of the scope.
337 Statement nodes for successive statements used to be chained together.
338 Often lists of things are represented by TREE_LIST nodes that
339 are chained together. */
340
341#define TREE_CHAIN(NODE)((contains_struct_check ((NODE), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 341, __FUNCTION__))->common.chain)
\
342(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"
, 342, __FUNCTION__))
->common.chain)
343
344/* In all nodes that are expressions, this is the data type of the expression.
345 In POINTER_TYPE nodes, this is the type that the pointer points to.
346 In ARRAY_TYPE nodes, this is the type of the elements.
347 In VECTOR_TYPE nodes, this is the type of the elements. */
348#define TREE_TYPE(NODE)((contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 348, __FUNCTION__))->typed.type)
\
349(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"
, 349, __FUNCTION__))
->typed.type)
350
351extern void tree_contains_struct_check_failed (const_tree,
352 const enum tree_node_structure_enum,
353 const char *, int, const char *)
354 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
355
356extern void tree_check_failed (const_tree, const char *, int, const char *,
357 ...) ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
358extern void tree_not_check_failed (const_tree, const char *, int, const char *,
359 ...) ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
360extern void tree_class_check_failed (const_tree, const enum tree_code_class,
361 const char *, int, const char *)
362 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
363extern void tree_range_check_failed (const_tree, const char *, int,
364 const char *, enum tree_code,
365 enum tree_code)
366 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
367extern void tree_not_class_check_failed (const_tree,
368 const enum tree_code_class,
369 const char *, int, const char *)
370 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
371extern void tree_int_cst_elt_check_failed (int, int, const char *,
372 int, const char *)
373 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
374extern void tree_vec_elt_check_failed (int, int, const char *,
375 int, const char *)
376 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
377extern void phi_node_elt_check_failed (int, int, const char *,
378 int, const char *)
379 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
380extern void tree_operand_check_failed (int, const_tree,
381 const char *, int, const char *)
382 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
383extern void omp_clause_check_failed (const_tree, const char *, int,
384 const char *, enum omp_clause_code)
385 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
386extern void omp_clause_operand_check_failed (int, const_tree, const char *,
387 int, const char *)
388 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
389extern void omp_clause_range_check_failed (const_tree, const char *, int,
390 const char *, enum omp_clause_code,
391 enum omp_clause_code)
392 ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
393
394#else /* not ENABLE_TREE_CHECKING, or not gcc */
395
396#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"
, 396, __FUNCTION__))
(T)
397#define TREE_CHECK(T, CODE)(tree_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 397, __FUNCTION__, (CODE)))
(T)
398#define TREE_NOT_CHECK(T, CODE)(tree_not_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 398, __FUNCTION__, (CODE)))
(T)
399#define TREE_CHECK2(T, CODE1, CODE2)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 399, __FUNCTION__, (CODE1), (CODE2)))
(T)
400#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"
, 400, __FUNCTION__, (CODE1), (CODE2)))
(T)
401#define TREE_CHECK3(T, CODE1, CODE2, CODE3)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 401, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
(T)
402#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"
, 402, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
(T)
403#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"
, 403, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
(T)
404#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"
, 404, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4)))
(T)
405#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"
, 405, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
(T)
406#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"
, 406, __FUNCTION__, (CODE1), (CODE2), (CODE3), (CODE4), (CODE5
)))
(T)
407#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"
, 407, __FUNCTION__))
(T)
408#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"
, 408, __FUNCTION__))
(T)
409#define EXPR_CHECK(T)(expr_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 409, __FUNCTION__))
(T)
410#define NON_TYPE_CHECK(T)(non_type_check ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 410, __FUNCTION__))
(T)
411#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"
, 411, __FUNCTION__))
((T)->int_cst.val[I])
412#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"
, 412, __FUNCTION__)))))
((T)->vec.a[I])
413#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"
, 413, __FUNCTION__)))))
((T)->exp.operands[I])
414#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"
, 414, __FUNCTION__)))
((T)->exp.operands[I])
415#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"
, 415, __FUNCTION__)))
((T)->omp_clause.ops[i])
416#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"
, 416, __FUNCTION__))
(T)
417#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"
, 417, __FUNCTION__))
(T)
418#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"
, 418, __FUNCTION__))
(T)
419
420#define TREE_CHAIN(NODE)((contains_struct_check ((NODE), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 420, __FUNCTION__))->common.chain)
((NODE)->common.chain)
421#define TREE_TYPE(NODE)((contains_struct_check ((NODE), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 421, __FUNCTION__))->typed.type)
((NODE)->typed.type)
422
423#endif
424
425#define TREE_BLOCK(NODE)(tree_block (NODE)) (tree_block (NODE))
426#define TREE_SET_BLOCK(T, B)(tree_set_block ((T), (B))) (tree_set_block ((T), (B)))
427
428#include "tree-check.h"
429
430#define TYPE_CHECK(T)(tree_class_check ((T), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 430, __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"
, 430, __FUNCTION__))
431#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"
, 431, __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"
, 431, __FUNCTION__))
432#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"
, 432, __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"
, 432, __FUNCTION__))
433#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"
, 433, __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"
, 433, __FUNCTION__))
434#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"
, 434, __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"
, 434, __FUNCTION__))
435#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"
, 435, __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"
, 435, __FUNCTION__))
436#define CST_CHECK(T)(tree_class_check ((T), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 436, __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"
, 436, __FUNCTION__))
437#define STMT_CHECK(T)(tree_class_check ((T), (tcc_statement), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 437, __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"
, 437, __FUNCTION__))
438#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"
, 438, __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"
, 438, __FUNCTION__))
439#define FUNC_OR_METHOD_CHECK(T)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 439, __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"
, 439, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))
440#define PTR_OR_REF_CHECK(T)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 440, __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"
, 440, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))
441
442#define RECORD_OR_UNION_CHECK(T)(tree_check3 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 442, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
\
443 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"
, 443, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
444#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"
, 444, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
\
445 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"
, 445, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))
446#define ARRAY_OR_INTEGER_TYPE_CHECK(T)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 446, __FUNCTION__, (ARRAY_TYPE), (INTEGER_TYPE)))
\
447 TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE)(tree_check2 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 447, __FUNCTION__, (ARRAY_TYPE), (INTEGER_TYPE)))
448
449#define NUMERICAL_TYPE_CHECK(T)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 449, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))
\
450 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"
, 451, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))
451 FIXED_POINT_TYPE)(tree_check5 ((T), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 451, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))
452
453/* Here is how primitive or already-canonicalized types' hash codes
454 are made. */
455#define TYPE_HASH(TYPE)(((tree_class_check ((TYPE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 455, __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"
, 455, __FUNCTION__))->type_common.uid)
)
456
457/* A simple hash function for an arbitrary tree node. This must not be
458 used in hash tables which are saved to a PCH. */
459#define TREE_HASH(NODE)((size_t) (NODE) & 0777777) ((size_t) (NODE) & 0777777)
460
461/* Tests if CODE is a conversion expr (NOP_EXPR or CONVERT_EXPR). */
462#define CONVERT_EXPR_CODE_P(CODE)((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR) \
463 ((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR)
464
465/* Similarly, but accept an expression instead of a tree code. */
466#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)
467
468/* Generate case for NOP_EXPR, CONVERT_EXPR. */
469
470#define CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR \
471 case NOP_EXPR: \
472 case CONVERT_EXPR
473
474/* Given an expression as a tree, strip any conversion that generates
475 no instruction. Accepts both tree and const_tree arguments since
476 we are not modifying the tree itself. */
477
478#define STRIP_NOPS(EXP)(EXP) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((EXP)))))
\
479 (EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP)(const_cast<union tree_node *> (((EXP)))))
480
481/* Like STRIP_NOPS, but don't let the signedness change either. */
482
483#define STRIP_SIGN_NOPS(EXP)(EXP) = tree_strip_sign_nop_conversions ((const_cast<union
tree_node *> (((EXP)))))
\
484 (EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP)(const_cast<union tree_node *> (((EXP)))))
485
486/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
487
488#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"
, 488, __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"
, 488, __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"
, 488, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 488, __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"
, 488, __FUNCTION__)))))
\
489 while ((CONVERT_EXPR_P (EXP)((((enum tree_code) (EXP)->base.code)) == NOP_EXPR || (((enum
tree_code) (EXP)->base.code)) == CONVERT_EXPR)
\
490 || TREE_CODE (EXP)((enum tree_code) (EXP)->base.code) == NON_LVALUE_EXPR) \
491 && 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"
, 491, __FUNCTION__)))))
!= error_mark_nodeglobal_trees[TI_ERROR_MARK] \
492 && (TREE_TYPE (EXP)((contains_struct_check ((EXP), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 492, __FUNCTION__))->typed.type)
\
493 == 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"
, 493, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 493, __FUNCTION__))->typed.type)
)) \
494 (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"
, 494, __FUNCTION__)))))
495
496/* Remove unnecessary type conversions according to
497 tree_ssa_useless_type_conversion. */
498
499#define STRIP_USELESS_TYPE_CONVERSION(EXP)(EXP) = tree_ssa_strip_useless_type_conversions (EXP) \
500 (EXP) = tree_ssa_strip_useless_type_conversions (EXP)
501
502/* Remove any VIEW_CONVERT_EXPR or NON_LVALUE_EXPR that's purely
503 in use to provide a location_t. */
504
505#define STRIP_ANY_LOCATION_WRAPPER(EXP)(EXP) = tree_strip_any_location_wrapper ((const_cast<union
tree_node *> (((EXP)))))
\
506 (EXP) = tree_strip_any_location_wrapper (CONST_CAST_TREE (EXP)(const_cast<union tree_node *> (((EXP)))))
507
508/* Nonzero if TYPE represents a vector type. */
509
510#define VECTOR_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)
511
512/* Nonzero if TYPE represents a vector of booleans. */
513
514#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"
, 514, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)
\
515 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE \
516 && 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"
, 516, __FUNCTION__))->typed.type))->base.code)
== BOOLEAN_TYPE)
517
518/* Nonzero if TYPE represents an integral type. Note that we do not
519 include COMPLEX types here. Keep these checks in ascending code
520 order. */
521
522#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)
\
523 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == ENUMERAL_TYPE \
524 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == BOOLEAN_TYPE \
525 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == INTEGER_TYPE)
526
527/* Nonzero if TYPE represents an integral type, including complex
528 and vector integer types. */
529
530#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"
, 530, __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"
, 530, __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"
, 530, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
\
531 (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)
\
532 || ((TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE \
533 || VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) \
534 && 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"
, 534, __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"
, 534, __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"
, 534, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
))
535
536/* Nonzero if TYPE represents a non-saturating fixed-point type. */
537
538#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"
, 538, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag))
\
539 (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"
, 539, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
)
540
541/* Nonzero if TYPE represents a saturating fixed-point type. */
542
543#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"
, 543, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag))
\
544 (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"
, 544, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
)
545
546/* Nonzero if TYPE represents a fixed-point type. */
547
548#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)
549
550/* Nonzero if TYPE represents a scalar floating-point type. */
551
552#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)
553
554/* Nonzero if TYPE represents a complex floating-point type. */
555
556#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"
, 556, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
\
557 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE \
558 && 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"
, 558, __FUNCTION__))->typed.type))->base.code)
== REAL_TYPE)
559
560/* Nonzero if TYPE represents a vector integer type. */
561
562#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"
, 562, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
\
563 (VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) \
564 && 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"
, 564, __FUNCTION__))->typed.type))->base.code)
== INTEGER_TYPE)
565
566
567/* Nonzero if TYPE represents a vector floating-point type. */
568
569#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"
, 569, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
\
570 (VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE) \
571 && 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"
, 571, __FUNCTION__))->typed.type))->base.code)
== REAL_TYPE)
572
573/* Nonzero if TYPE represents a floating-point type, including complex
574 and vector floating-point types. The vector and complex check does
575 not use the previous two macros to enable early folding. */
576
577#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"
, 577, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
\
578 (SCALAR_FLOAT_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == REAL_TYPE) \
579 || ((TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == COMPLEX_TYPE \
580 || VECTOR_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == VECTOR_TYPE)) \
581 && 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"
, 581, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
))
582
583/* Nonzero if TYPE represents a decimal floating-point type. */
584#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"
, 584, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(TYPE) : (TYPE)->type_common.mode)]) == MODE_DECIMAL_FLOAT
))
\
585 (SCALAR_FLOAT_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == REAL_TYPE) \
586 && 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"
, 586, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(TYPE) : (TYPE)->type_common.mode)]) == MODE_DECIMAL_FLOAT
)
)
587
588/* Nonzero if TYPE is a record or union type. */
589#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)
\
590 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == RECORD_TYPE \
591 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == UNION_TYPE \
592 || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == QUAL_UNION_TYPE)
593
594/* Nonzero if TYPE represents an aggregate (multi-component) type.
595 Keep these checks in ascending code order. */
596
597#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))
\
598 (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)
)
599
600/* Nonzero if TYPE represents a pointer or reference type.
601 (It should be renamed to INDIRECT_TYPE_P.) Keep these checks in
602 ascending code order. */
603
604#define POINTER_TYPE_P(TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
\
605 (TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || TREE_CODE (TYPE)((enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
606
607/* Nonzero if TYPE represents a pointer to function. */
608#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"
, 608, __FUNCTION__))->typed.type))->base.code) == FUNCTION_TYPE
)
\
609 (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"
, 609, __FUNCTION__))->typed.type))->base.code)
== FUNCTION_TYPE)
610
611/* Nonzero if this type is a complete type. */
612#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"
, 612, __FUNCTION__))->type_common.size) != (tree) nullptr
)
(TYPE_SIZE (NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 612, __FUNCTION__))->type_common.size)
!= NULL_TREE(tree) nullptr)
613
614/* Nonzero if this type is the (possibly qualified) void type. */
615#define VOID_TYPE_P(NODE)(((enum tree_code) (NODE)->base.code) == VOID_TYPE) (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == VOID_TYPE)
616
617/* Nonzero if this type is complete or is cv void. */
618#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"
, 618, __FUNCTION__))->type_common.size) != (tree) nullptr
) || (((enum tree_code) (NODE)->base.code) == VOID_TYPE))
\
619 (COMPLETE_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) nullptr
)
|| VOID_TYPE_P (NODE)(((enum tree_code) (NODE)->base.code) == VOID_TYPE))
620
621/* Nonzero if this type is complete or is an array with unspecified bound. */
622#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"
, 622, __FUNCTION__))->typed.type) : (NODE)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 622, __FUNCTION__))->type_common.size) != (tree) nullptr
))
\
623 (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"
, 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) nullptr
)
)
624
625#define FUNC_OR_METHOD_TYPE_P(NODE)(((enum tree_code) (NODE)->base.code) == FUNCTION_TYPE || (
(enum tree_code) (NODE)->base.code) == METHOD_TYPE)
\
626 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == FUNCTION_TYPE || TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == METHOD_TYPE)
627
628#define OPAQUE_TYPE_P(NODE)(((enum tree_code) (NODE)->base.code) == OPAQUE_TYPE) \
629 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == OPAQUE_TYPE)
630
631/* Define many boolean fields that all tree nodes have. */
632
633/* In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address
634 of this is needed. So it cannot be in a register.
635 In a FUNCTION_DECL it has no meaning.
636 In LABEL_DECL nodes, it means a goto for this label has been seen
637 from a place outside all binding contours that restore stack levels.
638 In an artificial SSA_NAME that points to a stack partition with at least
639 two variables, it means that at least one variable has TREE_ADDRESSABLE.
640 In ..._TYPE nodes, it means that objects of this type must be fully
641 addressable. This means that pieces of this object cannot go into
642 register parameters, for example. If this a function type, this
643 means that the value must be returned in memory.
644 In CONSTRUCTOR nodes, it means object constructed must be in memory.
645 In IDENTIFIER_NODEs, this means that some extern decl for this name
646 had its address taken. That matters for inline functions.
647 In a STMT_EXPR, it means we want the result of the enclosed expression. */
648#define TREE_ADDRESSABLE(NODE)((NODE)->base.addressable_flag) ((NODE)->base.addressable_flag)
649
650/* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
651 exit of a function. Calls for which this is true are candidates for tail
652 call optimizations. */
653#define CALL_EXPR_TAILCALL(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 653, __FUNCTION__, (CALL_EXPR)))->base.addressable_flag)
\
654 (CALL_EXPR_CHECK (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
656/* Set on a CALL_EXPR if the call has been marked as requiring tail call
657 optimization for correctness. */
658#define CALL_EXPR_MUST_TAIL_CALL(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 658, __FUNCTION__, (CALL_EXPR)))->base.static_flag)
\
659 (CALL_EXPR_CHECK (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
661/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
662 CASE_LOW operand has been processed. */
663#define CASE_LOW_SEEN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 663, __FUNCTION__, (CASE_LABEL_EXPR)))->base.addressable_flag
)
\
664 (CASE_LABEL_EXPR_CHECK (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
666#define PREDICT_EXPR_OUTCOME(NODE)((enum prediction) ((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 666, __FUNCTION__, (PREDICT_EXPR)))->base.addressable_flag
))
\
667 ((enum prediction) (PREDICT_EXPR_CHECK (NODE)(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#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 668, __FUNCTION__, (PREDICT_EXPR)))->base.addressable_flag
= (int) OUTCOME)
\
669 (PREDICT_EXPR_CHECK (NODE)(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#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"
, 670, __FUNCTION__, (PREDICT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 670, __FUNCTION__)))))))
\
671 ((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"
, 671, __FUNCTION__, (PREDICT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 671, __FUNCTION__)))))
))
672
673/* In a VAR_DECL, nonzero means allocate static storage.
674 In a FUNCTION_DECL, nonzero if function has been defined.
675 In a CONSTRUCTOR, nonzero means allocate static storage. */
676#define TREE_STATIC(NODE)((NODE)->base.static_flag) ((NODE)->base.static_flag)
677
678/* In an ADDR_EXPR, nonzero means do not use a trampoline. */
679#define TREE_NO_TRAMPOLINE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 679, __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"
, 679, __FUNCTION__, (ADDR_EXPR)))
->base.static_flag)
680
681/* In a TARGET_EXPR or WITH_CLEANUP_EXPR, means that the pertinent cleanup
682 should only be executed if an exception is thrown, not on normal exit
683 of its scope. */
684#define CLEANUP_EH_ONLY(NODE)((NODE)->base.static_flag) ((NODE)->base.static_flag)
685
686/* In a TRY_CATCH_EXPR, means that the handler should be considered a
687 separate cleanup in honor_protect_cleanup_actions. */
688#define TRY_CATCH_IS_CLEANUP(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 688, __FUNCTION__, (TRY_CATCH_EXPR)))->base.static_flag)
\
689 (TRY_CATCH_EXPR_CHECK (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
691/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
692 CASE_HIGH operand has been processed. */
693#define CASE_HIGH_SEEN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 693, __FUNCTION__, (CASE_LABEL_EXPR)))->base.static_flag
)
\
694 (CASE_LABEL_EXPR_CHECK (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
696/* Used to mark scoped enums. */
697#define ENUM_IS_SCOPED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 697, __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"
, 697, __FUNCTION__, (ENUMERAL_TYPE)))
->base.static_flag)
698
699/* Determines whether an ENUMERAL_TYPE has defined the list of constants. */
700#define ENUM_IS_OPAQUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 700, __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"
, 700, __FUNCTION__, (ENUMERAL_TYPE)))
->base.private_flag)
701
702/* In an expr node (usually a conversion) this means the node was made
703 implicitly and should not lead to any sort of warning. In a decl node,
704 warnings concerning the decl should be suppressed. This is used at
705 least for used-before-set warnings, and it set after one warning is
706 emitted. */
707#define TREE_NO_WARNING(NODE)((NODE)->base.nowarning_flag) ((NODE)->base.nowarning_flag)
708
709/* Nonzero if we should warn about the change in empty class parameter
710 passing ABI in this TU. */
711#define TRANSLATION_UNIT_WARN_EMPTY_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 711, __FUNCTION__, (TRANSLATION_UNIT_DECL)))->decl_common
.decl_flag_0)
\
712 (TRANSLATION_UNIT_DECL_CHECK (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
714/* Nonzero if this type is "empty" according to the particular psABI. */
715#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"
, 715, __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"
, 715, __FUNCTION__))
->type_common.empty_flag)
716
717/* Used to indicate that this TYPE represents a compiler-generated entity. */
718#define TYPE_ARTIFICIAL(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 718, __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"
, 718, __FUNCTION__))
->base.nowarning_flag)
719
720/* True if the type is indivisible at the source level, i.e. if its
721 component parts cannot be accessed directly. This is used to suppress
722 normal GNU extensions for target-specific vector types. */
723#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"
, 723, __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"
, 723, __FUNCTION__))
->type_common.indivisible_p)
724
725/* In an IDENTIFIER_NODE, this means that assemble_name was called with
726 this string as an argument. */
727#define TREE_SYMBOL_REFERENCED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 727, __FUNCTION__, (IDENTIFIER_NODE)))->base.static_flag
)
\
728 (IDENTIFIER_NODE_CHECK (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
730/* Nonzero in a pointer or reference type means the data pointed to
731 by this type can alias anything. */
732#define TYPE_REF_CAN_ALIAS_ALL(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 732, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))->base
.static_flag)
\
733 (PTR_OR_REF_CHECK (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
735/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
736 there was an overflow in folding. */
737
738#define TREE_OVERFLOW(NODE)((tree_class_check ((NODE), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 738, __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"
, 738, __FUNCTION__))
->base.public_flag)
739
740/* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P. */
741
742#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"
, 742, __FUNCTION__))->base.public_flag))
\
743 (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"
, 743, __FUNCTION__))->base.public_flag)
)
744
745/* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL,
746 nonzero means name is to be accessible from outside this translation unit.
747 In an IDENTIFIER_NODE, nonzero means an external declaration
748 accessible from outside this translation unit was previously seen
749 for this name in an inner scope. */
750#define TREE_PUBLIC(NODE)((NODE)->base.public_flag) ((NODE)->base.public_flag)
751
752/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
753 of cached values, or is something else. */
754#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"
, 754, __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"
, 754, __FUNCTION__))
->base.public_flag)
755
756/* In a SAVE_EXPR, indicates that the original expression has already
757 been substituted with a VAR_DECL that contains the value. */
758#define SAVE_EXPR_RESOLVED_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 758, __FUNCTION__, (SAVE_EXPR)))->base.public_flag)
\
759 (SAVE_EXPR_CHECK (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
761/* Set on a CALL_EXPR if this stdarg call should be passed the argument
762 pack. */
763#define CALL_EXPR_VA_ARG_PACK(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 763, __FUNCTION__, (CALL_EXPR)))->base.public_flag)
\
764 (CALL_EXPR_CHECK (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
766/* In any expression, decl, or constant, nonzero means it has side effects or
767 reevaluation of the whole expression could produce a different value.
768 This is set if any subexpression is a function call, a side effect or a
769 reference to a volatile variable. In a ..._DECL, this is set only if the
770 declaration said `volatile'. This will never be set for a constant. */
771#define TREE_SIDE_EFFECTS(NODE)((non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 771, __FUNCTION__))->base.side_effects_flag)
\
772 (NON_TYPE_CHECK (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
774/* In a LABEL_DECL, nonzero means this label had its address taken
775 and therefore can never be deleted and is a jump target for
776 computed gotos. */
777#define FORCED_LABEL(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 777, __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"
, 777, __FUNCTION__, (LABEL_DECL)))
->base.side_effects_flag)
778
779/* Whether a case or a user-defined label is allowed to fall through to.
780 This is used to implement -Wimplicit-fallthrough. */
781#define FALLTHROUGH_LABEL_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 781, __FUNCTION__, (LABEL_DECL)))->base.private_flag)
\
782 (LABEL_DECL_CHECK (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
784/* Set on the artificial label created for break; stmt from a switch.
785 This is used to implement -Wimplicit-fallthrough. */
786#define SWITCH_BREAK_LABEL_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 786, __FUNCTION__, (LABEL_DECL)))->base.protected_flag)
\
787 (LABEL_DECL_CHECK (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
789/* Nonzero means this expression is volatile in the C sense:
790 its address should be of type `volatile WHATEVER *'.
791 In other words, the declared item is volatile qualified.
792 This is used in _DECL nodes and _REF nodes.
793 On a FUNCTION_DECL node, this means the function does not
794 return normally. This is the same effect as setting
795 the attribute noreturn on the function in C.
796
797 In a ..._TYPE node, means this type is volatile-qualified.
798 But use TYPE_VOLATILE instead of this macro when the node is a type,
799 because eventually we may make that a different bit.
800
801 If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */
802#define TREE_THIS_VOLATILE(NODE)((NODE)->base.volatile_flag) ((NODE)->base.volatile_flag)
803
804/* Nonzero means this node will not trap. In an INDIRECT_REF, means
805 accessing the memory pointed to won't generate a trap. However,
806 this only applies to an object when used appropriately: it doesn't
807 mean that writing a READONLY mem won't trap.
808
809 In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
810 (or slice of the array) always belongs to the range of the array.
811 I.e. that the access will not trap, provided that the access to
812 the base to the array will not trap. */
813#define TREE_THIS_NOTRAP(NODE)((tree_check5 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 813, __FUNCTION__, (INDIRECT_REF), (MEM_REF), (TARGET_MEM_REF
), (ARRAY_REF), (ARRAY_RANGE_REF)))->base.nothrow_flag)
\
814 (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"
, 815, __FUNCTION__, (INDIRECT_REF), (MEM_REF), (TARGET_MEM_REF
), (ARRAY_REF), (ARRAY_RANGE_REF)))
815 ARRAY_RANGE_REF)(tree_check5 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 815, __FUNCTION__, (INDIRECT_REF), (MEM_REF), (TARGET_MEM_REF
), (ARRAY_REF), (ARRAY_RANGE_REF)))
->base.nothrow_flag)
816
817/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
818 nonzero means it may not be the lhs of an assignment.
819 Nonzero in a FUNCTION_DECL means this function should be treated
820 as "const" function (can only read its arguments). */
821#define TREE_READONLY(NODE)((non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 821, __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"
, 821, __FUNCTION__))
->base.readonly_flag)
822
823/* Value of expression is constant. Always on in all ..._CST nodes. May
824 also appear in an expression or decl where the value is constant. */
825#define TREE_CONSTANT(NODE)((non_type_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 825, __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"
, 825, __FUNCTION__))
->base.constant_flag)
826
827/* Nonzero if NODE, a type, has had its sizes gimplified. */
828#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"
, 828, __FUNCTION__))->base.constant_flag)
\
829 (TYPE_CHECK (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
831/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
832#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"
, 832, __FUNCTION__))->base.u.bits.unsigned_flag)
\
833 (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"
, 833, __FUNCTION__))
->base.u.bits.unsigned_flag)
834
835/* In integral and pointer types, means an unsigned type. */
836#define TYPE_UNSIGNED(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 836, __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"
, 836, __FUNCTION__))
->base.u.bits.unsigned_flag)
837
838/* Same as TYPE_UNSIGNED but converted to SIGNOP. */
839#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"
, 839, __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"
, 839, __FUNCTION__))->base.u.bits.unsigned_flag)
)
840
841/* True if overflow wraps around for the given integral or pointer type. That
842 is, TYPE_MAX + 1 == TYPE_MIN. */
843#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"
, 843, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
\
844 (POINTER_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
\
845 ? flag_wrapv_pointerglobal_options.x_flag_wrapv_pointer \
846 : (ANY_INTEGRAL_TYPE_CHECK(TYPE)(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 846, __FUNCTION__))
->base.u.bits.unsigned_flag \
847 || flag_wrapvglobal_options.x_flag_wrapv))
848
849/* True if overflow is undefined for the given integral or pointer type.
850 We may optimize on the assumption that values in the type never overflow.
851
852 IMPORTANT NOTE: Any optimization based on TYPE_OVERFLOW_UNDEFINED
853 must issue a warning based on warn_strict_overflow. In some cases
854 it will be appropriate to issue the warning immediately, and in
855 other cases it will be appropriate to simply set a flag and let the
856 caller decide whether a warning is appropriate or not. */
857#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"
, 857, __FUNCTION__))->base.u.bits.unsigned_flag &&
!global_options.x_flag_wrapv && !global_options.x_flag_trapv
))
\
858 (POINTER_TYPE_P (TYPE)(((enum tree_code) (TYPE)->base.code) == POINTER_TYPE || (
(enum tree_code) (TYPE)->base.code) == REFERENCE_TYPE)
\
859 ? !flag_wrapv_pointerglobal_options.x_flag_wrapv_pointer \
860 : (!ANY_INTEGRAL_TYPE_CHECK(TYPE)(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 860, __FUNCTION__))
->base.u.bits.unsigned_flag \
861 && !flag_wrapvglobal_options.x_flag_wrapv && !flag_trapvglobal_options.x_flag_trapv))
862
863/* True if overflow for the given integral type should issue a
864 trap. */
865#define TYPE_OVERFLOW_TRAPS(TYPE)(!(any_integral_type_check ((TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 865, __FUNCTION__))->base.u.bits.unsigned_flag &&
global_options.x_flag_trapv)
\
866 (!ANY_INTEGRAL_TYPE_CHECK(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 && flag_trapvglobal_options.x_flag_trapv)
867
868/* True if an overflow is to be preserved for sanitization. */
869#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"
, 869, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv)) && (global_options.x_flag_sanitize &
SANITIZE_SI_OVERFLOW))
\
870 (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)
\
871 && !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"
, 871, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
\
872 && (flag_sanitizeglobal_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
873
874/* Nonzero in a VAR_DECL or STRING_CST means assembler code has been written.
875 Nonzero in a FUNCTION_DECL means that the function has been compiled.
876 This is interesting in an inline function, since it might not need
877 to be compiled separately.
878 Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ENUMERAL_TYPE
879 or TYPE_DECL if the debugging info for the type has been written.
880 In a BLOCK node, nonzero if reorder_blocks has already seen this block.
881 In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
882 PHI node. */
883#define TREE_ASM_WRITTEN(NODE)((NODE)->base.asm_written_flag) ((NODE)->base.asm_written_flag)
884
885/* Nonzero in a _DECL if the name is used in its scope.
886 Nonzero in an expr node means inhibit warning if value is unused.
887 In IDENTIFIER_NODEs, this means that some extern decl for this name
888 was used.
889 In a BLOCK, this means that the block contains variables that are used. */
890#define TREE_USED(NODE)((NODE)->base.used_flag) ((NODE)->base.used_flag)
891
892/* In a FUNCTION_DECL, nonzero means a call to the function cannot
893 throw an exception. In a CALL_EXPR, nonzero means the call cannot
894 throw. We can't easily check the node type here as the C++
895 frontend also uses this flag (for AGGR_INIT_EXPR). */
896#define TREE_NOTHROW(NODE)((NODE)->base.nothrow_flag) ((NODE)->base.nothrow_flag)
897
898/* In a CALL_EXPR, means that it's safe to use the target of the call
899 expansion as the return slot for a call that returns in memory. */
900#define CALL_EXPR_RETURN_SLOT_OPT(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 900, __FUNCTION__, (CALL_EXPR)))->base.private_flag)
\
901 (CALL_EXPR_CHECK (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
903/* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that it is
904 passed by invisible reference (and the TREE_TYPE is a pointer to the true
905 type). */
906#define DECL_BY_REFERENCE(NODE)((tree_check3 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 906, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
\
907 (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \(tree_check3 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 908, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
908 RESULT_DECL)(tree_check3 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 908, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
909
910/* In VAR_DECL and PARM_DECL, set when the decl has been used except for
911 being set. */
912#define DECL_READ_P(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 912, __FUNCTION__, (VAR_DECL), (PARM_DECL)))->decl_common
.decl_read_flag)
\
913 (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)(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
915/* In VAR_DECL or RESULT_DECL, set when significant code movement precludes
916 attempting to share the stack slot with some other variable. */
917#define DECL_NONSHAREABLE(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 917, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))->decl_common
.decl_nonshareable_flag)
\
918 (TREE_CHECK2 (NODE, VAR_DECL, \(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 919, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))
919 RESULT_DECL)(tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 919, __FUNCTION__, (VAR_DECL), (RESULT_DECL)))
->decl_common.decl_nonshareable_flag)
920
921/* In a PARM_DECL, set for Fortran hidden string length arguments that some
922 buggy callers don't pass to the callee. */
923#define DECL_HIDDEN_STRING_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 923, __FUNCTION__, (PARM_DECL)))->decl_common.decl_nonshareable_flag
)
\
924 (TREE_CHECK (NODE, PARM_DECL)(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
926/* In a CALL_EXPR, means that the call is the jump from a thunk to the
927 thunked-to function. Be careful to avoid using this macro when one of the
928 next two applies instead. */
929#define CALL_FROM_THUNK_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 929, __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"
, 929, __FUNCTION__, (CALL_EXPR)))
->base.protected_flag)
930
931/* In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that
932 it has been built for the declaration of a variable-sized object and, if the
933 function being called is BUILT_IN_MEMCPY, means that it has been built for
934 the assignment of a variable-sized object. */
935#define CALL_ALLOCA_FOR_VAR_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 935, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
\
936 (CALL_EXPR_CHECK (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
938/* In a CALL_EXPR, if the function being called is DECL_IS_OPERATOR_NEW_P or
939 DECL_IS_OPERATOR_DELETE_P, true for allocator calls from C++ new or delete
940 expressions. */
941#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"
, 941, __FUNCTION__, (CALL_EXPR)))->base.protected_flag)
\
942 (CALL_EXPR_CHECK (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
944/* Used in classes in C++. */
945#define TREE_PRIVATE(NODE)((NODE)->base.private_flag) ((NODE)->base.private_flag)
946/* Used in classes in C++. */
947#define TREE_PROTECTED(NODE)((NODE)->base.protected_flag) ((NODE)->base.protected_flag)
948
949/* True if reference type NODE is a C++ rvalue reference. */
950#define TYPE_REF_IS_RVALUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 950, __FUNCTION__, (REFERENCE_TYPE)))->base.private_flag
)
\
951 (REFERENCE_TYPE_CHECK (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
953/* Nonzero in a _DECL if the use of the name is defined as a
954 deprecated feature by __attribute__((deprecated)). */
955#define TREE_DEPRECATED(NODE)((NODE)->base.deprecated_flag) \
956 ((NODE)->base.deprecated_flag)
957
958/* Nonzero indicates an IDENTIFIER_NODE that names an anonymous
959 aggregate, (as created by anon_aggr_name_format). */
960#define IDENTIFIER_ANON_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 960, __FUNCTION__, (IDENTIFIER_NODE)))->base.private_flag
)
\
961 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 961, __FUNCTION__, (IDENTIFIER_NODE)))
->base.private_flag)
962
963/* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
964 uses are to be substituted for uses of the TREE_CHAINed identifier. */
965#define IDENTIFIER_TRANSPARENT_ALIAS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 965, __FUNCTION__, (IDENTIFIER_NODE)))->base.deprecated_flag
)
\
966 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 966, __FUNCTION__, (IDENTIFIER_NODE)))
->base.deprecated_flag)
967
968/* In an aggregate type, indicates that the scalar fields of the type are
969 stored in reverse order from the target order. This effectively
970 toggles BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN within the type. */
971#define TYPE_REVERSE_STORAGE_ORDER(NODE)((tree_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 971, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
\
972 (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"
, 972, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))
->base.u.bits.saturating_flag)
973
974/* In a non-aggregate type, indicates a saturating type. */
975#define TYPE_SATURATING(NODE)((tree_not_check4 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 975, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->base.u.bits.saturating_flag)
\
976 (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"
, 976, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))
->base.u.bits.saturating_flag)
977
978/* In a BIT_FIELD_REF and MEM_REF, indicates that the reference is to a group
979 of bits stored in reverse order from the target order. This effectively
980 toggles both BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN for the reference.
981
982 The overall strategy is to preserve the invariant that every scalar in
983 memory is associated with a single storage order, i.e. all accesses to
984 this scalar are done with the same storage order. This invariant makes
985 it possible to factor out the storage order in most transformations, as
986 only the address and/or the value (in target order) matter for them.
987 But, of course, the storage order must be preserved when the accesses
988 themselves are rewritten or transformed. */
989#define REF_REVERSE_STORAGE_ORDER(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 989, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))->base.default_def_flag
)
\
990 (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"
, 990, __FUNCTION__, (BIT_FIELD_REF), (MEM_REF)))
->base.default_def_flag)
991
992 /* In an ADDR_EXPR, indicates that this is a pointer to nested function
993 represented by a descriptor instead of a trampoline. */
994#define FUNC_ADDR_BY_DESCRIPTOR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 994, __FUNCTION__, (ADDR_EXPR)))->base.default_def_flag)
\
995 (TREE_CHECK (NODE, ADDR_EXPR)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 995, __FUNCTION__, (ADDR_EXPR)))
->base.default_def_flag)
996
997/* In a CALL_EXPR, indicates that this is an indirect call for which
998 pointers to nested function are descriptors instead of trampolines. */
999#define CALL_EXPR_BY_DESCRIPTOR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 999, __FUNCTION__, (CALL_EXPR)))->base.default_def_flag)
\
1000 (TREE_CHECK (NODE, CALL_EXPR)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1000, __FUNCTION__, (CALL_EXPR)))
->base.default_def_flag)
1001
1002/* These flags are available for each language front end to use internally. */
1003#define TREE_LANG_FLAG_0(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1003, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)
\
1004 (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"
, 1004, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_0)
1005#define TREE_LANG_FLAG_1(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1005, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)
\
1006 (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"
, 1006, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_1)
1007#define TREE_LANG_FLAG_2(NODE)((tree_not_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1007, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)
\
1008 (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"
, 1008, __FUNCTION__, (TREE_VEC), (SSA_NAME)))
->base.u.bits.lang_flag_2)
1009#define TREE_LANG_FLAG_3(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_3)
\
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_3)
1011#define TREE_LANG_FLAG_4(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_4)
\
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_4)
1013#define TREE_LANG_FLAG_5(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_5)
\
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_5)
1015#define TREE_LANG_FLAG_6(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_6)
\
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_6)
1017
1018/* Define additional fields and accessors for nodes representing constants. */
1019
1020#define TREE_INT_CST_NUNITS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1020, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.unextended
)
\
1021 (INTEGER_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1021, __FUNCTION__, (INTEGER_CST)))
->base.u.int_length.unextended)
1022#define TREE_INT_CST_EXT_NUNITS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1022, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.extended
)
\
1023 (INTEGER_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1023, __FUNCTION__, (INTEGER_CST)))
->base.u.int_length.extended)
1024#define TREE_INT_CST_OFFSET_NUNITS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1024, __FUNCTION__, (INTEGER_CST)))->base.u.int_length.offset
)
\
1025 (INTEGER_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1025, __FUNCTION__, (INTEGER_CST)))
->base.u.int_length.offset)
1026#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"
, 1026, __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"
, 1026, __FUNCTION__))
1027#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"
, 1027, __FUNCTION__)))
\
1028 ((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"
, 1028, __FUNCTION__))
)
1029
1030/* Return true if NODE is a POLY_INT_CST. This is only ever true on
1031 targets with variable-sized modes. */
1032#define POLY_INT_CST_P(NODE)(1 > 1 && ((enum tree_code) (NODE)->base.code) ==
POLY_INT_CST)
\
1033 (NUM_POLY_INT_COEFFS1 > 1 && TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == POLY_INT_CST)
1034
1035/* In a POLY_INT_CST node. */
1036#define POLY_INT_CST_COEFF(NODE, I)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1036, __FUNCTION__, (POLY_INT_CST)))->poly_int_cst.coeffs
[I])
\
1037 (POLY_INT_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1037, __FUNCTION__, (POLY_INT_CST)))
->poly_int_cst.coeffs[I])
1038
1039#define TREE_REAL_CST_PTR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1039, __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"
, 1039, __FUNCTION__, (REAL_CST)))
->real_cst.real_cst_ptr)
1040#define TREE_REAL_CST(NODE)(*((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1040, __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"
, 1040, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)
1041
1042#define TREE_FIXED_CST_PTR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1042, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
)
\
1043 (FIXED_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1043, __FUNCTION__, (FIXED_CST)))
->fixed_cst.fixed_cst_ptr)
1044#define TREE_FIXED_CST(NODE)(*((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1044, __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"
, 1044, __FUNCTION__, (FIXED_CST)))->fixed_cst.fixed_cst_ptr
)
)
1045
1046/* In a STRING_CST */
1047/* In C terms, this is sizeof, not strlen. */
1048#define TREE_STRING_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1048, __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"
, 1048, __FUNCTION__, (STRING_CST)))
->string.length)
1049#define TREE_STRING_POINTER(NODE)((const char *)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1049, __FUNCTION__, (STRING_CST)))->string.str))
\
1050 ((const char *)(STRING_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1050, __FUNCTION__, (STRING_CST)))
->string.str))
1051
1052/* In a COMPLEX_CST node. */
1053#define TREE_REALPART(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1053, __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"
, 1053, __FUNCTION__, (COMPLEX_CST)))
->complex.real)
1054#define TREE_IMAGPART(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1054, __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"
, 1054, __FUNCTION__, (COMPLEX_CST)))
->complex.imag)
1055
1056/* In a VECTOR_CST node. See generic.texi for details. */
1057#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"
, 1057, __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"
, 1057, __FUNCTION__))->typed.type)
))
1058#define VECTOR_CST_ELT(NODE,IDX)vector_cst_elt (NODE, IDX) vector_cst_elt (NODE, IDX)
1059
1060#define VECTOR_CST_LOG2_NPATTERNS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1060, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
)
\
1061 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1061, __FUNCTION__, (VECTOR_CST)))
->base.u.vector_cst.log2_npatterns)
1062#define VECTOR_CST_NPATTERNS(NODE)(1U << ((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1062, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
))
\
1063 (1U << VECTOR_CST_LOG2_NPATTERNS (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1063, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.log2_npatterns
)
)
1064#define VECTOR_CST_NELTS_PER_PATTERN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1064, __FUNCTION__, (VECTOR_CST)))->base.u.vector_cst.nelts_per_pattern
)
\
1065 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1065, __FUNCTION__, (VECTOR_CST)))
->base.u.vector_cst.nelts_per_pattern)
1066#define VECTOR_CST_DUPLICATE_P(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.nelts_per_pattern
) == 1)
\
1067 (VECTOR_CST_NELTS_PER_PATTERN (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.nelts_per_pattern
)
== 1)
1068#define VECTOR_CST_STEPPED_P(NODE)(((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.nelts_per_pattern
) == 3)
\
1069 (VECTOR_CST_NELTS_PER_PATTERN (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.nelts_per_pattern
)
== 3)
1070#define VECTOR_CST_ENCODED_ELTS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1070, __FUNCTION__, (VECTOR_CST)))->vector.elts)
\
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)))
->vector.elts)
1072#define VECTOR_CST_ENCODED_ELT(NODE, ELT)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1072, __FUNCTION__, (VECTOR_CST)))->vector.elts[ELT])
\
1073 (VECTOR_CST_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1073, __FUNCTION__, (VECTOR_CST)))
->vector.elts[ELT])
1074
1075/* Define fields and accessors for some special-purpose tree nodes. */
1076
1077#define IDENTIFIER_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1077, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.len
)
\
1078 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1078, __FUNCTION__, (IDENTIFIER_NODE)))
->identifier.id.len)
1079#define IDENTIFIER_POINTER(NODE)((const char *) (tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1079, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
\
1080 ((const char *) IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1080, __FUNCTION__, (IDENTIFIER_NODE)))
->identifier.id.str)
1081#define IDENTIFIER_HASH_VALUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1081, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.hash_value
)
\
1082 (IDENTIFIER_NODE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1082, __FUNCTION__, (IDENTIFIER_NODE)))
->identifier.id.hash_value)
1083
1084/* Translate a hash table identifier pointer to a tree_identifier
1085 pointer, and vice versa. */
1086
1087#define HT_IDENT_TO_GCC_IDENT(NODE)((tree) ((char *) (NODE) - sizeof (struct tree_common))) \
1088 ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
1089#define GCC_IDENT_TO_HT_IDENT(NODE)(&((struct tree_identifier *) (NODE))->id) (&((struct tree_identifier *) (NODE))->id)
1090
1091/* In a TREE_LIST node. */
1092#define TREE_PURPOSE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1092, __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"
, 1092, __FUNCTION__, (TREE_LIST)))
->list.purpose)
1093#define TREE_VALUE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1093, __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"
, 1093, __FUNCTION__, (TREE_LIST)))
->list.value)
1094
1095/* In a TREE_VEC node. */
1096#define TREE_VEC_LENGTH(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1096, __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"
, 1096, __FUNCTION__, (TREE_VEC)))
->base.u.length)
1097#define TREE_VEC_END(NODE)((void) (tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1097, __FUNCTION__, (TREE_VEC))), &((NODE)->vec.a[(NODE
)->vec.base.u.length]))
\
1098 ((void) TREE_VEC_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1098, __FUNCTION__, (TREE_VEC)))
, &((NODE)->vec.a[(NODE)->vec.base.u.length]))
1099
1100#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"
, 1100, __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"
, 1100, __FUNCTION__)))))
1101
1102/* In a CONSTRUCTOR node. */
1103#define CONSTRUCTOR_ELTS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1103, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)
(CONSTRUCTOR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1103, __FUNCTION__, (CONSTRUCTOR)))
->constructor.elts)
1104#define CONSTRUCTOR_ELT(NODE,IDX)(&(*((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1104, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))[
IDX])
\
1105 (&(*CONSTRUCTOR_ELTS (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1105, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)
)[IDX])
1106#define CONSTRUCTOR_NELTS(NODE)(vec_safe_length (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1106, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
\
1107 (vec_safe_length (CONSTRUCTOR_ELTS (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1107, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)
))
1108#define CONSTRUCTOR_NO_CLEARING(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1108, __FUNCTION__, (CONSTRUCTOR)))->base.public_flag)
\
1109 (CONSTRUCTOR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1109, __FUNCTION__, (CONSTRUCTOR)))
->base.public_flag)
1110
1111/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
1112 value of each element (stored within VAL). IX must be a scratch variable
1113 of unsigned integer type. */
1114#define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL)for (IX = 0; (IX >= vec_safe_length (V)) ? false : ((VAL =
(*(V))[IX].value), true); (IX)++)
\
1115 for (IX = 0; (IX >= vec_safe_length (V)) \
1116 ? false \
1117 : ((VAL = (*(V))[IX].value), \
1118 true); \
1119 (IX)++)
1120
1121/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both
1122 the value of each element (stored within VAL) and its index (stored
1123 within INDEX). IX must be a scratch variable of unsigned integer type. */
1124#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)++)
\
1125 for (IX = 0; (IX >= vec_safe_length (V)) \
1126 ? false \
1127 : (((void) (VAL = (*V)[IX].value)), \
1128 (INDEX = (*V)[IX].index), \
1129 true); \
1130 (IX)++)
1131
1132/* Append a new constructor element to V, with the specified INDEX and VAL. */
1133#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE)do { constructor_elt _ce___ = {INDEX, VALUE}; vec_safe_push (
(V), _ce___); } while (0)
\
1134 do { \
1135 constructor_elt _ce___ = {INDEX, VALUE}; \
1136 vec_safe_push ((V), _ce___); \
1137 } while (0)
1138
1139/* True if NODE, a FIELD_DECL, is to be processed as a bitfield for
1140 constructor output purposes. */
1141#define CONSTRUCTOR_BITFIELD_P(NODE)(((tree_check (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1141, __FUNCTION__, (FIELD_DECL)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1141, __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"
, 1141, __FUNCTION__))->decl_common.mode) != ((void) 0, E_BLKmode
))
\
1142 (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"
, 1142, __FUNCTION__, (FIELD_DECL)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1142, __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"
, 1142, __FUNCTION__))->decl_common.mode)
!= BLKmode((void) 0, E_BLKmode))
1143
1144/* True if NODE is a clobber right hand side, an expression of indeterminate
1145 value that clobbers the LHS in a copy instruction. We use a volatile
1146 empty CONSTRUCTOR for this, as it matches most of the necessary semantic.
1147 In particular the volatile flag causes us to not prematurely remove
1148 such clobber instructions. */
1149#define TREE_CLOBBER_P(NODE)(((enum tree_code) (NODE)->base.code) == CONSTRUCTOR &&
((NODE)->base.volatile_flag))
\
1150 (TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE)((NODE)->base.volatile_flag))
1151
1152/* Define fields and accessors for some nodes that represent expressions. */
1153
1154/* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */
1155#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"
, 1155, __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"
, 1155, __FUNCTION__)))))))
(TREE_CODE (NODE)((enum tree_code) (NODE)->base.code) == NOP_EXPR \
1156 && 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"
, 1156, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
\
1157 && 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"
, 1157, __FUNCTION__)))))
))
1158
1159/* In ordinary expression nodes. */
1160#define TREE_OPERAND_LENGTH(NODE)tree_operand_length (NODE) tree_operand_length (NODE)
1161#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"
, 1161, __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"
, 1161, __FUNCTION__)))))
1162
1163/* In a tcc_vl_exp node, operand 0 is an INT_CST node holding the operand
1164 length. Its value includes the length operand itself; that is,
1165 the minimum valid length is 1.
1166 Note that we have to bypass the use of TREE_OPERAND to access
1167 that field to avoid infinite recursion in expanding the macros. */
1168#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"
, 1168, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1168, __FUNCTION__))))
\
1169 ((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"
, 1169, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1169, __FUNCTION__)))
)
1170
1171/* Nonzero if gimple_debug_nonbind_marker_p() may possibly hold. */
1172#define MAY_HAVE_DEBUG_MARKER_STMTSglobal_options.x_debug_nonbind_markers_p debug_nonbind_markers_pglobal_options.x_debug_nonbind_markers_p
1173/* Nonzero if gimple_debug_bind_p() (and thus
1174 gimple_debug_source_bind_p()) may possibly hold. */
1175#define MAY_HAVE_DEBUG_BIND_STMTSglobal_options.x_flag_var_tracking_assignments flag_var_tracking_assignmentsglobal_options.x_flag_var_tracking_assignments
1176/* Nonzero if is_gimple_debug() may possibly hold. */
1177#define MAY_HAVE_DEBUG_STMTS(global_options.x_debug_nonbind_markers_p || global_options.x_flag_var_tracking_assignments
)
\
1178 (MAY_HAVE_DEBUG_MARKER_STMTSglobal_options.x_debug_nonbind_markers_p || MAY_HAVE_DEBUG_BIND_STMTSglobal_options.x_flag_var_tracking_assignments)
1179
1180/* In a LOOP_EXPR node. */
1181#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"
, 1181, __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"
, 1181, __FUNCTION__)))
1182
1183/* The source location of this expression. Non-tree_exp nodes such as
1184 decls and constants can be shared among multiple locations, so
1185 return nothing. */
1186#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))
\
1187 (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))
1188#define SET_EXPR_LOCATION(NODE, LOCUS)(expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1188, __FUNCTION__))->exp.locus = (LOCUS)
EXPR_CHECK ((NODE))(expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1188, __FUNCTION__))
->exp.locus = (LOCUS)
1189#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))))
\
1190 != UNKNOWN_LOCATION((location_t) 0))
1191/* The location to be used in a diagnostic about this expression. Do not
1192 use this macro if the location will be assigned to other expressions. */
1193#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))
\
1194 ? (NODE)->exp.locus : (LOCUS))
1195#define EXPR_FILENAME(NODE)((expand_location ((expr_check (((NODE)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1195, __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"
, 1195, __FUNCTION__))->exp.locus)).file)
1196#define EXPR_LINENO(NODE)((expand_location ((expr_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1196, __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"
, 1196, __FUNCTION__))->exp.locus)).line)
1197
1198#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
))
)
1199#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"
, 1199, __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"
, 1199, __FUNCTION__))
))
1200
1201#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"
, 1201, __FUNCTION__)))).m_start != ((location_t) 0) : false)
\
1202 (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
)))
\
1203 ? 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"
, 1203, __FUNCTION__))))
.m_start != UNKNOWN_LOCATION((location_t) 0) \
1204 : false)
1205
1206/* True if a tree is an expression or statement that can have a
1207 location. */
1208#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
)
)
1209
1210static inline source_range
1211get_expr_source_range (tree expr)
1212{
1213 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))
;
1214 return get_range_from_loc (line_table, loc);
1215}
1216
1217extern void protected_set_expr_location (tree, location_t);
1218extern void protected_set_expr_location_if_unset (tree, location_t);
1219
1220WARN_UNUSED_RESULT__attribute__ ((__warn_unused_result__)) extern tree maybe_wrap_with_location (tree, location_t);
1221
1222extern int suppress_location_wrappers;
1223
1224/* A class for suppressing the creation of location wrappers.
1225 Location wrappers will not be created during the lifetime
1226 of an instance of this class. */
1227
1228class auto_suppress_location_wrappers
1229{
1230 public:
1231 auto_suppress_location_wrappers () { ++suppress_location_wrappers; }
1232 ~auto_suppress_location_wrappers () { --suppress_location_wrappers; }
1233};
1234
1235/* In a TARGET_EXPR node. */
1236#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"
, 1236, __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"
, 1236, __FUNCTION__)))
1237#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"
, 1237, __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"
, 1237, __FUNCTION__)))
1238#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"
, 1238, __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"
, 1238, __FUNCTION__)))
1239/* Don't elide the initialization of TARGET_EXPR_SLOT for this TARGET_EXPR
1240 on rhs of MODIFY_EXPR. */
1241#define TARGET_EXPR_NO_ELIDE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1241, __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"
, 1241, __FUNCTION__, (TARGET_EXPR)))
->base.private_flag)
1242
1243/* DECL_EXPR accessor. This gives access to the DECL associated with
1244 the given declaration statement. */
1245#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"
, 1245, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1245, __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"
, 1245, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1245, __FUNCTION__)))))
1246
1247#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"
, 1247, __FUNCTION__, (EXIT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1247, __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"
, 1247, __FUNCTION__, (EXIT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1247, __FUNCTION__)))))
1248
1249/* COMPOUND_LITERAL_EXPR accessors. */
1250#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"
, 1250, __FUNCTION__, (COMPOUND_LITERAL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1250, __FUNCTION__)))))
\
1251 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"
, 1251, __FUNCTION__, (COMPOUND_LITERAL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1251, __FUNCTION__)))))
1252#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"
, 1252, __FUNCTION__, (COMPOUND_LITERAL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1252, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1252, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1252, __FUNCTION__)))))
\
1253 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"
, 1253, __FUNCTION__, (COMPOUND_LITERAL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1253, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1253, __FUNCTION__, (DECL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1253, __FUNCTION__)))))
1254
1255/* SWITCH_EXPR accessors. These give access to the condition and body. */
1256#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"
, 1256, __FUNCTION__, (SWITCH_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1256, __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"
, 1256, __FUNCTION__, (SWITCH_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1256, __FUNCTION__)))))
1257#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"
, 1257, __FUNCTION__, (SWITCH_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1257, __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"
, 1257, __FUNCTION__, (SWITCH_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1257, __FUNCTION__)))))
1258/* True if there are case labels for all possible values of SWITCH_COND, either
1259 because there is a default: case label or because the case label ranges cover
1260 all values. */
1261#define SWITCH_ALL_CASES_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1261, __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"
, 1261, __FUNCTION__, (SWITCH_EXPR)))
->base.private_flag)
1262
1263/* CASE_LABEL_EXPR accessors. These give access to the high and low values
1264 of a case label, respectively. */
1265#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"
, 1265, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1265, __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"
, 1265, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1265, __FUNCTION__)))))
1266#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"
, 1266, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1266, __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"
, 1266, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1266, __FUNCTION__)))))
1267#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"
, 1267, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1267, __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"
, 1267, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1267, __FUNCTION__)))))
1268#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"
, 1268, __FUNCTION__, (CASE_LABEL_EXPR)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1268, __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"
, 1268, __FUNCTION__, (CASE_LABEL_EXPR)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1268, __FUNCTION__)))))
1269
1270/* The operands of a TARGET_MEM_REF. Operands 0 and 1 have to match
1271 corresponding MEM_REF operands. */
1272#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"
, 1272, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1272, __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"
, 1272, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1272, __FUNCTION__)))))
)
1273#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"
, 1273, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1273, __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"
, 1273, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1273, __FUNCTION__)))))
)
1274#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"
, 1274, __FUNCTION__, (TARGET_MEM_REF)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1274, __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"
, 1274, __FUNCTION__, (TARGET_MEM_REF)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1274, __FUNCTION__)))))
)
1275#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"
, 1275, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1275, __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"
, 1275, __FUNCTION__, (TARGET_MEM_REF)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1275, __FUNCTION__)))))
)
1276#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"
, 1276, __FUNCTION__, (TARGET_MEM_REF)))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1276, __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"
, 1276, __FUNCTION__, (TARGET_MEM_REF)))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1276, __FUNCTION__)))))
)
1277
1278#define MR_DEPENDENCE_CLIQUE(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1278, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique)
\
1279 (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"
, 1279, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))
->base.u.dependence_info.clique)
1280#define MR_DEPENDENCE_BASE(NODE)((tree_check2 ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1280, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.base)
\
1281 (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"
, 1281, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))
->base.u.dependence_info.base)
1282
1283/* The operands of a BIND_EXPR. */
1284#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"
, 1284, __FUNCTION__, (BIND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1284, __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"
, 1284, __FUNCTION__, (BIND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1284, __FUNCTION__)))))
)
1285#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"
, 1285, __FUNCTION__, (BIND_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1285, __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"
, 1285, __FUNCTION__, (BIND_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1285, __FUNCTION__)))))
)
1286#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"
, 1286, __FUNCTION__, (BIND_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1286, __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"
, 1286, __FUNCTION__, (BIND_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1286, __FUNCTION__)))))
)
1287
1288/* GOTO_EXPR accessor. This gives access to the label associated with
1289 a goto statement. */
1290#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"
, 1290, __FUNCTION__, (GOTO_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1290, __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"
, 1290, __FUNCTION__, (GOTO_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1290, __FUNCTION__)))))
1291
1292/* ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the
1293 instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
1294 ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
1295 statement. */
1296#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"
, 1296, __FUNCTION__, (ASM_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1296, __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"
, 1296, __FUNCTION__, (ASM_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1296, __FUNCTION__)))))
1297#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"
, 1297, __FUNCTION__, (ASM_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1297, __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"
, 1297, __FUNCTION__, (ASM_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1297, __FUNCTION__)))))
1298#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"
, 1298, __FUNCTION__, (ASM_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1298, __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"
, 1298, __FUNCTION__, (ASM_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1298, __FUNCTION__)))))
1299#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"
, 1299, __FUNCTION__, (ASM_EXPR)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1299, __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"
, 1299, __FUNCTION__, (ASM_EXPR)))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1299, __FUNCTION__)))))
1300#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"
, 1300, __FUNCTION__, (ASM_EXPR)))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1300, __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"
, 1300, __FUNCTION__, (ASM_EXPR)))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1300, __FUNCTION__)))))
1301/* Nonzero if we want to create an ASM_INPUT instead of an
1302 ASM_OPERAND with no operands. */
1303#define ASM_INPUT_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1303, __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"
, 1303, __FUNCTION__, (ASM_EXPR)))
->base.static_flag)
1304#define ASM_VOLATILE_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1304, __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"
, 1304, __FUNCTION__, (ASM_EXPR)))
->base.public_flag)
1305/* Nonzero if we want to consider this asm as minimum length and cost
1306 for inlining decisions. */
1307#define ASM_INLINE_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1307, __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"
, 1307, __FUNCTION__, (ASM_EXPR)))
->base.protected_flag)
1308
1309/* COND_EXPR accessors. */
1310#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"
, 1310, __FUNCTION__, (COND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1310, __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"
, 1310, __FUNCTION__, (COND_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1310, __FUNCTION__)))))
)
1311#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"
, 1311, __FUNCTION__, (COND_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1311, __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"
, 1311, __FUNCTION__, (COND_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1311, __FUNCTION__)))))
)
1312#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"
, 1312, __FUNCTION__, (COND_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1312, __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"
, 1312, __FUNCTION__, (COND_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1312, __FUNCTION__)))))
)
1313
1314/* Accessors for the chains of recurrences. */
1315#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"
, 1315, __FUNCTION__, (POLYNOMIAL_CHREC)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1315, __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"
, 1315, __FUNCTION__, (POLYNOMIAL_CHREC)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1315, __FUNCTION__)))))
1316#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"
, 1316, __FUNCTION__, (POLYNOMIAL_CHREC)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1316, __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"
, 1316, __FUNCTION__, (POLYNOMIAL_CHREC)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1316, __FUNCTION__)))))
1317#define CHREC_VARIABLE(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1317, __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"
, 1317, __FUNCTION__, (POLYNOMIAL_CHREC)))
->base.u.chrec_var
1318
1319/* LABEL_EXPR accessor. This gives access to the label associated with
1320 the given label expression. */
1321#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"
, 1321, __FUNCTION__, (LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1321, __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"
, 1321, __FUNCTION__, (LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1321, __FUNCTION__)))))
1322
1323/* CATCH_EXPR accessors. */
1324#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"
, 1324, __FUNCTION__, (CATCH_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1324, __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"
, 1324, __FUNCTION__, (CATCH_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1324, __FUNCTION__)))))
1325#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"
, 1325, __FUNCTION__, (CATCH_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1325, __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"
, 1325, __FUNCTION__, (CATCH_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1325, __FUNCTION__)))))
1326
1327/* EH_FILTER_EXPR accessors. */
1328#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"
, 1328, __FUNCTION__, (EH_FILTER_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1328, __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"
, 1328, __FUNCTION__, (EH_FILTER_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1328, __FUNCTION__)))))
1329#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"
, 1329, __FUNCTION__, (EH_FILTER_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1329, __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"
, 1329, __FUNCTION__, (EH_FILTER_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1329, __FUNCTION__)))))
1330
1331/* OBJ_TYPE_REF accessors. */
1332#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"
, 1332, __FUNCTION__, (OBJ_TYPE_REF)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1332, __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"
, 1332, __FUNCTION__, (OBJ_TYPE_REF)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1332, __FUNCTION__)))))
1333#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"
, 1333, __FUNCTION__, (OBJ_TYPE_REF)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1333, __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"
, 1333, __FUNCTION__, (OBJ_TYPE_REF)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1333, __FUNCTION__)))))
1334#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"
, 1334, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1334, __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"
, 1334, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1334, __FUNCTION__)))))
1335
1336/* ASSERT_EXPR accessors. */
1337#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"
, 1337, __FUNCTION__, (ASSERT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1337, __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"
, 1337, __FUNCTION__, (ASSERT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1337, __FUNCTION__)))))
1338#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"
, 1338, __FUNCTION__, (ASSERT_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1338, __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"
, 1338, __FUNCTION__, (ASSERT_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1338, __FUNCTION__)))))
1339
1340/* CALL_EXPR accessors. */
1341#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"
, 1341, __FUNCTION__, (CALL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1341, __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"
, 1341, __FUNCTION__, (CALL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1341, __FUNCTION__)))))
1342#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"
, 1342, __FUNCTION__, (CALL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1342, __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"
, 1342, __FUNCTION__, (CALL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1342, __FUNCTION__)))))
1343#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"
, 1343, __FUNCTION__, (CALL_EXPR)))), ((I) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1343, __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"
, 1343, __FUNCTION__, (CALL_EXPR)))), ((I) + 3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1343, __FUNCTION__)))))
1344#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"
, 1344, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1344, __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"
, 1344, __FUNCTION__))->exp.operands[0]), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1344, __FUNCTION__))))
- 3)
1345#define CALL_EXPR_IFN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1345, __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"
, 1345, __FUNCTION__, (CALL_EXPR)))
->base.u.ifn)
1346
1347/* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE.
1348 We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if
1349 the argument count is zero when checking is enabled. Instead, do
1350 the pointer arithmetic to advance past the 3 fixed operands in a
1351 CALL_EXPR. That produces a valid pointer to just past the end of the
1352 operand array, even if it's not valid to dereference it. */
1353#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"
, 1353, __FUNCTION__, (CALL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1353, __FUNCTION__)))))) + 3)
\
1354 (&(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"
, 1354, __FUNCTION__, (CALL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1354, __FUNCTION__)))))
) + 3)
1355
1356/* TM directives and accessors. */
1357#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"
, 1357, __FUNCTION__, (TRANSACTION_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1357, __FUNCTION__)))))
\
1358 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"
, 1358, __FUNCTION__, (TRANSACTION_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1358, __FUNCTION__)))))
1359#define TRANSACTION_EXPR_OUTER(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1359, __FUNCTION__, (TRANSACTION_EXPR)))->base.static_flag
)
\
1360 (TRANSACTION_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1360, __FUNCTION__, (TRANSACTION_EXPR)))
->base.static_flag)
1361#define TRANSACTION_EXPR_RELAXED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1361, __FUNCTION__, (TRANSACTION_EXPR)))->base.public_flag
)
\
1362 (TRANSACTION_EXPR_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1362, __FUNCTION__, (TRANSACTION_EXPR)))
->base.public_flag)
1363
1364/* OpenMP and OpenACC directive and clause accessors. */
1365
1366/* Generic accessors for OMP nodes that keep the body as operand 0, and clauses
1367 as operand 1. */
1368#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"
, 1368, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1368, __FUNCTION__)))))
\
1369 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"
, 1369, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1369, __FUNCTION__)))))
1370#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"
, 1370, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1370, __FUNCTION__)))))
\
1371 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"
, 1371, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1371, __FUNCTION__)))))
1372
1373/* Generic accessors for OMP nodes that keep clauses as operand 0. */
1374#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"
, 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_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"
, 1375, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1375, __FUNCTION__)))))
1376
1377#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"
, 1377, __FUNCTION__, (OACC_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1377, __FUNCTION__)))))
\
1378 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"
, 1378, __FUNCTION__, (OACC_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1378, __FUNCTION__)))))
1379#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"
, 1379, __FUNCTION__, (OACC_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1379, __FUNCTION__)))))
\
1380 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"
, 1380, __FUNCTION__, (OACC_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1380, __FUNCTION__)))))
1381
1382#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"
, 1382, __FUNCTION__, (OACC_HOST_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1382, __FUNCTION__)))))
\
1383 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"
, 1383, __FUNCTION__, (OACC_HOST_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1383, __FUNCTION__)))))
1384#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"
, 1384, __FUNCTION__, (OACC_HOST_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1384, __FUNCTION__)))))
\
1385 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"
, 1385, __FUNCTION__, (OACC_HOST_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1385, __FUNCTION__)))))
1386
1387#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"
, 1387, __FUNCTION__, (OACC_CACHE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1387, __FUNCTION__)))))
\
1388 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"
, 1388, __FUNCTION__, (OACC_CACHE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1388, __FUNCTION__)))))
1389
1390#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"
, 1390, __FUNCTION__, (OACC_DECLARE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1390, __FUNCTION__)))))
\
1391 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"
, 1391, __FUNCTION__, (OACC_DECLARE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1391, __FUNCTION__)))))
1392
1393#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"
, 1393, __FUNCTION__, (OACC_ENTER_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1393, __FUNCTION__)))))
\
1394 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"
, 1394, __FUNCTION__, (OACC_ENTER_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1394, __FUNCTION__)))))
1395
1396#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"
, 1396, __FUNCTION__, (OACC_EXIT_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1396, __FUNCTION__)))))
\
1397 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"
, 1397, __FUNCTION__, (OACC_EXIT_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1397, __FUNCTION__)))))
1398
1399#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"
, 1399, __FUNCTION__, (OACC_UPDATE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1399, __FUNCTION__)))))
\
1400 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"
, 1400, __FUNCTION__, (OACC_UPDATE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1400, __FUNCTION__)))))
1401
1402#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"
, 1402, __FUNCTION__, (OMP_PARALLEL)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1402, __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"
, 1402, __FUNCTION__, (OMP_PARALLEL)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1402, __FUNCTION__)))))
1403#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"
, 1403, __FUNCTION__, (OMP_PARALLEL)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1403, __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"
, 1403, __FUNCTION__, (OMP_PARALLEL)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1403, __FUNCTION__)))))
1404
1405#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"
, 1405, __FUNCTION__, (OMP_TASK)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1405, __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"
, 1405, __FUNCTION__, (OMP_TASK)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1405, __FUNCTION__)))))
1406#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"
, 1406, __FUNCTION__, (OMP_TASK)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1406, __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"
, 1406, __FUNCTION__, (OMP_TASK)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1406, __FUNCTION__)))))
1407
1408#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"
, 1408, __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"
, 1408, __FUNCTION__))
1409#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"
, 1409, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1409, __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"
, 1409, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1409, __FUNCTION__)))))
1410#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"
, 1410, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1410, __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"
, 1410, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1410, __FUNCTION__)))))
1411
1412#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"
, 1412, __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"
, 1412, __FUNCTION__))
1413#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"
, 1413, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1413, __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"
, 1413, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1413, __FUNCTION__)))))
1414#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"
, 1414, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1414, __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"
, 1414, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1414, __FUNCTION__)))))
1415#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"
, 1415, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1415, __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"
, 1415, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1415, __FUNCTION__)))))
1416#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"
, 1416, __FUNCTION__))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1416, __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"
, 1416, __FUNCTION__))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1416, __FUNCTION__)))))
1417#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"
, 1417, __FUNCTION__))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1417, __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"
, 1417, __FUNCTION__))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1417, __FUNCTION__)))))
1418#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"
, 1418, __FUNCTION__))), (5), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1418, __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"
, 1418, __FUNCTION__))), (5), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1418, __FUNCTION__)))))
1419#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"
, 1419, __FUNCTION__))), (6), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1419, __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"
, 1419, __FUNCTION__))), (6), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1419, __FUNCTION__)))))
1420
1421#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"
, 1421, __FUNCTION__, (OMP_SECTIONS)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1421, __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"
, 1421, __FUNCTION__, (OMP_SECTIONS)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1421, __FUNCTION__)))))
1422#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"
, 1422, __FUNCTION__, (OMP_SECTIONS)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1422, __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"
, 1422, __FUNCTION__, (OMP_SECTIONS)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1422, __FUNCTION__)))))
1423
1424#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"
, 1424, __FUNCTION__, (OMP_SECTION)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1424, __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"
, 1424, __FUNCTION__, (OMP_SECTION)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1424, __FUNCTION__)))))
1425
1426#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"
, 1426, __FUNCTION__, (OMP_SINGLE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1426, __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"
, 1426, __FUNCTION__, (OMP_SINGLE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1426, __FUNCTION__)))))
1427#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"
, 1427, __FUNCTION__, (OMP_SINGLE)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1427, __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"
, 1427, __FUNCTION__, (OMP_SINGLE)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1427, __FUNCTION__)))))
1428
1429#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"
, 1429, __FUNCTION__, (OMP_MASTER)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1429, __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"
, 1429, __FUNCTION__, (OMP_MASTER)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1429, __FUNCTION__)))))
1430
1431#define OMP_TASKGROUP_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"
, 1431, __FUNCTION__, (OMP_TASKGROUP)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1431, __FUNCTION__)))))
TREE_OPERAND (OMP_TASKGROUP_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"
, 1431, __FUNCTION__, (OMP_TASKGROUP)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1431, __FUNCTION__)))))
1432#define OMP_TASKGROUP_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"
, 1432, __FUNCTION__, (OMP_TASKGROUP)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1432, __FUNCTION__)))))
\
1433 TREE_OPERAND (OMP_TASKGROUP_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_TASKGROUP)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1433, __FUNCTION__)))))
1434
1435#define OMP_ORDERED_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_ORDERED)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1435, __FUNCTION__)))))
TREE_OPERAND (OMP_ORDERED_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_ORDERED)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1435, __FUNCTION__)))))
1436#define OMP_ORDERED_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_ORDERED)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1436, __FUNCTION__)))))
TREE_OPERAND (OMP_ORDERED_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_ORDERED)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1436, __FUNCTION__)))))
1437
1438#define OMP_CRITICAL_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_CRITICAL)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1438, __FUNCTION__)))))
TREE_OPERAND (OMP_CRITICAL_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_CRITICAL)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1438, __FUNCTION__)))))
1439#define OMP_CRITICAL_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"
, 1439, __FUNCTION__, (OMP_CRITICAL)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1439, __FUNCTION__)))))
TREE_OPERAND (OMP_CRITICAL_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"
, 1439, __FUNCTION__, (OMP_CRITICAL)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1439, __FUNCTION__)))))
1440#define OMP_CRITICAL_NAME(NODE)(*((const_cast<tree*> (tree_operand_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1440, __FUNCTION__, (OMP_CRITICAL)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1440, __FUNCTION__)))))
TREE_OPERAND (OMP_CRITICAL_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"
, 1440, __FUNCTION__, (OMP_CRITICAL)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1440, __FUNCTION__)))))
1441
1442#define OMP_TEAMS_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"
, 1442, __FUNCTION__, (OMP_TEAMS)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1442, __FUNCTION__)))))
TREE_OPERAND (OMP_TEAMS_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"
, 1442, __FUNCTION__, (OMP_TEAMS)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1442, __FUNCTION__)))))
1443#define OMP_TEAMS_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"
, 1443, __FUNCTION__, (OMP_TEAMS)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1443, __FUNCTION__)))))
TREE_OPERAND (OMP_TEAMS_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"
, 1443, __FUNCTION__, (OMP_TEAMS)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1443, __FUNCTION__)))))
1444
1445#define OMP_TARGET_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"
, 1445, __FUNCTION__, (OMP_TARGET_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1445, __FUNCTION__)))))
\
1446 TREE_OPERAND (OMP_TARGET_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"
, 1446, __FUNCTION__, (OMP_TARGET_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1446, __FUNCTION__)))))
1447#define OMP_TARGET_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"
, 1447, __FUNCTION__, (OMP_TARGET_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1447, __FUNCTION__)))))
\
1448 TREE_OPERAND (OMP_TARGET_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"
, 1448, __FUNCTION__, (OMP_TARGET_DATA)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1448, __FUNCTION__)))))
1449
1450#define OMP_TARGET_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"
, 1450, __FUNCTION__, (OMP_TARGET)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1450, __FUNCTION__)))))
TREE_OPERAND (OMP_TARGET_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"
, 1450, __FUNCTION__, (OMP_TARGET)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1450, __FUNCTION__)))))
1451#define OMP_TARGET_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"
, 1451, __FUNCTION__, (OMP_TARGET)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1451, __FUNCTION__)))))
TREE_OPERAND (OMP_TARGET_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"
, 1451, __FUNCTION__, (OMP_TARGET)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1451, __FUNCTION__)))))
1452
1453#define OMP_TARGET_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"
, 1453, __FUNCTION__, (OMP_TARGET_UPDATE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1453, __FUNCTION__)))))
\
1454 TREE_OPERAND (OMP_TARGET_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"
, 1454, __FUNCTION__, (OMP_TARGET_UPDATE)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1454, __FUNCTION__)))))
1455
1456#define OMP_TARGET_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"
, 1456, __FUNCTION__, (OMP_TARGET_ENTER_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1456, __FUNCTION__)))))
\
1457 TREE_OPERAND (OMP_TARGET_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"
, 1457, __FUNCTION__, (OMP_TARGET_ENTER_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1457, __FUNCTION__)))))
1458
1459#define OMP_TARGET_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"
, 1459, __FUNCTION__, (OMP_TARGET_EXIT_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1459, __FUNCTION__)))))
\
1460 TREE_OPERAND (OMP_TARGET_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"
, 1460, __FUNCTION__, (OMP_TARGET_EXIT_DATA)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1460, __FUNCTION__)))))
1461
1462#define OMP_SCAN_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"
, 1462, __FUNCTION__, (OMP_SCAN)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1462, __FUNCTION__)))))
TREE_OPERAND (OMP_SCAN_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"
, 1462, __FUNCTION__, (OMP_SCAN)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1462, __FUNCTION__)))))
1463#define OMP_SCAN_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"
, 1463, __FUNCTION__, (OMP_SCAN)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1463, __FUNCTION__)))))
TREE_OPERAND (OMP_SCAN_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"
, 1463, __FUNCTION__, (OMP_SCAN)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1463, __FUNCTION__)))))
1464
1465#define OMP_CLAUSE_SIZE(NODE)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1465, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_FROM), (OMP_CLAUSE__CACHE_
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1465, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1465, __FUNCTION__)))
\
1466 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1466, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_FROM), (OMP_CLAUSE__CACHE_
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1468, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1468, __FUNCTION__)))
1467 OMP_CLAUSE_FROM, \(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1466, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_FROM), (OMP_CLAUSE__CACHE_
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1468, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1468, __FUNCTION__)))
1468 OMP_CLAUSE__CACHE_), 1)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1466, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_FROM), (OMP_CLAUSE__CACHE_
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1468, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1468, __FUNCTION__)))
1469
1470#define OMP_CLAUSE_CHAIN(NODE)((contains_struct_check (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1470, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1470, __FUNCTION__))->common.chain)
TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))((contains_struct_check (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1470, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1470, __FUNCTION__))->common.chain)
1471#define OMP_CLAUSE_DECL(NODE)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1471, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1471, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1471, __FUNCTION__)))
\
1472 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1472, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1474, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1474, __FUNCTION__)))
1473 OMP_CLAUSE_PRIVATE, \(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1472, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1474, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1474, __FUNCTION__)))
1474 OMP_CLAUSE__SCANTEMP_), 0)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1472, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1474, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1474, __FUNCTION__)))
1475#define OMP_CLAUSE_HAS_LOCATION(NODE)(((IS_ADHOC_LOC (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1475, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.locus)) ?
get_location_from_adhoc_loc (line_table, ((tree_check ((NODE
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1475, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.locus) :
(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1475, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.locus)) !=
((location_t) 0))
\
1476 (LOCATION_LOCUS ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus)((IS_ADHOC_LOC (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1476, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.locus)) ?
get_location_from_adhoc_loc (line_table, ((tree_check ((NODE
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1476, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.locus) :
(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1476, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.locus))
\
1477 != UNKNOWN_LOCATION((location_t) 0))
1478#define OMP_CLAUSE_LOCATION(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1478, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.locus
(OMP_CLAUSE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1478, __FUNCTION__, (OMP_CLAUSE)))
)->omp_clause.locus
1479
1480/* True on OMP_FOR and other OpenMP/OpenACC looping constructs if the loop nest
1481 is non-rectangular. */
1482#define OMP_FOR_NON_RECTANGULAR(NODE)((tree_range_check ((NODE), (OMP_FOR), (OACC_LOOP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1482, __FUNCTION__))->base.private_flag)
\
1483 (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"
, 1483, __FUNCTION__))
->base.private_flag)
1484
1485/* True on an OMP_SECTION statement that was the last lexical member.
1486 This status is meaningful in the implementation of lastprivate. */
1487#define OMP_SECTION_LAST(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1487, __FUNCTION__, (OMP_SECTION)))->base.private_flag)
\
1488 (OMP_SECTION_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1488, __FUNCTION__, (OMP_SECTION)))
->base.private_flag)
1489
1490/* True on an OMP_PARALLEL statement if it represents an explicit
1491 combined parallel work-sharing constructs. */
1492#define OMP_PARALLEL_COMBINED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1492, __FUNCTION__, (OMP_PARALLEL)))->base.private_flag)
\
1493 (OMP_PARALLEL_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1493, __FUNCTION__, (OMP_PARALLEL)))
->base.private_flag)
1494
1495/* True on an OMP_TEAMS statement if it represents an explicit
1496 combined teams distribute constructs. */
1497#define OMP_TEAMS_COMBINED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1497, __FUNCTION__, (OMP_TEAMS)))->base.private_flag)
\
1498 (OMP_TEAMS_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1498, __FUNCTION__, (OMP_TEAMS)))
->base.private_flag)
1499
1500/* True on an OMP_TARGET statement if it represents explicit
1501 combined target teams, target parallel or target simd constructs. */
1502#define OMP_TARGET_COMBINED(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1502, __FUNCTION__, (OMP_TARGET)))->base.private_flag)
\
1503 (OMP_TARGET_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1503, __FUNCTION__, (OMP_TARGET)))
->base.private_flag)
1504
1505/* Memory order for OMP_ATOMIC*. */
1506#define OMP_ATOMIC_MEMORY_ORDER(NODE)((tree_range_check ((NODE), (OMP_ATOMIC), (OMP_ATOMIC_CAPTURE_NEW
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1506, __FUNCTION__))->base.u.omp_atomic_memory_order)
\
1507 (TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \(tree_range_check ((NODE), (OMP_ATOMIC), (OMP_ATOMIC_CAPTURE_NEW
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1508, __FUNCTION__))
1508 OMP_ATOMIC_CAPTURE_NEW)(tree_range_check ((NODE), (OMP_ATOMIC), (OMP_ATOMIC_CAPTURE_NEW
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1508, __FUNCTION__))
->base.u.omp_atomic_memory_order)
1509
1510/* True on a PRIVATE clause if its decl is kept around for debugging
1511 information only and its DECL_VALUE_EXPR is supposed to point
1512 to what it has been remapped to. */
1513#define OMP_CLAUSE_PRIVATE_DEBUG(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_PRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1513, __FUNCTION__))->base.public_flag)
\
1514 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_PRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1514, __FUNCTION__))
->base.public_flag)
1515
1516/* True on a PRIVATE clause if ctor needs access to outer region's
1517 variable. */
1518#define OMP_CLAUSE_PRIVATE_OUTER_REF(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_PRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1518, __FUNCTION__)))->base.private_flag)
\
1519 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_PRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1519, __FUNCTION__)))->base.private_flag)
1520
1521/* True if a PRIVATE clause is for a C++ class IV on taskloop construct
1522 (thus should be private on the outer taskloop and firstprivate on
1523 task). */
1524#define OMP_CLAUSE_PRIVATE_TASKLOOP_IV(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_PRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1524, __FUNCTION__)))->base.protected_flag)
\
1525 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_PRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1525, __FUNCTION__)))->base.protected_flag)
1526
1527/* True on a FIRSTPRIVATE clause if it has been added implicitly. */
1528#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_FIRSTPRIVATE)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1528, __FUNCTION__))->base.public_flag)
\
1529 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_FIRSTPRIVATE),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1529, __FUNCTION__))
->base.public_flag)
1530
1531/* True on a FIRSTPRIVATE clause if only the reference and not what it refers
1532 to should be firstprivatized. */
1533#define OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_FIRSTPRIVATE
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1533, __FUNCTION__)))->base.private_flag)
\
1534 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_FIRSTPRIVATE
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1534, __FUNCTION__)))->base.private_flag)
1535
1536/* True on a LASTPRIVATE clause if a FIRSTPRIVATE clause for the same
1537 decl is present in the chain. */
1538#define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LASTPRIVATE),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1538, __FUNCTION__))->base.public_flag)
\
1539 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LASTPRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1539, __FUNCTION__))
->base.public_flag)
1540#define OMP_CLAUSE_LASTPRIVATE_STMT(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_LASTPRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1540, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1540, __FUNCTION__)))
\
1541 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_LASTPRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1542, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1543, __FUNCTION__)))
1542 OMP_CLAUSE_LASTPRIVATE),\(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_LASTPRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1542, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1543, __FUNCTION__)))
1543 1)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_LASTPRIVATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1542, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1543, __FUNCTION__)))
1544#define OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1544, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.gimple_reduction_init
\
1545 (OMP_CLAUSE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1545, __FUNCTION__, (OMP_CLAUSE)))
)->omp_clause.gimple_reduction_init
1546
1547/* True if a LASTPRIVATE clause is for a C++ class IV on taskloop or
1548 loop construct (thus should be lastprivate on the outer taskloop and
1549 firstprivate on task for the taskloop construct and carefully handled
1550 for loop construct). */
1551#define OMP_CLAUSE_LASTPRIVATE_LOOP_IV(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LASTPRIVATE)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1551, __FUNCTION__)))->base.protected_flag)
\
1552 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LASTPRIVATE)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1552, __FUNCTION__)))->base.protected_flag)
1553
1554/* True if a LASTPRIVATE clause has CONDITIONAL: modifier. */
1555#define OMP_CLAUSE_LASTPRIVATE_CONDITIONAL(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LASTPRIVATE)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1555, __FUNCTION__)))->base.private_flag)
\
1556 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LASTPRIVATE)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1556, __FUNCTION__)))->base.private_flag)
1557
1558/* True on a SHARED clause if a FIRSTPRIVATE clause for the same
1559 decl is present in the chain (this can happen only for taskloop
1560 with FIRSTPRIVATE/LASTPRIVATE on it originally. */
1561#define OMP_CLAUSE_SHARED_FIRSTPRIVATE(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_SHARED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1561, __FUNCTION__))->base.public_flag)
\
1562 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_SHARED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1562, __FUNCTION__))
->base.public_flag)
1563
1564/* True on a SHARED clause if a scalar is not modified in the body and
1565 thus could be optimized as firstprivate. */
1566#define OMP_CLAUSE_SHARED_READONLY(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_SHARED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1566, __FUNCTION__)))->base.private_flag)
\
1567 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_SHARED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1567, __FUNCTION__)))->base.private_flag)
1568
1569#define OMP_CLAUSE_IF_MODIFIER(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_IF), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1569, __FUNCTION__))->omp_clause.subcode.if_modifier)
\
1570 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_IF), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1570, __FUNCTION__))
->omp_clause.subcode.if_modifier)
1571
1572#define OMP_CLAUSE_FINAL_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_FINAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1572, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1572, __FUNCTION__)))
\
1573 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FINAL), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_FINAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1573, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1573, __FUNCTION__)))
1574#define OMP_CLAUSE_IF_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_IF), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1574, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1574, __FUNCTION__)))
\
1575 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_IF), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1575, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1575, __FUNCTION__)))
1576#define OMP_CLAUSE_NUM_THREADS_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_THREADS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1576, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1576, __FUNCTION__)))
\
1577 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_THREADS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1577, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1577, __FUNCTION__)))
1578#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_SCHEDULE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1578, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1578, __FUNCTION__)))
\
1579 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_SCHEDULE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1579, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1579, __FUNCTION__)))
1580#define OMP_CLAUSE_NUM_TASKS_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_TASKS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1580, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1580, __FUNCTION__)))
\
1581 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_TASKS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1581, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1581, __FUNCTION__)))
1582#define OMP_CLAUSE_HINT_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_HINT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1582, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1582, __FUNCTION__)))
\
1583 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_HINT), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_HINT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1583, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1583, __FUNCTION__)))
1584
1585#define OMP_CLAUSE_GRAINSIZE_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_GRAINSIZE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1585, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1585, __FUNCTION__)))
\
1586 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE),0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_GRAINSIZE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1586, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1586, __FUNCTION__)))
1587
1588#define OMP_CLAUSE_PRIORITY_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_PRIORITY), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1588, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1588, __FUNCTION__)))
\
1589 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIORITY),0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_PRIORITY), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1589, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1589, __FUNCTION__)))
1590
1591/* OpenACC clause expressions */
1592#define OMP_CLAUSE_EXPR(NODE, CLAUSE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
CLAUSE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1592, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1592, __FUNCTION__)))
\
1593 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, CLAUSE), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
CLAUSE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1593, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1593, __FUNCTION__)))
1594#define OMP_CLAUSE_GANG_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_GANG), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1594, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1594, __FUNCTION__)))
\
1595 OMP_CLAUSE_OPERAND ( \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_GANG), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1596, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1596, __FUNCTION__)))
1596 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_GANG), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1596, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1596, __FUNCTION__)))
1597#define OMP_CLAUSE_GANG_STATIC_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_GANG), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1597, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1597, __FUNCTION__)))
\
1598 OMP_CLAUSE_OPERAND ( \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_GANG), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1599, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1599, __FUNCTION__)))
1599 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 1)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_GANG), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1599, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1599, __FUNCTION__)))
1600#define OMP_CLAUSE_ASYNC_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_ASYNC), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1600, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1600, __FUNCTION__)))
\
1601 OMP_CLAUSE_OPERAND ( \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_ASYNC), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1602, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1602, __FUNCTION__)))
1602 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ASYNC), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_ASYNC), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1602, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1602, __FUNCTION__)))
1603#define OMP_CLAUSE_WAIT_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_WAIT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1603, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1603, __FUNCTION__)))
\
1604 OMP_CLAUSE_OPERAND ( \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_WAIT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1605, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1605, __FUNCTION__)))
1605 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WAIT), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_WAIT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1605, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1605, __FUNCTION__)))
1606#define OMP_CLAUSE_VECTOR_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_VECTOR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1606, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1606, __FUNCTION__)))
\
1607 OMP_CLAUSE_OPERAND ( \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_VECTOR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1608, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1608, __FUNCTION__)))
1608 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_VECTOR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1608, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1608, __FUNCTION__)))
1609#define OMP_CLAUSE_WORKER_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_WORKER), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1609, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1609, __FUNCTION__)))
\
1610 OMP_CLAUSE_OPERAND ( \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_WORKER), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1611, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1611, __FUNCTION__)))
1611 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WORKER), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_WORKER), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1611, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1611, __FUNCTION__)))
1612#define OMP_CLAUSE_NUM_GANGS_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_GANGS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1612, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1612, __FUNCTION__)))
\
1613 OMP_CLAUSE_OPERAND ( \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_GANGS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1614, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1614, __FUNCTION__)))
1614 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_GANGS), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_GANGS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1614, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1614, __FUNCTION__)))
1615#define OMP_CLAUSE_NUM_WORKERS_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_WORKERS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1615, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1615, __FUNCTION__)))
\
1616 OMP_CLAUSE_OPERAND ( \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_WORKERS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1617, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1617, __FUNCTION__)))
1617 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_WORKERS), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_WORKERS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1617, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1617, __FUNCTION__)))
1618#define OMP_CLAUSE_VECTOR_LENGTH_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_VECTOR_LENGTH), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1618, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1618, __FUNCTION__)))
\
1619 OMP_CLAUSE_OPERAND ( \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_VECTOR_LENGTH), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1620, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1620, __FUNCTION__)))
1620 OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR_LENGTH), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_VECTOR_LENGTH), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1620, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1620, __FUNCTION__)))
1621
1622#define OMP_CLAUSE_DEPEND_KIND(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEPEND), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1622, __FUNCTION__))->omp_clause.subcode.depend_kind)
\
1623 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEPEND)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEPEND), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1623, __FUNCTION__))
->omp_clause.subcode.depend_kind)
1624
1625#define OMP_CLAUSE_DEPEND_SINK_NEGATIVE(NODE)(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1625, __FUNCTION__, (TREE_LIST))))->base.public_flag)
\
1626 TREE_PUBLIC (TREE_LIST_CHECK (NODE))(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1626, __FUNCTION__, (TREE_LIST))))->base.public_flag)
1627
1628#define OMP_CLAUSE_MAP_KIND(NODE)((enum gomp_map_kind) (omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1628, __FUNCTION__))->omp_clause.subcode.map_kind)
\
1629 ((enum gomp_map_kind) OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1629, __FUNCTION__))
->omp_clause.subcode.map_kind)
1630#define OMP_CLAUSE_SET_MAP_KIND(NODE, MAP_KIND)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1630, __FUNCTION__))->omp_clause.subcode.map_kind = (unsigned
int) (MAP_KIND))
\
1631 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1631, __FUNCTION__))
->omp_clause.subcode.map_kind \
1632 = (unsigned int) (MAP_KIND))
1633
1634/* Nonzero if this map clause is for array (rather than pointer) based array
1635 section with zero bias. Both the non-decl OMP_CLAUSE_MAP and corresponding
1636 OMP_CLAUSE_MAP with GOMP_MAP_POINTER are marked with this flag. */
1637#define OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1637, __FUNCTION__))->base.public_flag)
\
1638 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1638, __FUNCTION__))
->base.public_flag)
1639/* Nonzero if this is a mapped array section, that might need special
1640 treatment if OMP_CLAUSE_SIZE is zero. */
1641#define OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1641, __FUNCTION__)))->base.protected_flag)
\
1642 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1642, __FUNCTION__)))->base.protected_flag)
1643/* Nonzero if this map clause is for an OpenACC compute construct's reduction
1644 variable. */
1645#define OMP_CLAUSE_MAP_IN_REDUCTION(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1645, __FUNCTION__)))->base.private_flag)
\
1646 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_MAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1646, __FUNCTION__)))->base.private_flag)
1647
1648/* True on an OMP_CLAUSE_USE_DEVICE_PTR with an OpenACC 'if_present'
1649 clause. */
1650#define OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_USE_DEVICE_PTR
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1650, __FUNCTION__))->base.public_flag)
\
1651 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USE_DEVICE_PTR)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_USE_DEVICE_PTR
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1651, __FUNCTION__))
->base.public_flag)
1652
1653#define OMP_CLAUSE_PROC_BIND_KIND(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_PROC_BIND), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1653, __FUNCTION__))->omp_clause.subcode.proc_bind_kind)
\
1654 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PROC_BIND)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_PROC_BIND), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1654, __FUNCTION__))
->omp_clause.subcode.proc_bind_kind)
1655
1656#define OMP_CLAUSE_DEVICE_TYPE_KIND(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEVICE_TYPE),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1656, __FUNCTION__))->omp_clause.subcode.device_type_kind
)
\
1657 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE_TYPE)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEVICE_TYPE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1657, __FUNCTION__))
->omp_clause.subcode.device_type_kind)
1658
1659#define OMP_CLAUSE_COLLAPSE_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_COLLAPSE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1659, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1659, __FUNCTION__)))
\
1660 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_COLLAPSE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1660, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1660, __FUNCTION__)))
1661#define OMP_CLAUSE_COLLAPSE_ITERVAR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_COLLAPSE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1661, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1661, __FUNCTION__)))
\
1662 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 1)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_COLLAPSE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1662, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1662, __FUNCTION__)))
1663#define OMP_CLAUSE_COLLAPSE_COUNT(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_COLLAPSE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1663, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1663, __FUNCTION__)))
\
1664 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 2)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_COLLAPSE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1664, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1664, __FUNCTION__)))
1665
1666#define OMP_CLAUSE_ORDERED_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_ORDERED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1666, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1666, __FUNCTION__)))
\
1667 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_ORDERED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1667, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1667, __FUNCTION__)))
1668
1669#define OMP_CLAUSE_REDUCTION_CODE(NODE)((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION), (OMP_CLAUSE_IN_REDUCTION
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1669, __FUNCTION__))->omp_clause.subcode.reduction_code)
\
1670 (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \(omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION), (OMP_CLAUSE_IN_REDUCTION
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1671, __FUNCTION__))
1671 OMP_CLAUSE_IN_REDUCTION)(omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION), (OMP_CLAUSE_IN_REDUCTION
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1671, __FUNCTION__))
->omp_clause.subcode.reduction_code)
1672#define OMP_CLAUSE_REDUCTION_INIT(NODE)(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1672, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1672, __FUNCTION__)))
\
1673 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1674, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1674, __FUNCTION__)))
1674 OMP_CLAUSE_IN_REDUCTION), 1)(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1674, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1674, __FUNCTION__)))
1675#define OMP_CLAUSE_REDUCTION_MERGE(NODE)(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1675, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1675, __FUNCTION__)))
\
1676 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1677, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1677, __FUNCTION__)))
1677 OMP_CLAUSE_IN_REDUCTION), 2)(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1677, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1677, __FUNCTION__)))
1678#define OMP_CLAUSE_REDUCTION_GIMPLE_INIT(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1678, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.gimple_reduction_init
\
1679 (OMP_CLAUSE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1679, __FUNCTION__, (OMP_CLAUSE)))
)->omp_clause.gimple_reduction_init
1680#define OMP_CLAUSE_REDUCTION_GIMPLE_MERGE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1680, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.gimple_reduction_merge
\
1681 (OMP_CLAUSE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1681, __FUNCTION__, (OMP_CLAUSE)))
)->omp_clause.gimple_reduction_merge
1682#define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE)(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1682, __FUNCTION__))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1682, __FUNCTION__)))
\
1683 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1684, __FUNCTION__))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1684, __FUNCTION__)))
1684 OMP_CLAUSE_IN_REDUCTION), 3)(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1684, __FUNCTION__))), (3), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1684, __FUNCTION__)))
1685#define OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER(NODE)(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1685, __FUNCTION__))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1685, __FUNCTION__)))
\
1686 OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1687, __FUNCTION__))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1687, __FUNCTION__)))
1687 OMP_CLAUSE_IN_REDUCTION), 4)(*(omp_clause_elt_check (((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION
), (OMP_CLAUSE_IN_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1687, __FUNCTION__))), (4), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1687, __FUNCTION__)))
1688
1689/* True if a REDUCTION clause may reference the original list item (omp_orig)
1690 in its OMP_CLAUSE_REDUCTION_{,GIMPLE_}INIT. */
1691#define OMP_CLAUSE_REDUCTION_OMP_ORIG_REF(NODE)((omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION), (OMP_CLAUSE_IN_REDUCTION
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1691, __FUNCTION__))->base.public_flag)
\
1692 (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \(omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION), (OMP_CLAUSE_IN_REDUCTION
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1693, __FUNCTION__))
1693 OMP_CLAUSE_IN_REDUCTION)(omp_clause_range_check ((NODE), (OMP_CLAUSE_REDUCTION), (OMP_CLAUSE_IN_REDUCTION
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1693, __FUNCTION__))
->base.public_flag)
1694
1695/* True if a REDUCTION clause has task reduction-modifier. */
1696#define OMP_CLAUSE_REDUCTION_TASK(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1696, __FUNCTION__)))->base.protected_flag)
\
1697 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1697, __FUNCTION__)))->base.protected_flag)
1698
1699/* True if a REDUCTION clause has inscan reduction-modifier. */
1700#define OMP_CLAUSE_REDUCTION_INSCAN(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1700, __FUNCTION__)))->base.private_flag)
\
1701 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_REDUCTION), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1701, __FUNCTION__)))->base.private_flag)
1702
1703/* True if a LINEAR clause doesn't need copy in. True for iterator vars which
1704 are always initialized inside of the loop construct, false otherwise. */
1705#define OMP_CLAUSE_LINEAR_NO_COPYIN(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1705, __FUNCTION__))->base.public_flag)
\
1706 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1706, __FUNCTION__))
->base.public_flag)
1707
1708/* True if a LINEAR clause doesn't need copy out. True for iterator vars which
1709 are declared inside of the simd construct. */
1710#define OMP_CLAUSE_LINEAR_NO_COPYOUT(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1710, __FUNCTION__)))->base.private_flag)
\
1711 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1711, __FUNCTION__)))->base.private_flag)
1712
1713/* True if a LINEAR clause has a stride that is variable. */
1714#define OMP_CLAUSE_LINEAR_VARIABLE_STRIDE(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1714, __FUNCTION__)))->base.protected_flag)
\
1715 TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1715, __FUNCTION__)))->base.protected_flag)
1716
1717/* True if a LINEAR clause is for an array or allocatable variable that
1718 needs special handling by the frontend. */
1719#define OMP_CLAUSE_LINEAR_ARRAY(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1719, __FUNCTION__))->base.deprecated_flag)
\
1720 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1720, __FUNCTION__))
->base.deprecated_flag)
1721
1722#define OMP_CLAUSE_LINEAR_STEP(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1722, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1722, __FUNCTION__)))
\
1723 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 1)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1723, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1723, __FUNCTION__)))
1724
1725#define OMP_CLAUSE_LINEAR_STMT(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1725, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1725, __FUNCTION__)))
\
1726 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 2)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1726, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1726, __FUNCTION__)))
1727
1728#define OMP_CLAUSE_LINEAR_GIMPLE_SEQ(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1728, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.gimple_reduction_init
\
1729 (OMP_CLAUSE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1729, __FUNCTION__, (OMP_CLAUSE)))
)->omp_clause.gimple_reduction_init
1730
1731#define OMP_CLAUSE_LINEAR_KIND(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1731, __FUNCTION__))->omp_clause.subcode.linear_kind)
\
1732 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_LINEAR), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1732, __FUNCTION__))
->omp_clause.subcode.linear_kind)
1733
1734#define OMP_CLAUSE_ALIGNED_ALIGNMENT(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_ALIGNED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1734, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1734, __FUNCTION__)))
\
1735 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALIGNED), 1)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_ALIGNED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1735, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1735, __FUNCTION__)))
1736
1737#define OMP_CLAUSE_ALLOCATE_ALLOCATOR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_ALLOCATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1737, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1737, __FUNCTION__)))
\
1738 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 1)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_ALLOCATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1738, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1738, __FUNCTION__)))
1739
1740/* True if an ALLOCATE clause was present on a combined or composite
1741 construct and the code for splitting the clauses has already performed
1742 checking if the listed variable has explicit privatization on the
1743 construct. */
1744#define OMP_CLAUSE_ALLOCATE_COMBINED(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_ALLOCATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1744, __FUNCTION__))->base.public_flag)
\
1745 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_ALLOCATE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1745, __FUNCTION__))
->base.public_flag)
1746
1747#define OMP_CLAUSE_NUM_TEAMS_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_TEAMS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1747, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1747, __FUNCTION__)))
\
1748 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_NUM_TEAMS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1748, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1748, __FUNCTION__)))
1749
1750#define OMP_CLAUSE_THREAD_LIMIT_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_THREAD_LIMIT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1750, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1750, __FUNCTION__)))
\
1751 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_THREAD_LIMIT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1752, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1752, __FUNCTION__)))
1752 OMP_CLAUSE_THREAD_LIMIT), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_THREAD_LIMIT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1752, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1752, __FUNCTION__)))
1753
1754#define OMP_CLAUSE_DEVICE_ID(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_DEVICE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1754, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1754, __FUNCTION__)))
\
1755 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_DEVICE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1755, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1755, __FUNCTION__)))
1756
1757#define OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_DIST_SCHEDULE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1757, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1757, __FUNCTION__)))
\
1758 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_DIST_SCHEDULE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1759, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1759, __FUNCTION__)))
1759 OMP_CLAUSE_DIST_SCHEDULE), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_DIST_SCHEDULE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1759, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1759, __FUNCTION__)))
1760
1761#define OMP_CLAUSE_SAFELEN_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_SAFELEN), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1761, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1761, __FUNCTION__)))
\
1762 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SAFELEN), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_SAFELEN), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1762, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1762, __FUNCTION__)))
1763
1764#define OMP_CLAUSE_SIMDLEN_EXPR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_SIMDLEN), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1764, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1764, __FUNCTION__)))
\
1765 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIMDLEN), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_SIMDLEN), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1765, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1765, __FUNCTION__)))
1766
1767#define OMP_CLAUSE__SIMDUID__DECL(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE__SIMDUID_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1767, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1767, __FUNCTION__)))
\
1768 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SIMDUID_), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE__SIMDUID_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1768, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1768, __FUNCTION__)))
1769
1770#define OMP_CLAUSE_SCHEDULE_KIND(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_SCHEDULE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1770, __FUNCTION__))->omp_clause.subcode.schedule_kind)
\
1771 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_SCHEDULE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1771, __FUNCTION__))
->omp_clause.subcode.schedule_kind)
1772
1773/* True if a SCHEDULE clause has the simd modifier on it. */
1774#define OMP_CLAUSE_SCHEDULE_SIMD(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_SCHEDULE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1774, __FUNCTION__))->base.public_flag)
\
1775 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_SCHEDULE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1775, __FUNCTION__))
->base.public_flag)
1776
1777#define OMP_CLAUSE_DEFAULT_KIND(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEFAULT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1777, __FUNCTION__))->omp_clause.subcode.default_kind)
\
1778 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEFAULT), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1778, __FUNCTION__))
->omp_clause.subcode.default_kind)
1779
1780#define OMP_CLAUSE_DEFAULTMAP_KIND(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEFAULTMAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1780, __FUNCTION__))->omp_clause.subcode.defaultmap_kind
)
\
1781 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULTMAP)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEFAULTMAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1781, __FUNCTION__))
->omp_clause.subcode.defaultmap_kind)
1782#define OMP_CLAUSE_DEFAULTMAP_CATEGORY(NODE)((enum omp_clause_defaultmap_kind) (((omp_clause_subcode_check
((NODE), (OMP_CLAUSE_DEFAULTMAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1782, __FUNCTION__))->omp_clause.subcode.defaultmap_kind
) & OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK))
\
1783 ((enum omp_clause_defaultmap_kind) \
1784 (OMP_CLAUSE_DEFAULTMAP_KIND (NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEFAULTMAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1784, __FUNCTION__))->omp_clause.subcode.defaultmap_kind
)
& OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK))
1785#define OMP_CLAUSE_DEFAULTMAP_BEHAVIOR(NODE)((enum omp_clause_defaultmap_kind) (((omp_clause_subcode_check
((NODE), (OMP_CLAUSE_DEFAULTMAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1785, __FUNCTION__))->omp_clause.subcode.defaultmap_kind
) & OMP_CLAUSE_DEFAULTMAP_MASK))
\
1786 ((enum omp_clause_defaultmap_kind) \
1787 (OMP_CLAUSE_DEFAULTMAP_KIND (NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEFAULTMAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1787, __FUNCTION__))->omp_clause.subcode.defaultmap_kind
)
& OMP_CLAUSE_DEFAULTMAP_MASK))
1788#define OMP_CLAUSE_DEFAULTMAP_SET_KIND(NODE, BEHAVIOR, CATEGORY)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEFAULTMAP),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1788, __FUNCTION__))->omp_clause.subcode.defaultmap_kind
) = (enum omp_clause_defaultmap_kind) (CATEGORY | BEHAVIOR))
\
1789 (OMP_CLAUSE_DEFAULTMAP_KIND (NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_DEFAULTMAP), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1789, __FUNCTION__))->omp_clause.subcode.defaultmap_kind
)
\
1790 = (enum omp_clause_defaultmap_kind) (CATEGORY | BEHAVIOR))
1791
1792#define OMP_CLAUSE_BIND_KIND(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE_BIND), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1792, __FUNCTION__))->omp_clause.subcode.bind_kind)
\
1793 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_BIND)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE_BIND), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1793, __FUNCTION__))
->omp_clause.subcode.bind_kind)
1794
1795#define OMP_CLAUSE_TILE_LIST(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_TILE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1795, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1795, __FUNCTION__)))
\
1796 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 0)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_TILE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1796, __FUNCTION__))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1796, __FUNCTION__)))
1797#define OMP_CLAUSE_TILE_ITERVAR(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_TILE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1797, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1797, __FUNCTION__)))
\
1798 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 1)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_TILE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1798, __FUNCTION__))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1798, __FUNCTION__)))
1799#define OMP_CLAUSE_TILE_COUNT(NODE)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_TILE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1799, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1799, __FUNCTION__)))
\
1800 OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 2)(*(omp_clause_elt_check (((omp_clause_subcode_check ((NODE), (
OMP_CLAUSE_TILE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1800, __FUNCTION__))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1800, __FUNCTION__)))
1801
1802/* _CONDTEMP_ holding temporary with iteration count. */
1803#define OMP_CLAUSE__CONDTEMP__ITER(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE__CONDTEMP_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1803, __FUNCTION__))->base.public_flag)
\
1804 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CONDTEMP_)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE__CONDTEMP_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1804, __FUNCTION__))
->base.public_flag)
1805
1806/* _SCANTEMP_ holding temporary with pointer to thread's local array;
1807 allocation. */
1808#define OMP_CLAUSE__SCANTEMP__ALLOC(NODE)((omp_clause_subcode_check ((NODE), (OMP_CLAUSE__SCANTEMP_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1808, __FUNCTION__))->base.public_flag)
\
1809 (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_)(omp_clause_subcode_check ((NODE), (OMP_CLAUSE__SCANTEMP_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1809, __FUNCTION__))
->base.public_flag)
1810
1811/* _SCANTEMP_ holding temporary with a control variable for deallocation;
1812 one boolean_type_node for test whether alloca was used, another one
1813 to pass to __builtin_stack_restore or free. */
1814#define OMP_CLAUSE__SCANTEMP__CONTROL(NODE)(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE__SCANTEMP_),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1814, __FUNCTION__)))->base.private_flag)
\
1815 TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_))(((omp_clause_subcode_check ((NODE), (OMP_CLAUSE__SCANTEMP_),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1815, __FUNCTION__)))->base.private_flag)
1816
1817/* SSA_NAME accessors. */
1818
1819/* Whether SSA_NAME NODE is a virtual operand. This simply caches the
1820 information in the underlying SSA_NAME_VAR for efficiency. */
1821#define SSA_NAME_IS_VIRTUAL_OPERAND(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1821, __FUNCTION__, (SSA_NAME)))->base.public_flag
\
1822 SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1822, __FUNCTION__, (SSA_NAME)))
->base.public_flag
1823
1824/* Returns the IDENTIFIER_NODE giving the SSA name a name or NULL_TREE
1825 if there is no name associated with it. */
1826#define SSA_NAME_IDENTIFIER(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1826, __FUNCTION__, (SSA_NAME)))->ssa_name.var != (tree)
nullptr ? (((enum tree_code) ((NODE)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (NODE)->ssa_name.var : ((contains_struct_check
(((NODE)->ssa_name.var), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1826, __FUNCTION__))->decl_minimal.name)) : (tree) nullptr
)
\
1827 (SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1827, __FUNCTION__, (SSA_NAME)))
->ssa_name.var != NULL_TREE(tree) nullptr \
1828 ? (TREE_CODE ((NODE)->ssa_name.var)((enum tree_code) ((NODE)->ssa_name.var)->base.code) == IDENTIFIER_NODE \
1829 ? (NODE)->ssa_name.var \
1830 : DECL_NAME ((NODE)->ssa_name.var)((contains_struct_check (((NODE)->ssa_name.var), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1830, __FUNCTION__))->decl_minimal.name)
) \
1831 : NULL_TREE(tree) nullptr)
1832
1833/* Returns the variable being referenced. This can be NULL_TREE for
1834 temporaries not associated with any user variable.
1835 Once released, this is the only field that can be relied upon. */
1836#define SSA_NAME_VAR(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1836, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
nullptr || ((enum tree_code) ((NODE)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (NODE)->ssa_name
.var)
\
1837 (SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1837, __FUNCTION__, (SSA_NAME)))
->ssa_name.var == NULL_TREE(tree) nullptr \
1838 || TREE_CODE ((NODE)->ssa_name.var)((enum tree_code) ((NODE)->ssa_name.var)->base.code) == IDENTIFIER_NODE \
1839 ? NULL_TREE(tree) nullptr : (NODE)->ssa_name.var)
1840
1841#define SET_SSA_NAME_VAR_OR_IDENTIFIER(NODE,VAR)do { tree var_ = (VAR); (tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1841, __FUNCTION__, (SSA_NAME)))->ssa_name.var = var_; (
tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1841, __FUNCTION__, (SSA_NAME)))->base.public_flag = (var_
&& ((enum tree_code) (var_)->base.code) == VAR_DECL
&& ((tree_check ((var_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1841, __FUNCTION__, (VAR_DECL)))->base.u.bits.saturating_flag
)); } while (0)
\
1842 do \
1843 { \
1844 tree var_ = (VAR); \
1845 SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1845, __FUNCTION__, (SSA_NAME)))
->ssa_name.var = var_; \
1846 SSA_NAME_IS_VIRTUAL_OPERAND (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1846, __FUNCTION__, (SSA_NAME)))->base.public_flag
\
1847 = (var_ \
1848 && TREE_CODE (var_)((enum tree_code) (var_)->base.code) == VAR_DECL \
1849 && VAR_DECL_IS_VIRTUAL_OPERAND (var_)((tree_check ((var_), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1849, __FUNCTION__, (VAR_DECL)))->base.u.bits.saturating_flag
)
); \
1850 } \
1851 while (0)
1852
1853/* Returns the statement which defines this SSA name. */
1854#define SSA_NAME_DEF_STMT(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1854, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1854, __FUNCTION__, (SSA_NAME)))
->ssa_name.def_stmt
1855
1856/* Returns the SSA version number of this SSA name. Note that in
1857 tree SSA, version numbers are not per variable and may be recycled. */
1858#define SSA_NAME_VERSION(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1858, __FUNCTION__, (SSA_NAME)))->base.u.version
SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1858, __FUNCTION__, (SSA_NAME)))
->base.u.version
1859
1860/* Nonzero if this SSA name occurs in an abnormal PHI. SSA_NAMES are
1861 never output, so we can safely use the ASM_WRITTEN_FLAG for this
1862 status bit. */
1863#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1863, __FUNCTION__, (SSA_NAME)))->base.asm_written_flag
\
1864 SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1864, __FUNCTION__, (SSA_NAME)))
->base.asm_written_flag
1865
1866/* Nonzero if this SSA_NAME expression is currently on the free list of
1867 SSA_NAMES. Using NOTHROW_FLAG seems reasonably safe since throwing
1868 has no meaning for an SSA_NAME. */
1869#define SSA_NAME_IN_FREE_LIST(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1869, __FUNCTION__, (SSA_NAME)))->base.nothrow_flag
\
1870 SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1870, __FUNCTION__, (SSA_NAME)))
->base.nothrow_flag
1871
1872/* Nonzero if this SSA_NAME is the default definition for the
1873 underlying symbol. A default SSA name is created for symbol S if
1874 the very first reference to S in the function is a read operation.
1875 Default definitions are always created by an empty statement and
1876 belong to no basic block. */
1877#define SSA_NAME_IS_DEFAULT_DEF(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1877, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
\
1878 SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1878, __FUNCTION__, (SSA_NAME)))
->base.default_def_flag
1879
1880/* Nonzero if this SSA_NAME is known to point to memory that may not
1881 be written to. This is set for default defs of function parameters
1882 that have a corresponding r or R specification in the functions
1883 fn spec attribute. This is used by alias analysis. */
1884#define SSA_NAME_POINTS_TO_READONLY_MEMORY(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1884, __FUNCTION__, (SSA_NAME)))->base.deprecated_flag
\
1885 SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1885, __FUNCTION__, (SSA_NAME)))
->base.deprecated_flag
1886
1887/* Attributes for SSA_NAMEs for pointer-type variables. */
1888#define SSA_NAME_PTR_INFO(N)(tree_check ((N), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1888, __FUNCTION__, (SSA_NAME)))->ssa_name.info.ptr_info
\
1889 SSA_NAME_CHECK (N)(tree_check ((N), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1889, __FUNCTION__, (SSA_NAME)))
->ssa_name.info.ptr_info
1890
1891/* True if SSA_NAME_RANGE_INFO describes an anti-range. */
1892#define SSA_NAME_ANTI_RANGE_P(N)(tree_check ((N), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1892, __FUNCTION__, (SSA_NAME)))->base.static_flag
\
1893 SSA_NAME_CHECK (N)(tree_check ((N), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1893, __FUNCTION__, (SSA_NAME)))
->base.static_flag
1894
1895/* The type of range described by SSA_NAME_RANGE_INFO. */
1896#define SSA_NAME_RANGE_TYPE(N)((tree_check ((N), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1896, __FUNCTION__, (SSA_NAME)))->base.static_flag ? VR_ANTI_RANGE
: VR_RANGE)
\
1897 (SSA_NAME_ANTI_RANGE_P (N)(tree_check ((N), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1897, __FUNCTION__, (SSA_NAME)))->base.static_flag
? VR_ANTI_RANGE : VR_RANGE)
1898
1899/* Value range info attributes for SSA_NAMEs of non pointer-type variables. */
1900#define SSA_NAME_RANGE_INFO(N)(tree_check ((N), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1900, __FUNCTION__, (SSA_NAME)))->ssa_name.info.range_info
\
1901 SSA_NAME_CHECK (N)(tree_check ((N), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1901, __FUNCTION__, (SSA_NAME)))
->ssa_name.info.range_info
1902
1903/* Return the immediate_use information for an SSA_NAME. */
1904#define SSA_NAME_IMM_USE_NODE(NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1904, __FUNCTION__, (SSA_NAME)))->ssa_name.imm_uses
SSA_NAME_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1904, __FUNCTION__, (SSA_NAME)))
->ssa_name.imm_uses
1905
1906#define OMP_CLAUSE_CODE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1906, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.code
\
1907 (OMP_CLAUSE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1907, __FUNCTION__, (OMP_CLAUSE)))
)->omp_clause.code
1908
1909#define OMP_CLAUSE_SET_CODE(NODE, CODE)(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1909, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.code = (
CODE))
\
1910 ((OMP_CLAUSE_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1910, __FUNCTION__, (OMP_CLAUSE)))
)->omp_clause.code = (CODE))
1911
1912#define OMP_CLAUSE_OPERAND(NODE, I)(*(omp_clause_elt_check ((NODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1912, __FUNCTION__)))
\
1913 OMP_CLAUSE_ELT_CHECK (NODE, I)(*(omp_clause_elt_check ((NODE), (I), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1913, __FUNCTION__)))
1914
1915/* In a BLOCK node. */
1916#define BLOCK_VARS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1916, __FUNCTION__, (BLOCK)))->block.vars)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1916, __FUNCTION__, (BLOCK)))
->block.vars)
1917#define BLOCK_NONLOCALIZED_VARS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1917, __FUNCTION__, (BLOCK)))->block.nonlocalized_vars)
\
1918 (BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1918, __FUNCTION__, (BLOCK)))
->block.nonlocalized_vars)
1919#define BLOCK_NUM_NONLOCALIZED_VARS(NODE)vec_safe_length (((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1919, __FUNCTION__, (BLOCK)))->block.nonlocalized_vars))
\
1920 vec_safe_length (BLOCK_NONLOCALIZED_VARS (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1920, __FUNCTION__, (BLOCK)))->block.nonlocalized_vars)
)
1921#define BLOCK_NONLOCALIZED_VAR(NODE,N)(*((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1921, __FUNCTION__, (BLOCK)))->block.nonlocalized_vars))
[N]
(*BLOCK_NONLOCALIZED_VARS (NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1921, __FUNCTION__, (BLOCK)))->block.nonlocalized_vars)
)[N]
1922#define BLOCK_SUBBLOCKS(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1922, __FUNCTION__, (BLOCK)))->block.subblocks)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1922, __FUNCTION__, (BLOCK)))
->block.subblocks)
1923#define BLOCK_SUPERCONTEXT(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1923, __FUNCTION__, (BLOCK)))->block.supercontext)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1923, __FUNCTION__, (BLOCK)))
->block.supercontext)
1924#define BLOCK_CHAIN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1924, __FUNCTION__, (BLOCK)))->block.chain)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1924, __FUNCTION__, (BLOCK)))
->block.chain)
1925#define BLOCK_ABSTRACT_ORIGIN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1925, __FUNCTION__, (BLOCK)))->block.abstract_origin)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1925, __FUNCTION__, (BLOCK)))
->block.abstract_origin)
1926#define BLOCK_ORIGIN(NODE)(((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1926, __FUNCTION__, (BLOCK)))->block.abstract_origin) ? (
(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1926, __FUNCTION__, (BLOCK)))->block.abstract_origin) : (
NODE))
\
1927 (BLOCK_ABSTRACT_ORIGIN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1927, __FUNCTION__, (BLOCK)))->block.abstract_origin)
? BLOCK_ABSTRACT_ORIGIN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1927, __FUNCTION__, (BLOCK)))->block.abstract_origin)
: (NODE))
1928#define BLOCK_DIE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1928, __FUNCTION__, (BLOCK)))->block.die)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1928, __FUNCTION__, (BLOCK)))
->block.die)
1929
1930/* True if BLOCK has the same ranges as its BLOCK_SUPERCONTEXT. */
1931#define BLOCK_SAME_RANGE(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1931, __FUNCTION__, (BLOCK)))->base.u.bits.nameless_flag
)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1931, __FUNCTION__, (BLOCK)))
->base.u.bits.nameless_flag)
1932
1933/* True if BLOCK appears in cold section. */
1934#define BLOCK_IN_COLD_SECTION_P(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1934, __FUNCTION__, (BLOCK)))->base.u.bits.atomic_flag)
\
1935 (BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1935, __FUNCTION__, (BLOCK)))
->base.u.bits.atomic_flag)
1936
1937/* An index number for this block. These values are not guaranteed to
1938 be unique across functions -- whether or not they are depends on
1939 the debugging output format in use. */
1940#define BLOCK_NUMBER(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1940, __FUNCTION__, (BLOCK)))->block.block_num)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1940, __FUNCTION__, (BLOCK)))
->block.block_num)
1941
1942/* If block reordering splits a lexical block into discontiguous
1943 address ranges, we'll make a copy of the original block.
1944
1945 Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
1946 In that case, we have one source block that has been replicated
1947 (through inlining or unrolling) into many logical blocks, and that
1948 these logical blocks have different physical variables in them.
1949
1950 In this case, we have one logical block split into several
1951 non-contiguous address ranges. Most debug formats can't actually
1952 represent this idea directly, so we fake it by creating multiple
1953 logical blocks with the same variables in them. However, for those
1954 that do support non-contiguous regions, these allow the original
1955 logical block to be reconstructed, along with the set of address
1956 ranges.
1957
1958 One of the logical block fragments is arbitrarily chosen to be
1959 the ORIGIN. The other fragments will point to the origin via
1960 BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
1961 be null. The list of fragments will be chained through
1962 BLOCK_FRAGMENT_CHAIN from the origin. */
1963
1964#define BLOCK_FRAGMENT_ORIGIN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1964, __FUNCTION__, (BLOCK)))->block.fragment_origin)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1964, __FUNCTION__, (BLOCK)))
->block.fragment_origin)
1965#define BLOCK_FRAGMENT_CHAIN(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1965, __FUNCTION__, (BLOCK)))->block.fragment_chain)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1965, __FUNCTION__, (BLOCK)))
->block.fragment_chain)
1966
1967/* For an inlined function, this gives the location where it was called
1968 from. This is only set in the top level block, which corresponds to the
1969 inlined function scope. This is used in the debug output routines. */
1970
1971#define BLOCK_SOURCE_LOCATION(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1971, __FUNCTION__, (BLOCK)))->block.locus)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1971, __FUNCTION__, (BLOCK)))
->block.locus)
1972
1973/* This gives the location of the end of the block, useful to attach
1974 code implicitly generated for outgoing paths. */
1975
1976#define BLOCK_SOURCE_END_LOCATION(NODE)((tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1976, __FUNCTION__, (BLOCK)))->block.end_locus)
(BLOCK_CHECK (NODE)(tree_check ((NODE), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1976, __FUNCTION__, (BLOCK)))
->block.end_locus)
1977
1978/* Define fields and accessors for nodes representing data types. */
1979
1980/* See tree.def for documentation of the use of these fields.
1981 Look at the documentation of the various ..._TYPE tree codes.
1982
1983 Note that the type.values, type.minval, and type.maxval fields are
1984 overloaded and used for different macros in different kinds of types.
1985 Each macro must check to ensure the tree node is of the proper kind of
1986 type. Note also that some of the front-ends also overload these fields,
1987 so they must be checked as well. */
1988
1989#define TYPE_UID(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1989, __FUNCTION__))->type_common.uid)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1989, __FUNCTION__))
->type_common.uid)
1990/* Type size in bits as a tree expression. Need not be constant and may
1991 be greater than TYPE_SIZE for a C++ FIELD_DECL representing a base
1992 class subobject with its own virtual base classes (which are laid out
1993 separately). */
1994#define TYPE_SIZE(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1994, __FUNCTION__))->type_common.size)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1994, __FUNCTION__))
->type_common.size)
1995/* Likewise, type size in bytes. */
1996#define TYPE_SIZE_UNIT(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1996, __FUNCTION__))->type_common.size_unit)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1996, __FUNCTION__))
->type_common.size_unit)
1997#define TYPE_POINTER_TO(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1997, __FUNCTION__))->type_common.pointer_to)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1997, __FUNCTION__))
->type_common.pointer_to)
1998#define TYPE_REFERENCE_TO(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1998, __FUNCTION__))->type_common.reference_to)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1998, __FUNCTION__))
->type_common.reference_to)
1999#define TYPE_PRECISION(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1999, __FUNCTION__))->type_common.precision)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 1999, __FUNCTION__))
->type_common.precision)
2000#define TYPE_NAME(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2000, __FUNCTION__))->type_common.name)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2000, __FUNCTION__))
->type_common.name)
2001#define TYPE_NEXT_VARIANT(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2001, __FUNCTION__))->type_common.next_variant)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2001, __FUNCTION__))
->type_common.next_variant)
2002#define TYPE_MAIN_VARIANT(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2002, __FUNCTION__))->type_common.main_variant)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2002, __FUNCTION__))
->type_common.main_variant)
2003#define TYPE_CONTEXT(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2003, __FUNCTION__))->type_common.context)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2003, __FUNCTION__))
->type_common.context)
2004
2005#define TYPE_MODE_RAW(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2005, __FUNCTION__))->type_common.mode)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2005, __FUNCTION__))
->type_common.mode)
2006#define TYPE_MODE(NODE)((((enum tree_code) ((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2006, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(NODE) : (NODE)->type_common.mode)
\
2007 (VECTOR_TYPE_P (TYPE_CHECK (NODE))(((enum tree_code) ((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2007, __FUNCTION__)))->base.code) == VECTOR_TYPE)
\
2008 ? vector_type_mode (NODE) : (NODE)->type_common.mode)
2009#define SCALAR_TYPE_MODE(NODE)(as_a <scalar_mode> ((tree_class_check ((NODE), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2009, __FUNCTION__))->type_common.mode))
\
2010 (as_a <scalar_mode> (TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2010, __FUNCTION__))
->type_common.mode))
2011#define SCALAR_INT_TYPE_MODE(NODE)(as_a <scalar_int_mode> ((tree_class_check ((NODE), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2011, __FUNCTION__))->type_common.mode))
\
2012 (as_a <scalar_int_mode> (TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2012, __FUNCTION__))
->type_common.mode))
2013#define SCALAR_FLOAT_TYPE_MODE(NODE)(as_a <scalar_float_mode> ((tree_class_check ((NODE), (
tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2013, __FUNCTION__))->type_common.mode))
\
2014 (as_a <scalar_float_mode> (TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2014, __FUNCTION__))
->type_common.mode))
2015#define SET_TYPE_MODE(NODE, MODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2015, __FUNCTION__))->type_common.mode = (MODE))
\
2016 (TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2016, __FUNCTION__))
->type_common.mode = (MODE))
2017
2018extern machine_mode element_mode (const_tree);
2019extern machine_mode vector_type_mode (const_tree);
2020extern unsigned int vector_element_bits (const_tree);
2021extern tree vector_element_bits_tree (const_tree);
2022
2023/* The "canonical" type for this type node, which is used by frontends to
2024 compare the type for equality with another type. If two types are
2025 equal (based on the semantics of the language), then they will have
2026 equivalent TYPE_CANONICAL entries.
2027
2028 As a special case, if TYPE_CANONICAL is NULL_TREE, and thus
2029 TYPE_STRUCTURAL_EQUALITY_P is true, then it cannot
2030 be used for comparison against other types. Instead, the type is
2031 said to require structural equality checks, described in
2032 TYPE_STRUCTURAL_EQUALITY_P.
2033
2034 For unqualified aggregate and function types the middle-end relies on
2035 TYPE_CANONICAL to tell whether two variables can be assigned
2036 to each other without a conversion. The middle-end also makes sure
2037 to assign the same alias-sets to the type partition with equal
2038 TYPE_CANONICAL of their unqualified variants. */
2039#define TYPE_CANONICAL(NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2039, __FUNCTION__))->type_common.canonical)
(TYPE_CHECK (NODE)(tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2039, __FUNCTION__))
->type_common.canonical)
2040/* Indicates that the type node requires structural equality
2041 checks. The compiler will need to look at the composition of the
2042 type to determine whether it is equal to another type, rather than
2043 just comparing canonical type pointers. For instance, we would need
2044 to look at the return and parameter types of a FUNCTION_TYPE
2045 node. */
2046#define TYPE_STRUCTURAL_EQUALITY_P(NODE)(((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2046, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
(TYPE_CANONICAL (NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2046, __FUNCTION__))->type_common.canonical)
== NULL_TREE(tree) nullptr)
2047/* Sets the TYPE_CANONICAL field to NULL_TREE, indicating that the
2048 type node requires structural equality. */
2049#define SET_TYPE_STRUCTURAL_EQUALITY(NODE)(((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2049, __FUNCTION__))->type_common.canonical) = (tree) nullptr
)
(TYPE_CANONICAL (NODE)((tree_class_check ((NODE), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2049, __FUNCTION__))->type_common.canonical)
= NULL_TREE(tree) nullptr)
2050
2051#define TYPE_IBIT(NODE)(mode_ibit[((((enum tree_code) ((tree_class_check ((NODE), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2051, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(NODE) : (NODE)->type_common.mode)])
(GET_MODE_IBIT (TYPE_MODE (NODE))mode_ibit[((((enum tree_code) ((tree_class_check ((NODE), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree.h"
, 2051, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(NODE) : (NODE)->type_common.mode)]
)
2052#define TYPE_FBIT(NODE)(mode_fbit[((((enum tree_code) ((tree_class_check ((NODE), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-st