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

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

Show analyzer invocation

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
 Copyright (C) 2010-2021 Free Software Foundation, Inc.
 Contributed by Jan Hubicka  <jh@suse.cz>

5This file is part of GCC.

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.

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.

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/>.  */

21/* The purpose of this pass is to split function bodies to improve
 inlining.  I.e. for function of the form:

 func (...)
   {
     if (cheap_test)
something_small
     else
something_big
   }

 Produce:

 func.part (...)
   {
something_big
   }

 func (...)
   {
     if (cheap_test)
something_small
     else
func.part (...);
   }

 When func becomes inlinable and when cheap_test is often true, inlining func,
 but not fund.part leads to performance improvement similar as inlining
 original func while the code size growth is smaller.

 The pass is organized in three stages:
 1) Collect local info about basic block into BB_INFO structure and
    compute function body estimated size and time.
 2) Via DFS walk find all possible basic blocks where we can split
    and chose best one.
 3) If split point is found, split at the specified BB by creating a clone
    and updating function to call it.  

 The decisions what functions to split are in execute_split_functions
 and consider_split.  

 There are several possible future improvements for this pass including:

 1) Splitting to break up large functions
 2) Splitting to reduce stack frame usage
 3) Allow split part of function to use values computed in the header part.
    The values needs to be passed to split function, perhaps via same
    interface as for nested functions or as argument.
 4) Support for simple rematerialization.  I.e. when split part use
    value computed in header from function parameter in very cheap way, we
    can just recompute it.
 5) Support splitting of nested functions.
 6) Support non-SSA arguments.  
 7) There is nothing preventing us from producing multiple parts of single function
    when needed or splitting also the parts.  */

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"

108/* Per basic block info.  */

110class split_bb_info
111{
112public:
unsigned int size;
sreal time;
115};

117static vec<split_bb_info> bb_info_vec;

119/* Description of split point.  */

121class split_point
122{
123public:
/* Size of the partitions.  */
sreal header_time, split_time;
unsigned int header_size, split_size;

/* SSA names that need to be passed into spit function.  */
bitmap ssa_names_to_pass;

/* Basic block where we split (that will become entry point of new function.  */
basic_block entry_bb;

/* Count for entering the split part.
   This is not count of the entry_bb because it may be in loop.  */
profile_count count;

/* Basic blocks we are splitting away.  */
bitmap split_bbs;

/* True when return value is computed on split part and thus it needs
   to be returned.  */
bool split_part_set_retval;
144};

146/* Best split point found.  */

148class split_point best_split_point;

150/* Set of basic blocks that are not allowed to dominate a split point.  */

152static bitmap forbidden_dominators;

154static tree find_retval (basic_block return_bb);

156/* Callback for walk_stmt_load_store_addr_ops.  If T is non-SSA automatic
 variable, check it if it is present in bitmap passed via DATA.  */

159static bool
160test_nonssa_use (gimple *, tree t, tree, void *data)
161{
t = get_base_address (t);

if (!t || is_gimple_reg (t))
  return false;

if (TREE_CODE (t)((enum tree_code) (t)->base.code) == PARM_DECL
    || (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL)
 && auto_var_in_fn_p (t, current_function_decl))
    || TREE_CODE (t)((enum tree_code) (t)->base.code) == RESULT_DECL
/* Normal labels are part of CFG and will be handled gratefully.
   Forced labels however can be used directly by statements and
   need to stay in one partition along with their uses.  */
    || (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"
, 175, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
)))
  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));

/* For DECL_BY_REFERENCE, the return value is actually a pointer.  We want
   to pretend that the value pointed to is actual result decl.  */
if ((TREE_CODE (t)((enum tree_code) (t)->base.code) == MEM_REF || INDIRECT_REF_P (t)(((enum tree_code) (t)->base.code) == INDIRECT_REF))
    && 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
    && 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)
    && 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
    && 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))
  return
    bitmap_bit_p ((bitmap)data,
    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));

return false;
190}

192/* Dump split point CURRENT.  */

194static void
195dump_split_point (FILE * file, class split_point *current)
196{
fprintf (file,
  "Split point at BB %i\n"
  "  header time: %f header size: %i\n"
  "  split time: %f split size: %i\n  bbs: ",
  current->entry_bb->index, current->header_time.to_double (),
  current->header_size, current->split_time.to_double (),
  current->split_size);
dump_bitmap (file, current->split_bbs);
fprintf (file, "  SSA names to pass: ");
dump_bitmap (file, current->ssa_names_to_pass);
207}

209/* Look for all BBs in header that might lead to the split part and verify
 that they are not defining any non-SSA var used by the split part.
 Parameters are the same as for consider_split.  */

213static bool
214verify_non_ssa_vars (class split_point *current, bitmap non_ssa_vars,
     basic_block return_bb)
216{
bitmap seen = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
vec<basic_block> worklist = vNULL;
edge e;
edge_iterator ei;
bool ok = true;
basic_block bb;

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)))
  if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
&& !bitmap_bit_p (current->split_bbs, e->src->index))
    {
      worklist.safe_push (e->src);
bitmap_set_bit (seen, e->src->index);
    }

while (!worklist.is_empty ())
  {
    bb = worklist.pop ();
    FOR_EACH_EDGE (e, ei, bb->preds)for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
   && bitmap_set_bit (seen, e->src->index))
 {
   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))
			        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));
   worklist.safe_push (e->src);
 }
    for (gimple_stmt_iterator bsi = gsi_start_bb (bb); !gsi_end_p (bsi);
  gsi_next (&bsi))
{
 gimple *stmt = gsi_stmt (bsi);
 if (is_gimple_debug (stmt))
   continue;
 if (walk_stmt_load_store_addr_ops
     (stmt, non_ssa_vars, test_nonssa_use, test_nonssa_use,
      test_nonssa_use))
   {
     ok = false;
     goto done;
   }
 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
   if (test_nonssa_use (stmt, gimple_label_label (label_stmt),
		 NULL_TREE(tree) nullptr, non_ssa_vars))
     {
ok = false;
goto done;
     }
}
    for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
  gsi_next (&bsi))
{
 if (walk_stmt_load_store_addr_ops
     (gsi_stmt (bsi), non_ssa_vars, test_nonssa_use, test_nonssa_use,
      test_nonssa_use))
   {
     ok = false;
     goto done;
   }
}
    FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
{
 if (e->dest != return_bb)
   continue;
 for (gphi_iterator bsi = gsi_start_phis (return_bb);
      !gsi_end_p (bsi);
      gsi_next (&bsi))
   {
     gphi *stmt = bsi.phi ();
     tree op = gimple_phi_arg_def (stmt, e->dest_idx);

     if (virtual_operand_p (gimple_phi_result (stmt)))
continue;
     if (TREE_CODE (op)((enum tree_code) (op)->base.code) != SSA_NAME
  && test_nonssa_use (stmt, op, op, non_ssa_vars))
{
  ok = false;
  goto done;
}
   }
}
  }

/* Verify that the rest of function does not define any label
   used by the split part.  */
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)
  if (!bitmap_bit_p (current->split_bbs, bb->index)
&& !bitmap_bit_p (seen, bb->index))
    {
      gimple_stmt_iterator bsi;
      for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 if (glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (bsi)))
   {
     if (test_nonssa_use (label_stmt,
		   gimple_label_label (label_stmt),
		   NULL_TREE(tree) nullptr, non_ssa_vars))
{
  ok = false;
  goto done;
}
   }
 else
   break;
    }
  
320done:
BITMAP_FREE (seen)((void) (bitmap_obstack_free ((bitmap) seen), (seen) = (bitmap
) nullptr));
worklist.release ();
return ok;
324}

326/* If STMT is a call, check the callee against a list of forbidden
 predicate functions.  If a match is found, look for uses of the
 call result in condition statements that compare against zero.
 For each such use, find the block targeted by the condition
 statement for the nonzero result, and set the bit for this block
 in the forbidden dominators bitmap.  The purpose of this is to avoid
 selecting a split point where we are likely to lose the chance
 to optimize away an unused function call.  */

335static void
336check_forbidden_calls (gimple *stmt)
337{
imm_use_iterator use_iter;
use_operand_p use_p;
tree lhs;

/* At the moment, __builtin_constant_p is the only forbidden
   predicate function call (see PR49642).  */
if (!gimple_call_builtin_p (stmt, BUILT_IN_CONSTANT_P))
  return;

lhs = gimple_call_lhs (stmt);

if (!lhs || TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) != SSA_NAME)
  return;

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))))
  {
    tree op1;
    basic_block use_bb, forbidden_bb;
    enum tree_code code;
    edge true_edge, false_edge;
    gcond *use_stmt;

    use_stmt = dyn_cast <gcond *> (USE_STMT (use_p)(use_p)->loc.stmt);
    if (!use_stmt)
continue;

    /* Assuming canonical form for GIMPLE_COND here, with constant
in second position.  */
    op1 = gimple_cond_rhs (use_stmt);
    code = gimple_cond_code (use_stmt);
    use_bb = gimple_bb (use_stmt);

    extract_true_false_edges_from_block (use_bb, &true_edge, &false_edge);

    /* We're only interested in comparisons that distinguish
unambiguously from zero.  */
    if (!integer_zerop (op1) || code == LE_EXPR || code == GE_EXPR)
continue;

    if (code == EQ_EXPR)
forbidden_bb = false_edge->dest;
    else
forbidden_bb = true_edge->dest;

    bitmap_set_bit (forbidden_dominators, forbidden_bb->index);
  }
384}

386/* If BB is dominated by any block in the forbidden dominators set,
 return TRUE; else FALSE.  */

389static bool
390dominated_by_forbidden (basic_block bb)
391{
unsigned dom_bb;
bitmap_iterator bi;

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)))
  {
    if (dominated_by_p (CDI_DOMINATORS, bb,
	  BASIC_BLOCK_FOR_FN (cfun, dom_bb)((*(((cfun + 0))->cfg->x_basic_block_info))[(dom_bb)])))
return true;
  }

return false;
403}

405/* For give split point CURRENT and return block RETURN_BB return 1
 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,
	   basic_block return_bb)
410{
if (TREE_CODE (val)((enum tree_code) (val)->base.code) != SSA_NAME)
  return false;

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
 && (bitmap_bit_p (current->split_bbs,
	    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)
     || 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}

420/* We found an split_point CURRENT.  NON_SSA_VARS is bitmap of all non ssa
 variables used and RETURN_BB is return basic block.
 See if we can split function here.  */

424static void
425consider_split (class split_point *current, bitmap non_ssa_vars,
basic_block return_bb)
427{
tree parm;
unsigned int num_args = 0;
unsigned int call_overhead;
edge e;
edge_iterator ei;
gphi_iterator bsi;
unsigned int i;
tree retval;
bool back_edge = false;

if (dump_file && (dump_flags & TDF_DETAILS))
  dump_split_point (dump_file, current);

current->count = profile_count::zero ();
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)))
  {
    if (e->flags & EDGE_DFS_BACK)
back_edge = true;
    if (!bitmap_bit_p (current->split_bbs, e->src->index))
current->count += e->count ();
  }

/* Do not split when we would end up calling function anyway.
   Compares are three state, use !(...<...) to also give up when outcome
   is unknown.  */
if (!(current->count
     < (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count.apply_scale
  (param_partial_inlining_entry_probabilityglobal_options.x_param_partial_inlining_entry_probability, 100))))
  {
    /* When profile is guessed, we cannot expect it to give us
realistic estimate on likeliness of function taking the
complex path.  As a special case, when tail of the function is
a loop, enable splitting since inlining code skipping the loop
is likely noticeable win.  */
    if (back_edge
 && profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) != PROFILE_READ
 && current->count
 < ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count)
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   {
     fprintf (dump_file,
       "  Split before loop, accepting despite low counts");
     current->count.dump (dump_file);
     fprintf (dump_file, " ");
     ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->count.dump (dump_file);
   }
}
    else
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file,
     "  Refused: incoming frequency is too large.\n");
 return;
}
  }

if (!current->header_size)
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "  Refused: header empty\n");
    return;
  }

/* Verify that PHI args on entry are either virtual or all their operands
   incoming from header are the same.  */
for (bsi = gsi_start_phis (current->entry_bb); !gsi_end_p (bsi); gsi_next (&bsi))
  {
    gphi *stmt = bsi.phi ();
    tree val = NULLnullptr;

    if (virtual_operand_p (gimple_phi_result (stmt)))
continue;
    for (i = 0; i < gimple_phi_num_args (stmt); i++)
{
 edge e = gimple_phi_arg_edge (stmt, i);
 if (!bitmap_bit_p (current->split_bbs, e->src->index))
   {
     tree edge_val = gimple_phi_arg_def (stmt, i);
     if (val && edge_val != val)
       {
  if (dump_file && (dump_flags & TDF_DETAILS))
    fprintf (dump_file,
	     "  Refused: entry BB has PHI with multiple variants\n");
  return;
       }
     val = edge_val;
   }
}
  }


/* See what argument we will pass to the split function and compute
   call overhead.  */
call_overhead = eni_size_weights.call_cost;
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;
     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)))
  {
    if (!is_gimple_reg (parm))
{
 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)))
   {
     if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
	 "  Refused: need to pass non-ssa param values\n");
     return;
   }
}
    else
{
 tree ddef = ssa_default_def (cfun(cfun + 0), parm);
 if (ddef
     && bitmap_bit_p (current->ssa_names_to_pass,
	       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))
   {
     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
))
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);
     num_args++;
   }
}
  }
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
))
  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),
			 false);

if (current->split_size <= call_overhead)
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
 "  Refused: split size is smaller than call overhead\n");
    return;
  }
/* FIXME: The logic here is not very precise, because inliner does use
   inline predicates to reduce function body size.  We add 10 to anticipate
   that.  Next stage1 we should try to be more meaningful here.  */
if (current->header_size + call_overhead
    >= (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
)
	? param_max_inline_insns_singleglobal_options.x_param_max_inline_insns_single
	: param_max_inline_insns_autoglobal_options.x_param_max_inline_insns_auto) + 10)
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
 "  Refused: header size is too large for inline candidate\n");
    return;
  }

/* Splitting functions brings the target out of comdat group; this will
   lead to code duplication if the function is reused by other unit.
   Limit this duplication.  This is consistent with limit in tree-sra.c  
   FIXME: with LTO we ought to be able to do better!  */
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)))
    && current->split_size >= (unsigned int) param_max_inline_insns_autoglobal_options.x_param_max_inline_insns_auto + 10)
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
 "  Refused: function is COMDAT and tail is too large\n");
    return;
  }
/* For comdat functions also reject very small tails; those will likely get
   inlined back and we do not want to risk the duplication overhead.
   FIXME: with LTO we ought to be able to do better!  */
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)))
    && current->split_size
<= (unsigned int) param_early_inlining_insnsglobal_options.x_param_early_inlining_insns / 2)
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
 "  Refused: function is COMDAT and tail is too small\n");
    return;
  }

/* FIXME: we currently can pass only SSA function parameters to the split
   arguments.  Once parm_adjustment infrastructure is supported by cloning,
   we can pass more than that.  */
if (num_args != bitmap_count_bits (current->ssa_names_to_pass))
  {
    
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
 "  Refused: need to pass non-param values\n");
    return;
  }

/* When there are non-ssa vars used in the split region, see if they
   are used in the header region.  If so, reject the split.
   FIXME: we can use nested function support to access both.  */
if (!bitmap_empty_p (non_ssa_vars)
    && !verify_non_ssa_vars (current, non_ssa_vars, return_bb))
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
 "  Refused: split part has non-ssa uses\n");
    return;
  }

/* If the split point is dominated by a forbidden block, reject
   the split.  */
if (!bitmap_empty_p (forbidden_dominators)
    && dominated_by_forbidden (current->entry_bb))
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
 "  Refused: split point dominated by forbidden block\n");
    return;
  }

/* See if retval used by return bb is computed by header or split part.
   When it is computed by split part, we need to produce return statement
   in the split part and add code to header to pass it around.

   This is bit tricky to test:
     1) When there is no return_bb or no return value, we always pass
        value around.
     2) Invariants are always computed by caller.
     3) For SSA we need to look if defining statement is in header or split part
     4) For non-SSA we need to look where the var is computed. */
retval = find_retval (return_bb);
if (!retval)
  {
    /* If there is a return_bb with no return value in function returning
value by reference, also make the split part return void, otherwise
we expansion would try to create a non-POD temporary, which is
invalid.  */
    if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
 && 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
)
 && 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))
current->split_part_set_retval = false;
    else
current->split_part_set_retval = true;
  }
else if (is_gimple_min_invariant (retval))
  current->split_part_set_retval = false;
/* Special case is value returned by reference we record as if it was non-ssa
   set to result_decl.  */
else if (TREE_CODE (retval)((enum tree_code) (retval)->base.code) == SSA_NAME
  && 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)
  && 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
  && 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))
  current->split_part_set_retval
     = 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));
else if (TREE_CODE (retval)((enum tree_code) (retval)->base.code) == SSA_NAME)
  current->split_part_set_retval
    = split_part_set_ssa_name_p (retval, current, return_bb);
else if (TREE_CODE (retval)((enum tree_code) (retval)->base.code) == PARM_DECL)
  current->split_part_set_retval = false;
else if (VAR_P (retval)(((enum tree_code) (retval)->base.code) == VAR_DECL)
  || TREE_CODE (retval)((enum tree_code) (retval)->base.code) == RESULT_DECL)
  current->split_part_set_retval
    = 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));
else
  current->split_part_set_retval = true;

/* split_function fixes up at most one PHI non-virtual PHI node in return_bb,
   for the return value.  If there are other PHIs, give up.  */
if (return_bb != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  {
    gphi_iterator psi;

    for (psi = gsi_start_phis (return_bb); !gsi_end_p (psi); gsi_next (&psi))
if (!virtual_operand_p (gimple_phi_result (psi.phi ()))
   && !(retval
 && current->split_part_set_retval
 && TREE_CODE (retval)((enum tree_code) (retval)->base.code) == SSA_NAME
 && !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)
 && 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 ()))
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file,
       "  Refused: return bb has extra PHIs\n");
   return;
 }
  }

if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file, "  Accepted!\n");

/* At the moment chose split point with lowest count and that leaves
   out smallest size of header.
   In future we might re-consider this heuristics.  */
if (!best_split_point.split_bbs
    || best_split_point.count
> current->count
    || (best_split_point.count == current->count 
 && best_split_point.split_size < current->split_size))

  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "  New best split point!\n");
    if (best_split_point.ssa_names_to_pass)
{
 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));
 BITMAP_FREE (best_split_point.split_bbs)((void) (bitmap_obstack_free ((bitmap) best_split_point.split_bbs
), (best_split_point.split_bbs) = (bitmap) nullptr));
}
    best_split_point = *current;
    best_split_point.ssa_names_to_pass = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
    bitmap_copy (best_split_point.ssa_names_to_pass,
   current->ssa_names_to_pass);
    best_split_point.split_bbs = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
    bitmap_copy (best_split_point.split_bbs, current->split_bbs);
  }
728}

730/* Return basic block containing RETURN statement.  We allow basic blocks
 of the form:
 <retval> = tmp_var;
 return <retval>
 but return_bb cannot be more complex than this (except for
 -fsanitize=thread we allow TSAN_FUNC_EXIT () internal call in there).
 If nothing is found, return the exit block.

 When there are multiple RETURN statement, chose one with return value,
 since that one is more likely shared by multiple code paths.

 Return BB is special, because for function splitting it is the only
 basic block that is duplicated in between header and split part of the
 function.

 TODO: We might support multiple return blocks.  */

747static basic_block
748find_return_bb (void)
749{
edge e;
basic_block return_bb = EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr);
gimple_stmt_iterator bsi;
bool found_return = false;
tree retval = NULL_TREE(tree) nullptr;

if (!single_pred_p (EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)))
  return return_bb;

e = single_pred_edge (EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr));
for (bsi = gsi_last_bb (e->src); !gsi_end_p (bsi); gsi_prev (&bsi))
  {
    gimple *stmt = gsi_stmt (bsi);
    if (gimple_code (stmt) == GIMPLE_LABEL
 || is_gimple_debug (stmt)
 || gimple_clobber_p (stmt))
;
    else if (gimple_code (stmt) == GIMPLE_ASSIGN
      && found_return
      && gimple_assign_single_p (stmt)
      && (auto_var_in_fn_p (gimple_assign_rhs1 (stmt),
		     current_function_decl)
   || is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
      && retval == gimple_assign_lhs (stmt))
;
    else if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
{
 found_return = true;
 retval = gimple_return_retval (return_stmt);
}
    /* For -fsanitize=thread, allow also TSAN_FUNC_EXIT () in the return
bb.  */
    else if ((flag_sanitizeglobal_options.x_flag_sanitize & SANITIZE_THREAD)
      && gimple_call_internal_p (stmt, IFN_TSAN_FUNC_EXIT))
;
    else
break;
  }
if (gsi_end_p (bsi) && found_return)
  return_bb = e->src;

return return_bb;
792}

794/* Given return basic block RETURN_BB, see where return value is really
 stored.  */
796static tree
797find_retval (basic_block return_bb)
798{
gimple_stmt_iterator bsi;
for (bsi = gsi_start_bb (return_bb); !gsi_end_p (bsi); gsi_next (&bsi))
  if (greturn *return_stmt = dyn_cast <greturn *> (gsi_stmt (bsi)))
    return gimple_return_retval (return_stmt);
  else if (gimple_code (gsi_stmt (bsi)) == GIMPLE_ASSIGN
    && !gimple_clobber_p (gsi_stmt (bsi)))
    return gimple_assign_rhs1 (gsi_stmt (bsi));
return NULLnullptr;
807}

809/* Callback for walk_stmt_load_store_addr_ops.  If T is non-SSA automatic
 variable, mark it as used in bitmap passed via DATA.
 Return true when access to T prevents splitting the function.  */

813static bool
814mark_nonssa_use (gimple *, tree t, tree, void *data)
815{
t = get_base_address (t);

if (!t || is_gimple_reg (t))
  return false;

/* At present we can't pass non-SSA arguments to split function.
   FIXME: this can be relaxed by passing references to arguments.  */
if (TREE_CODE (t)((enum tree_code) (t)->base.code) == PARM_DECL)
  {
    if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
 "Cannot split: use of non-ssa function parameter.\n");
    return true;
  }

if ((VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL) && auto_var_in_fn_p (t, current_function_decl))
    || TREE_CODE (t)((enum tree_code) (t)->base.code) == RESULT_DECL
    || (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
)))
  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));

/* For DECL_BY_REFERENCE, the return value is actually a pointer.  We want
   to pretend that the value pointed to is actual result decl.  */
if ((TREE_CODE (t)((enum tree_code) (t)->base.code) == MEM_REF || INDIRECT_REF_P (t)(((enum tree_code) (t)->base.code) == INDIRECT_REF))
    && 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
    && 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)
    && 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
    && 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))
  return
    bitmap_bit_p ((bitmap)data,
    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));

return false;
848}

850/* Compute local properties of basic block BB we collect when looking for
 split points.  We look for ssa defs and store them in SET_SSA_NAMES,
 for ssa uses and store them in USED_SSA_NAMES and for any non-SSA automatic
 vars stored in NON_SSA_VARS.

 When BB has edge to RETURN_BB, collect uses in RETURN_BB too.  

 Return false when BB contains something that prevents it from being put into
 split function.  */

860static bool
861visit_bb (basic_block bb, basic_block return_bb,
 bitmap set_ssa_names, bitmap used_ssa_names,
 bitmap non_ssa_vars)
864{
edge e;
edge_iterator ei;
bool can_split = true;

for (gimple_stmt_iterator bsi = gsi_start_bb (bb); !gsi_end_p (bsi);
     gsi_next (&bsi))
  {
    gimple *stmt = gsi_stmt (bsi);
    tree op;
    ssa_op_iter iter;
    tree decl;

    if (is_gimple_debug (stmt))
continue;

    if (gimple_clobber_p (stmt))
continue;

    /* FIXME: We can split regions containing EH.  We cannot however
split RESX, EH_DISPATCH and EH_POINTER referring to same region
into different partitions.  This would require tracking of
EH regions and checking in consider_split_point if they 
are not used elsewhere.  */
    if (gimple_code (stmt) == GIMPLE_RESX)
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, "Cannot split: resx.\n");
 can_split = false;
}
    if (gimple_code (stmt) == GIMPLE_EH_DISPATCH)
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, "Cannot split: eh dispatch.\n");
 can_split = false;
}

    /* Check builtins that prevent splitting.  */
    if (gimple_code (stmt) == GIMPLE_CALL
 && (decl = gimple_call_fndecl (stmt)) != NULL_TREE(tree) nullptr
 && fndecl_built_in_p (decl, BUILT_IN_NORMAL))
switch (DECL_FUNCTION_CODE (decl))
 {
 /* FIXME: once we will allow passing non-parm values to split part,
    we need to be sure to handle correct builtin_stack_save and
    builtin_stack_restore.  At the moment we are safe; there is no
    way to store builtin_stack_save result in non-SSA variable
    since all calls to those are compiler generated.  */
 case BUILT_IN_APPLY:
 case BUILT_IN_APPLY_ARGS:
 case BUILT_IN_VA_START:
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file,
       "Cannot split: builtin_apply and va_start.\n");
   can_split = false;
   break;
 case BUILT_IN_EH_POINTER:
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "Cannot split: builtin_eh_pointer.\n");
   can_split = false;
   break;
 default:
   break;
 }

    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)))
)
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);
    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)))
)
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);
    can_split &= !walk_stmt_load_store_addr_ops (stmt, non_ssa_vars,
				   mark_nonssa_use,
				   mark_nonssa_use,
				   mark_nonssa_use);
  }
for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
     gsi_next (&bsi))
  {
    gphi *stmt = bsi.phi ();
    unsigned int i;

    if (virtual_operand_p (gimple_phi_result (stmt)))
continue;
    bitmap_set_bit (set_ssa_names,
      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);
    for (i = 0; i < gimple_phi_num_args (stmt); i++)
{
 tree op = gimple_phi_arg_def (stmt, i);
 if (TREE_CODE (op)((enum tree_code) (op)->base.code) == SSA_NAME)
   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);
}
    can_split &= !walk_stmt_load_store_addr_ops (stmt, non_ssa_vars,
				   mark_nonssa_use,
				   mark_nonssa_use,
				   mark_nonssa_use);
  }
/* Record also uses coming from PHI operand in return BB.  */
FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
  if (e->dest == return_bb)
    {
for (gphi_iterator bsi = gsi_start_phis (return_bb);
    !gsi_end_p (bsi);
    gsi_next (&bsi))
 {
   gphi *stmt = bsi.phi ();
   tree op = gimple_phi_arg_def (stmt, e->dest_idx);

   if (virtual_operand_p (gimple_phi_result (stmt)))
     continue;
   if (TREE_CODE (op)((enum tree_code) (op)->base.code) == SSA_NAME)
     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);
   else
     can_split &= !mark_nonssa_use (stmt, op, op, non_ssa_vars);
 }
    }
return can_split;
979}

981/* Stack entry for recursive DFS walk in find_split_point.  */

983class stack_entry
984{
985public:
/* Basic block we are examining.  */
basic_block bb;

/* SSA names set and used by the BB and all BBs reachable
   from it via DFS walk.  */
bitmap set_ssa_names, used_ssa_names;
bitmap non_ssa_vars;

/* All BBS visited from this BB via DFS walk.  */
bitmap bbs_visited;

/* Last examined edge in DFS walk.  Since we walk unoriented graph,
   the value is up to sum of incoming and outgoing edges of BB.  */
unsigned int edge_num;

/* Stack entry index of earliest BB reachable from current BB
   or any BB visited later in DFS walk.  */
int earliest;

/* Overall time and size of all BBs reached from this BB in DFS walk.  */
sreal overall_time;
int overall_size;

/* When false we cannot split on this BB.  */
bool can_split;
1011};


1014/* Find all articulations and call consider_split on them.
 OVERALL_TIME and OVERALL_SIZE is time and size of the function.

 We perform basic algorithm for finding an articulation in a graph
 created from CFG by considering it to be an unoriented graph.

 The articulation is discovered via DFS walk. We collect earliest
 basic block on stack that is reachable via backward edge.  Articulation
 is any basic block such that there is no backward edge bypassing it.
 To reduce stack usage we maintain heap allocated stack in STACK vector.
 AUX pointer of BB is set to index it appears in the stack or -1 once
 it is visited and popped off the stack.

 The algorithm finds articulation after visiting the whole component
 reachable by it.  This makes it convenient to collect information about
 the component used by consider_split.  */

1031static void
1032find_split_points (basic_block return_bb, sreal overall_time, int overall_size)
1033{
stack_entry first;
vec<stack_entry> stack = vNULL;
basic_block bb;
class split_point current;

current.header_time = overall_time;
current.header_size = overall_size;
current.split_time = 0;
current.split_size = 0;
current.ssa_names_to_pass = BITMAP_ALLOCbitmap_alloc (NULLnullptr);

first.bb = ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr);
first.edge_num = 0;
first.overall_time = 0;
first.overall_size = 0;
first.earliest = INT_MAX2147483647;
first.set_ssa_names = 0;
first.used_ssa_names = 0;
first.non_ssa_vars = 0;
first.bbs_visited = 0;
first.can_split = false;
stack.safe_push (first);
ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->aux = (void *)(intptr_t)-1;

while (!stack.is_empty ())
  {
    stack_entry *entry = &stack.last ();

    /* We are walking an acyclic graph, so edge_num counts
succ and pred edges together.  However when considering
       articulation, we want to have processed everything reachable
from articulation but nothing that reaches into it.  */
    if (entry->edge_num == EDGE_COUNT (entry->bb->succs)vec_safe_length (entry->bb->succs)
 && entry->bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr))
{
 int pos = stack.length ();
 entry->can_split &= visit_bb (entry->bb, return_bb,
			entry->set_ssa_names,
			entry->used_ssa_names,
			entry->non_ssa_vars);
 if (pos <= entry->earliest && !entry->can_split
     && dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file,
     "found articulation at bb %i but cannot split\n",
     entry->bb->index);
 if (pos <= entry->earliest && entry->can_split)
    {
      if (dump_file && (dump_flags & TDF_DETAILS))
 fprintf (dump_file, "found articulation at bb %i\n",
	  entry->bb->index);
      current.entry_bb = entry->bb;
      current.ssa_names_to_pass = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
      bitmap_and_compl (current.ssa_names_to_pass,
		 entry->used_ssa_names, entry->set_ssa_names);
      current.header_time = overall_time - entry->overall_time;
      current.header_size = overall_size - entry->overall_size;
      current.split_time = entry->overall_time;
      current.split_size = entry->overall_size;
      current.split_bbs = entry->bbs_visited;
      consider_split (&current, entry->non_ssa_vars, return_bb);
      BITMAP_FREE (current.ssa_names_to_pass)((void) (bitmap_obstack_free ((bitmap) current.ssa_names_to_pass
), (current.ssa_names_to_pass) = (bitmap) nullptr));
    }
}
    /* Do actual DFS walk.  */
    if (entry->edge_num
 < (EDGE_COUNT (entry->bb->succs)vec_safe_length (entry->bb->succs)
    + EDGE_COUNT (entry->bb->preds)vec_safe_length (entry->bb->preds)))
{
        edge e;
 basic_block dest;
 if (entry->edge_num < EDGE_COUNT (entry->bb->succs)vec_safe_length (entry->bb->succs))
   {
     e = EDGE_SUCC (entry->bb, entry->edge_num)(*(entry->bb)->succs)[(entry->edge_num)];
     dest = e->dest;
   }
 else
   {
     e = EDGE_PRED (entry->bb, entry->edge_num(*(entry->bb)->preds)[(entry->edge_num - vec_safe_length
 (entry->bb->succs))]
	     - EDGE_COUNT (entry->bb->succs))(*(entry->bb)->preds)[(entry->edge_num - vec_safe_length
 (entry->bb->succs))];
     dest = e->src;
   }

 entry->edge_num++;

 /* New BB to visit, push it to the stack.  */
 if (dest != return_bb && dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
     && !dest->aux)
   {
     stack_entry new_entry;

     new_entry.bb = dest;
     new_entry.edge_num = 0;
     new_entry.overall_time
 = bb_info_vec[dest->index].time;
     new_entry.overall_size
 = bb_info_vec[dest->index].size;
     new_entry.earliest = INT_MAX2147483647;
     new_entry.set_ssa_names = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
     new_entry.used_ssa_names = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
     new_entry.bbs_visited = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
     new_entry.non_ssa_vars = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
     new_entry.can_split = true;
     bitmap_set_bit (new_entry.bbs_visited, dest->index);
     stack.safe_push (new_entry);
     dest->aux = (void *)(intptr_t)stack.length ();
   }
 /* Back edge found, record the earliest point.  */
 else if ((intptr_t)dest->aux > 0
   && (intptr_t)dest->aux < entry->earliest)
   entry->earliest = (intptr_t)dest->aux;
}
    /* We are done with examining the edges.  Pop off the value from stack
and merge stuff we accumulate during the walk.  */
    else if (entry->bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr))
{
 stack_entry *prev = &stack[stack.length () - 2];

 entry->bb->aux = (void *)(intptr_t)-1;
 prev->can_split &= entry->can_split;
 if (prev->set_ssa_names)
   {
     bitmap_ior_into (prev->set_ssa_names, entry->set_ssa_names);
     bitmap_ior_into (prev->used_ssa_names, entry->used_ssa_names);
     bitmap_ior_into (prev->bbs_visited, entry->bbs_visited);
     bitmap_ior_into (prev->non_ssa_vars, entry->non_ssa_vars);
   }
 if (prev->earliest > entry->earliest)
   prev->earliest = entry->earliest;
 prev->overall_time += entry->overall_time;
 prev->overall_size += entry->overall_size;
 BITMAP_FREE (entry->set_ssa_names)((void) (bitmap_obstack_free ((bitmap) entry->set_ssa_names
), (entry->set_ssa_names) = (bitmap) nullptr));
 BITMAP_FREE (entry->used_ssa_names)((void) (bitmap_obstack_free ((bitmap) entry->used_ssa_names
), (entry->used_ssa_names) = (bitmap) nullptr));
 BITMAP_FREE (entry->bbs_visited)((void) (bitmap_obstack_free ((bitmap) entry->bbs_visited)
, (entry->bbs_visited) = (bitmap) nullptr));
 BITMAP_FREE (entry->non_ssa_vars)((void) (bitmap_obstack_free ((bitmap) entry->non_ssa_vars
), (entry->non_ssa_vars) = (bitmap) nullptr));
 stack.pop ();
}
    else
      stack.pop ();
  }
ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)->aux = NULLnullptr;
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)
  bb->aux = NULLnullptr;
stack.release ();
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}

1180/* Split function at SPLIT_POINT.  */

1182static void
1183split_function (basic_block return_bb, class split_point *split_point,
bool add_tsan_func_exit)
1185{
vec<tree> args_to_pass = vNULL;
bitmap args_to_skip;
tree parm;
int num = 0;
cgraph_node *node, *cur_node = cgraph_node::get (current_function_decl);
basic_block call_bb;
gcall *call, *tsan_func_exit_call = NULLnullptr;
edge e;
edge_iterator ei;
tree retval = NULLnullptr, real_retval = NULLnullptr;
gimple *last_stmt = NULLnullptr;
unsigned int i;
tree arg, ddef;

if (dump_file)
1
Assuming 'dump_file' is null→
2
←
Taking false branch→
  {
    fprintf (dump_file, "\n\nSplitting function at:\n");
    dump_split_point (dump_file, split_point);
  }

if (cur_node->can_change_signature)
3
←
Assuming field 'can_change_signature' is 0→
4
←
Taking false branch→
  args_to_skip = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
else
  args_to_skip = NULLnullptr;

/* Collect the parameters of new function and args_to_skip bitmap.  */
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→
     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++)
  if (args_to_skip
&& (!is_gimple_reg (parm)
   || (ddef = ssa_default_def (cfun(cfun + 0), parm)) == NULL_TREE(tree) nullptr
   || !bitmap_bit_p (split_point->ssa_names_to_pass,
	      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)))
    bitmap_set_bit (args_to_skip, num);
  else
    {
/* This parm might not have been used up to now, but is going to be
  used, hence register it.  */
if (is_gimple_reg (parm))
 arg = get_or_create_ssa_default_def (cfun(cfun + 0), parm);
else
 arg = parm;

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)))
 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);
args_to_pass.safe_push (arg);
    }

/* See if the split function will return.  */
bool split_part_return_p = false;
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→
  {
    if (bitmap_bit_p (split_point->split_bbs, e->src->index))
split_part_return_p = true;
  }

/* Add return block to what will become the split function.
   We do not return; no return block is needed.  */
if (!split_part_return_p6.1
'split_part_return_p' is false
1
'split_part_return_p' is false
1
'split_part_return_p' is false
)
7
←
Taking true branch→
  ;
/* We have no return block, so nothing is needed.  */
else if (return_bb == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  ;
/* When we do not want to return value, we need to construct
   new return block with empty return statement.
   FIXME: Once we are able to change return type, we should change function
   to return void instead of just outputting function with undefined return
   value.  For structures this affects quality of codegen.  */
else if ((retval = find_retval (return_bb))
  && !split_point->split_part_set_retval)
  {
    bool redirected = true;
    basic_block new_return_bb = create_basic_block (NULLnullptr, 0, return_bb);
    gimple_stmt_iterator gsi = gsi_start_bb (new_return_bb);
    gsi_insert_after (&gsi, gimple_build_return (NULLnullptr), GSI_NEW_STMT);
    new_return_bb->count = profile_count::zero ();
    while (redirected)
{
 redirected = false;
 FOR_EACH_EDGE (e, ei, return_bb->preds)for ((ei) = ei_start_1 (&((return_bb->preds))); ei_cond
 ((ei), &(e)); ei_next (&(ei)))
   if (bitmap_bit_p (split_point->split_bbs, e->src->index))
     {
new_return_bb->count += e->count ();
redirect_edge_and_branch (e, new_return_bb);
redirected = true;
break;
     }
}
    e = make_single_succ_edge (new_return_bb, EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr), 0);
    add_bb_to_loop (new_return_bb, current_loops((cfun + 0)->x_current_loops)->tree_root);
    bitmap_set_bit (split_point->split_bbs, new_return_bb->index);
  }
/* When we pass around the value, use existing return block.  */
else
  bitmap_set_bit (split_point->split_bbs, return_bb->index);

/* If RETURN_BB has virtual operand PHIs, they must be removed and the
   virtual operand marked for renaming as we change the CFG in a way that
   tree-inline is not able to compensate for.

   Note this can happen whether or not we have a return value.  If we have
   a return value, then RETURN_BB may have PHIs for real operands too.  */
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→
  {
    bool phi_p = false;
    for (gphi_iterator gsi = gsi_start_phis (return_bb);
  !gsi_end_p (gsi);)
{
 gphi *stmt = gsi.phi ();
 if (!virtual_operand_p (gimple_phi_result (stmt)))
   {
     gsi_next (&gsi);
     continue;
   }
 mark_virtual_phi_result_for_renaming (stmt);
 remove_phi_node (&gsi, true);
 phi_p = true;
}
    /* In reality we have to rename the reaching definition of the
virtual operand at return_bb as we will eventually release it
when we remove the code region we outlined.
So we have to rename all immediate virtual uses of that region
if we didn't see a PHI definition yet.  */
    /* ???  In real reality we want to set the reaching vdef of the
       entry of the SESE region as the vuse of the call and the reaching
vdef of the exit of the SESE region as the vdef of the call.  */
    if (!phi_p)
for (gimple_stmt_iterator gsi = gsi_start_bb (return_bb);
    !gsi_end_p (gsi);
    gsi_next (&gsi))
 {
   gimple *stmt = gsi_stmt (gsi);
   if (gimple_vuse (stmt))
     {
gimple_set_vuse (stmt, NULL_TREE(tree) nullptr);
update_stmt (stmt);
     }
   if (gimple_vdef (stmt))
     break;
 }
  }

ipa_param_adjustments *adjustments;
bool skip_return = (!split_part_return_p9.1
'split_part_return_p' is false
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))

←

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;

←

Calling 'tree_check'

→

←

Returning from 'tree_check'

→

←

Loop condition is true. Entering loop body

→

←

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++)

←

Calling 'contains_struct_check'

→

←

Returning from 'contains_struct_check'

→

←

Calling 'contains_struct_check'

→

←

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);

←

Calling 'vec_safe_push<ipa_adjusted_param, va_gc>'

→

←

Returning from 'vec_safe_push<ipa_adjusted_param, va_gc>'

→

←

Passing value via 1st parameter 'v'

→

←

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
4	This file is part of GCC.
5
6	GCC is free software; you can redistribute it and/or modify it under
7	the terms of the GNU General Public License as published by the Free
8	Software Foundation; either version 3, or (at your option) any later
9	version.
10
11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14	for more details.
15
16	You should have received a copy of the GNU General Public License
17	along 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
27	inline combined_fn
28	as_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
35	inline combined_fn
36	as_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
43	inline bool
44	builtin_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
52	inline built_in_function
53	as_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
61	inline bool
62	internal_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
70	inline internal_fn
71	as_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
351	extern 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
356	extern void tree_check_failed (const_tree, const char , int, const char ,
357	...) ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
358	extern void tree_not_check_failed (const_tree, const char , int, const char ,
359	...) ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
360	extern 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;
363	extern 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;
367	extern 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;
371	extern void tree_int_cst_elt_check_failed (int, int, const char *,
372	int, const char *)
373	ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
374	extern void tree_vec_elt_check_failed (int, int, const char *,
375	int, const char *)
376	ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
377	extern void phi_node_elt_check_failed (int, int, const char *,
378	int, const char *)
379	ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
380	extern void tree_operand_check_failed (int, const_tree,
381	const char , int, const char )
382	ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
383	extern void omp_clause_check_failed (const_tree, const char *, int,
384	const char *, enum omp_clause_code)
385	ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
386	extern void omp_clause_operand_check_failed (int, const_tree, const char *,
387	int, const char *)
388	ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) ATTRIBUTE_COLD;
389	extern 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
1210	static inline source_range
1211	get_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
1217	extern void protected_set_expr_location (tree, location_t);
1218	extern void protected_set_expr_location_if_unset (tree, location_t);
1219
1220	WARN_UNUSED_RESULT__attribute__ ((__warn_unused_result__)) extern tree maybe_wrap_with_location (tree, location_t);
1221
1222	extern 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
1228	class 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
2018	extern machine_mode element_mode (const_tree);
2019	extern machine_mode vector_type_mode (const_tree);
2020	extern unsigned int vector_element_bits (const_tree);
2021	extern 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